package com.fdkankan.tk.service.impl;
import java.util.Date;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.tk.common.ResultCode;
import com.fdkankan.tk.common.util.RoomUtil;
import com.fdkankan.tk.entity.Room;
import com.fdkankan.tk.entity.RoomUser;
import com.fdkankan.tk.exception.BusinessException;
import com.fdkankan.tk.httpClient.FdKKService;
import com.fdkankan.tk.mapper.IRoomUserMapper;
import com.fdkankan.tk.response.RoomAddUserParam;
import com.fdkankan.tk.service.IRoomLiveService;
import com.fdkankan.tk.service.IRoomUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.tk.service.IRoomVisitLogService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2023-02-28
 */
@Service
public class RoomUserServiceImpl extends ServiceImpl<IRoomUserMapper, RoomUser> implements IRoomUserService {

    @Autowired
    FdKKService fdKKService;
    @Autowired
    IRoomLiveService roomLiveService;
    @Autowired
    IRoomVisitLogService roomVisitLogService;
    @Autowired
    RedisUtil redisUtil;


    @Override
    public void updateByUserObjList(List<RoomUser> userObjList, Room room) {
        if(userObjList == null || userObjList.size() <=0){
            this.delByRoomId(room.getRoomId());
            return;
        }
        HashMap<String,RoomUser> roomUserHashMap = this.getMapByRoomId(room.getRoomId());
        if(roomUserHashMap.size() >0){  //删除数据库中多余的userName
            Set<String> dbUserName = roomUserHashMap.keySet();
            Set<String> userNameSet = userObjList.stream().map(RoomUser::getUserName).collect(Collectors.toSet());
            if(userNameSet.size() <=0){
                this.delByRoomId(room.getRoomId());
                return;
            }
            List<String> delUserName = new ArrayList<>();
            for (String userName : dbUserName) {
                if(!userNameSet.contains(userName)){
                    delUserName.add(userName);
                }
            }
            this.delByUserNameList(delUserName,room.getRoomId());
        }

        List<RoomUser> roomUserList = new ArrayList<>();
        for (RoomUser roomUser : userObjList) {
            if(room.getUseStartTime().getTime() < roomUser.getUseStartTime().getTime()
                    || room.getUseEndTime().getTime() < roomUser.getUseEndTime().getTime()){
                throw new BusinessException(ResultCode.ROOM_TIME_ERROR);
            }
            roomUser.setRoomId(room.getRoomId());
            RoomUser dbRoomUser = roomUserHashMap.get(roomUser.getUserName());
            if(dbRoomUser != null){
                roomUser.setRoomUserId(dbRoomUser.getRoomUserId());
                roomUser.setUseStartTime(room.getUseStartTime());
                roomUser.setUseEndTime(room.getUseEndTime());
            }
            roomUserList.add(roomUser);
        }
        this.saveOrUpdateBatch(roomUserList);


    }

    @Override
    public void delByRoomId(String roomId) {
        LambdaQueryWrapper<RoomUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(RoomUser::getRoomId,roomId);
        this.remove(wrapper);
    }


    @Override
    public List<RoomUser> getByRoomId(String roomId) {
        LambdaQueryWrapper<RoomUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(RoomUser::getRoomId,roomId);
        return this.list(wrapper);
    }

    @Override
    public HashMap<String, RoomUser> getMapByRoomId(String roomId) {
        HashMap<String,RoomUser> map = new HashMap<>();
        List<RoomUser> list = this.getByRoomId(roomId);
        list.forEach(entity -> map.put(entity.getUserName(),entity));
        return map;
    }

    @Override
    public void delByUserNameList(List<String> delUserName,String roomId) {
        LambdaQueryWrapper<RoomUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(RoomUser::getRoomId,roomId);
        wrapper.in(RoomUser::getUserName,delUserName);
        this.remove(wrapper);
    }

    @Override
    public void stopRoom(RoomUser roomUser) {
        LambdaUpdateWrapper<RoomUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(RoomUser::getRoomUserId,roomUser.getRoomUserId());
        wrapper.set(RoomUser::getRoomStatus,2);
        this.update(wrapper);

        String liveId = redisUtil.get(RoomUtil.redisKey+"live:"+RoomUtil.getLiveRoomId(roomUser.getRoomId(),roomUser.getRoomUserId().toString()));
        if(StringUtils.isNotBlank(liveId)){
            roomLiveService.stopByLiveId(liveId);
            roomVisitLogService.stopRoom(Integer.parseInt(liveId));
            redisUtil.del(RoomUtil.redisKey+"live:"+RoomUtil.getLiveRoomId(roomUser.getRoomId(),roomUser.getRoomUserId().toString()));

        }
    }

    @Override
    public List<RoomUser> getRunningRoom() {
        LambdaQueryWrapper<RoomUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(RoomUser::getRoomStatus,1);
        return list(wrapper);
    }
}