package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.ReportAffairDTO;
import cn.cslg.pas.common.dto.invalidDTO.*;
import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
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.vo.invalidVO.*;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.ReportAffairMapper;
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.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;

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

/**
 * 报告事务Service层
 *
 * @Author xiexiang
 * @Date 2023/12/23
 */
@Slf4j
@Service
public class ReportAffairService extends ServiceImpl<ReportAffairMapper, ReportAffair> {
    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private AssoReportAffairFileService assoReportAffairFileService;
    @Autowired
    private FileManagerService fileManagerService;
    @Autowired
    @Lazy
    private InvalidRequestFileService invalidRequestFileService;
    @Autowired
    private PermissionService permissionService;
    @Autowired
    @Lazy
    private OralTrailService oralTrailService;
    @Autowired
    @Lazy
    private InvalidDecisionFileService invalidDecisionFileService;
    @Autowired
    @Lazy
    private AdminProceedService adminProceedService;
    @Autowired
    @Lazy
    private OtherDocumentsService otherDocumentsService;

    /**
     * 创建报告事务
     *
     * @param reportAffairDTO
     */
    public Integer addReportAffair(ReportAffairDTO reportAffairDTO) {
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        if (reportAffairDTO != null) {
            ReportAffair reportAffair = new ReportAffair();
            BeanUtils.copyProperties(reportAffairDTO, reportAffair);
            reportAffair.setCreateId(personnelVO.getId());
            reportAffair.insert();
            return reportAffair.getId();
        } else {
            throw new XiaoShiException("入参为空");
        }
    }

    /**
     * 删除报告事务
     * @param ids
     */
    public void delete(List<Integer> ids) {
        for (Integer id : ids) {
            LambdaQueryWrapper<ReportAffair> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ReportAffair::getId, id);
            ReportAffair reportAffair = this.getOne(queryWrapper, false);
            if (reportAffair != null) {
                //删除事务关联的文件
                LambdaQueryWrapper<AssoReportAffairFile> queryWrapper2 = new LambdaQueryWrapper<>();
                queryWrapper2.eq(AssoReportAffairFile::getReportAffairId, id);
                assoReportAffairFileService.remove(queryWrapper2);
                // 根据类型删除对应信息
                if (reportAffair.getAffairType() == 1) { //无效请求书
                    LambdaQueryWrapper<InvalidRequestFile> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(InvalidRequestFile::getReportAffairId, id);
                    invalidRequestFileService.remove(queryWrapper1);
                } else if (reportAffair.getAffairType() == 0) {//口审查记录
                    LambdaQueryWrapper<OralTrail> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(OralTrail::getReportAffairId, id);
                    oralTrailService.remove(queryWrapper1);
                } else if (reportAffair.getAffairType() == 3) {//无效决定书
                    LambdaQueryWrapper<InvalidDecisionFile> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(InvalidDecisionFile::getReportAffairId, id);
                    invalidDecisionFileService.remove(queryWrapper1);
                } else if (reportAffair.getAffairType().equals(8)) {//其他文档
                    LambdaQueryWrapper<OtherDocuments> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(OtherDocuments::getReportAffairId, id);
                    otherDocumentsService.remove(queryWrapper1);
                }
                this.removeById(id);
            }
        }
    }

    /**
     * 查询报告事务
     *
     * @param queryReportAffairDTO
     */
    public List<ReportAffairVO> queryReportAffair(QueryReportAffairDTO queryReportAffairDTO) {
        Integer projectId = queryReportAffairDTO.getProjectId();
        List<ReportAffairVO> reportAffairVOS = new ArrayList<>();
        //判空
        if (projectId == null) {
            throw new XiaoShiException("projectId为空");
        }
        //根据报告id查询事务
        LambdaQueryWrapper<ReportAffair> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportAffair::getProjectId, projectId)
                .orderByAsc(ReportAffair::getOccurredTime);
        List<ReportAffair> reportAffairs = this.list(queryWrapper);
        if (reportAffairs.isEmpty()) {
            return reportAffairVOS;
        }
        reportAffairVOS = this.loadReportAffairVOS(reportAffairs);
        return reportAffairVOS;
    }


    public List<ReportAffairVO> loadReportAffairVOS(List<ReportAffair> reportAffairs) {
        List<ReportAffairVO> reportAffairVOS = new ArrayList<>();
        reportAffairs.forEach(item -> {
            ReportAffairVO reportAffairVO = new ReportAffairVO();
            BeanUtils.copyProperties(item, reportAffairVO);
            //根据事务类型选择不同的装载方式
            Integer type = reportAffairVO.getAffairType();
            if (type.equals(0)) {//0 口审记录
                this.loadOralTrail(reportAffairVO);
            } else if (type.equals(1)) {//1 无效请求书
                this.loadInvalidRequestFile(reportAffairVO);
            } else if (type.equals(2)) {//2 陈述意见书
                this.loadStateOpinion(reportAffairVO);
            } else if (type.equals(3)) {//3 无效决定书
                this.loadInvalidDecisionFile(reportAffairVO);
            } else if (type.equals(4)) {//4 行政诉讼书
                this.loadAdminProceed(reportAffairVO);
            } else if (type.equals(5)) {//5 行政诉讼判决书
                this.loadJudgment(reportAffairVO);
            } else if (type.equals(6)) {//6 权要修改记录
                this.loadClaimHistory(reportAffairVO);
            } else if (type.equals(7)) {//7 补充证据及理由
                this.loadSupplyEvidence(reportAffairVO);
            } else if (type.equals(8)) {//8 其他文档
                this.loadOtherDocuments(reportAffairVO);
            }
            reportAffairVOS.add(reportAffairVO);
        });
        if (!reportAffairVOS.isEmpty()) {
            //装载文件信息
            this.loadSystemFile(reportAffairVOS);
            //装载创建人名
            this.loadCreateName(reportAffairVOS);
        }
        return reportAffairVOS;
    }

    /**
     * 装载文件
     *
     * @param reportAffairVOS
     */
    public void loadSystemFile(List<ReportAffairVO> reportAffairVOS) {
        reportAffairVOS.forEach(item -> {
            Integer reportAffairId = item.getId();
            List<SystemFile> systemFiles = new ArrayList<>();
            LambdaQueryWrapper<AssoReportAffairFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AssoReportAffairFile::getReportAffairId, reportAffairId);
            List<AssoReportAffairFile> files = assoReportAffairFileService.list(queryWrapper);
            if (!files.isEmpty()) {
                List<String> fileGuids = files.stream().map(AssoReportAffairFile::getFileGuid).collect(Collectors.toList());
                //根据fileGuids查询文件信息
                //查询文件
                if (fileGuids.size() != 0) {
                    try {
                        String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                        if (res != null && !res.trim().equals("")) {
                            systemFiles = JSONObject.parseArray(res, SystemFile.class);
                        }
                    } catch (Exception e) {
                        throw new XiaoShiException("查询文件详情错误");
                    }
                }
            }
            item.setSystemFileList(systemFiles);
        });
    }

    /**
     * 装载无效请求书
     *
     * @param reportAffairVO
     */
    public void loadInvalidRequestFile(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        InvalidRequestFileVO invalidRequestFileVO = invalidRequestFileService.getInvalidRequestFileVO(reportAffairId);
        reportAffairVO.setInvalidRequestFileVO(invalidRequestFileVO);
    }

    public void loadCreateName(List<ReportAffairVO> reportAffairVOS) {
        List<String> createIds = new ArrayList<>();
        reportAffairVOS.forEach(item -> {
            if (item.getCreateId() != null) {
                createIds.add(item.getCreateId());
            }
        });
        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            try {
                String res = permissionService.getPersonnelByIdsFromPCS(createIds);
                JSONObject jsonObject = JSONObject.parseObject(res);
                personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
            } catch (Exception e) {

            }
        }
        for (ReportAffairVO reportAffairVO : reportAffairVOS) {
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(reportAffairVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                reportAffairVO.setCreateName(personnel.getPersonnelName());
            }
        }
    }


    /**
     * 装载口审记录
     *
     * @param reportAffairVO
     */
    public void loadOralTrail(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        OralTrailVO oralTrailVO = oralTrailService.getOralTrailVO(reportAffairId);
        reportAffairVO.setOralTrailVO(oralTrailVO);
    }


    /**
     * 装载无效决定书
     *
     * @param reportAffairVO
     */
    public void loadInvalidDecisionFile(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        InvalidDecisionFileVO invalidDecisionFileVO = invalidDecisionFileService.getInvalidDecisionFile(reportAffairId);
        reportAffairVO.setInvalidDecisionFileVO(invalidDecisionFileVO);
    }

    /**
     * 装载行政诉讼书
     *
     * @param reportAffairVO
     */
    public void loadAdminProceed(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        AdminProceedVO adminProceedVO = adminProceedService.getAdminProceed(reportAffairId);
        reportAffairVO.setAdminProceedVO(adminProceedVO);
    }

    /**
     * 上传陈述意见书
     * @param addStateOpinionDTO
     * @return
     */
    public Integer addStateOpinion(AddStateOpinionDTO addStateOpinionDTO){
        if (addStateOpinionDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = addStateOpinionDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //1. 首先上传报告事务,拿到报告事务id
        ReportAffairDTO reportAffairDTO = new ReportAffairDTO();
        reportAffairDTO.setProjectId(projectId);
        //陈述意见书 2
        reportAffairDTO.setAffairType(2);
        //发生时间是无效请求日
        reportAffairDTO.setOccurredTime(addStateOpinionDTO.getStateReplyTime());
        //备注
        reportAffairDTO.setDescription(addStateOpinionDTO.getDescription());
        Integer reportAffairId = this.addReportAffair(reportAffairDTO);

        if (reportAffairId == null) {
            throw new XiaoShiException("上传报告事务失败");
        }
        //3. 添加报告事务与文件关联
        List<String> fileGuids = addStateOpinionDTO.getFileGuids();
        if (fileGuids != null && !fileGuids.isEmpty()) {
            List<AssoReportAffairFile> assoReportAffairFiles = new ArrayList<>();
            fileGuids.forEach(item -> {
                AssoReportAffairFile assoReportAffairFile = new AssoReportAffairFile();
                assoReportAffairFile.setReportAffairId(reportAffairId);
                assoReportAffairFile.setFileGuid(item);
                assoReportAffairFiles.add(assoReportAffairFile);
            });
            assoReportAffairFileService.saveBatch(assoReportAffairFiles);
        }
        return reportAffairId;
    }

    /**
     * 更新陈述意见
     * @param updateStateOpinionDTO
     * @return
     */
    public Integer updateStateOpinion(UpdateStateOpinionDTO updateStateOpinionDTO){
        if (updateStateOpinionDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = updateStateOpinionDTO.getProjectId();
        Integer reportAffairId = updateStateOpinionDTO.getStateOpinionId();
        if (reportAffairId == null) {
            throw new XiaoShiException("reportAffairId为空");
        }
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //2. 拿到报告事务id，获取报告事务
        ReportAffair reportAffair = this.getById(reportAffairId);
        reportAffair.setProjectId(projectId);
        //发生时间是无效请求日
        reportAffair.setOccurredTime(updateStateOpinionDTO.getStateReplyTime());
        //备注
        reportAffair.setDescription(updateStateOpinionDTO.getDescription());
        reportAffair.updateById();
        //3. 更新报告事务与文件关联
        List<String> fileGuids = updateStateOpinionDTO.getFileGuids();
        assoReportAffairFileService.updateAffairFile(reportAffairId, fileGuids);
        return reportAffairId;
    }

    /**
     * 装载陈述意见书
     *
     * @param reportAffairVO
     */
    public void loadStateOpinion(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        StateOpinionVO stateOpinionVO = new StateOpinionVO();
        ReportAffair reportAffair = this.getById(reportAffairId);
        stateOpinionVO.setStateOpinionId(reportAffairId);
        stateOpinionVO.setDescription(reportAffair.getDescription());
        stateOpinionVO.setStateReplyTime(reportAffair.getOccurredTime());
        stateOpinionVO.setProjectId(reportAffair.getProjectId());
        reportAffairVO.setStateOpinionVO(stateOpinionVO);
    }

    /**
     * 装载行政诉讼判决书
     *
     * @param reportAffairVO
     */
    public void loadJudgment(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        JudgementVO judgementVO = adminProceedService.getJudgment(reportAffairId);
        reportAffairVO.setJudgementVO(judgementVO);
    }

    /**
     * 上传权要修改记录
     * @param addClaimHistoryDTO
     * @return
     */
    public Integer addClaimHistory(AddClaimHistoryDTO addClaimHistoryDTO){
        if (addClaimHistoryDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = addClaimHistoryDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //1. 首先上传报告事务,拿到报告事务id
        ReportAffairDTO reportAffairDTO = new ReportAffairDTO();
        reportAffairDTO.setProjectId(projectId);
        //权要修改历史 6
        reportAffairDTO.setAffairType(6);
        //发生时间是无效请求日
        reportAffairDTO.setOccurredTime(addClaimHistoryDTO.getClaimHistoryTime());
        //备注
        reportAffairDTO.setDescription(addClaimHistoryDTO.getDescription());
        Integer reportAffairId = this.addReportAffair(reportAffairDTO);

        if (reportAffairId == null) {
            throw new XiaoShiException("上传报告事务失败");
        }
        //3. 添加报告事务与文件关联
        List<String> fileGuids = addClaimHistoryDTO.getFileGuids();
        if (fileGuids != null && !fileGuids.isEmpty()) {
            List<AssoReportAffairFile> assoReportAffairFiles = new ArrayList<>();
            fileGuids.forEach(item -> {
                AssoReportAffairFile assoReportAffairFile = new AssoReportAffairFile();
                assoReportAffairFile.setReportAffairId(reportAffairId);
                assoReportAffairFile.setFileGuid(item);
                assoReportAffairFiles.add(assoReportAffairFile);
            });
            assoReportAffairFileService.saveBatch(assoReportAffairFiles);
        }
        return reportAffairId;
    }

    /**
     * 更新权要修改历史
     * @param updateClaimHistoryDTO
     * @return
     */
    public Integer updateClaimHistory(UpdateClaimHistoryDTO updateClaimHistoryDTO){
        if (updateClaimHistoryDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = updateClaimHistoryDTO.getProjectId();
        Integer reportAffairId = updateClaimHistoryDTO.getClaimHistoryId();
        if (reportAffairId == null) {
            throw new XiaoShiException("reportAffairId为空");
        }
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //2. 拿到报告事务id，获取报告事务
        ReportAffair reportAffair = this.getById(reportAffairId);
        reportAffair.setProjectId(projectId);
        //发生时间是无效请求日
        reportAffair.setOccurredTime(updateClaimHistoryDTO.getClaimHistoryTime());
        //备注
        reportAffair.setDescription(updateClaimHistoryDTO.getDescription());
        reportAffair.updateById();
        //3. 更新报告事务与文件关联
        List<String> fileGuids = updateClaimHistoryDTO.getFileGuids();
        assoReportAffairFileService.updateAffairFile(reportAffairId, fileGuids);
        return reportAffairId;
    }

    /**
     * 上传补充证据及理由
     * @param addSupplyEvidenceDTO
     * @return
     */
    public Integer addSupplyEvidence(AddSupplyEvidenceDTO addSupplyEvidenceDTO){
        if (addSupplyEvidenceDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = addSupplyEvidenceDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //1. 首先上传报告事务,拿到报告事务id
        ReportAffairDTO reportAffairDTO = new ReportAffairDTO();
        reportAffairDTO.setProjectId(projectId);
        //补充证据及理由 7
        reportAffairDTO.setAffairType(7);
        //发生时间是无效请求日
        reportAffairDTO.setOccurredTime(addSupplyEvidenceDTO.getSupplyEvidenceTime());
        //备注
        reportAffairDTO.setDescription(addSupplyEvidenceDTO.getDescription());
        Integer reportAffairId = this.addReportAffair(reportAffairDTO);

        if (reportAffairId == null) {
            throw new XiaoShiException("上传报告事务失败");
        }
        //3. 添加报告事务与文件关联
        List<String> fileGuids = addSupplyEvidenceDTO.getFileGuids();
        if (fileGuids != null && !fileGuids.isEmpty()) {
            List<AssoReportAffairFile> assoReportAffairFiles = new ArrayList<>();
            fileGuids.forEach(item -> {
                AssoReportAffairFile assoReportAffairFile = new AssoReportAffairFile();
                assoReportAffairFile.setReportAffairId(reportAffairId);
                assoReportAffairFile.setFileGuid(item);
                assoReportAffairFiles.add(assoReportAffairFile);
            });
            assoReportAffairFileService.saveBatch(assoReportAffairFiles);
        }
        return reportAffairId;
    }

    /**
     * 更新补充证据及理由
     * @param updateSupplyEvidenceDTO
     * @return
     */
    public Integer updateSupplyEvidence(UpdateSupplyEvidenceDTO updateSupplyEvidenceDTO){
        if (updateSupplyEvidenceDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = updateSupplyEvidenceDTO.getProjectId();
        Integer reportAffairId = updateSupplyEvidenceDTO.getSupplyEvidenceId();
        if (reportAffairId == null) {
            throw new XiaoShiException("reportAffairId为空");
        }
        if (projectId == null) {
            throw new XiaoShiException("报告id为空");
        }
        //2. 拿到报告事务id，获取报告事务
        ReportAffair reportAffair = this.getById(reportAffairId);
        reportAffair.setProjectId(projectId);
        //发生时间是无效请求日
        reportAffair.setOccurredTime(updateSupplyEvidenceDTO.getSupplyEvidenceTime());
        //备注
        reportAffair.setDescription(updateSupplyEvidenceDTO.getDescription());
        reportAffair.updateById();
        //3. 更新报告事务与文件关联
        List<String> fileGuids = updateSupplyEvidenceDTO.getFileGuids();
        assoReportAffairFileService.updateAffairFile(reportAffairId, fileGuids);
        return reportAffairId;
    }

    /**
     * 装载权利要求修改记录
     * @param reportAffairVO
     */
    public void loadClaimHistory(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        ClaimHistoryVO claimHistoryVO = new ClaimHistoryVO();
        ReportAffair reportAffair = this.getById(reportAffairId);
        claimHistoryVO.setClaimHistoryId(reportAffairId);
        claimHistoryVO.setDescription(reportAffair.getDescription());
        claimHistoryVO.setClaimHistoryTime(reportAffair.getOccurredTime());
        claimHistoryVO.setProjectId(reportAffair.getProjectId());
        reportAffairVO.setClaimHistoryVO(claimHistoryVO);
    }

    /**
     * 装载补充证据及理由
     * @param reportAffairVO
     */
    public void loadSupplyEvidence(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        SupplyEvidenceVO supplyEvidenceVO = new SupplyEvidenceVO();
        ReportAffair reportAffair = this.getById(reportAffairId);
        supplyEvidenceVO.setSupplyEvidenceId(reportAffairId);
        supplyEvidenceVO.setDescription(reportAffair.getDescription());
        supplyEvidenceVO.setSupplyEvidenceTime(reportAffair.getOccurredTime());
        supplyEvidenceVO.setProjectId(reportAffair.getProjectId());
        reportAffairVO.setSupplyEvidenceVO(supplyEvidenceVO);
    }

    /**
     * 装载其他文档
     * @param reportAffairVO
     */
    public void loadOtherDocuments(ReportAffairVO reportAffairVO) {
        Integer reportAffairId = reportAffairVO.getId();
        OtherDocumentsVO otherDocumentsVO = otherDocumentsService.getOtherDocuments(reportAffairId);
        reportAffairVO.setOtherDocumentsVO(otherDocumentsVO);
    }

}