package com.fdkankan.tk.service;
import cn.hutool.core.date.DateUnit;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.tk.common.PageInfo;
import com.fdkankan.tk.common.util.JwtUtil;
import com.fdkankan.tk.entity.*;
import com.fdkankan.tk.response.*;
import com.fdkankan.tk.util.DataCountUtil;
import com.fdkankan.tk.util.Dateutils;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class DataCountService {

    @Autowired
    IRoomService roomService;
    @Autowired
    IRoomVisitLogService roomVisitLogService;
    @Autowired
    IRoomShareLogService roomShareLogService;
    @Autowired
    IRoomDanmakuService roomDanmakuService;
    @Autowired
    IRoomNumService roomNumService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    IRoomUserService roomUserService;
    @Autowired
    IWxUserService wxUserService;


    public Object roomData(String token) {
        List<Room> roomList = roomService.getRoomByToken(token);
        List<String> roomIds = roomList.stream().map(Room::getRoomId).collect(Collectors.toList());
        if(roomIds.size() <=0){
            return new RoomData();
        }
        Long roomCount = Long.valueOf(roomList.size());

        Long visitManCount = roomVisitLogService.manCount(roomIds);
        LambdaQueryWrapper<RoomVisitLog> wrapper2 = new LambdaQueryWrapper<>();
        if(roomIds.size() >0){
            wrapper2.in(RoomVisitLog::getRoomId,roomIds);
        }
        Long visitCount = roomVisitLogService.count(wrapper2);

        LambdaQueryWrapper<RoomShareLog> wrapper3 = new LambdaQueryWrapper<>();
        if(roomIds.size() >0){
            wrapper3.in(RoomShareLog::getRoomId,roomIds);
        }
        Integer shareCount = 0 ;
        for (Room room : roomList) {
            shareCount += room.getShareCount();
        }

        RoomData roomData = new RoomData();
        roomData.setRoomCount(roomCount);
        roomData.setVisitManCount(visitManCount);
        roomData.setVisitCount(visitCount);
        roomData.setShareCount(shareCount);
        return roomData;
    }

    public Object takeLookTop5(String token) {
        List<Room> roomList = roomService.getRoomByToken(token);
        List<String> roomIds = roomList.stream().map(Room::getRoomId).collect(Collectors.toList());
        TakeLookTop5 takeLookTop5 = new TakeLookTop5();
        if(roomIds.size() <=0){
            return takeLookTop5;
        }

        List<DataCount> lookList = roomVisitLogService.getDataCountTop5(roomIds);
        HashMap<String,Room> roomHashMap = new HashMap<>();
        List<String> roomIdList = lookList.stream().map(DataCount::getDataKey).collect(Collectors.toList());
        if(roomIdList.size() >0){
            List<Room> roomListDb = roomService.listByIds(roomIdList);
            roomListDb.forEach(entity-> roomHashMap.put(entity.getRoomId(),entity));
        }
        for (DataCount dataCount : lookList) {
            if(dataCount != null && roomHashMap.get(dataCount.getDataKey()) != null){
                dataCount.setDataKey(roomHashMap.get(dataCount.getDataKey()).getRoomTitle());
            }
        }

        List<DataCount> danmakuList = roomDanmakuService.getDataCountTop5(roomIds);

        takeLookTop5.setTakeLookList(lookList);
        takeLookTop5.setDanmakuList(danmakuList);
        return takeLookTop5;
    }

    public Object onlineTimeCount(String token) {
        List<Room> roomList = roomService.getRoomByToken(token);
        List<String> roomIds = roomList.stream().map(Room::getRoomId).collect(Collectors.toList());

        List<Integer> keys = DataCountUtil.timeShardingRes;
        List<DataCount> dataCounts = new ArrayList<>();
        for (Integer key : keys) {
            Long count = null;
            if(roomIds.isEmpty()){
                count = 0L;
            }else {
                count = roomVisitLogService.getCountByTime(key,roomIds);
            }
            DataCount dataCount = new DataCount();
            dataCount.setDataKey(key.toString());
            dataCount.setDataCount(count);
            dataCounts.add(dataCount);
        }
        return dataCounts;
    }

    public Object roomVisitData(String token,String roomTitle, String startTime, String endTime) {
        List<Room> roomList = roomService.getRoomByToken(token);
        List<String> roomIdsDb = roomList.stream().map(Room::getRoomId).collect(Collectors.toList());
        List<String> roomIds = roomIdsDb;

        if(StringUtils.isNotBlank(roomTitle)){
            List<Room> roomListLike = roomService.getLikeTitle(roomTitle);
            if(roomList.size() >0){
               List<String> roomIds2 = roomListLike.stream().map(Room::getRoomId).collect(Collectors.toList());
               roomIds = roomIdsDb.stream().filter(roomIds2::contains).collect(Collectors.toList());
            }
        }
        RoomVisitData roomVisitData = new RoomVisitData();
        if(roomIds.isEmpty()){
            return roomVisitData;
        }
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);
        List<DataCount> dbVisitList = roomVisitLogService.getByGroupRoomId("t_room_visit_log",roomIds,startTime,endTime);
        List<DataCount>  dbVisitListFmt =  getDataCountListByList(dbVisitList, startTime, endTime);

        List<DataCount> dbSharList = roomVisitLogService.getByGroupRoomId("t_room_share_log",roomIds,startTime,endTime);
        List<DataCount>  dbSharListFmt =  getDataCountListByList(dbSharList, startTime, endTime);

        List<DataCount> dbDanmakuList = roomVisitLogService.getByGroupRoomId("t_room_danmaku",roomIds,startTime,endTime);
        List<DataCount>  dbDanmakuListFmt =  getDataCountListByList(dbDanmakuList, startTime, endTime);

        List<DataCount> dbDanmakuListD = roomVisitLogService.getByDGroupRoomId("t_room_danmaku",roomIds,startTime,endTime);
        List<DataCount>  dbDanmakuListFmtD =  getDataCountListByList(dbDanmakuListD, startTime, endTime);

        roomVisitData.setUserVisitList(dbVisitListFmt);
        roomVisitData.setUserShareList(dbSharListFmt);
        roomVisitData.setUserMsgManList(dbDanmakuListFmtD);
        roomVisitData.setUserMsgCountList(dbDanmakuListFmt);

        return roomVisitData;
    }

    public  List<DataCount> getDataCountListByList( List<DataCount> visitList,String startTime,String endTime){
        HashMap<String ,DataCount> map = new HashMap<>();
        visitList.forEach(entity -> map.put(entity.getDataKey(),entity));

        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),Dateutils.DAY );
        List<DataCount> dataCounts = new ArrayList<>();
        for (String date : dates) {
            DataCount dataCount = map.get(date);
            if(dataCount == null){
                dataCount = new DataCount();
                dataCount.setDataKey(date);
                dataCount.setDataCount(0L);
            }
            dataCounts.add(dataCount);
        }
        return dataCounts;
    }

    public Page<RoomListDataVo> roomDataList(String token, String roomTitle, String startTime, String endTime, Integer pageNum, Integer pageSize) {
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(token)){
            String userName = JwtUtil.getUserName(token);
            wrapper.eq(Room::getRoomUserName,userName);
        }
        if(StringUtils.isNotBlank(roomTitle)){
            wrapper.like(Room::getRoomTitle,roomTitle);
        }
        if(StringUtils.isNotBlank(startTime)){
            wrapper.ge(Room::getCreateTime,startTime);
        }
        if(StringUtils.isNotBlank(endTime)){
            wrapper.le(Room::getCreateTime,endTime);
        }
        wrapper.orderByDesc(Room::getCreateTime);

        List<RoomListDataVo> voList = new ArrayList<>();
        Page<Room> page = roomService.page(new Page<>(pageNum, pageSize), wrapper);

        List<String> roomIds = page.getRecords().stream().map(Room::getRoomId).collect(Collectors.toList());
        List<RoomNum> roomNumList = roomNumService.getListByRoomIds(roomIds);
        Set<String> numList = roomNumList.stream().map(RoomNum::getNum).collect(Collectors.toSet());
        HashMap<String,List<RoomNum>> numRoomMap = new HashMap<>();
        for (RoomNum roomNum : roomNumList) {
            if(numRoomMap.get(roomNum.getRoomId()) == null){
                List<RoomNum> numList1 = new ArrayList<>();
                numList1.add(roomNum);
                numRoomMap.put(roomNum.getRoomId(),numList1);
            }else {
                numRoomMap.get(roomNum.getRoomId()).add(roomNum);
            }
        }

        List<SceneVo> list = new ArrayList<>();
        HashMap<String,SceneVo> sceneMap  = new HashMap<>();

        if(numList.size() >0){
            list = sceneService.getListByNumList(new ArrayList<>(numList));
            list.forEach(entity -> sceneMap.put(entity.getNum(),entity));
        }

        List<DataCount> roomList = roomVisitLogService.getGroupByRoomId();
        HashMap<String,Long> roomManMap = new HashMap<>();
        roomList.forEach(entity -> roomManMap.put(entity.getDataKey(),entity.getDataCount()));

        for (Room record : page.getRecords()) {
            List<RoomNum> roomNums = numRoomMap.get(record.getRoomId());
            List<String> sceneTileList = new ArrayList<>();
            if(roomNums !=null){
                roomNums.forEach(entity -> {
                    SceneVo sceneVo = sceneMap.get(entity.getNum());
                    if(sceneVo != null){
                        sceneTileList.add(sceneVo.getTitle());
                    }
                });
            }
            List<RoomVisitLog> roomLives = roomVisitLogService.getByRoomId(record.getRoomId());
            Long minute = 0L;
            for (RoomVisitLog roomLive : roomLives) {
                Date overTime = roomLive.getOutRoomTime();
                if(overTime == null){
                    overTime = record.getUseEndTime();
                }
                minute +=  Dateutils.getLongTime(roomLive.getCreateTime(), overTime,DateUnit.MINUTE);
            }
            RoomListDataVo roomListDataVo = new RoomListDataVo();
            roomListDataVo.setRoomTitle(record.getRoomTitle());
            roomListDataVo.setSceneNameList(sceneTileList);
            roomListDataVo.setCreateTime(record.getCreateTime());
            roomListDataVo.setRoomStatus(record.getRoomStatus());
            roomListDataVo.setLookTime(minute);
            roomListDataVo.setLookManCount(roomManMap.get(record.getRoomId()) == null ? 0L:roomManMap.get(record.getRoomId()) );
            roomListDataVo.setShareCount(record.getShareCount());
            voList.add(roomListDataVo);
        }
        Page<RoomListDataVo> pageVo = new Page<>(pageNum,pageSize);
        pageVo.setRecords(voList);
        pageVo.setTotal(page.getTotal());
        return pageVo;
    }

    public Page<UserMsgVo> roomMsgList(String token ,String roomTitle, String startTime, String endTime, Integer pageNum, Integer pageSize) {
        List<Room> roomList = roomService.getRoomByToken(token);
        List<String> roomIdsDb = roomList.stream().map(Room::getRoomId).collect(Collectors.toList());
        List<String> roomIds = roomIdsDb;

        if(StringUtils.isNotBlank(roomTitle)){
            List<Room> roomListLike = roomService.getLikeTitle(roomTitle);
            if(roomList.size() >0){
                List<String> roomIds2 = roomListLike.stream().map(Room::getRoomId).collect(Collectors.toList());
                roomIds = roomIdsDb.stream().filter(roomIds2::contains).collect(Collectors.toList());
            }
        }
        if(roomIds.isEmpty()){
            return  new Page<>(pageNum,pageSize);
        }

        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        Page<UserMsgVo> page = roomDanmakuService.pageList(new Page<>(pageNum,pageSize) ,roomIds,startTime,endTime);
        Set<String> roomIdsVo = page.getRecords().stream().map(UserMsgVo::getRoomId).collect(Collectors.toSet());
        HashMap<String, Room> roomHashMap = roomService.getByIds(roomIdsVo);

        HashMap<String,List<RoomVisitLog>> roomVisitLogsMap = new HashMap<>();
        HashMap<String,List<RoomDanmaku>> danmakusMap = new HashMap<>();

        for (UserMsgVo record : page.getRecords()) {
            List<RoomVisitLog> roomVisitLogs  = roomVisitLogsMap.get(record.getRoomId());
            if(roomVisitLogs == null){
                roomVisitLogs = roomVisitLogService.getByRoomId(record.getRoomId());
                roomVisitLogsMap.put(record.getRoomId(),roomVisitLogs);
            }
            Long time = 0L;
            Date firstOutTime = null;
            Date endOutTime = null;
            for (RoomVisitLog roomVisitLog : roomVisitLogs) {
                Room room = roomHashMap.get(roomVisitLog.getRoomId());
                if(room == null){
                    continue;
                }
                Date outRoomTime = roomVisitLog.getOutRoomTime() == null ? room.getUseEndTime() : roomVisitLog.getOutRoomTime();
                if(outRoomTime == null || roomVisitLog.getInRoomTime() == null){
                    continue;
                }
                if(firstOutTime == null){
                    firstOutTime = roomVisitLog.getInRoomTime();
                }else {
                    firstOutTime = firstOutTime.getTime() <= roomVisitLog.getInRoomTime().getTime() ? firstOutTime : roomVisitLog.getInRoomTime();
                }
                if(endOutTime == null){
                    endOutTime = outRoomTime;
                }else {
                    endOutTime = endOutTime.getTime() >= outRoomTime.getTime() ? endOutTime : outRoomTime;
                }
                time += (outRoomTime.getTime() - roomVisitLog.getInRoomTime().getTime());
            }
            List<RoomDanmaku> danmakus  = danmakusMap.get(record.getRoomId()+record.getWxUserId());
            if(danmakus == null){
                danmakus = roomDanmakuService.getByRoomId(record.getRoomId(),record.getWxUserId());
                danmakusMap.put(record.getRoomId()+record.getWxUserId(),danmakus);
            }
            List<String> collect = danmakus.stream().map(RoomDanmaku::getText).collect(Collectors.toList());
            record.setOnlineTime(time/1000/60);
            record.setFirstInRoomTime(firstOutTime);
            record.setLastOutRoomTime(endOutTime);
            record.setTextCount(Long.valueOf(danmakus.size()));
            record.setTexts(collect);
        }
        return page;
    }



}