package com.zhentao.userRelationships.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zhentao.user.domain.UserLogin;
import com.zhentao.user.mapper.UserLoginMapper;
import com.zhentao.userRelationships.domain.UserRelationships;
import com.zhentao.userRelationships.domain.UserRequest;
import com.zhentao.userRelationships.domain.UserShouye;
import com.zhentao.userRelationships.dto.FriendDto;

import com.zhentao.userRelationships.dto.FriendsTDto;
import com.zhentao.userRelationships.mapper.UserRequestMapper;
import com.zhentao.userRelationships.mapper.UserShouyeMapper;
import com.zhentao.userRelationships.service.UserRelationshipsService;
import com.zhentao.userRelationships.mapper.UserRelationshipsMapper;

import com.zhentao.userRelationships.util.PinyinUtil;
import com.zhentao.userRelationships.util.SnowflakeUtil;

import com.zhentao.vo.Result;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.util.*;
import java.util.stream.Collectors;

/**
* @author lenovo
* @description 针对表【user_relationships(用户好友关系表)】的数据库操作Service实现
* @createDate 2025-06-10 20:29:55
*/
@Service
public class UserRelationshipsServiceImpl extends ServiceImpl<UserRelationshipsMapper, UserRelationships>
    implements UserRelationshipsService{
    @Autowired
    private UserRelationshipsMapper userRelationshipsMapper;
    @Autowired
    private UserLoginMapper userLoginMapper;
    @Autowired
    private UserRequestMapper userRequestMapper;
    @Autowired
    private UserShouyeMapper userShouyeMapper;
    //查询好友
    @Override
    public List<UserRelationships> getFriendIdsByUserId(Long userId) {
        QueryWrapper<UserRelationships> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1);
        queryWrapper.eq("user_id", userId);
        List<UserRelationships> list = this.list(queryWrapper);

        return list;

    }

    //添加好友

    @Override
    public Result sendFriendRequest(String senderId, Long receiverId, String message) {
        // 检查是否已经是好友关系
        QueryWrapper<UserRelationships> relationshipQuery = new QueryWrapper<>();
        relationshipQuery.eq("user_id", senderId);
        relationshipQuery.eq("friend_id", receiverId);
        relationshipQuery.eq("status", 1);
        UserRelationships existingRelationship = userRelationshipsMapper.selectOne(relationshipQuery);

        if (existingRelationship != null) {
            return Result.error(null,"已经是好友关系，无需重复申请");
        }
        // 检查是否已经有未处理的申请
        QueryWrapper<UserRequest> requestQuery = new QueryWrapper<>();
        requestQuery.eq("send_id", senderId);
        requestQuery.eq("receiver_id", receiverId);
        requestQuery.eq("status", 0);
        UserRequest existingRequest = userRequestMapper.selectOne(requestQuery);

        if (existingRequest != null) {
            return Result.error(null,"已经有未处理的好友申请，请勿重复发送");
        }

        UserLogin userLogin = userLoginMapper.selectById(senderId);
        // 创建新的好友申请记录
        UserRequest userRequest = new UserRequest();
        userRequest.setSendId(senderId);
        userRequest.setReceiverId(receiverId.toString());
        userRequest.setMessage(message);
        userRequest.setNickName(userLogin.getNickName());
        userRequest.setAvatar(userLogin.getAvatar()); // 设置头像
        userRequest.setStatus(0);
        userRequest.setCreateTime(new Date());

        // 插入记录
        int result = userRequestMapper.insert(userRequest);

        if (result > 0) {
            return Result.OK(userRequest, "好友申请发送成功");
        } else {
            return Result.error(null,"好友申请发送失败");
        }
    }


    @Override
    public List<UserRequest> getFriendRequestsByUserId(String token) {
        QueryWrapper<UserRequest> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("receiver_id", token);                            
//        queryWrapper.eq("status", 0); // 只查询待处理的申请
        queryWrapper.orderByAsc("create_time"); // 按照创建时间倒序排列
        System.err.println(queryWrapper);
        return userRequestMapper.selectList(queryWrapper);
    }

    // 查询待处理的申请
//    @Override
//    public List<UserRequest> getPendingFriendRequests(Long userId) {
//        QueryWrapper<UserRequest> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("receiver_id", userId.toString());
//        queryWrapper.eq("status", 0);
//        return userRequestMapper.selectList(queryWrapper);
//    }

    // 处理申请添加好友成功
    @Override
    public Result handleFriendRequest(Long requestId, boolean isAccepted) {
        // 查询好友申请记录
        UserRequest userRequest = userRequestMapper.selectById(requestId);

        if (userRequest == null) {
            return Result.error(null,"好友申请记录不存在");
        }

        if (userRequest.getStatus() != 0) {
            return Result.error(null,"该申请已处理，请勿重复操作");
        }

        if (isAccepted) {
            // 更新申请状态为已同意
            userRequest.setStatus(1);
            userRequest.setHandledTime(new Date());
            userRequestMapper.updateById(userRequest);

            // 创建好友关系记录
            Long senderId = Long.parseLong(userRequest.getSendId());
            Long receiverId = Long.parseLong(userRequest.getReceiverId());

            // 插入发送者的好友关系记录
            UserRelationships senderRelationship = new UserRelationships();
            senderRelationship.setUserId(senderId);
            senderRelationship.setFriendId(receiverId);
            senderRelationship.setStatus(1);
            senderRelationship.setCreatedAt(new Date());
            senderRelationship.setUpdatedAt(new Date());
            senderRelationship.setIsBlacklist(0);
            senderRelationship.setIsDel(0);
            senderRelationship.setIsMoments(0);
            userRelationshipsMapper.insert(senderRelationship);

            // 插入接收者的好友关系记录
            UserRelationships receiverRelationship = new UserRelationships();
            receiverRelationship.setUserId(receiverId);
            receiverRelationship.setFriendId(senderId);
            receiverRelationship.setStatus(1);
            receiverRelationship.setCreatedAt(new Date());
            receiverRelationship.setUpdatedAt(new Date());
            receiverRelationship.setIsBlacklist(0);
            receiverRelationship.setIsDel(0);
            receiverRelationship.setIsMoments(0);
            userRelationshipsMapper.insert(receiverRelationship);

            //插入首页的发送者的好友关系记录表
            UserShouye senduserShouye=new UserShouye();
            senduserShouye.setId(Long.valueOf(String.valueOf(SnowflakeUtil.nextId())));
            senduserShouye.setUid1(senderId);
            senduserShouye.setUid2(receiverId);
            senduserShouye.setStatus(0);
            userShouyeMapper.insert(senduserShouye);

            //插入接收者的好友关系记录
            UserShouye receiveuserShouye=new UserShouye();
            receiveuserShouye.setId(Long.valueOf(String.valueOf(SnowflakeUtil.nextId())));
            receiveuserShouye.setUid1(receiverId);
            receiveuserShouye.setUid2(senderId);
            receiveuserShouye.setStatus(0);
            userShouyeMapper.insert(receiveuserShouye);

            return Result.OK(null, "好友申请已同意，添加好友成功");
        } else {
            // 更新申请状态为已拒绝
            userRequest.setStatus(2);
            userRequest.setHandledTime(new Date());
            userRequestMapper.updateById(userRequest);
            return Result.OK(null, "好友申请已拒绝");
        }
    }
    //根据当前登录的用户获取所有好友并且按照首字母进行排序
    @Override
    public List<Map<String, Object>> getFriendsByUserIdAndSort(Long userId) {
        // 创建一个查询条件对象，用于后续查询用户关系状态为1（例如：好友关系有效）且用户ID为指定值的记录
        QueryWrapper<UserRelationships> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("status",1)
                .eq("user_id",userId);
        // 执行查询，获取用户的关系记录列表
        List<UserRelationships> relationships=this.list(queryWrapper);
        // 如果没有找到任何关系记录，则返回一个空列表
        if(relationships.isEmpty()){
            return Collections.emptyList();
        }
        // 从关系记录中提取所有好友ID
        List<Long> friendIds = relationships.stream()
                .map(UserRelationships::getFriendId)
                .collect(Collectors.toList());
        // 根据提取的好友ID列表，查询所有对应的好友登录信息
        List<UserLogin> friends = userLoginMapper.selectBatchIds(friendIds);
        // 如果没有找到任何好友信息，则返回一个空列表
        if (friends.isEmpty()) {
            return Collections.emptyList();
        }
        // 3. 转换为FriendDto并处理首字母
        // 使用Java Stream API对朋友列表进行处理，转换为FriendsTDto列表
        List<FriendsTDto> FriendsTDtos = friends.stream().map(friend -> {
            // 创建一个新的FriendsTDto对象
            FriendsTDto friendsTDto=new FriendsTDto();
            // 设置朋友的ID
            friendsTDto.setFriendId(friend.getId());
            // 设置朋友的昵称
            friendsTDto.setNickName(friend.getNickName());
            // 设置朋友的头像
            friendsTDto.setAvatar(friend.getAvatar());
            // 获取昵称首字母（拼音缩写）
            String firstLetter = PinyinUtil.getFirstLetter(friend.getNickName());
            // 设置昵称首字母
            friendsTDto.setFirstLetter(firstLetter);
            // 返回处理后的FriendsTDto对象
            return friendsTDto;
        }).collect(Collectors.toList());
        // 4. 按首字母分组（使用TreeMap保证字母顺序）
        Map<String, List<FriendsTDto>> groupByFirstLetter = FriendsTDtos.stream()
                .collect(Collectors.groupingBy(
                        FriendsTDto::getFirstLetter,
                        TreeMap::new,
                        Collectors.toList()
                ));

        // 5. 整理结果（先A-Z，再#）
        List<Map<String, Object>> result = new ArrayList<>();
        // 处理A-Z字母分组
        for (char c = 'A'; c <= 'Z'; c++) {
            String letter = String.valueOf(c);
            if (groupByFirstLetter.containsKey(letter)) {
                // 对每组好友按昵称拼音排序
                groupByFirstLetter.get(letter).sort(
                        Comparator.comparing(f -> PinyinUtil.getFullPinyin(f.getNickName()))
                );
                result.add(Collections.singletonMap(letter, groupByFirstLetter.get(letter)));
            }
        }

        // 处理特殊字符分组（#）
        if (groupByFirstLetter.containsKey("#")) {
            groupByFirstLetter.get("#").sort(
                    Comparator.comparing(f -> PinyinUtil.getFullPinyin(f.getNickName()))
            );
                result.add(Collections.singletonMap("#", groupByFirstLetter.get("#")));
        }
        return result;
    }
}