package com.fdkankan.site.service.impl;

import com.alibaba.fastjson.JSONObject;
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.site.common.PageInfo;
import com.fdkankan.site.common.ResultCode;
import com.fdkankan.site.common.util.JwtUtil;
import com.fdkankan.site.common.util.VUtils;
import com.fdkankan.site.entity.Project;
import com.fdkankan.site.entity.ProjectBim;
import com.fdkankan.site.entity.ProjectNum;
import com.fdkankan.site.entity.ProjectTeam;
import com.fdkankan.site.exception.BusinessException;
import com.fdkankan.site.httpClient.bim.BusinessStatus;
import com.fdkankan.site.httpClient.client.FdKKClient;
import com.fdkankan.site.httpClient.response.FdkkResponse;
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 org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
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;

    @Override
    public Object getUserData(String token) {
        UserData userData = new UserData();

        String userName = JwtUtil.getUserName(token);
        List<ProjectTeam> teamList = projectTeamService.getListByUserName(userName);
        Set<Integer> projectIds = teamList.parallelStream().map(ProjectTeam::getProjectId).collect(Collectors.toSet());
        List<ProjectNum> numList = projectNumService.getListByProjectIds(projectIds);
        long count = 0L;
        if(projectIds.size() >0){
            LambdaQueryWrapper<Project> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(Project::getProjectId,projectIds);
            wrapper.eq(Project::getProjectStatus,1);
            count = this.count(wrapper);
        }

        userData.setProjectCount((long) projectIds.size());
        userData.setProjectSceneCount((long) numList.size());
        userData.setProjectOverCount(count);
        return userData;
    }

    @Override
    public Object pageList(ProjectListParam param, String token) {
        String userName = JwtUtil.getUserName(token);
        List<ProjectTeam> projectTeamList = projectTeamService.getListByUserName(userName);
        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);
        }
        LambdaQueryWrapper<Project> wrapper = new LambdaQueryWrapper<>();
        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(StringUtils.isNotBlank(param.getProjectCreater())){
            Set<Integer> projectIds = projectTeamService.getProjectIdByCreater(param.getProjectCreater());
            if(projectIds.size() >0){
                wrapper.in(Project::getProjectId,projectIds);
            }
        }

        wrapper.orderByDesc(Project::getCreateTime);

        Page<Project> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        Set<Integer> projectIds = page.getRecords().stream().map(Project::getProjectId).collect(Collectors.toSet());
        HashMap<Integer,String> createrMap = projectTeamService.getProjectCreaterMap(projectIds);
        List<ProjectVo> voList = new ArrayList<>();
        for (Project record : page.getRecords()) {
            ProjectVo projectVo = new ProjectVo();
            BeanUtils.copyProperties(record,projectVo);
            projectVo.setProjectCreater(createrMap.get(record.getProjectId()));
            voList.add(projectVo);
        }
        Page<ProjectVo> voPage = new Page<>(param.getPageNum(), param.getPageSize());
        voPage.setTotal(page.getTotal());
        voPage.setRecords(voList);
        return PageInfo.PageInfo(voPage);
    }

    @Override
    public ProjectInfoVo getProjectInfo(Integer projectId) {
        VUtils.isTure(projectId == null).throwMessage(ResultCode.PARAM_MISS);
        Project project = this.getById(projectId);
        VUtils.isTure(project == null).throwMessage(ResultCode.PROJECT_NOT_EXIST);
        ProjectInfoVo infoVo = new ProjectInfoVo();
        BeanUtils.copyProperties(project,infoVo);
        ProjectTeam projectCreater = projectTeamService.getProjectCreater(projectId);
        if(projectCreater!= null){
            infoVo.setProjectCreater(projectCreater.getUserName());
        }

        infoVo.setSceneList(this.getSceneList(projectId));
        ProjectBim bim = null;
        List<ProjectBim> projectBims = projectBimService.getByProjectId(projectId);
        for (ProjectBim projectBim : projectBims) {
            if(projectBim.getBimStatus().equals(BusinessStatus.DONE.getInfo()) ||
                projectBim.getBimStatus().equals(BusinessStatus.UPLOAD.getInfo())){
                bim = projectBim;
            }
        }
        infoVo.setBimData(bim);
        return infoVo;
    }

    @Override
    public void over(Project param) {
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        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.PARAM_MISS);

        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);
        }
        project.setUpdateTime(null);
        this.updateById(project);
    }

    @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);
        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()));
        project.setUpdateTime(null);
        this.updateById(project);
    }

    @Override
    public void deleteBim(Integer bimId,String token) {
        ProjectBim bim = projectBimService.getById(bimId);
        if(bim != null){
            projectLogService.addLog(bim.getProjectId(),"删除BIM:"+bim.getBimName(),token,null);
            projectBimService.removeById(bimId);
        }
    }

    @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) {
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);

        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) {
        projectBimService.updateBimName(projectBim);
        projectLogService.addLog(projectBim.getProjectId(),"修改BIM名称:"+projectBim.getBimName(),token,null);

    }

    @Override
    public void updatePanos(Project param) {
        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);
    }
}