package com.zhangshu.chat.demo.service;

import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.core.lang.UUID;
import com.zhangshu.chat.demo.constant.ERoomUserType;
import com.zhangshu.chat.demo.entity.Room;
import com.zhangshu.chat.demo.vo.RoomUserVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;

@Component
public class RoomCache {
    private final Cache<String, Room> roomCache = CacheUtil.newFIFOCache(4);
    private final Cache<Long, String> userRoomCache = CacheUtil.newFIFOCache(16);
    /**
     * 正在创建
     */
    private final Cache<String, Room> roomCreatingCache = CacheUtil.newFIFOCache(4);

    public List<Room> list() {
        List<Room> resp = new ArrayList<>(roomCache.size());
        roomCache.forEach(resp::add);
        return resp;
    }

    /**
     *
     * @param userId
     * @return
     *  NullException
     */
    public Room getRoomByUser(Long userId){
        String roomId = userRoomCache.get(userId);
        if (StringUtils.isBlank(roomId)) {
            return null;
        }
        return roomCache.get(roomId);
    }

    public boolean isExistUser(Long userId){
        return userRoomCache.containsKey(userId);
    }

    public synchronized Room addCreating(String roomName) {
        Room room = Room.builder()
                .id(UUID.fastUUID().toString())
                .name(roomName)
                .build();
        roomCreatingCache.put(room.getId(), room);
        return room;
    }

    public boolean createSuccess(String roomId) {
        return roomCache.containsKey(roomId);
    }

    public Room get(String roomId) {
        return roomCache.get(roomId);
    }

    public synchronized void add(String roomId) {
        Room room = roomCreatingCache.get(roomId);
        if (Objects.isNull(room)) {
            return;
        }
        roomCache.put(roomId, room);
        roomCreatingCache.remove(roomId);
    }

    public synchronized void addUser(String roomId, RoomUserVo user) {
        Room room = roomCache.get(roomId);
        if (Objects.nonNull(room) && room.getUserList().stream().noneMatch(v -> v.getId().equals(user.getId()))) {
            if (room.getUserList().size() == 0) {
                user.setType(ERoomUserType.lord);
            }
            room.getUserList().add(user);
            userRoomCache.put(user.getId(), room.getId());
        }
    }

    public void remove(String roomId) {
        roomCache.remove(roomId);
    }

    public synchronized void removeUser(String roomId, Long userId) {
        Room room = roomCache.get(roomId);
        if (Objects.nonNull(room)) {
            room.getUserList().stream().filter(v -> v.getId().equals(userId)).findFirst().ifPresent(user -> {
                room.getUserList().remove(user);
                userRoomCache.remove(userId);
                //设置最早的一个成为房主
                if (ERoomUserType.lord.equals(user.getType())) {
                    room.getUserList().stream().filter(v->ERoomUserType.broadcaster.equals(v.getType()))
                            .min(Comparator.comparing(RoomUserVo::getJoinTime))
                            .ifPresent(user2 -> user2.setType(ERoomUserType.lord));
                }
            });
        }
    }

    public void changeUserType(String roomId, Long userId, ERoomUserType type) {
        Room room = roomCache.get(roomId);
        if (Objects.nonNull(room)) {
            room.getUserList().stream().filter(v -> v.getId().equals(userId)).findFirst().ifPresent(v -> v.setType(type));
        }
    }
}