package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.AsInvalidReasonHistoryDTO;
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.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.utils.StringUtils;
import cn.cslg.pas.common.vo.business.AsInvalidReasonHistoryVO;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.AsInvalidReasonHistoryMapper;
import cn.cslg.pas.service.business.invalidReport.AssoReasonLiteratureService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 作为无效证据使用历史
 * @Author xiexiang
 * @Date 2024/1/19
 */
@Slf4j
@Service
public class AsInvalidReasonHistoryService extends ServiceImpl<AsInvalidReasonHistoryMapper, AsInvalidReasonHistory> {
    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoOtherPatentInfoFileService assoOtherPatentInfoFileService;

    @Autowired
    private OtherReferencesService otherReferencesService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private CompareLiteratureService compareLiteratureService;

    @Autowired
    private ReportProjectService reportProjectService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private InvalidRecordService invalidRecordService;

    @Autowired
    private AssoReasonLiteratureService assoReasonLiteratureService;

    /**
     * 新增or更新
     * @param asInvalidReasonHistoryDTO
     * @return
     */
    public Integer saveOrUpdate(AsInvalidReasonHistoryDTO asInvalidReasonHistoryDTO){
        if (asInvalidReasonHistoryDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer id = asInvalidReasonHistoryDTO.getId();
        List<String> fileGuids = asInvalidReasonHistoryDTO.getFileGuids();
        AsInvalidReasonHistory asInvalidReasonHistory = new AsInvalidReasonHistory();
        Integer type = 5;
        if (id != null) {
            //update
            asInvalidReasonHistory = this.getById(id);
            BeanUtils.copyProperties(asInvalidReasonHistoryDTO, asInvalidReasonHistory);
            asInvalidReasonHistory.updateById();
            //先删除 后添加
            LambdaQueryWrapper<AssoOtherPatentInfoFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AssoOtherPatentInfoFile::getOtherPatentInfoId, id)
                    .eq(AssoOtherPatentInfoFile::getType, type);
            assoOtherPatentInfoFileService.remove(queryWrapper);
            if (fileGuids != null && !fileGuids.isEmpty()) {
                List<Integer> fileIds = otherReferencesService.addFile(asInvalidReasonHistory.getId(), fileGuids, type);
            }
        } else {
            BeanUtils.copyProperties(asInvalidReasonHistoryDTO, asInvalidReasonHistory);
            PersonnelVO personnelVO = new PersonnelVO();
            try {
                personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
            } catch (Exception e) {
                throw new XiaoShiException("未查询到当前登陆人");
            }
            asInvalidReasonHistory.setCreateId(personnelVO.getId());
            asInvalidReasonHistory.setTenantId(personnelVO.getTenantId());
            asInvalidReasonHistory.insert();
            if (fileGuids != null && !fileGuids.isEmpty()) {
                //先删除 后添加
                List<Integer> fileIds = otherReferencesService.addFile(asInvalidReasonHistory.getId(), fileGuids, type);
            }
        }
        return asInvalidReasonHistory.getId();
    }

    /**
     * 查询
     * @param patentNo
     * @return
     * @throws IOException
     */
    public Records getAsInvalidReasonHistory(String patentNo) throws IOException {
        List<AsInvalidReasonHistoryVO> asInvalidReasonHistoryVOS = new ArrayList<>();
        if (patentNo == null || StringUtils.isEmpty(patentNo)) {
            throw new XiaoShiException("入参为空");
        }
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new XiaoShiException("未查询到当前登陆人");
        }
        LambdaQueryWrapper<AsInvalidReasonHistory> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AsInvalidReasonHistory::getPatentNo, patentNo)
                .eq(AsInvalidReasonHistory::getTenantId, personnelVO.getTenantId())
                .orderByDesc(AsInvalidReasonHistory::getInvalidTime);
        List<AsInvalidReasonHistory> asInvalidReasonHistories = this.list(queryWrapper);

        if (!asInvalidReasonHistories.isEmpty()) {
            asInvalidReasonHistories.forEach(item -> {
                AsInvalidReasonHistoryVO asInvalidReasonHistoryVO = new AsInvalidReasonHistoryVO();
                BeanUtils.copyProperties(item, asInvalidReasonHistoryVO);
                asInvalidReasonHistoryVO.setIfAdd(true);
                LambdaQueryWrapper<AssoOtherPatentInfoFile> queryWrapper1 = new LambdaQueryWrapper<>();
                queryWrapper1.eq(AssoOtherPatentInfoFile::getOtherPatentInfoId, asInvalidReasonHistoryVO.getId())
                        .eq(AssoOtherPatentInfoFile::getType, 5);
                List<AssoOtherPatentInfoFile> assoOtherPatentInfoFiles = assoOtherPatentInfoFileService.list(queryWrapper1);
                if (!assoOtherPatentInfoFiles.isEmpty()) {
                    List<String> fileGuids = assoOtherPatentInfoFiles.stream().map(AssoOtherPatentInfoFile::getFileGuid).collect(Collectors.toList());
                    asInvalidReasonHistoryVO.setFileGuids(fileGuids);
                }
                asInvalidReasonHistoryVOS.add(asInvalidReasonHistoryVO);
            });
        }
        List<AsInvalidReasonHistoryVO> finalVOS = this.findInInvalidReport(patentNo, asInvalidReasonHistoryVOS);
        this.loadAsInvalidReasonHistoryVOS(finalVOS);
        Records records = new Records();
        records.setData(finalVOS);
        return records;
    }

    /**
     * 装载
     * @param asInvalidReasonHistoryVOS
     * @throws IOException
     */
    public void loadAsInvalidReasonHistoryVOS(List<AsInvalidReasonHistoryVO> asInvalidReasonHistoryVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        asInvalidReasonHistoryVOS.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 (AsInvalidReasonHistoryVO asInvalidReasonHistoryVO : asInvalidReasonHistoryVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(asInvalidReasonHistoryVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                asInvalidReasonHistoryVO.setCreateName(personnel.getPersonnelName());
            }
            LambdaQueryWrapper<AssoOtherPatentInfoFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AssoOtherPatentInfoFile::getOtherPatentInfoId, asInvalidReasonHistoryVO.getId())
                    .eq(AssoOtherPatentInfoFile::getType, 5);
            List<AssoOtherPatentInfoFile> assoOtherPatentInfoFiles = assoOtherPatentInfoFileService.list(queryWrapper);
            if (!assoOtherPatentInfoFiles.isEmpty()) {
                List<String> fileGuids = assoOtherPatentInfoFiles.stream().map(AssoOtherPatentInfoFile::getFileGuid).collect(Collectors.toList());
                asInvalidReasonHistoryVO.setFileGuids(fileGuids);
                List<SystemFile> systemFiles = new ArrayList<>();
                if (fileGuids.size() != 0) {
                    String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                    systemFiles = JSONObject.parseArray(res, SystemFile.class);
                }
                if (!systemFiles.isEmpty()) {
                    Map<String, SystemFile> fileGuidToSystemFileMap = systemFiles.stream()
                            .collect(Collectors.toMap(SystemFile::getGuid, sf -> sf));

                    List<SystemFile> sortedSystemFiles = fileGuids.stream()
                            .map(fileGuid -> fileGuidToSystemFileMap.get(fileGuid))
                            .filter(Objects::nonNull)
                            .collect(Collectors.toList());

                    systemFiles = sortedSystemFiles;

                    asInvalidReasonHistoryVO.setSystemFileList(systemFiles);
                }
            }
        }
    }

    /**
     * 删除
     * @param ids
     * @return
     */
    public List<Integer> deleteAsInvalidReasonHistory(List<Integer> ids) {
        if (!ids.isEmpty()) {
            //先删除附件
            LambdaQueryWrapper<AssoOtherPatentInfoFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(AssoOtherPatentInfoFile::getOtherPatentInfoId, ids)
                    .eq(AssoOtherPatentInfoFile::getType, 5);
            assoOtherPatentInfoFileService.remove(queryWrapper);
            this.removeBatchByIds(ids);
        }
        return ids;
    }

    /**
     * 查询全部的
     * @param patentNo
     * @param asInvalidReasonHistoryVOS
     * @return
     */
    public List<AsInvalidReasonHistoryVO> findInInvalidReport(String patentNo, List<AsInvalidReasonHistoryVO> asInvalidReasonHistoryVOS){
        List<AsInvalidReasonHistoryVO> finalVOS = new ArrayList<>();
        finalVOS.addAll(asInvalidReasonHistoryVOS);
        //查询出所有的projectId
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareLiterature::getLiteratureNo, patentNo);
        List<CompareLiterature> compareLiteratures = compareLiteratureService.list(queryWrapper);
        //对比文献号存在
        if (!compareLiteratures.isEmpty()) {
            //取出所有报告并留下是无效的
            List<Integer> projectIds = compareLiteratures
                    .stream()
                    .map(CompareLiterature::getProjectId)
                    .collect(Collectors.toList());
            LambdaQueryWrapper<ReportProject> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(ReportProject::getProjectId, projectIds);
            List<ReportProject> results = reportProjectService.list(queryWrapper1);
            if (!results.isEmpty()) {
                results.forEach(
                        item -> {
                            Project project = projectService.getById(item.getProjectId());
                            if (project.getType().equals(2)) {
                                if (item.getReportType().equals(7)) {
                                    AsInvalidReasonHistoryVO asVO = new AsInvalidReasonHistoryVO();
                                    asVO.setPatentNo(patentNo);
                                    asVO.setInvalidedPatent(item.getSignPatentNo());
                                    asVO.setInvalidCaseNum(item.getCaseNumber());
                                    Integer affairType = 1;
                                    Date invalidTime = invalidRecordService.loadInvalidTime(affairType, item);
                                    asVO.setInvalidTime(invalidTime);
                                    asVO.setCreateId(project.getCreateId());
                                    asVO.setCreateTime(project.getCreateTime());
                                    List<String> fileGuids = invalidRecordService.loadFileGuids(item.getProjectId());
                                    asVO.setFileGuids(fileGuids);
                                    asVO.setIfAdd(false);
                                    finalVOS.add(asVO);
                                } else if (item.getReportType().equals(1) || item.getReportType().equals(2)) {
                                    //判断是否有对比结果
                                    LambdaQueryWrapper<CompareLiterature> queryWrapper2 = new LambdaQueryWrapper<>();
                                    queryWrapper2.eq(CompareLiterature::getLiteratureNo, patentNo)
                                            .eq(CompareLiterature::getProjectId, item.getProjectId());
                                    CompareLiterature compareLiterature = compareLiteratureService.getOne(queryWrapper2, false);
                                    if (compareLiterature != null) {
                                        Integer compareLiteratureId = compareLiterature.getId();
                                        LambdaQueryWrapper<AssoReasonLiterature> queryWrapper3 = new LambdaQueryWrapper<>();
                                        queryWrapper3.eq(AssoReasonLiterature::getLiteratureId, compareLiteratureId);
                                        List<AssoReasonLiterature> assoReasonLiteratures = assoReasonLiteratureService.list(queryWrapper3);
                                        if (!assoReasonLiteratures.isEmpty()) {
                                            AsInvalidReasonHistoryVO asVO = new AsInvalidReasonHistoryVO();
                                            asVO.setPatentNo(patentNo);
                                            asVO.setInvalidedPatent(item.getSignPatentNo());
                                            asVO.setInvalidCaseNum(item.getCaseNumber());
                                            Integer affairType = 1;
                                            Date invalidTime = invalidRecordService.loadInvalidTime(affairType, item);
                                            asVO.setInvalidTime(invalidTime);
                                            asVO.setCreateId(project.getCreateId());
                                            asVO.setCreateTime(project.getCreateTime());
                                            List<String> fileGuids = invalidRecordService.loadFileGuids(item.getProjectId());
                                            asVO.setFileGuids(fileGuids);
                                            asVO.setIfAdd(false);
                                            finalVOS.add(asVO);
                                        }
                                    }
                                }
                            }
                        }
                );
            }
        }
        return finalVOS;
    }

}