package xin.merlin.myplayerbackend.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import xin.merlin.myplayerbackend.entity.Friends;
import xin.merlin.myplayerbackend.entity.Inviting;
import xin.merlin.myplayerbackend.entity.Playrooms;
import xin.merlin.myplayerbackend.entity.UserInfo;
import xin.merlin.myplayerbackend.entity.http.InvitingDetails;
import xin.merlin.myplayerbackend.mapper.FriendsMapper;
import xin.merlin.myplayerbackend.mapper.InvitingMapper;
import xin.merlin.myplayerbackend.mapper.PlayroomsMapper;
import xin.merlin.myplayerbackend.mapper.UserMapper;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
@RequiredArgsConstructor
public class InvitingServiceImpl extends ServiceImpl<InvitingMapper, Inviting> {

    private final InvitingMapper invitingMapper;

    private final UserMapper userMapper;

    private final FriendsMapper friendsMapper;

    private final PlayroomsMapper playroomsMapper;

    // TODO: 修改关联查询逻辑
    private Map<String, Object> getInvitingDetails(List<Inviting> invitings) {
        List<InvitingDetails> invitingDetails = new ArrayList<>();
        for (Inviting inviting : invitings){
            InvitingDetails invitingDetail = new InvitingDetails(inviting,
                    userMapper.selectOne(Wrappers.<UserInfo>lambdaQuery().eq(UserInfo::getId,inviting.getInviter())));
            invitingDetails.add(invitingDetail);
        }
        return Map.of("result",invitingDetails);
    }

    public Boolean inviting(Integer inviter, Integer target,Integer room){
        Inviting inviting = new Inviting();
        inviting.setInviter(inviter);
        inviting.setTarget(target);
        inviting.setStatus(0);
        if (room != null){
            inviting.setRoom(room);
        }
        if (invitingMapper.selectCount(Wrappers.<Inviting>lambdaQuery().eq(Inviting::getInviter,inviter).eq(Inviting::getTarget,target).eq(Inviting::getStatus,0).eq(Inviting::getRoom,room)) > 0) return false;
        return invitingMapper.insert(inviting) == 1;
    }

    public Map<String,Object> getInvitingDetail(Integer target, Integer size, Integer page){
        try {
            List<Inviting> invitings = invitingMapper.selectList(new Page<>(page,size), Wrappers.<Inviting>lambdaQuery().eq(Inviting::getTarget,target));
            return getInvitingDetails(invitings);
        } catch (Exception e) {
            log.error(e.getMessage());
            throw new RuntimeException(e);
        }
    }

    public Map<String,Object> getSelfInvitingDetail(Integer room, Integer size, Integer page){
        try {
            List<Inviting> invitings = invitingMapper.selectList(new Page<>(page,size), Wrappers.<Inviting>lambdaQuery().eq(Inviting::getRoom,room).apply("inviter = target"));
            return getInvitingDetails(invitings);
        } catch (Exception e) {
            log.error(e.getMessage());
            throw new RuntimeException(e);
        }
    }



    @Transactional
    public Boolean handleFriendInviting(Inviting inviting) {
        try {
            if (inviting.getStatus().equals(0)) return false;
            else if (inviting.getStatus().equals(1)){
                friendsMapper.insert(new Friends(inviting.getInviter(), inviting.getTarget(), null));
                friendsMapper.insert(new Friends(inviting.getTarget(), inviting.getInviter(), null));
                return true;
            }
            else return true;
        } catch (Exception e) {
            log.error(e.getMessage());
            throw new RuntimeException(e);
        }

    }

//    public Integer playroomIsAdmin(Integer id, Integer r_id) {
//        try {
//            Playrooms playrooms = playroomsMapper.selectOne(Wrappers.<Playrooms>lambdaQuery().eq(Playrooms::getId,id).eq(Playrooms::getR_id,r_id));
//            if (playrooms == null) return 1;
//            else return playrooms.getRole();
//        } catch (Exception e) {
//            log.error(e.getMessage());
//            throw new RuntimeException(e);
//        }
//    }

    public Boolean handlePlayroomInviting(Inviting inviting) {
        try {
            if (inviting.getStatus().equals(0) || inviting.getRoom() == null) return false;
            else if (inviting.getStatus().equals(1)){
                playroomsMapper.insert(new Playrooms(inviting.getRoom(), inviting.getTarget(), 1));
                return true;
            }
            else return true;
        } catch (Exception e) {
            log.error(e.getMessage());
            throw new RuntimeException(e);
        }
    }
}