package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.PatentDigProjectFilesDTO;
import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.business.PatentDigProjectFilesVO;
import cn.cslg.pas.domain.business.PatentDigProjectFiles;
import cn.cslg.pas.domain.business.ProjectTask;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.PatentDigProjectFilesMapper;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 专利挖掘项目文件Service层
 * @Author xiexiang
 * @Date 2023/11/8
 */
@Service
public class PatentDigProjectFilesService extends ServiceImpl<PatentDigProjectFilesMapper, PatentDigProjectFiles> implements Business {

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private PatentDigProjectFilesMapper patentDigProjectFilesMapper;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    @Lazy
    private ProjectTaskService projectTaskService;


    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        //根据专题库/报告id查询自定义栏位
        List<String> sqls = formatQueryService.reSqls(queryRequest,"patentDigProjectFiles");
        //根据sql查询自定义栏位信息
        List<PatentDigProjectFilesVO> patentDigProjectFilesVOS = patentDigProjectFilesMapper.getPatentDigProjectFiles(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = patentDigProjectFilesMapper.getPatentDigProjectFilesCount(sqls.get(0));
        //装载自定义栏位信息
        this.loadPatentDigProjectFiles(patentDigProjectFilesVOS);
        //装载返回信息
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(patentDigProjectFilesVOS);
        records.setTotal(total);
        return records;
    }

    @Override
    public Object addMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        if (!ids.isEmpty()) {
            this.removeBatchByIds(ids);
        }
        return ids;
    }

    @Override
    public Object updateMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        return null;
    }

    /**
     * 新增专利挖掘项目文件
     * @param object
     * @return
     */
    @Override
    public Object addMessage(Object object) {
        //object to patentDigProjectFilesDTO
        PatentDigProjectFilesDTO patentDigProjectFilesDTO = (PatentDigProjectFilesDTO) object;
        //判断projectId是否为空
        if (patentDigProjectFilesDTO.getProjectId() == null) {
            throw new XiaoShiException("projectId不能为空");
        }
        //判断processId是否为空
        if (patentDigProjectFilesDTO.getProcessId() == null) {
            throw new XiaoShiException("processId不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        List<Integer> ids = new ArrayList<>();

        if (patentDigProjectFilesDTO.getFileGuids() != null && !patentDigProjectFilesDTO.getFileGuids().isEmpty()){
            List<String> fileGuids = patentDigProjectFilesDTO.getFileGuids();
            List<SystemFile> systemFiles = new ArrayList<>();
            List<PatentDigProjectFiles> patentDigProjectFilesS = new ArrayList<>();
            //调用文件系统查询文件信息接口
            if (fileGuids.size() != 0) {
                try {
                    String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                    systemFiles = JSONObject.parseArray(res, SystemFile.class);
                    if (systemFiles.size() != 0) {
                        for (String item : fileGuids) {
                            SystemFile systemFile = systemFiles.stream().filter(item1 -> item1.getGuid().equals(item)).findFirst().orElse(null);
                            PatentDigProjectFiles patentDigProjectFiles = new PatentDigProjectFiles();
                            BeanUtils.copyProperties(patentDigProjectFilesDTO, patentDigProjectFiles);
                            patentDigProjectFiles.setFileGuid(item);
                            patentDigProjectFiles.setName(systemFile.getOriginalName());
                            patentDigProjectFiles.setCreateId(personnelVO.getId());
                            patentDigProjectFilesS.add(patentDigProjectFiles);
                        }
                        this.saveBatch(patentDigProjectFilesS);
                    }
                } catch (Exception e) {
                    throw new XiaoShiException("查询文件信息错误");
                }
            }

            patentDigProjectFilesS.forEach(item -> {
                ids.add(item.getId());
            });
        }

        return ids;
    }

    @Override
    public Object updateMessage(Object object) {
        return null;
    }

    /**
     * 装载专利挖掘文件列表信息
     * @param patentDigProjectFilesVOS
     */
    private void loadPatentDigProjectFiles(List<PatentDigProjectFilesVO> patentDigProjectFilesVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        patentDigProjectFilesVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        for (PatentDigProjectFilesVO patentDigProjectFilesVO : patentDigProjectFilesVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(patentDigProjectFilesVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                patentDigProjectFilesVO.setCreateName(personnel.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到当前登陆人信息");
            }
            //调用查询流程名称方法
            String name = this.getProcessName(patentDigProjectFilesVO.getProcessId());
            patentDigProjectFilesVO.setProcessName(name);
        }
    }

    /**
     * 装载流程名
     * @param processId
     * @return
     */
    public String getProcessName(Integer processId){
        String name = null;
        Map<Integer, String> processMap = new HashMap<>();
        processMap.put(1, "创新点梳理");
        processMap.put(2, "查新检索");
        processMap.put(3, "保护主题规划");
        processMap.put(4, "独权撰写");
        processMap.put(5, "从权撰写");
        processMap.put(6, "申请文件定稿");
        processMap.put(7, "说明书规划撰写");
        name = processMap.get(processId);
        return name;
    }

    /**
     * 上传专利挖掘项目文件后提交审核，新增专利挖掘文件审核记录
     * @param patentDigProjectFilesDTO
     * @return
     */
    public Integer addPDProjectFilesTask(PatentDigProjectFilesDTO patentDigProjectFilesDTO){
        //首先调用新增文件接口
        List<Integer> ids = (List<Integer>) this.addMessage(patentDigProjectFilesDTO);
        //其次调用新增任务接口
        patentDigProjectFilesDTO.getProjectTaskDTO().setProjectId(patentDigProjectFilesDTO.getProjectId());
        patentDigProjectFilesDTO.getProjectTaskDTO().setProcessId(patentDigProjectFilesDTO.getProcessId());
        Integer taskType = 7;
        patentDigProjectFilesDTO.getProjectTaskDTO().setType(taskType);
        Integer taskId = projectTaskService.addTask(patentDigProjectFilesDTO.getProjectTaskDTO());
        if (!ids.isEmpty()) {
            LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(PatentDigProjectFiles::getId, ids);
            List<PatentDigProjectFiles> patentDigProjectFiles = this.list(queryWrapper);
            if (!patentDigProjectFiles.isEmpty()) {
                patentDigProjectFiles.forEach(item -> {
                    item.setTaskId(taskId);
                });
                this.updateBatchById(patentDigProjectFiles);
            }
        }
        return taskId;
    }

    public Map<Integer, Map<String, Integer>> getProcessInfo(Integer projectId){
        Map<Integer, Map<String, Integer>> processInfo = new HashMap<>();
        for (int i = 1; i < 8; i++) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getProcessId, i).eq(ProjectTask::getProjectId, projectId);
            Integer taskCount = (int) projectTaskService.count(queryWrapper);
            LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(PatentDigProjectFiles::getProcessId, i).eq(PatentDigProjectFiles::getProjectId, projectId);
            Integer fileCount = (int) this.count(queryWrapper1);
            Map<String, Integer> countMap = new HashMap<>();
            countMap.put("taskCount", taskCount);
            countMap.put("fileCount", fileCount);
            processInfo.put(i, countMap);
        }
        return processInfo;
    }
}