package com.fdkankan.jp.xspace.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.common.constant.RecStatus;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.jp.xspace.common.PageInfo;
import com.fdkankan.jp.xspace.common.Result;
import com.fdkankan.jp.xspace.common.ResultCode;
import com.fdkankan.jp.xspace.common.constant.OSSPathConstant;
import com.fdkankan.jp.xspace.common.exception.BusinessException;
import com.fdkankan.jp.xspace.common.rabbitmq.RabbitmqConstant;
import com.fdkankan.jp.xspace.common.rabbitmq.dto.SceneXspaceMqDTO;
import com.fdkankan.jp.xspace.dto.XspacePageDTO;
import com.fdkankan.jp.xspace.entity.ScenePlus;
import com.fdkankan.jp.xspace.entity.SceneXspace;
import com.fdkankan.jp.xspace.entity.User;
import com.fdkankan.jp.xspace.mapper.ISceneXspaceMapper;
import com.fdkankan.jp.xspace.service.IScenePlusService;
import com.fdkankan.jp.xspace.service.ISceneXspaceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.jp.xspace.service.IUserRoleService;
import com.fdkankan.jp.xspace.service.IUserService;
import com.fdkankan.jp.xspace.common.util.UniqueStringGenerator;
import com.fdkankan.jp.xspace.vo.XspaceVO;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 * xspace同步表 服务实现类
 * </p>
 *
 * @author
 * @since 2024-07-22
 */
@RefreshScope
@Service
public class SceneXspaceServiceImpl extends ServiceImpl<ISceneXspaceMapper, SceneXspace> implements ISceneXspaceService {

    @Value("${webSiteFormat}")
    private String webSiteFormat;

    @Autowired
    private IUserRoleService userRoleService;
    @Autowired
    private IUserService userService;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private RabbitMqProducer mqProducer;
    @Resource
    private FYunFileServiceInterface fYunFileService;

    @Override
    public PageInfo pageXspace(XspacePageDTO param, User user) {
        Set<Long> roleIds = userRoleService.getByUser(user);
        if(!roleIds.contains(5L)){//平台管理员可以看到所有
            if(roleIds.contains(6L)){//公司管理员可以看到同一公司下所有
                param.setCompanyId(user.getCompanyId());
            }else{//普通员工只能看到自己的
                param.setUserId(user.getId());
            }
        }
        Page<XspaceVO> xspaceVOPage = this.baseMapper.pageXspace(new Page(param.getPageNum(), param.getPageSize()), param);
        xspaceVOPage.getRecords().stream().forEach(v->{
            v.setWebSite(String.format(webSiteFormat, v.getNum(), v.getSerial()));
        });
        return PageInfo.PageInfo(xspaceVOPage);
    }

    @Override
    public Result delete(List<Long> ids, User user) {

        List<SceneXspace> sceneXspaces = this.listByIds(ids);
        if(CollUtil.isEmpty(sceneXspaces)){
            return Result.success();
        }
        //校验数据
        Set<Long> userIds = sceneXspaces.stream().map(x -> x.getUserId()).collect(Collectors.toSet());
        Set<Long> roleIds = userRoleService.getByUser(user);
        boolean notPermission = false;
        if(!roleIds.contains(5L)){//平台管理员可以看到所有
            if(roleIds.contains(6L)){//公司管理员可以看到同一公司下所有
                List<User> users = userService.listByIds(userIds);
                notPermission = users.stream().anyMatch(u -> !u.getCompanyId().equals(user.getCompanyId()));
            }else{//普通员工只能删除自己的
                notPermission = userIds.stream().anyMatch(id -> !id.equals(user.getId()));
            }
        }
        if(notPermission){
            return Result.failure(ResultCode.NOT_PERMISSION);
        }

        sceneXspaces.stream().forEach(x->{
            x.setUpdater(user.getId());
            x.setRecStatus(RecStatus.DISABLE.code());
            this.updateById(x);
            this.removeById(x.getId());

            String xspaceSceneKey = String.format(OSSPathConstant.XSPACE_SCENE_FORMAT, x.getNum(), x.getSerial());
            fYunFileService.deleteFolder(xspaceSceneKey);
        });

        return Result.success();
    }

    @Override
    public Result sync(List<String> nums, User user) {

//        List<String> canSyncList = nums;//实际需要同步的场景集合
//        if(CollUtil.isNotEmpty(syncList)){
//            List<String> doneNumsList = syncList.stream().map(v -> v.getNum()).collect(Collectors.toList());
//            canSyncList = nums.stream().filter(v->!doneNumsList.contains(v)).collect(Collectors.toList());
//        }
//        if(CollUtil.isEmpty(canSyncList)){
//            return  Result.success();
//        }

        List<ScenePlus> scenePlusList = scenePlusService.list(new LambdaQueryWrapper<ScenePlus>().in(ScenePlus::getNum, nums));//.eq(ScenePlus::getUserId, user.getId());
        if(CollUtil.isEmpty(scenePlusList)){
            return Result.success();
        }

        //过滤掉已同步的场景，防止前端传参错误
        List<SceneXspace> syncList = this.list(new LambdaQueryWrapper<SceneXspace>().in(SceneXspace::getNum, nums));
        if(CollUtil.isNotEmpty(syncList)){
            Set<String> doneSet = syncList.stream().map(v -> v.getNum() + "-" + v.getUserId()).collect(Collectors.toSet());
            scenePlusList = scenePlusList.stream().filter(v -> {
                String userId = v.getUserId() == null ? "" : String.valueOf(v.getUserId());
                return !doneSet.contains(v.getNum() + "-" + userId);
            }).collect(Collectors.toList());
        }

        //平台管理员：能查看全部场景数据并且支持同步全部得数据 (平台管理员同步后的场景还是归属于之前这个场景的归属者)
        //公司管理员：仅能看到自己的场景并且同步自己的场景数据
        //公司员工：仅能看到自己的场景并且同步自己的场景数据
        Set<Long> roleIds = userRoleService.getByUser(user);
        if(!roleIds.contains(5L)){
            List<String> notPermisionNums = scenePlusList.stream().filter(p->!p.getUserId().equals(user.getId())).map(p->p.getNum()).collect(Collectors.toList());
            if(CollUtil.isNotEmpty(notPermisionNums)){
                throw new BusinessException(ResultCode.NOT_PERMISSION.code(), JSON.toJSONString(notPermisionNums));
            }
        }


        List<SceneXspace> sceneXspaceList = scenePlusList.stream().map(p -> {
            SceneXspace sceneXspace = new SceneXspace();
            sceneXspace.setNum(p.getNum());
            sceneXspace.setUserId(p.getUserId());
            sceneXspace.setSerial(UniqueStringGenerator.getUniqueString());
            sceneXspace.setCreator(user.getId());
            return sceneXspace;
        }).collect(Collectors.toList());

        this.saveBatch(sceneXspaceList);
        sceneXspaceList.stream().forEach(v->{
            mqProducer.sendByWorkQueue(RabbitmqConstant.QUEUE_PACK_XSPACE, v);
        });

        return Result.success();
    }

    @Override
    public SceneXspace getByNumAndUserId(String num, long userId) {
        return this.getOne(new LambdaQueryWrapper<SceneXspace>().eq(SceneXspace::getNum, num).eq(SceneXspace::getUserId, userId));
    }
}