package com.fdkankan.manage.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.jwt.JWTUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.manage.common.PageInfo;
import com.fdkankan.manage.common.RedisKeyUtil;
import com.fdkankan.manage.common.ResultCode;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.mapper.IJySceneUserAuthMapper;
import com.fdkankan.manage.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.manage.vo.request.SceneParam;
import com.fdkankan.manage.vo.response.CheckOtherVo;
import com.fdkankan.manage.vo.response.ManageLoginResponse;
import com.fdkankan.manage.vo.response.SceneAuthVo;
import com.fdkankan.redis.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2023-08-24
 */
@Service
public class JySceneUserAuthServiceImpl extends ServiceImpl<IJySceneUserAuthMapper, JySceneUserAuth> implements IJySceneUserAuthService {

    @Autowired
    IJyUserService jyUserService;
    @Autowired
    IJySceneAuthService jySceneAuthService;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    ISysUserService sysUserService;


    @Override
    public Object getAuthList(SceneParam param) {
        if(StringUtils.isBlank(param.getNum())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }

        ScenePro pro = sceneProService.getByNum(param.getNum());
        ScenePlus plus = scenePlusService.getByNum(param.getNum());
        if(pro == null && plus == null){
            throw new BusinessException(ResultCode.SCENE_NOT_EXIST);
        }
        Long sceneUserId = pro  == null ? plus.getUserId(): pro.getUserId();

        SysUser byId = sysUserService.getById(Long.valueOf(StpUtil.getLoginId().toString()));
        JyUser loginUser = jyUserService.getBySysId(byId.getId());


        JySceneAuth jySceneAuth = jySceneAuthService.getByNum(param.getNum());
        if(jySceneAuth == null ){
            return new JySceneAuth(0);
        }


        LambdaQueryWrapper<JySceneUserAuth> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(JySceneUserAuth::getNum,param.getNum());
        if(!sceneUserId.equals(loginUser.getUserId())){
            List<Integer> ids = new ArrayList<>();
            getSubAuthorIdsById(loginUser.getId(),param.getNum(),ids);
            if(ids.size()<=0){
                return jySceneAuth;
            }
            wrapper.in(JySceneUserAuth::getAuthorId,ids);
        }
        wrapper.orderByDesc(JySceneUserAuth::getCreateTime);
        Page<JySceneUserAuth> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);

        List<Integer> jyUserIds = page.getRecords().stream().map(JySceneUserAuth::getJyUserId).collect(Collectors.toList());
        HashMap<Integer, JyUser> map = jyUserService.getByIds(jyUserIds);

        for (JySceneUserAuth jySceneUserAuth : page.getRecords()) {
            JyUser jyUser = map.get(jySceneUserAuth.getJyUserId());
            if(jyUser != null){
                jySceneUserAuth.setRyId(jyUser.getRyId());
                jySceneUserAuth.setRyNickName(jyUser.getRyNickName());
            }

        }
        jySceneAuth.setPageInfo(PageInfo.PageInfo(page));
        return jySceneAuth;
    }

    private void getSubAuthorIdsById(Integer id,String num,List<Integer> ids) {
        ids.add(id);
        LambdaQueryWrapper<JySceneUserAuth> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(JySceneUserAuth::getNum,num);
        wrapper.eq(JySceneUserAuth::getAuthorId,id);
        List<JySceneUserAuth> list = this.list(wrapper);
        if(list.size() >0){
            for (JySceneUserAuth auth : list) {
                ids.add(auth.getAuthorId());
                getSubAuthorIdsById(auth.getId(),num,ids);
            }
        }
    }


    @Override
    public void setAuthType(JySceneUserAuth param) {
        if(StringUtils.isBlank(param.getNum()) || param.getAuthType() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        ScenePro pro = sceneProService.getByNum(param.getNum());
        ScenePlus plus = scenePlusService.getByNum(param.getNum());
        if(pro == null && plus == null){
            throw new BusinessException(ResultCode.SCENE_NOT_EXITS);
        }

        jySceneAuthService.updateAuthTypeByNum(param.getNum(),param.getAuthType());
    }

    @Override
    public void addAuth(JySceneUserAuth param) {
        if(StringUtils.isBlank(param.getNum()) ){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        ScenePro pro = sceneProService.getByNum(param.getNum());
        ScenePlus plus = scenePlusService.getByNum(param.getNum());
        if(pro == null && plus == null){
            throw new BusinessException(ResultCode.SCENE_NOT_EXITS);
        }


        if(StringUtils.isBlank(param.getRyId()) ){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyUser = jyUserService.getByRyId(param.getRyId());
        if(jyUser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }
        Long sceneUserId = pro == null ? plus.getUserId():pro.getUserId();

        if(sceneUserId.equals(jyUser.getUserId())){
            throw new BusinessException(ResultCode.AUTH_ERROR);
        }
        JyUser sceneJyUser = jyUserService.getByUserId(sceneUserId);

        JySceneUserAuth auth = this.getByNumAndJyUserId(jyUser.getId(),param.getNum());
        if(auth != null){
            param.setId(auth.getId());
        }
        param.setJyUserId(jyUser.getId());
        param.setAuthorId(sceneJyUser.getId());
        this.saveOrUpdate(param);

    }



    @Override
    public void delAuth(JySceneUserAuth param) {
        if(param.getId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        this.removeById(param.getId());
    }

    @Override
    public JySceneUserAuth getByNumAndJyUserId(Integer jyUserId, String num) {
        LambdaQueryWrapper<JySceneUserAuth> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(JySceneUserAuth::getJyUserId,jyUserId);
        wrapper.eq(JySceneUserAuth::getNum,num);
        return this.getOne(wrapper);
    }

    @Override
    public JySceneUserAuth getByNumAndRyId(String num, String ryId) {
        JyUser jyUser = jyUserService.getByRyId(ryId);
        if(jyUser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }
        return this.getByNumAndJyUserId(jyUser.getId(),num);
    }

    @Override
    public Object checkAuthOther(JySceneUserAuth param) {
        if(StringUtils.isBlank(param.getNum())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        ScenePro pro = sceneProService.getByNum(param.getNum());
        ScenePlus plus = scenePlusService.getByNum(param.getNum());
        if(pro == null && plus == null){
            throw new BusinessException(ResultCode.SCENE_NOT_EXITS);
        }
        Long sceneUserId = pro == null ? plus.getUserId() :pro.getUserId();
        CheckOtherVo vo = new CheckOtherVo();
        SysUser byId = sysUserService.getById(Long.valueOf(StpUtil.getLoginId().toString()));
        JyUser jyUser = jyUserService.getBySysId(byId.getId());
        if( byId.getRoleId() == 1L || byId.getRoleId() ==45L ||  jyUser.getUserId().equals(sceneUserId)){
            vo.setIsAuthor(1);
            vo.setEditAuth(1);
            vo.setLookAuth(1);
        }else {
            JySceneUserAuth auth = jySceneUserAuthService.getByNumAndJyUserId(jyUser.getId(), param.getNum());
            if(auth !=null){
                if(auth.getCanAuthLook() == 1 ){
                    vo.setLookAuth(auth.getLookAuth());
                    vo.setLookEndTime(auth.getLookEndTime());
                }
                if(auth.getCanEditLook() == 1){
                    vo.setEditAuth(auth.getEditAuth());
                    vo.setEditEndTime(auth.getEditEndTime());
                }
            }
        }
        return vo;
    }

    @Autowired
    RedisUtil redisUtil;
    @Autowired
    IJySceneUserAuthService jySceneUserAuthService;

    @Override
    public Object checkNumAuth(String num,String token) {
        if(StringUtils.isBlank(num)){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        ScenePro pro = sceneProService.getByNum(num);
        ScenePlus plus = scenePlusService.getByNum(num);
        if(pro == null && plus == null){
            throw new BusinessException(ResultCode.SCENE_NOT_EXITS);
        }
        String redisKey = String.format(RedisKeyUtil.loginToken,token);
        if(!redisUtil.hasKey(redisKey)){
            throw new BusinessException(ResultCode.USER_NOT_LOGIN);
        }
        String userStr = redisUtil.get(redisKey);
        ManageLoginResponse result = JSONObject.parseObject(userStr,ManageLoginResponse.class);
        Long userId = result.getUserId();
        if(userId == null){
            redisUtil.del(redisKey);
            throw new BusinessException(ResultCode.USER_NOT_LOGIN);
        }
        SceneAuthVo sceneAuthVo = new SceneAuthVo();

        JySceneAuth jySceneAuth = jySceneAuthService.getByNum(num);
        if(jySceneAuth!=null && jySceneAuth.getAuthType() == 1){
            sceneAuthVo.setViewAuth(true);
        }

        SysUser byId = sysUserService.getById(result.getId());
        JyUser jyUser = jyUserService.getBySysId(byId.getId());
        JySceneUserAuth jySceneUserAuth = jySceneUserAuthService.getByNumAndJyUserId(jyUser.getId(), num);
        if(jySceneAuth != null && jySceneUserAuth !=null){
            Date date = new Date();
            if(jySceneUserAuth.getLookAuth() == 1 ||
                    ( jySceneUserAuth.getLookAuth() == 2 && jySceneUserAuth.getLookEndTime().getTime() >date.getTime())){
                sceneAuthVo.setViewAuth(true);
            }
            if(jySceneUserAuth.getEditAuth() == 1 ||
                    (jySceneUserAuth.getEditAuth() == 2 && jySceneUserAuth.getEditEndTime().getTime() >date.getTime())){
                sceneAuthVo.setEditAuth(true);
            }
        }

        if(pro != null && jyUser.getUserId().equals(pro.getUserId())){
            sceneAuthVo.setViewAuth(true);
            sceneAuthVo.setEditAuth(true);
        }
        if(plus != null && jyUser.getUserId().equals(plus.getUserId())){
            sceneAuthVo.setViewAuth(true);
            sceneAuthVo.setEditAuth(true);
        }

        return sceneAuthVo;
    }

    @Override
    public List<JySceneUserAuth> getByJyUserId(Integer jyUserId) {
        LambdaQueryWrapper<JySceneUserAuth> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(JySceneUserAuth::getJyUserId,jyUserId);
        return this.list(wrapper);
    }
}