package com.fdkankan.tk.service.impl;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.jwt.JWTUtil;
import com.auth0.jwt.JWT;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.tk.common.FilePath;
import com.fdkankan.tk.common.PageInfo;
import com.fdkankan.tk.common.ResultCode;
import com.fdkankan.tk.common.util.JwtUtil;
import com.fdkankan.tk.common.util.RedisKeyUtil;
import com.fdkankan.tk.common.util.UploadToOssUtil;
import com.fdkankan.tk.entity.Room;
import com.fdkankan.tk.exception.BusinessException;
import com.fdkankan.tk.mapper.IRoomMapper;
import com.fdkankan.tk.request.RoomAddParam;
import com.fdkankan.tk.request.RoomListParam;
import com.fdkankan.tk.response.RoomVo;
import com.fdkankan.tk.response.SceneVo;
import com.fdkankan.tk.service.IRoomNumService;
import com.fdkankan.tk.service.IRoomService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.tk.service.ISceneService;
import com.fdkankan.tk.service.IWxService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-09-19
 */
@Service
public class RoomServiceImpl extends ServiceImpl<IRoomMapper, Room> implements IRoomService {

    @Autowired
    IRoomNumService roomNumService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    UploadToOssUtil uploadToOssUtil;
    @Autowired
    IWxService wxService;
    @Value("${upload.query-path}")
    private String queryPath;
    @Autowired
    RedisUtil redisUtil;

    @Override
    public PageInfo pageList(RoomListParam param, String token) {
        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(token)){
            String fdToken = String.format(RedisKey.TOKEN_V3,token);
            if(! redisUtil.hasKey(fdToken)){
                throw new BusinessException(ResultCode.USER_NOT_LOGIN);
            }
            redisUtil.expire(fdToken,6 * 60 * 60);
            String userName = JwtUtil.getUserName(token);
            wrapper.eq(Room::getRoomUserName,userName);
        }
        if (StringUtils.isNotBlank(param.getRoomTitle()) ) {
            wrapper.like(Room::getRoomTitle,param.getRoomTitle());
        }
        wrapper.orderByDesc(Room::getCreateTime);

        Page<Room> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);


        return PageInfo.PageInfo(page);
    }

    @Override
    public Room addOrUpdate(RoomAddParam param, String token) {
        if(param.getNumList() == null || param.getNumList().size() <=0){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        if(StringUtils.isEmpty(param.getRoomTitle()) ){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        Room room = new Room();
        BeanUtils.copyProperties(param,room);
        room.setRoomUserName(JwtUtil.getUserName(token));
        if(StringUtils.isEmpty(room.getRoomHostName())){
            room.setRoomHostName(room.getRoomUserName());
        }
        if(param.getRoomId() != null){
            room.setUpdateTime(null);
        }
        this.saveOrUpdate(room);
        roomNumService.addBatch(room.getRoomId(),param.getNumList());
        param.setRoomId(room.getRoomId());
        return param;
    }

    @Override
    public void deleteById(Integer roomId) {
        roomNumService.deleteByRoomId(roomId);
        Room room = this.getById(roomId);
        if(StringUtils.isNotBlank(room.getRoomShareUrl())){
            uploadToOssUtil.delete(room.getRoomShareUrl());
        }
        this.removeById(roomId);
    }

    @Override
    public RoomVo getRoomInfo(Integer roomId) {
        Room room = this.getById(roomId);
        List<String> numList = roomNumService.getListByRoomId(roomId);
        List<SceneVo> list = new ArrayList<>();
        if(numList.size() >0){
            list = sceneService.getListByNumList(numList);
        }
        RoomVo roomVo = new RoomVo();
        BeanUtils.copyProperties(room,roomVo);
        roomVo.setSceneData(list);
        return roomVo;
    }

    @Override
    public void roomAddView(Integer roomId) {
        LambdaUpdateWrapper<Room> wrapper = new LambdaUpdateWrapper<>();
        wrapper.setSql("room_view_count = room_view_count +1");
        wrapper.eq(Room::getRoomId,roomId);
        this.update(wrapper);
    }


    @Override
    public String getWxQrCode(Integer roomId,String type) {
        Room room = this.getById(roomId);
        if(room == null){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }
        if(type.equals("follower") && StringUtils.isNotBlank(room.getRoomShareCode())){     //普通用户二维码
            if(uploadToOssUtil.existKey(room.getRoomShareCode())){
                return  room.getRoomShareCode();
            }
        }

        if(type.equals("leader") && StringUtils.isNotBlank(room.getRoomHostCode())){      //主持人二维码
            if(uploadToOssUtil.existKey(room.getRoomHostCode())){
                return  room.getRoomHostCode();
            }
        }

        String localPath = String.format(FilePath.LOCAL_QRCODE_PATH, type,roomId);
        String ossPath = String.format(FilePath.OSS_QRCODE_PATH,type, roomId);
        String path = "id="+roomId+"&role=%s";
        path = String.format(path,type);
        wxService.getWxQRCode(path,localPath,0);
        if(!new File(localPath).exists()){
            throw new BusinessException(ResultCode.QRCODE_MISS);
        }
        uploadToOssUtil.uploadOss(localPath,ossPath);
        if(!uploadToOssUtil.existKey(ossPath)){
            FileUtil.del(localPath);
            throw new BusinessException(ResultCode.QRCODE_MISS);
        }
        if(type.equals("leader")){
            room.setRoomHostCode(queryPath + ossPath);
        }else {
            room.setRoomShareCode(queryPath + ossPath);
        }
        this.updateById(room);
        FileUtil.del(localPath);
        return queryPath + ossPath;
    }

    @Override
    public void inOrOutRoom(Integer roomId, String role, Integer type) {
        if(roomId == null || StringUtils.isBlank(role)
                || ( !role.equals("leader") && !role.equals("follower"))){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        if(role.equals("follower")){
            return;
        }
        Room room = this.getById(roomId);
        if(room == null){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }
        if(type == 0 ){
            room.setLastLookTime(DateUtil.formatDateTime(new Date()));
            room.setRoomStatus(1);
        }
        if(type == 1 ){
            room.setLastLookTime(DateUtil.formatDateTime(new Date()));
            room.setRoomStatus(2);
        }
        room.setUpdateTime(null);
        this.updateById(room);
    }
}