package com.fdkankan.site.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.site.common.PageInfo;
import com.fdkankan.site.common.ResultCode;
import com.fdkankan.site.common.util.DateUtils;
import com.fdkankan.site.common.util.JwtUtil;
import com.fdkankan.site.common.util.VUtils;
import com.fdkankan.site.entity.*;
import com.fdkankan.site.entity.dto.MarkingDTO;
import com.fdkankan.site.entity.dto.ProjectTeamDTO;
import com.fdkankan.site.exception.BusinessException;
import com.fdkankan.site.httpClient.bim.BusinessStatus;
import com.fdkankan.site.mapper.IProjectMapper;
import com.fdkankan.site.request.ProjectAddSceneParam;
import com.fdkankan.site.request.ProjectDelSceneParam;
import com.fdkankan.site.request.ProjectListParam;
import com.fdkankan.site.request.SceneNumParam;
import com.fdkankan.site.response.ProjectInfoVo;
import com.fdkankan.site.response.ProjectVo;
import com.fdkankan.site.response.SceneVo;
import com.fdkankan.site.response.UserData;
import com.fdkankan.site.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.site.util.EscapeUtil;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-10-10
 */
@Service
public class ProjectServiceImpl extends ServiceImpl<IProjectMapper, Project> implements IProjectService {

    @Autowired
    IProjectNumService projectNumService;
    @Autowired
    IProjectTeamService projectTeamService;
    @Autowired
    IProjectBimService projectBimService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    IProjectLogService projectLogService;
    @Autowired
    IUserService userService;
    @Autowired
    IUserRoleService userRoleService;
    @Autowired
    IRoleService roleService;
    @Autowired
    IMarkingService markingService;
    @Override
    public Object getUserData(String token) {
        UserData userData = new UserData();
        User user = userService.findByTokenCovUserName(token);
        List<ProjectTeam> teamList = projectTeamService.getListByUserId(user.getUserId());
        Set<Integer> projectIds = teamList.parallelStream().map(ProjectTeam::getProjectId).collect(Collectors.toSet());
        List<ProjectNum> numList = projectNumService.getListByProjectIds(projectIds);
        Integer projectCount = 0;
        Long overCount = 0L;
        Long bimCount = 0L;
        if(projectIds.size() >0){
            LambdaQueryWrapper<Project> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(Project::getProjectId,projectIds);
            List<Project> list = this.list(wrapper);
            projectCount = list.size();
            for (Project project : list) {
                if(project.getProjectStatus() == 1){
                    overCount ++;
                }
            }
            LambdaQueryWrapper<ProjectBim> bimWr = new LambdaQueryWrapper<>();
            bimWr.in(ProjectBim::getProjectId,projectIds);
            bimCount = projectBimService.count(bimWr);
        }
        userData.setProjectCount(Long.valueOf(projectCount));
        userData.setProjectSceneCount((long) numList.size() + bimCount);
        userData.setProjectOverCount(overCount);
        return userData;
    }

    @Override
    public Object pageList(ProjectListParam param, String token) {
        User user = userService.findByTokenCovUserName(token);
        List<ProjectTeam> projectTeamList = projectTeamService.getListByUserId(user.getUserId());
        Set<Integer> projectIdSet = projectTeamList.stream().map(ProjectTeam::getProjectId).collect(Collectors.toSet());
        if(projectIdSet.size() <=0){
            Page<ProjectVo> voPage = new Page<>(param.getPageNum(), param.getPageSize());
            voPage.setTotal(0);
            voPage.setRecords(new ArrayList<>());
            return PageInfo.PageInfo(voPage);
        }


        MPJLambdaWrapper<Project> wrapper = new MPJLambdaWrapper<Project>()
                .selectAll(Project.class)
                .select(User::getUserName)
                .selectAs(User::getUserName, ProjectVo::getProjectCreater)//别名
                .leftJoin(ProjectTeam.class,ProjectTeam::getProjectId,Project::getProjectId)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .eq(ProjectTeam::getIsCreater,1)
                .orderByDesc(Project::getCreateTime);
        ;

        wrapper.in(Project::getProjectId,projectIdSet);
        if(StringUtils.isNotBlank(param.getProjectName())){
            wrapper.like(Project::getProjectName,param.getProjectName());
        }
        if(StringUtils.isNotBlank(param.getStartTime())){
            wrapper.ge(Project::getCreateTime,param.getStartTime());
        }
        if(StringUtils.isNotBlank(param.getEndTime())){
            wrapper.le(Project::getCreateTime,param.getEndTime());
        }
        if(param.getProjectStatus() !=null){
            wrapper.eq(Project::getProjectStatus,param.getProjectStatus());
        }
        if(StrUtil.isNotEmpty(param.getProjectCreater())){
            wrapper.like(User::getUserName, EscapeUtil.escapeChar(param.getProjectCreater()));
        }
//        if(StringUtils.isNotBlank(param.getProjectCreater())){
//            Set<Integer> projectIds = projectTeamService.getProjectIdByCreater(param.getProjectCreater());
//            if(projectIds.size() >0){
//                wrapper.in(Project::getProjectId,projectIds);
//            }
//        }
        IPage<ProjectVo> page = baseMapper.selectJoinPage(new Page<>(param.getPageNum(), param.getPageSize()), ProjectVo.class, wrapper);
        return PageInfo.PageInfo(page);

    }

    @Override
    public ProjectInfoVo getProjectInfo(Integer projectId,String sceneOrder,String token) {
        VUtils.isTure(projectId == null).throwMessage(ResultCode.PARAM_MISS);
        Project project = this.getById(projectId);
        VUtils.isTure(project == null).throwMessage(ResultCode.PROJECT_NOT_EXIST);
        if(StringUtils.isNotBlank(token) && StringUtils.isBlank(sceneOrder)){
            checkTokenPer(token, projectId);
        }
        ProjectInfoVo infoVo = new ProjectInfoVo();
        BeanUtils.copyProperties(project,infoVo);
        ProjectTeamDTO projectCreater = projectTeamService.getProjectCreater(projectId);
        if(projectCreater!= null){
            infoVo.setProjectCreater(projectCreater.getUserName());
        }
        List<SceneVo> sceneList = this.getSceneList(projectId);
        if(StringUtils.isNotBlank(sceneOrder) && sceneOrder.equals("asc")){
            sceneList= sceneList.stream().sorted(Comparator.comparing(SceneVo::getCreateTime)).collect(Collectors.toList());
        }else if (StringUtils.isNotBlank(sceneOrder) && sceneOrder.equals("desc")){
            sceneList=sceneList.stream().sorted(Comparator.comparing(SceneVo::getCreateTime,Comparator.reverseOrder())).collect(Collectors.toList());
        }
        infoVo.setSceneList(sceneList);
        ProjectBim bim = null;
        List<ProjectBim> projectBims = projectBimService.getByProjectId(projectId);
        for (ProjectBim projectBim : projectBims) {
            if(!projectBim.getBimStatus().equals(BusinessStatus.ERROR.getInfo())) {
                bim = projectBim;
            }
        }
        infoVo.setBimData(bim);
        return infoVo;
    }

    @Override
    public void over(Project param,String token) {
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        checkTokenPer(token, param.getProjectId());

        LambdaUpdateWrapper<Project> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Project::getProjectId,param.getProjectId())
                .set(Project::getProjectStatus,1);
        this.update(wrapper);
    }

    @Override
    public List<SceneVo> getSceneList(Integer projectId) {
        Set<Integer> projectIds = new HashSet<>(Arrays.asList(projectId));
        List<ProjectNum> projectNums = projectNumService.getListByProjectIds(projectIds);

        HashMap<Integer,List<String>> typeMap = projectNumService.getTypeMap(projectNums);
        List<SceneVo> list = new ArrayList<>();
        if(typeMap.size() >0){
            list = sceneService.getListByNumMap(typeMap);
        }
        return list;
    }


    @Override
    public Project addProject(Project param, String token) {
        VUtils.isTure(StringUtils.isBlank(param.getProjectName()) ).throwMessage(ResultCode.PARAM_MISS);
        Project project = new Project();
        BeanUtils.copyProperties(param,project);
        this.save(project);
        projectTeamService.addProject(project.getProjectId(),token);
        return project;
    }

    @Override
    public void addScene(ProjectAddSceneParam param) {
        Project project = this.getById(param.getProjectId());
        VUtils.isTure(project == null).throwMessage(ResultCode.PROJECT_NOT_EXIST);
        checkTokenPer(param.getToken(), param.getProjectId());

        Set<Integer> projectIds = new HashSet<>(Arrays.asList(param.getProjectId()));
        List<ProjectNum> projectNums = projectNumService.getListByProjectIds(projectIds);
        List<String> hasNumList = projectNums.stream().map(ProjectNum::getNum).collect(Collectors.toList());

        List<String> paramNumList = new ArrayList<>();
        HashMap<String, Integer> numType = new HashMap<>();
        List<SceneNumParam> sceneNumParam = param.getSceneNumParam();
        for (SceneNumParam numParam : sceneNumParam) {
            if(numParam.getNumList() == null || numParam.getNumList().size() <=0){
                continue;
            }
            for (String num : numParam.getNumList()) {
                numType.put(num,numParam.getType());
            }
            paramNumList.addAll(numParam.getNumList());
        }
        List<String> delNumList = new ArrayList<>();
        for (String num : hasNumList) {
            if(!paramNumList.contains(num)){
                delNumList.add(num);
            }
        }
        List<String> addNumList = new ArrayList<>();
        for (String num : paramNumList) {
            if(!hasNumList.contains(num)){
                addNumList.add(num);
            }
        }
        Set<String> numList = projectNumService.getNumList();
        for (String num : addNumList) {
            if(numList.contains(num)){
                throw new BusinessException(ResultCode.SCENE_BIND.code,num +ResultCode.SCENE_BIND.msg);
            }
        }

        if(delNumList.size() >0){
            projectNumService.delByNumList(param.getProjectId(),delNumList);
            projectLogService.addLog(param.getProjectId(),"シーンの削除",param.getToken(),delNumList);
        }
        if(addNumList.size() >0){
            projectNumService.addByNumList(param.getProjectId(),numType,addNumList);
            projectLogService.addLog(param.getProjectId(),"シーンの追加",param.getToken(),addNumList);
        }
        this.updateTime(project.getProjectId());
    }

    @Override
    public void delScene(ProjectDelSceneParam param) {
        Project project = this.getById(param.getProjectId());
        VUtils.isTure(project == null).throwMessage(ResultCode.PARAM_MISS);
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        checkTokenPer(param.getToken(), param.getProjectId());

        VUtils.isTure(StringUtils.isBlank(param.getNum())).throwMessage(ResultCode.PARAM_MISS);
        projectNumService.delByNumList(param.getProjectId(),Arrays.asList(param.getNum()));
        projectLogService.addLog(param.getProjectId(),"シーンの削除",param.getToken(),Arrays.asList(param.getNum()));
        this.updateTime(project.getProjectId());

        List<Marking> markings = markingService.findByProjectIdAndNum(project.getProjectId(),param.getNum());
        for (Marking marking : markings) {
            markingService.delMarking(marking.getMarkingId(),param.getToken());
         }
    }

    @Override
    public void deleteBim(Integer bimId,String token) {

        ProjectBim bim = projectBimService.getById(bimId);
        if(bim != null){
            checkTokenPer(token, bim.getProjectId());
            projectLogService.addLog(bim.getProjectId(),"BIMの削除:"+bim.getBimName(),token,null);
            projectBimService.removeById(bimId);
            this.updateTime(bim.getProjectId());
        }
    }

    @Override
    public HashMap<Integer, Project> getByIds(Set<Integer> projectIds) {
        HashMap<Integer, Project> map = new HashMap<>();
        if(projectIds.size() >0){
            LambdaQueryWrapper<Project> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(Project::getProjectId,projectIds);
            List<Project> list = this.list(wrapper);
            list.forEach(entity -> map.put(entity.getProjectId(),entity));
        }
        return map;
    }

    @Override
    public HashMap<Integer, Project> getAndDelByIds(Set<Integer> projectIds) {
        HashMap<Integer, Project> map = new HashMap<>();
        if(projectIds.size() >0){
            List<Project> list = this.getBaseMapper().getAndDelByIds(projectIds);
            list.forEach(entity -> map.put(entity.getProjectId(),entity));
        }
        return map;
    }

    @Override
    public void updateName(Project param,String token) {

        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        checkTokenPer(token, param.getProjectId());

        LambdaUpdateWrapper<Project> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Project::getProjectId,param.getProjectId());
        if(StringUtils.isNotBlank(param.getProjectName())){
            wrapper.set(Project::getProjectName,param.getProjectName());
        }
        if(StringUtils.isNotBlank(param.getProjectMsg())){
            wrapper.set(Project::getProjectMsg,param.getProjectMsg());
        }
        if(StringUtils.isNotBlank(param.getProjectImg())){
            wrapper.set(Project::getProjectImg,param.getProjectImg());
        }
        this.update(wrapper);
    }

    @Override
    public void updateBimName(ProjectBim projectBim,String token) {
        ProjectBim bim = projectBimService.getById(projectBim.getBimId());
        checkTokenPer(token, bim.getProjectId());
        projectBimService.updateBimName(projectBim);
        this.updateTime(bim.getProjectId());
        projectLogService.addLog(bim.getProjectId(),"BIM名の変更:"+projectBim.getBimName(),token,null);

    }

    @Override
    public void updatePanos(Project param,String token) {
        checkTokenPer(token, param.getProjectId());
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        VUtils.isTure(StringUtils.isBlank(param.getPanos())).throwMessage(ResultCode.PARAM_MISS);

        LambdaUpdateWrapper<Project> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Project::getProjectId,param.getProjectId());
        if(StringUtils.isNotBlank(param.getPanos())){
            wrapper.set(Project::getPanos,param.getPanos());
        }
        this.update(wrapper);
        this.updateTime(param.getProjectId());
        projectLogService.addLog(param.getProjectId(),"BIM位置の同期",token,null);

    }

    @Override
    public void delProject(Integer projectId, String token) {
        checkTokenPer(token, projectId);
        Project project = this.getById(projectId);
        if(project == null){
            throw new BusinessException(ResultCode.PROJECT_NOT_EXIST);
        }
        projectNumService.delByProjectId(projectId,token);
        projectBimService.delByProjectId(projectId,token);
        this.removeById(projectId);

        userRoleService.delUserRole(null,projectId);
        roleService.delRoleByProjectId(projectId);
        //projectLogService.addLog(project.getProjectId(),"删除项目:"+project.getProjectName(),token,null);
    }

    @Override
    public void updateTime(Integer projectId) {
        LambdaUpdateWrapper<Project> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Project::getProjectId,projectId);
        wrapper.set(Project::getUpdateTime, DateUtils.getData(new Date()));
        this.update(wrapper);
    }

    @Override
    public void checkTokenPer(String token,Integer projectId){
        User user = userService.findByTokenCovUserName(token);
        List<ProjectTeam> teamList = projectTeamService.getListByUserIdAndProjectId(user.getUserId(),projectId);
        if(CollectionUtil.isEmpty(teamList)){
            throw new BusinessException(ResultCode.NOT_PERM);
        }
    }

    @Override
    public void checkProjectPer(String userName, Integer projectId) {
        User user = userService.findByUserName(userName);
        List<ProjectTeam> teamList = projectTeamService.getListByUserIdAndProjectId(user.getUserId(),projectId);
        if(CollectionUtil.isEmpty(teamList)){
            throw new BusinessException(ResultCode.NOT_PERM);
        }
    }
}