package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.ClientDTO;
import cn.cslg.pas.common.dto.UpdateSingleColumnDTO;
import cn.cslg.pas.common.dto.business.PatentProjectDTO;
import cn.cslg.pas.common.dto.business.ProjectEventDTO;
import cn.cslg.pas.common.dto.business.ReportProjectDTO;
import cn.cslg.pas.common.dto.business.UpdateReportProjectDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateIfSecondInvalidDTO;
import cn.cslg.pas.common.model.cronModel.*;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.model.request.StringRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.GenerateObjectUtil;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.DepartmentVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.QueryCasePhaseVO;
import cn.cslg.pas.common.vo.QueryReportAffairConclusionVO;
import cn.cslg.pas.common.vo.business.*;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentPerson;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.factorys.reGroupFactory.QueryGroupFactory;
import cn.cslg.pas.factorys.reGroupFactory.QueryGroupImp;
import cn.cslg.pas.mapper.*;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsService;
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.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.validation.constraints.AssertFalse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
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.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
public class ReportProjectService extends ServiceImpl<ReportProjectMapper, ReportProject> implements Business {

    @Autowired
    private ReportProjectMapper reportProjectMapper;
    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private QueryGroupFactory queryGroupFactory;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoProjectEventService assoProjectEventService;

    @Autowired
    private AssoProjectFileService assoProjectFileService;

    @Autowired
    private AssoReportCronService assoReportCronService;

    @Autowired
    private AssoProjectPersonService assoProjectPersonService;

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private FollowUpService followUpService;

    @Autowired
    private EventService eventService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private AssoProjectService assoProjectService;

    @Autowired
    private SystemDictService systemDictService;
    @Autowired
    private MatterService matterService;

    @Autowired
    private ScenarioService scenarioService;
    @Autowired
    private EsService esService;
    @Autowired
    private EsPatentService esPatentService;
    @Autowired
    private CustomFieldService customFieldService;
    @Autowired
    @Lazy
    private CompareLiteratureService compareLiteratureService;
    @Autowired
    private ReportAffairMapper reportAffairMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        String tableName = "reportProject";
        Boolean ifInvalidReport = queryRequest.getIfInvalidReport();
        if (ifInvalidReport != null && ifInvalidReport) {
            tableName = "invalidReportProject";
        }
        List<String> sqls = formatQueryService.reSqls(queryRequest, tableName);
        sqls = this.loadSearchSql(sqls);
        //根据sql查询事件信息
        List<ReportProjectVO> reportProject = reportProjectMapper.getReportProject(this.getSelectMessage(), sqls.get(0), sqls.get(1), sqls.get(2));
        this.loadReportProjectVO(reportProject, ifInvalidReport);

        //查询总数
        Long total = reportProjectMapper.getReportProjectCount(this.getSelectMessage(), sqls.get(0));

        //装载事件信息
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(reportProject);
        records.setTotal(total);
        return records;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer addMessage(Object object, List<MultipartFile> files) {

        return null;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object deleteMessage(List<Integer> ids) throws IOException {

        //后续事项
        LambdaQueryWrapper<FollowUp> followUpWrapper = new LambdaQueryWrapper<>();
        followUpWrapper.in(FollowUp::getProjectId, ids);
        followUpService.remove(followUpWrapper);

        //事件
        LambdaQueryWrapper<AssoProjectEvent> eventWrapper = new LambdaQueryWrapper<>();
        eventWrapper.in(AssoProjectEvent::getProjectId, ids);
        assoProjectEventService.remove(eventWrapper);

        //附件
        LambdaQueryWrapper<AssoProjectFile> fileWrapper = new LambdaQueryWrapper<>();
        fileWrapper.in(AssoProjectFile::getProjectId, ids);
        assoProjectFileService.remove(fileWrapper);

        //核心结论
        LambdaQueryWrapper<AssoReportCron> reportCronWrapper = new LambdaQueryWrapper<>();
        reportCronWrapper.in(AssoReportCron::getProjectId, ids);
        assoReportCronService.remove(reportCronWrapper);

        //和报告关联
        LambdaQueryWrapper<AssoProject> assoReportWrapper = new LambdaQueryWrapper<>();
        assoReportWrapper.in(AssoProject::getProjectId, ids);
        assoReportWrapper.eq(AssoProject::getProjectType, 2);
        assoReportWrapper.eq(AssoProject::getAssoProjectType, 2);
        assoProjectService.remove(assoReportWrapper);

        //report
        LambdaQueryWrapper<ReportProject> reportProjectWrapper = new LambdaQueryWrapper<>();
        reportProjectWrapper.in(ReportProject::getProjectId, ids);
        this.remove(reportProjectWrapper);

        //project
        projectService.removeBatchByIds(ids);
        return ids;
    }

    /**
     * 更新事件接口
     *
     * @param object
     * @param files
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object updateMessage(Object object, List<MultipartFile> files) {

        return null;
    }

    /**
     * 查询事件分组信息
     *
     * @param groupRequest
     * @return
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    public Object getGroup(GroupRequest groupRequest, String groupTableName) throws Exception {
        StringRequest stringRequest = new StringRequest();
        BeanUtils.copyProperties(groupRequest, stringRequest);
        String tableName = "reportProject";
        Boolean ifInvalidReport = stringRequest.getIfInvalidReport();
        if (ifInvalidReport != null && ifInvalidReport) {
            tableName = "invalidReportProject";
        }
        List<String> sqls = formatQueryService.reSqls(stringRequest, tableName);
        sqls = this.loadSearchSql(sqls);
        //格式化 分组
        GroupConfig groupConfig = null;
        if (groupRequest.getGroupBy() != null) {
            String json = CommonService.readJsonFile(tableName + ".json");
            List<GroupConfig> groupConfigs = JSON.parseArray(json, GroupConfig.class);
            groupConfig = groupConfigs.stream().filter(item -> groupRequest.getGroupBy().equals(item.getField())).findFirst().orElse(null);
            if (groupConfig == null) {
                throw new XiaoShiException("未找到配置");
            }
        }
        tableName = "(" + getSelectMessage() + ") as t";
        //返回分组数据
        QueryGroupImp queryGroupImp = queryGroupFactory.getClass(groupConfig.getGroupClass());
        String countFiled = "distinct t.id";
        ReGroupDataVO reGroupDataVO = queryGroupImp.getGroup(sqls, tableName, groupConfig.getSqlField(), countFiled);

        //装载数据
        GroupVO groupVO = new GroupVO();
        groupVO.setField(groupRequest.getGroupBy());
        groupVO.setValues(reGroupDataVO.getValues());
        Records records = new Records();
        records.setCurrent(groupRequest.getCurrent());
        records.setSize(groupRequest.getSize());
        records.setData(groupVO);
        records.setTotal(reGroupDataVO.getTotal());
        return records;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object addMessage(Object object) {
        //TODO 校验参数
        //object to reportProjectDTO
        ReportProjectDTO reportProjectDTO = (ReportProjectDTO) object;
        /**
         * 校验必传参数是否上传
         */
        //负责人id
        if (reportProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //报告类型
        if (reportProjectDTO.getReportType().equals(null)) {
            throw new XiaoShiException("报告类型不能为空");
        }

        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        String userId = personnelVO.getId();

        /**
         * 装载project
         */
        Project project = new Project();
        BeanUtils.copyProperties(reportProjectDTO, project);
        project.setCreateId(personnelVO.getId());
        project.setTenantId(personnelVO.getTenantId());
        //TODO 当委托方id或者委托方名称不为空时，
        if (reportProjectDTO.getEntrustId() != null || reportProjectDTO.getEntrustName() != null) {

            //根据创建人的租户类型设置project的委托类型
            if (personnelVO.getTenantType().equals("1")) {
                project.setEntrustType(1);

                //当委托方id不为空时
                if (StringUtils.isNotEmpty(reportProjectDTO.getEntrustId()) && !StringUtils.equals(reportProjectDTO.getEntrustId(), "-1")) {
                    project.setEntrustId(reportProjectDTO.getEntrustId());
                }

                //若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
                else {
                    if (reportProjectDTO.getEntrustName() != null && reportProjectDTO.getEntrustName().trim() != "") {
                        ClientDTO clientDTO = new ClientDTO();
                        clientDTO.setName(reportProjectDTO.getEntrustName());
                        clientDTO.setTenantId(personnelVO.getTenantId());

                        try {
                            String res = permissionService.addClient(clientDTO);
                            JSONObject jsonObject = JSONObject.parseObject(res);
                            Integer clientId = Integer.parseInt(jsonObject.get("data").toString());
                            project.setEntrustId(clientId.toString());
                            project.setEntrustType(1);
                        } catch (Exception e) {
                            throw new XiaoShiException("网络异常");
                        }
                    }
                }

            } else {
                if (reportProjectDTO.getEntrustId() != null) {
                    project.setEntrustType(0);
                    project.setEntrustId(reportProjectDTO.getEntrustId());
                }
            }
        }
        project.insert();

        /**
         * 装载和报告关联
         */
        if (reportProjectDTO.getAssoReportId() != null) {
            AssoProject assoProject = new AssoProject();
            assoProject.setAssoProjectId(project.getId());
            assoProject.setAssoProjectType(2);
            assoProject.setProjectId(reportProjectDTO.getAssoReportId());
            assoProject.setProjectType(2);
            assoProject.insert();
        }

        /**
         * 装载reportProject
         */
        ReportProject reportProject = new ReportProject();
        BeanUtils.copyProperties(reportProjectDTO, reportProject);
        if (reportProject.getSignPatentNo() != null&&!reportProject.getReportType().equals(3)) {
            try {
                PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo(reportProject.getSignPatentNo());
                if (patentWithIdVO != null && patentWithIdVO.getPatent() != null) {
                    if (patentWithIdVO.getPatent().getPatentType() != null) {
                        reportProject.setPatentType(Integer.parseInt(patentWithIdVO.getPatent().getPatentType()));
                    }
                }
                Patent patent = patentWithIdVO.getPatent();
                if (patent.getRightHolder() != null && patent.getRightHolder().size() > 0) {
                    List<String> rightHolders = patent.getRightHolder().stream().map(PatentPerson::getName).collect(Collectors.toList());
                    String holderString = StringUtils.join(rightHolders, ",");
                    reportProject.setRightHolder(holderString);
                }
            } catch (Exception e) {
                throw new XiaoShiException("未查询到标的专利");
            }
            //根据专利号查询专利
        }
        reportProject.setProjectId(project.getId());
        //根据是否直接完成设置报告的状态
        if (reportProjectDTO.getIfFinish() == null || !reportProjectDTO.getIfFinish()) {
            reportProject.setStatus(2);
        } else if (reportProjectDTO.getIfFinish()) {
            reportProject.setStatus(3);
        }
        reportProject.insert();

        /**
         * 装载后续事项和project关联
         */
        if (reportProjectDTO.getFollowUps() != null && reportProjectDTO.getFollowUps().size() != 0) {
            List<FollowUp> followUps = new ArrayList<>();
            reportProjectDTO.getFollowUps().forEach(item -> {
                FollowUp followUp = new FollowUp();
                BeanUtils.copyProperties(item, followUp);
                followUp.setProjectId(project.getId());
                followUp.setCreateId(userId);
                followUps.add(followUp);
            });
            followUpService.saveBatch(followUps);
        }

        /**
         * 装载事件与project关联
         */
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        List<ProjectEventDTO> events = reportProjectDTO.getEvents();
        if (events != null && events.size() != 0) {
            assoProjectEventService.addAssoEventProject(events, project.getId(), 1);
        }
        /**
         * 装载和附件关联
         */
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        List<String> fileGuids = reportProjectDTO.getFileGuids();
        if (fileGuids != null && fileGuids.size() != 0) {
            for (String fileGuid : fileGuids) {
                AssoProjectFile assoProjectFile = new AssoProjectFile();
                assoProjectFile.setProjectId(project.getId());
                assoProjectFile.setFileGuid(fileGuid);
                assoProjectFile.setCreateId(personnelVO.getId());
                assoProjectFiles.add(assoProjectFile);
            }
            if (assoProjectFiles != null && assoProjectFiles.size() != 0) {
                assoProjectFileService.saveBatch(assoProjectFiles);
            }
        }

        /**
         * 装载核心结论
         */
        List<Integer> cronIds = reportProjectDTO.getCronIds();
        List<AssoReportCron> assoReportCrons = new ArrayList<>();
        if (cronIds != null && cronIds.size() != 0) {
            cronIds.forEach(item -> {
                AssoReportCron assoReportCron = new AssoReportCron();
                assoReportCron.setProjectId(project.getId());
                assoReportCron.setCronId(item);
                assoReportCrons.add(assoReportCron);
            });
            assoReportCronService.saveBatch(assoReportCrons);
        }

        List<String> involvedPersonIds = reportProjectDTO.getInvolvedPersonIds();

        //添加项目的参与人
        assoProjectPersonService.addProjectPeople(1, project.getId(), involvedPersonIds);
        /**
         * 复制信息
         */
        Boolean track = reportProjectDTO.getTrack();
        if (track != null && track.equals(true)) {
            List<Integer> copyIds = reportProjectDTO.getCopyIds();
            //复制对比文献
            if (copyIds != null && copyIds.contains(0)) {
                Integer oldProjectId = reportProjectDTO.getAssociateReportId();
                compareLiteratureService.copyCompareLiterature(oldProjectId, project.getId());
            }
            //复制标引信息
            if (copyIds != null && copyIds.contains(1)) {
                Integer oldProjectId = reportProjectDTO.getAssociateReportId();
                customFieldService.copyCustomField(oldProjectId, project.getId());
            }


        }

        //返回id
        return project.getId();
    }

    @Override
    public Object updateMessage(Object object) {
        //TODO 校验参数
        //object to reportProjectDTO
        UpdateReportProjectDTO updateReportProjectDTO = (UpdateReportProjectDTO) object;
        /**
         * 校验必传参数是否上传
         */
        //负责人id
        if (updateReportProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //报告类型
        if (updateReportProjectDTO.getReportType().equals(null)) {
            throw new XiaoShiException("报告类型不能为空");
        }

        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        String userId = personnelVO.getId();
        /**
         * 装载project
         */
        Project project = projectService.getById(updateReportProjectDTO.getId());
        BeanUtils.copyProperties(updateReportProjectDTO, project);
        //TODO 当委托方id或者委托方名称不为空时，
        if (updateReportProjectDTO.getEntrustId() != null || updateReportProjectDTO.getEntrustName() != null) {
            //根据创建人的租户类型设置project的委托类型
            if (personnelVO.getTenantType().equals("1")) {
                project.setEntrustType(1);

                //当委托方id不为空时
                if (StringUtils.isNotEmpty(updateReportProjectDTO.getEntrustId()) && !StringUtils.equals(updateReportProjectDTO.getEntrustId(), "-1")) {
                    project.setEntrustId(updateReportProjectDTO.getEntrustId());
                }
                //若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
                else {
                    if (updateReportProjectDTO.getEntrustName() != null && updateReportProjectDTO.getEntrustName().trim() != "") {
                        ClientDTO clientDTO = new ClientDTO();
                        clientDTO.setName(updateReportProjectDTO.getEntrustName());
                        clientDTO.setTenantId(personnelVO.getTenantId());
                        try {
                            String res = permissionService.addClient(clientDTO);
                            JSONObject jsonObject = JSONObject.parseObject(res);
                            Integer clientId = Integer.parseInt(jsonObject.get("data").toString());
                            project.setEntrustId(clientId.toString());
                            project.setEntrustType(1);
                        } catch (Exception e) {
                            throw new XiaoShiException("网络异常");
                        }
                    }
                }
            } else {
                if (updateReportProjectDTO.getEntrustId() != null) {
                    project.setEntrustType(0);
                    project.setEntrustId(updateReportProjectDTO.getEntrustId());
                }
            }
        }
        project.updateById();
        /**
         * 装载和报告关联
         */
        if (updateReportProjectDTO.getAssoReportId() != null) {
            LambdaQueryWrapper<AssoProject> deleteReportWrapper = new LambdaQueryWrapper<>();
            deleteReportWrapper.eq(AssoProject::getProjectId, project.getId());
            assoProjectService.remove(deleteReportWrapper);

            AssoProject assoProject = new AssoProject();
            assoProject.setAssoProjectId(project.getId());
            assoProject.setAssoProjectType(2);
            assoProject.setProjectId(updateReportProjectDTO.getAssoReportId());
            assoProject.setProjectType(2);
            assoProject.insert();
        }
        /**
         * 装载reportProject
         */
        LambdaQueryWrapper<ReportProject> reportProjectWrapper = new LambdaQueryWrapper<>();
        reportProjectWrapper.eq(ReportProject::getProjectId, project.getId());
        ReportProject reportProject = this.getOne(reportProjectWrapper);
        Integer reportId = reportProject.getId();
        if (reportProject.getSignPatentNo() != null && reportProject.getSignPatentNo() != updateReportProjectDTO.getSignPatentNo()) {
            try {
                String patentNo =updateReportProjectDTO.getSignPatentNo();
                PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo(patentNo);
                if(patentWithIdVO==null){
                    reportProject.setRightHolder("");
                }else {
                    Patent patent = patentWithIdVO.getPatent();
                    if (patent.getRightHolder() != null && patent.getRightHolder().size() > 0) {
                        List<String> rightHolders = patent.getRightHolder().stream().map(PatentPerson::getName).collect(Collectors.toList());
                        String holderString = StringUtils.join(rightHolders, ",");
                        reportProject.setRightHolder(holderString);
                    }
                    else {
                        reportProject.setRightHolder("");
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        updateReportProjectDTO.setEvidenceRiskResponse(reportProject.getEvidenceRiskResponse());
        updateReportProjectDTO.setOralPanelMembers(reportProject.getOralPanelMembers());
        updateReportProjectDTO.setOfficialDeadline(reportProject.getOfficialDeadline());
        BeanUtils.copyProperties(updateReportProjectDTO, reportProject);
        reportProject.setId(reportId);

        reportProject.updateById();
        /**
         * 装载后续事项和project关联
         */
        LambdaQueryWrapper<FollowUp> followUpWrapper = new LambdaQueryWrapper<>();
        followUpWrapper.eq(FollowUp::getProjectId, project.getId());
        followUpService.remove(followUpWrapper);
        if (updateReportProjectDTO.getFollowUps() != null && updateReportProjectDTO.getFollowUps().size() != 0) {
            List<FollowUp> followUps = new ArrayList<>();
            updateReportProjectDTO.getFollowUps().forEach(item -> {
                FollowUp followUp = new FollowUp();
                BeanUtils.copyProperties(item, followUp);
                followUp.setCreateId(userId);
                followUp.setProjectId(project.getId());
                followUps.add(followUp);
            });
            followUpService.saveBatch(followUps);
        }

        /**
         * 装载事件与project关联
         */
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        LambdaQueryWrapper<AssoProjectEvent> deleteEventWrapper = new LambdaQueryWrapper<>();
        deleteEventWrapper.eq(AssoProjectEvent::getProjectId, project.getId());
        assoProjectEventService.remove(deleteEventWrapper);

        List<ProjectEventDTO> events = updateReportProjectDTO.getEvents();
        if (events != null && events.size() != 0) {
            if (events != null && events.size() != 0) {
                assoProjectEventService.addAssoEventProject(events, project.getId(), 1);
            }
        }
        /**
         * 装载和附件关联
         */
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        LambdaQueryWrapper<AssoProjectFile> deleteFileWrapper = new LambdaQueryWrapper<>();
        deleteFileWrapper.eq(AssoProjectFile::getProjectId, project.getId());
        assoProjectFileService.remove(deleteFileWrapper);
        List<String> fileGuids = updateReportProjectDTO.getFileGuids();
        if (fileGuids != null && fileGuids.size() != 0) {
            for (String fileGuid : fileGuids) {
                AssoProjectFile assoProjectFile = new AssoProjectFile();
                assoProjectFile.setProjectId(project.getId());
                assoProjectFile.setFileGuid(fileGuid);
                assoProjectFile.setCreateId(personnelVO.getId());
                assoProjectFiles.add(assoProjectFile);
            }
            if (assoProjectFiles != null && assoProjectFiles.size() != 0) {
                assoProjectFileService.saveBatch(assoProjectFiles);
            }
        }

        /**
         * 装载核心结论
         */
        List<Integer> cronIds = updateReportProjectDTO.getCronIds();
        LambdaQueryWrapper<AssoReportCron> reportCronWrapper = new LambdaQueryWrapper<>();
        reportCronWrapper.eq(AssoReportCron::getProjectId, project.getId());
        assoReportCronService.remove(reportCronWrapper);
        List<AssoReportCron> assoReportCrons = new ArrayList<>();
        if (cronIds != null && cronIds.size() != 0) {
            cronIds.forEach(item -> {
                AssoReportCron assoReportCron = new AssoReportCron();
                assoReportCron.setProjectId(project.getId());
                assoReportCron.setCronId(item);
                assoReportCrons.add(assoReportCron);
            });
            assoReportCronService.saveBatch(assoReportCrons);
        }


        /**
         *装载参与人
         */
        List<String> involvedPersonIds = updateReportProjectDTO.getInvolvedPersonIds();
        assoProjectPersonService.updateProjectPeople(1, project.getId(), involvedPersonIds);

        //返回id
        return project.getId();
    }

    /**
     * 装载报告返回类
     *
     * @param reportProjectVOs
     */
    private void loadReportProjectVO(List<ReportProjectVO> reportProjectVOs, Boolean ifInvalidReport) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<String> departmentIds = new ArrayList<>();
        List<DepartmentVO> departmentVOS = new ArrayList<>();
        List<Integer> clientIds = new ArrayList<>();
        List<Integer> ids = new ArrayList<>();
        List<Client> clients = new ArrayList<>();
        List<Event> events = new ArrayList<>();
        List<AssoReportCron> assoReportCrons = new ArrayList<>();
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        List<SystemDict> systemDictList = new ArrayList<>();
        List<SystemDict> reportTypeList = new ArrayList<>();
        List<Scenario> scenarios = new ArrayList<>();
        List<Matter> matters = new ArrayList<>();
        List<AssoProject> assoProjects = new ArrayList<>();
        List<String> patentNos = new ArrayList<>();
        List<Patent> patentList = new ArrayList<>();
        List<AssoProjectPerson> assoProjectPersonList = new ArrayList<>();
        reportProjectVOs.forEach(
                item -> {

                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }

                    if (item.getHeadId() != null) {
                        createIds.add(item.getHeadId());
                    }

                    if (item.getId() != null) {
                        ids.add(item.getId());
                    }

                    if (item.getDepartmentId() != null) {
                        departmentIds.add(item.getDepartmentId());
                    }

                    if (item.getEntrustType() != null && item.getEntrustType().equals(2)) {
                        departmentIds.add(item.getEntrustId());
                    }

                    if (item.getEntrustType() != null && item.getEntrustType().equals(1)) {
                        clientIds.add(Integer.parseInt(item.getEntrustId()));
                    }
                    if (ifInvalidReport != null && ifInvalidReport && item.getSignPatentNo() != null) {
                        patentNos.add(item.getSignPatentNo());
                    }
                }
        );

        List<Personnel> personnels = new ArrayList<>();
        List<String> guids = new ArrayList<>();
        List<SystemFile> systemFiles = new ArrayList<>();
        List<AssoProjectFile> assoEventFiles = new ArrayList<>();
        List<QueryCasePhaseVO> casePhaseVOS = new ArrayList<>();
        List<QueryCasePhaseVO> casePhaseVOS1 = new ArrayList<>();
        List<QueryReportAffairConclusionVO> conclusionVOS = new ArrayList<>();


        //查询部门名称
        if (departmentIds.size() != 0) {
            String json = permissionService.getDepartmentByIdsFromPCS(departmentIds);
            departmentVOS = JSON.parseArray(json, DepartmentVO.class);

        }
        //查询标的专利信息
        if (ifInvalidReport != null && ifInvalidReport && patentNos.size() > 0) {
            try {
                patentList = esPatentService.getPatentsByNo(patentNos, true, null, null);

            } catch (Exception e) {
            }
        }
        if (ids.size() != 0) {
            //根据事件id获得专利数据库文件关联表
            LambdaQueryWrapper<AssoProjectFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(AssoProjectFile::getProjectId, ids);
            assoEventFiles = assoProjectFileService.list(queryWrapper);
            guids = assoEventFiles.stream().map(AssoProjectFile::getFileGuid).collect(Collectors.toList());

            //查询核心结论
            LambdaQueryWrapper<AssoReportCron> reportCronLambdaQueryWrapper = new LambdaQueryWrapper<>();
            reportCronLambdaQueryWrapper.in(AssoReportCron::getProjectId, ids);
            assoReportCrons = assoReportCronService.list(reportCronLambdaQueryWrapper);
            if (assoReportCrons != null && assoReportCrons.size() != 0) {
                LambdaQueryWrapper<SystemDict> systemDictLambdaQueryWrapper = new LambdaQueryWrapper<>();
                systemDictLambdaQueryWrapper.eq(SystemDict::getGroupType, "ASSESS");
                systemDictList = systemDictService.list(systemDictLambdaQueryWrapper);

            }
            LambdaQueryWrapper<SystemDict> systemDictLambdaQueryWrapper = new LambdaQueryWrapper<>();
            systemDictLambdaQueryWrapper.eq(SystemDict::getType, "REPORT_TYPE").or().eq(SystemDict::getType, "REPORT_STATE");
            reportTypeList = systemDictService.list(systemDictLambdaQueryWrapper);


            LambdaQueryWrapper<AssoProject> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(AssoProject::getAssoProjectId, ids);
            assoProjects = assoProjectService.list(queryWrapper1);

            //查询和参与人关联
            LambdaQueryWrapper<AssoProjectPerson> projectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
            projectPersonLambdaQueryWrapper.in(AssoProjectPerson::getProjectId, ids)
                    .eq(AssoProjectPerson::getRole, 1);
            assoProjectPersonList = assoProjectPersonService.list(projectPersonLambdaQueryWrapper);
            List<String> personIds = assoProjectPersonList.stream().map(AssoProjectPerson::getPersonId).collect(Collectors.toList());
            createIds.addAll(personIds);

            casePhaseVOS = reportAffairMapper.queryCasePhase(ids);
            casePhaseVOS1 = reportAffairMapper.queryCasePhaseOral(ids);
            conclusionVOS = reportAffairMapper.queryReportAffairConclusion(ids);
        }

        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //查询文件
        if (guids.size() != 0) {
            try {
                String res = fileManagerService.getSystemFileFromFMS(guids);

                systemFiles = JSONObject.parseArray(res, SystemFile.class);
            } catch (Exception e) {
            }
        }

        //查询客户名称
        if (clientIds.size() != 0) {
            String res = permissionService.getClientByIdsFromPCS(clientIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            clients = JSONObject.parseArray(jsonObject.getString("data"), Client.class);
        }

        //查询应用场景、调查类型、事件和专题库的关联
        if (ids != null && ids.size() > 0) {
            LambdaQueryWrapper<AssoProjectEvent> assoProjectEventQueryWrapper = new LambdaQueryWrapper<>();
            assoProjectEventQueryWrapper.in(AssoProjectEvent::getProjectId, ids);
            assoProjectEvents = assoProjectEventService.list(assoProjectEventQueryWrapper);

            //查询事件
            if (assoProjectEvents != null && assoProjectEvents.size() != 0) {
                scenarios = scenarioService.list();
                matters = matterService.list();
                List<Integer> eventIds = assoProjectEvents.stream().filter(item -> item.getEventId() != null).map(AssoProjectEvent::getEventId).collect(Collectors.toList());
                if (eventIds.size() != 0) {
                    LambdaQueryWrapper<Event> eventQueryWrapper = new LambdaQueryWrapper<>();
                    eventQueryWrapper.in(Event::getId, eventIds);
                    events = eventService.list(eventQueryWrapper);
                }


            }
        }

        //装载信息
        for (ReportProjectVO reportProjectVO : reportProjectVOs) {

            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(reportProjectVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                reportProjectVO.setCreateName(personnel.getPersonnelName());
            }

            if (reportProjectVO.getHeadId() != null) {
                Personnel headPersonnel = personnels.stream().filter(item -> item.getId().equals(reportProjectVO.getHeadId())).findFirst().orElse(null);
                if (headPersonnel != null) {
                    reportProjectVO.setHeadName(headPersonnel.getPersonnelName());
                }
            }

            //装载文件信息
            List<AssoProjectFile> assoProjectFileTemp = assoEventFiles.stream().filter(item -> item.getProjectId().equals(reportProjectVO.getId())).collect(Collectors.toList());
            if (assoProjectFileTemp.size() != 0) {
                List<String> guidTemp = assoProjectFileTemp.stream().map(AssoProjectFile::getFileGuid).collect(Collectors.toList());
                if (guidTemp.size() != 0) {
                    if (systemFiles != null) {
                        List<SystemFile> systemFileTemp = systemFiles.stream().filter(item -> guidTemp.contains(item.getGuid())).collect(Collectors.toList());
                        if (systemFileTemp.size() != 0) {
                            reportProjectVO.setSystemFileList(systemFileTemp);
                        }
                    }
                }
            }

            //装载参与人
            List<SimplePersonVO> simplePersonVOS = new ArrayList<>();
            List<AssoProjectPerson> assoProjectPersonTmps = assoProjectPersonList.stream().filter(item -> item.getProjectId().equals(reportProjectVO.getId())).collect(Collectors.toList());
            List<String> personIds = assoProjectPersonTmps.stream().map(AssoProjectPerson::getPersonId).collect(Collectors.toList());
            if (!CollectionUtils.isEmpty(personIds)) {
                List<Personnel> personneltmps = personnels.stream().filter(item -> personIds.contains(item.getId())).collect(Collectors.toList());
                personneltmps.forEach(item -> {
                    SimplePersonVO simplePersonVO = new SimplePersonVO();
                    simplePersonVO.setPersonId(item.getId());
                    simplePersonVO.setPersonName(item.getPersonnelName());
                    simplePersonVOS.add(simplePersonVO);
                });
            }
            reportProjectVO.setInvolvedPersons(simplePersonVOS);

            //装载部门
            if (reportProjectVO.getDepartmentId() != null) {
                DepartmentVO departmentVO = departmentVOS.stream().filter(item -> item.getDepartId().equals(reportProjectVO.getDepartmentId())).findFirst().orElse(null);
                if (departmentVO != null) {
                    reportProjectVO.setDepartmentName(departmentVO.getDepartName());
                }
            }

            //裝載委托方
            if (reportProjectVO.getEntrustType() != null) {
                //当委托方为客户时
                if (reportProjectVO.getEntrustType().equals(1)) {
                    Client client = clients.stream().filter(item -> item.getId().equals(Integer.parseInt(reportProjectVO.getEntrustId()))).findFirst().orElse(null);

                    if (client != null) {
                        reportProjectVO.setEntrustName(client.getName());
                    }

                } else if (reportProjectVO.getEntrustType().equals(2)) {
                    DepartmentVO departmentVO = departmentVOS.stream().filter(item -> item.getDepartId().equals(reportProjectVO.getEntrustId())).findFirst().orElse(null);

                    if (departmentVO != null) {
                        reportProjectVO.setEntrustName(departmentVO.getDepartName());
                    }
                }

            }

            //装载事件
            //装载事件 应用场景，处理事项
            List<Integer> eventIds = new ArrayList<>();
            List<Integer> matterIds = new ArrayList<>();
            List<Integer> scenarioIds = new ArrayList<>();
            List<String> eventTmpNames = new ArrayList<>();
            List<String> matterTmpNames = new ArrayList<>();
            List<String> scenarioTmpNames = new ArrayList<>();
            if (assoProjectEvents != null) {
                List<AssoProjectEvent> assoProjectEventTmps = assoProjectEvents.stream().filter(item -> item.getProjectId().equals(reportProjectVO.getId())).collect(Collectors.toList());

                if (assoProjectEventTmps.size() != 0) {
                    //过滤出事件
                    eventIds = assoProjectEventTmps.stream().filter(item -> item.getEventId() != null).map(AssoProjectEvent::getEventId).collect(Collectors.toList());
                    matterIds = assoProjectEventTmps.stream().filter(item -> item.getMatterId() != null).map(AssoProjectEvent::getMatterId).collect(Collectors.toList());
                    scenarioIds = assoProjectEventTmps.stream().filter(item -> item.getScenarioId() != null).map(AssoProjectEvent::getScenarioId).collect(Collectors.toList());

                    List<Integer> eventIdsFilter = eventIds;
                    List<Integer> matterIdsFilter = matterIds;
                    List<Integer> scenarioIdsFilter = scenarioIds;

                    List<Event> eventTmps = events.stream().filter(item -> eventIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    List<Matter> matterTmps = matters.stream().filter(item -> matterIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    List<Scenario> scenarioTmps = scenarios.stream().filter(item -> scenarioIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    eventTmpNames = eventTmps.stream().map(Event::getName).collect(Collectors.toList());
                    eventIds = eventTmps.stream().map(Event::getId).collect(Collectors.toList());
                    matterTmpNames = matterTmps.stream().map(Matter::getName).collect(Collectors.toList());
                    matterIds = matterTmps.stream().map(Matter::getId).collect(Collectors.toList());
                    scenarioTmpNames = scenarioTmps.stream().map(Scenario::getName).collect(Collectors.toList());
                    scenarioIds = scenarioTmps.stream().map(Scenario::getId).collect(Collectors.toList());

                }
            }
            reportProjectVO.setScenarioIds(scenarioIds);
            reportProjectVO.setMatterIds(matterIds);
            reportProjectVO.setEventIds(eventIds);
            reportProjectVO.setScenarioNames(scenarioTmpNames);
            reportProjectVO.setMatterNames(matterTmpNames);
            reportProjectVO.setEventNames(eventTmpNames);


            List<Integer> reCronIds = new ArrayList<>();
            List<String> reCronNames = new ArrayList<>();
            //装载核心结论
            if (assoReportCrons != null && assoReportCrons.size() != 0) {
                List<AssoReportCron> assoReportCronTmps = assoReportCrons.stream().filter(item -> item.getProjectId().equals(reportProjectVO.getId())).collect(Collectors.toList());
                if (assoReportCronTmps.size() != 0) {
                    //过滤出事件
                    List<Integer> cronIds = assoReportCronTmps.stream().map(AssoReportCron::getCronId).collect(Collectors.toList());
                    List<SystemDict> systemDicts = systemDictList.stream().filter(item -> cronIds.contains(Integer.parseInt(item.getValue()))).collect(Collectors.toList());
                    systemDicts.forEach(item -> {
                        CronVO cronVO = new CronVO();
                        reCronIds.add(Integer.parseInt(item.getValue()));
                        reCronNames.add(item.getLabel());
                    });

                }
            }
            reportProjectVO.setCronIds(reCronIds);
            reportProjectVO.setCronNames(reCronNames);

            //装载案件阶段与案件子阶段
            if (!CollectionUtils.isEmpty(casePhaseVOS) && !CollectionUtils.isEmpty(casePhaseVOS1)) {
                QueryCasePhaseVO casePhaseVO1 = casePhaseVOS1.stream().filter(i -> i.getProjectId().equals(reportProjectVO.getId())).findFirst().orElse(null);
                QueryCasePhaseVO casePhaseVO = casePhaseVOS.stream().filter(i -> i.getProjectId().equals(reportProjectVO.getId())).findFirst().orElse(null);
                if (casePhaseVO != null) {
                    reportProjectVO.setCasePhase(casePhaseVO.getCasePhase());
                    reportProjectVO.setCaseChildPhase(casePhaseVO.getCaseChildPhase());
                } else {
                    if (casePhaseVO1 != null) {
                        Integer flowType = casePhaseVO1.getFlowType();
                        if (flowType == 6) {
                            reportProjectVO.setCasePhase(casePhaseVO1.getCasePhase());
                        }
                    }
                }
            }
            //装载行诉结果
            if (!CollectionUtils.isEmpty(conclusionVOS)) {
                QueryReportAffairConclusionVO conclusionVO = conclusionVOS.stream().filter(i -> i.getProjectId().equals(reportProjectVO.getId())).findFirst().orElse(null);
                if (conclusionVO != null) {
                    reportProjectVO.setConclusion(conclusionVO.getConclusion());
                }
            }
            //装载报告类型
            SystemDict systemDict = reportTypeList.stream().filter(item -> reportProjectVO.getReportType().equals(Integer.parseInt(item.getValue())) && item.getType().equals("REPORT_TYPE")).findFirst().orElse(null);
            if (systemDict != null) {
                reportProjectVO.setReportTypeName(systemDict.getLabel());
            }

            //装载报告状态
            SystemDict systemDictStatus = reportTypeList.stream().filter(item -> reportProjectVO.getStatus().equals(Integer.parseInt(item.getValue())) && item.getType().equals("REPORT_STATE")).findFirst().orElse(null);
            if (systemDict != null) {
                if (systemDictStatus != null) {
                    reportProjectVO.setStatusName(systemDictStatus.getLabel());
                }
            }
            //装载关联报告id
            AssoProject assoProject = assoProjects.stream().filter(item -> item.getAssoProjectId().equals(reportProjectVO.getId())).findFirst().orElse(null);
            if (assoProject != null) {
                reportProjectVO.setAssoReportId(assoProject.getProjectId());
            }

            //装载专利权人
            if (ifInvalidReport != null && ifInvalidReport && reportProjectVO.getSignPatentNo() != null && patentList.size() > 0) {
                String rightHolderStr = reportProjectVO.getRightHolderStr();
                if (rightHolderStr != null) {
                    List<String> rightHolders = Arrays.asList(rightHolderStr.split(","));
                    reportProjectVO.setRightHolder(rightHolders);

                }
            }
        }
    }


    //更新是否有第二次更新
    public Boolean updateIfSecondInvalid(UpdateIfSecondInvalidDTO dto) {
        Integer projectId = dto.getProjectId();
        Boolean ifSecondInvalid = dto.getIfSecondInvalid();
        if (ifSecondInvalid == null) {
            throw new XiaoShiException("");
        }
        //根据 项目id查询报告
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = this.getOne(queryWrapper);
        if (reportProject == null) {
            throw new XiaoShiException("不存在报告");
        }

        reportProject.setIfSecondInvalid(dto.getIfSecondInvalid());
        reportProject.updateById();
        return true;
    }

    //装载查询语句
    private List<String> loadSearchSql(List<String> sqls) {
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        String id = personnelVO.getId();
        Integer tenantId = personnelVO.getTenantId();
        Integer roleType = personnelVO.getRoleType();
        String rootSql = "";
        if (roleType == null || roleType.equals(0)) {
            rootSql = "(t.createId =" + id + " or t.headId=" + id + " or t.id in (select project_id from asso_project_person where person_id =" + id + "))";

        } else if (roleType.equals(2)) {
            rootSql = "t.tenantId=" + tenantId;
        }
        if (sqls.get(0) != null && !sqls.get(0).equals("") && !rootSql.equals("")) {
            sqls.set(0, rootSql + " and " + "(" + sqls.get(0) + ")");
        } else if ((sqls.get(0) == null || sqls.get(0).equals("")) && !rootSql.equals("")) {
            sqls.set(0, rootSql);
        }

        return sqls;

    }

    public String getSelectMessage() {
        String tableName = "";
        tableName = "select p.id as id,p.name as name ,rp.sign_patent_no as signPatentNo,p.contract_no as\n" +
                "        contract_no,p.volume_number as volumeNumber,p.commission_case_day as commissionCaseDay,\n" +
                "        p.description as description,p.create_id as createId,p.create_time as createTime, rp.report_type as reportType ,\n" +
                "        p.head_id as headId,p.department_id as departmentId, p.tenant_id as tenantId,\n" +
                "        p.entrust_type as entrustType,p.entrust_id as entrustId,rp.product_or_tech as productOrTech,rp.cron_description\n" +
                "        as cronDescription ,rp.status as status,rp.if_second_invalid as ifSecondInvalid,rp.case_number as caseNumber ,rp.issue_number as issueNumber ,rp.invalid_application as\n" +
                "        invalidApplication ,rp.act_type as actType ,rp.patent_type as patentType ,rp.current_application as\n" +
                "        currentApplication, rp.invention_name as inventionName,p.contract_no as contractNo,rp.carding_opinion,rp.official_deadline as officialDeadline,rp.oral_panel_members as oralPanelMembers,rp.evidence_risk_response as evidenceRiskResponse,\n" +
                "        rp.accept_year as acceptYear,rp.applicant_agency as applicantAgency,rp.right_holder_agency as rightHolderAgency,rp.case_stage as caseStage,\n" +
                "        aspe.event_id as eventId,arc.cron_id as cronId,aspm.matter_id as matterId,asps.scenario_id as scenarioId,rp.actual_person as actualPerson,rp.litigation_party as litigationParty,rp.right_holder as rightHolderStr from report as rp left join project as p on rp.project_id =p.id ";
        tableName += "left join asso_report_cron arc on p.id =arc.project_id " +
                "left join (select * from asso_project_event where scenario_id is not null ) as asps on p.id = asps.project_id " +
                "left join (select * from asso_project_event where event_id is not null ) as aspe on p.id = aspe.project_id " +
                "left join (select * from asso_project_event where matter_id is not null ) as aspm on p.id = aspm.project_id ";
        return tableName;
    }

    public Integer updateReportSingleColumn(UpdateSingleColumnDTO columnDTO) throws Exception {
        if (ObjectUtils.isEmpty(columnDTO)) {
            throw new XiaoShiException("请输入值");
        }
        Integer projectId = columnDTO.getProjectId();
        ReportProject reportProject = this.getOne(new LambdaQueryWrapper<ReportProject>()
                .eq(ReportProject::getProjectId, projectId));
        if (ObjectUtils.isEmpty(reportProject)) {
            throw new XiaoShiException("未查询到该报告");
        }
        String columnName = GenerateObjectUtil.getTableColumnName(reportProject, columnDTO.getField());
        if (StringUtils.isNotEmpty(columnName)) {
            reportProjectMapper.updateReportField(projectId, columnName, columnDTO.getValue());
        } else {
            throw new XiaoShiException("获取栏位错误");
        }
        return reportProject.getId();
    }

    public List<ReportProjectVO> queryReportVOs(QueryRequest queryRequest) throws Exception{
        String tableName = "reportProject";
        Boolean ifInvalidReport = queryRequest.getIfInvalidReport();
        if (ifInvalidReport != null && ifInvalidReport) {
            tableName = "invalidReportProject";
        }
        List<String> sqls = formatQueryService.reSqls(queryRequest, tableName);
        sqls = this.loadSearchSql(sqls);
        //根据sql查询事件信息
        List<ReportProjectVO> reportProject = reportProjectMapper.getReportProject(this.getSelectMessage(), sqls.get(0), sqls.get(1), sqls.get(2));
        this.loadReportProjectVO(reportProject, ifInvalidReport);
        return reportProject;
    }
}