package com.doumee.service.business.impl;

import com.alibaba.fastjson.JSONObject;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DateUtil;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.dto.SCSupplementDTO;
import com.doumee.dao.business.dto.SettleClaimsDTO;
import com.doumee.dao.business.join.MultifileJoinMapper;
import com.doumee.dao.business.join.SettleClaimsJoinMapper;
import com.doumee.dao.business.join.SettleClaimsLogJoinMapper;
import com.doumee.dao.business.model.*;
import com.doumee.dao.business.vo.RiskConfigVO;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.SettleClaimsLogService;
import com.doumee.service.business.SettleClaimsService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.service.system.impl.SystemDictDataServiceImpl;
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 理赔申请表Service实现
 * @author 江蹄蹄
 * @date 2024/01/16 10:03
 */
@Service
public class SettleClaimsServiceImpl implements SettleClaimsService {

    @Autowired
    private SettleClaimsMapper settleClaimsMapper;

    @Autowired
    private SettleClaimsLogMapper settleClaimsLogMapper;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private MultifileJoinMapper multifileJoinMapper;

    @Autowired
    private SettleClaimsJoinMapper settleClaimsJoinMapper;

    @Autowired
    private SettleClaimsLogJoinMapper settleClaimsLogJoinMapper;

    @Autowired
    private NoticesMapper noticesMapper;

    @Autowired
    private InsuranceApplyMapper insuranceApplyMapper;

    @Autowired
    private SolutionsMapper solutionsMapper;

    @Autowired
    private SolutionsBaseMapper solutionsBaseMapper;

    @Autowired
    private ApplyDetailMapper applyDetailMapper;

    /**
     * 删除附件
     * @return
     */
    @Override
    public  Integer delFile(Integer id,Integer fileId){
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        return   multifileJoinMapper.update(null,new UpdateWrapper<Multifile>().lambda()
                .set(Multifile::getIsdeleted,Constants.ONE)
                .set(Multifile::getEditDate,new Date())
                .set(Multifile::getEditor,user.getId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .eq(Multifile::getObjId,id)
                .eq(Multifile::getId,fileId)
                .in(Multifile::getObjType,Arrays.asList(new Integer[]{
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey(),
                        Constants.MultiFile.LP_JACL_FILE.getKey(),
                })));
    }
    @Override
    public      Integer back(SettleClaims  param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }

        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey());
        settleClaimsMapper.updateById(update);


        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));

        Notices notices = new Notices(noticeObjectType,Constants.ONE,model.getId(),model.getInformantName(),
                model.getCompanyId(), Constants.NoticeType.FOUR);
        noticesMapper.insert(notices);


        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_RETURN;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 资料确认
     * @param param
     * @return
     */
    @Override
    public      Integer confirm(SettleClaims  param){
        if(param.getId() == null ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey());
        settleClaimsMapper.updateById(update);


        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_CONFIRM_INFORMATION;
        String info =applyLogType.getInfo();
//        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔备注标签
     * @param param
     * @return
     */
    @Override
    public       Integer remark(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
     /*   if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
*/
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备注标签");
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_REMARK;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", param.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔结案提交
     * @param param
     * @return
     */
    @Override
    public    Integer doneCommit(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //受理中和已确认资料可以进行理赔处理
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
              ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setStatus(Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey());
        update.setId(model.getId());
        update.setYlClaimAccount(Constants.formatBigdecimal(param.getYlClaimAccount()));
        update.setSwClaimAccount(Constants.formatBigdecimal(param.getSwClaimAccount()));
        update.setWgClaimAccount(Constants.formatBigdecimal(param.getWgClaimAccount()));
        update.setScClaimAccount(Constants.formatBigdecimal(param.getScClaimAccount()));
        update.setClaimAccount(update.getYlClaimAccount().add(update.getSwClaimAccount()).add(update.getScClaimAccount()).add(update.getWgClaimAccount()));
        settleClaimsMapper.updateById(update);

        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));
        Notices notices = new Notices(noticeObjectType,Constants.ONE,model.getId(),model.getInformantName(),
                model.getCompanyId(), Constants.NoticeType.ONE);
        noticesMapper.insert(notices);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_FINISH;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔处理
     * @param param
     * @return
     */
    @Override
    public Integer dealBiz(SettleClaims  param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //受理中和已确认资料可以进行理赔处理
        if( Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey())
              ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_LP_DEAL;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 添加备案号
     * @param param
     * @return
     */
    @Override
    public Integer addCode(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getReportNum()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备案号");
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.DEAL_ING.getKey());
        update.setReportNum(param.getReportNum());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_ADDCODE;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getReportNum());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    @Override
    public Integer create(SettleClaims settleClaims) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(settleClaims)
                || Objects.isNull(settleClaims.getMemberId())
                || Objects.isNull(settleClaims.getSolutionId())
                || Objects.isNull(settleClaims.getDuId())
                || Objects.isNull(settleClaims.getWorktypeId())
                || Objects.isNull(settleClaims.getHappenTime())
                || Objects.isNull(settleClaims.getType())
                || Objects.isNull(settleClaims.getInHospital())
                || Objects.isNull(settleClaims.getMedicalInsurance())
                || Objects.isNull(settleClaims.getContent())
                || Objects.isNull(settleClaims.getInformantName())
                || Objects.isNull(settleClaims.getInformantPhone())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        //查询是否存在已提报的数据  根据人员和保险方案进行过滤 是否存在进行中的数据
        if(settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getSolutionId,settleClaims.getSolutionId())
                .eq(SettleClaims::getMemberId,loginUserInfo.getId())
                .in(SettleClaims::getStatus,Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey(),
                        Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())
        )>Constants.ZERO){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在提报中的报案数据!");
        }
        settleClaims.setCreateDate(new Date());
        settleClaims.setIsdeleted(Constants.ZERO);
        settleClaims.setCompanyId(loginUserInfo.getCompanyId());
        settleClaims.setStatus(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
        settleClaims.setCreator(loginUserInfo.getId());
        settleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaimsMapper.insert(settleClaims);

        List<Multifile> reportVideo = settleClaims.getReportFileList();
        if(CollectionUtils.isNotEmpty(reportVideo)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.ONE);
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }
        //记录日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.UPLOAD,null);


        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,settleClaims.getId()));
        Notices notices = new Notices(noticeObjectType,Constants.ZERO,settleClaims.getId(),settleClaims.getInformantName(),
                settleClaims.getCompanyId(), Constants.NoticeType.ZERO);
        noticesMapper.insert(notices);


        return settleClaims.getId();
    }

    @Override
    public  void exportFiles(Integer id, HttpServletResponse response) {
        try {
            SettleClaims model = settleClaimsMapper.selectById(id);
            if(model == null){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
            SettleClaims update = new SettleClaims();
            update.setEditDate(new Date());
            update.setEditor(loginUserInfo.getId());
            Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_DOWNLOAD;
            String info =applyLogType.getInfo();
            SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
            settleClaimsLogMapper.insert(log);

            List<File> fileList = new ArrayList<>();
            List<Multifile> multifileList = multifileJoinMapper.selectList(new QueryWrapper<Multifile>().lambda()
                    .eq(Multifile::getIsdeleted,Constants.ZERO)
                    .eq(Multifile::getObjId,id)
                    .isNotNull(Multifile::getFileurl)
                    .in(Multifile::getObjType, Arrays.asList(new Integer[]{
                            Constants.MultiFile.LP_YGGX_FILE.getKey(),
                            Constants.MultiFile.LP_MZCL_FILE.getKey(),
                            Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                            Constants.MultiFile.LP_SCZL_FILE.getKey(),
                            Constants.MultiFile.LP_JACL_FILE.getKey(),
                    }))
                    .orderByAsc(Multifile::getCreateDate)
            );
            if(multifileList== null || multifileList.size() == 0){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            String path = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode()+systemDictDataBiz.queryByCode(Constants.OSS,Constants.SETTLE_FILE).getCode();
            Integer sn = 1;
            for(Multifile l : multifileList){
                File f = Constants.getFileByNetFile(path + l.getFileurl(),StringUtils.defaultString(sn + "_" +l.getName(),"未命名"));
                if(f !=null && f.isFile()){
                    fileList.add(f);
                }
                sn = sn +1;
            }
            if(fileList == null || fileList.size() == 0){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            String fileName =  model.getInformantName() +"-理赔资料-" +System.currentTimeMillis();
            String encodeFileName =URLEncoder.encode(fileName, Charset.forName("UTF-8").toString())+".zip";
            response.setHeader("Content-Disposition","attachment;filename=" + encodeFileName);
            response.setContentType("application/octet-stream");
            response.setHeader("eva-opera-type", "download");
            response.setHeader("eva-download-filename", encodeFileName);
            Constants.packFilesToZip(fileList,response.getOutputStream());
        } catch (Exception e) {
            throw new BusinessException(ResponseStatus.EXPORT_EXCEL_ERROR, e);
        }
    }

    @Override
    public SettleClaims getSettleClaimsDetail(Integer id){

        MPJLambdaWrapper<SettleClaims>  queryWrapper =    new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(Company::getName,SettleClaims::getCompanyName)
                .selectAs(Solutions::getName,SettleClaims::getSolutionName)
                .selectAs(Member::getName,SettleClaims::getMemberName)
                .selectAs(Member::getIdcardNo,SettleClaims::getMemberIdcardNo)
                .selectAs(InsuranceApply::getCode,SettleClaims::getApplyCode)
                .selectAs(Worktype::getName,SettleClaims::getWorktypeName)
                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
                .selectAs(InsuranceApply::getEndTime,SettleClaims::getBaoxianEndTime)
                .selectAs(DispatchUnit::getName,SettleClaims::getDuName)
                .leftJoin(Company.class,Company::getId,SettleClaims::getCompanyId)
                .leftJoin(Member.class,Member::getId,SettleClaims::getMemberId)
                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)
                .leftJoin(Worktype.class,Worktype::getId,SettleClaims::getWorktypeId)
                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
                .leftJoin(Solutions.class,Solutions::getId,SettleClaims::getSolutionId)
                .eq(SettleClaims::getId,id);
        SettleClaims settleClaims = settleClaimsJoinMapper.selectJoinOne(SettleClaims.class,queryWrapper);
        if(settleClaims == null){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        List<Multifile> multifileList = multifileJoinMapper.selectJoinList(Multifile.class,
                new MPJLambdaWrapper<Multifile>()
                .selectAll(Multifile.class)
                .selectAs(SystemUser::getRealname,Multifile::getCreatorName)
                .leftJoin(SystemUser.class,SystemUser::getId,Multifile::getCreator)
                .eq(Multifile::getObjId,id)
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .orderByAsc(Multifile::getCreateDate)
        );
        String rPath = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode();
        String path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.SETTLE_FILE).getCode();
        if(multifileList!=null){
            for(Multifile f : multifileList){
                if(f!=null&& StringUtils.isNotBlank(f.getFileurl())){
                    f.setFileurlFull(path+f.getFileurl());
                }
            }
        }
        Multifile baoxiandanFile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda().eq(Multifile::getObjId,settleClaims.getInsuranceApplyId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .eq(Multifile::getObjType,Constants.MultiFile.BD_DONE_PDF.getKey())
                .last("limit 1"));
        if(baoxiandanFile!=null&& StringUtils.isNotBlank(baoxiandanFile.getFileurl())){
            path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.APPLY_FILE).getCode();
            baoxiandanFile.setFileurlFull(path+baoxiandanFile.getFileurl());
        }
        settleClaims.setBaoxiandanFile(baoxiandanFile);//保险单
        if(CollectionUtils.isNotEmpty(multifileList)){
            settleClaims.setReportFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SGXC_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setRelationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_YGGX_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setOutpatientFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_MZCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setHospitalFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_ZYCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setDisabilityFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SCZL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setCompensationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_JACL_FILE.getKey())).collect(Collectors.toList()));
        }

        //查询操作记录
        List<SettleClaimsLog> settleClaimsLogList = settleClaimsLogJoinMapper.selectJoinList(SettleClaimsLog.class,
                new MPJLambdaWrapper<SettleClaimsLog>()
                        .selectAll(SettleClaimsLog.class)
                        .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                        .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                        .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                        .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                        .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                        .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                        .orderByAsc(SettleClaimsLog::getCreateDate)
        );
        settleClaims.setSettleClaimsLogList(settleClaimsLogList);
        SettleClaimsLog lastConfirm = settleClaimsLogMapper.selectOne(new QueryWrapper<SettleClaimsLog>().lambda()
                .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                .eq(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_CONFIRM_INFORMATION.getKey())
                .orderByDesc(SettleClaimsLog::getCreateDate)
                .last(" limit 1")
        );

        Multifile multifile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda()
                .eq(Multifile::getObjId,settleClaims.getId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .in(Multifile::getObjType,
                        Constants.MultiFile.LP_SGXC_FILE.getKey(),
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey(),
                        Constants.MultiFile.LP_JACL_FILE.getKey())
                .orderByDesc(Multifile::getCreateDate)
                .last(" limit 1")
        );

        if(!Objects.isNull(lastConfirm)&&!Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate().compareTo(multifile.getCreateDate())>=0?lastConfirm.getCreateDate():multifile.getCreateDate());
        }else if(!Objects.isNull(lastConfirm)&&Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate());
        }
        return settleClaims;
    }



    @Override
    public Integer updateForCompany(SettleClaims settleClaims) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(settleClaims)
                || Objects.isNull(settleClaims.getId())
                || Objects.isNull(settleClaims.getMemberId())
                || Objects.isNull(settleClaims.getSolutionId())
                || Objects.isNull(settleClaims.getDuId())
                || Objects.isNull(settleClaims.getWorktypeId())
                || Objects.isNull(settleClaims.getType())
                || Objects.isNull(settleClaims.getInHospital())
                || Objects.isNull(settleClaims.getMedicalInsurance())
                || Objects.isNull(settleClaims.getInformantName())
                || Objects.isNull(settleClaims.getInformantPhone())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        SettleClaims oldSettleClaims  = settleClaimsMapper.selectById(settleClaims.getId());
        if(Objects.isNull(oldSettleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到修改数据");
        }
        if(!oldSettleClaims.getSolutionId().equals(settleClaims.getSolutionId())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"无法修改方案信息");
        }
        if(!(oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        oldSettleClaims.setEditor(loginUserInfo.getId());
        oldSettleClaims.setEditDate(new Date());
        oldSettleClaims.setDuId(settleClaims.getDuId());
        oldSettleClaims.setWorktypeId(settleClaims.getWorktypeId());
        oldSettleClaims.setInHospital(settleClaims.getInHospital());
        oldSettleClaims.setMedicalInsurance(settleClaims.getMedicalInsurance());
        oldSettleClaims.setAreaId(settleClaims.getAreaId());
        oldSettleClaims.setAreaInfo(settleClaims.getAreaInfo());
        oldSettleClaims.setType(settleClaims.getType());
        oldSettleClaims.setInformantName(settleClaims.getInformantName());
        oldSettleClaims.setInformantPhone(settleClaims.getInformantPhone());
        oldSettleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaimsMapper.updateById(oldSettleClaims);
        //记录日志
        Constants.SettleClaimsLogType settleClaimsLogType =  Constants.SettleClaimsLogType.UPDATE_DATA;
        this.saveSettleClaimsLog(settleClaims,settleClaimsLogType,null);
        return oldSettleClaims.getId();
    }

    @Override
    public void supplement(SCSupplementDTO scSupplementDTO){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(scSupplementDTO)
                || Objects.isNull(scSupplementDTO.getId())
                || Objects.isNull(scSupplementDTO.getSupplement())
                || Objects.isNull(scSupplementDTO.getObjType())
                || !(scSupplementDTO.getObjType().equals(Constants.ZERO))
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsMapper.selectById(scSupplementDTO.getId());
        if(!(settleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        settleClaims.setEditor(loginUserInfo.getId());
        settleClaims.setEditDate(new Date());
        settleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaims.setCheckInfo(scSupplementDTO.getSupplement());
        settleClaimsMapper.updateById(settleClaims);

        Constants.SettleClaimsLogType settleClaimsLogType =  Constants.SettleClaimsLogType.SUPPLEMENT;
        String content = settleClaimsLogType.getInfo().replace("${param}", scSupplementDTO.getSupplement());
        this.saveSettleClaimsLog(settleClaims,settleClaimsLogType,content);
    }




    @Override
    public void claimsUploadFile(SCSupplementDTO scSupplementDTO){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(scSupplementDTO)
                || Objects.isNull(scSupplementDTO.getId())
                || Objects.isNull(scSupplementDTO.getObjType())
                || Objects.isNull(scSupplementDTO.getFileUrl())
                || Objects.isNull(scSupplementDTO.getFileType())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims settleClaims  = settleClaimsMapper.selectById(scSupplementDTO.getId());
        if(!(settleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        Multifile multifile = new Multifile();
        if(loginUserInfo.getType().equals(Constants.ONE)){
            multifile.setCompanyId(loginUserInfo.getCompanyId());
        }
        multifile.setCreator(loginUserInfo.getId());
        multifile.setCreateDate(new Date());
        multifile.setIsdeleted(Constants.ZERO);
        multifile.setObjType(scSupplementDTO.getObjType());
        multifile.setObjId(scSupplementDTO.getId());
        multifile.setFileurl(scSupplementDTO.getFileUrl());
        multifile.setName(scSupplementDTO.getFileName());
        multifile.setType(scSupplementDTO.getFileType());
        multifileJoinMapper.insert(multifile);
    }




    public void saveSettleClaimsLog(SettleClaims settleClaims, Constants.SettleClaimsLogType settleClaimsLogType, String content){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal(); 
        SettleClaimsLog settleClaimsLog = new SettleClaimsLog();
        settleClaimsLog.setCreateDate(new Date());
        settleClaimsLog.setCreator(loginUserInfo.getId());
        settleClaimsLog.setIsdeleted(Constants.ZERO);
        settleClaimsLog.setSettleClainmsId(settleClaims.getId());
        settleClaimsLog.setTitle(settleClaimsLogType.getName());
        settleClaimsLog.setContent(content);
        settleClaimsLog.setObjType(settleClaimsLogType.getKey());
        settleClaimsLog.setObjId(settleClaims.getId());
        settleClaimsLogMapper.insert(settleClaimsLog);
    }

    @Override
    public void deleteById(Integer id) {
        settleClaimsMapper.deleteById(id);
    }

    @Override
    public void delete(SettleClaims settleClaims) {
        UpdateWrapper<SettleClaims> deleteWrapper = new UpdateWrapper<>(settleClaims);
        settleClaimsMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        settleClaimsMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(SettleClaims settleClaims) {
        settleClaimsMapper.updateById(settleClaims);
    }

    @Override
    public void updateByIdInBatch(List<SettleClaims> settleClaimss) {
        if (CollectionUtils.isEmpty(settleClaimss)) {
            return;
        }
        for (SettleClaims settleClaims: settleClaimss) {
            this.updateById(settleClaims);
        }
    }

    @Override
    public SettleClaims findById(Integer id) {

        return settleClaimsMapper.selectById(id);
    }

    @Override
    public SettleClaims findOne(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectOne(wrapper);
    }

    @Override
    public List<SettleClaims> findList(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<SettleClaims> findPage(PageWrap<SettleClaims> pageWrap) {
        IPage<SettleClaims> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Utils.MP.blankToNull(pageWrap.getModel());
        MPJLambdaWrapper<SettleClaims>  queryWrapper =    new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(Company::getName,SettleClaims::getCompanyName)
                .selectAs(Solutions::getName,SettleClaims::getSolutionName)
                .selectAs(Member::getName,SettleClaims::getMemberName)
                .selectAs(Member::getIdcardNo,SettleClaims::getMemberIdcardNo)
                .selectAs(Worktype::getName,SettleClaims::getWorktypeName)
                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
                .selectAs(DispatchUnit::getName,SettleClaims::getDuName)
                .leftJoin(Company.class,Company::getId,SettleClaims::getCompanyId)
                .leftJoin(Member.class,Member::getId,SettleClaims::getMemberId)
                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)
                .leftJoin(Worktype.class,Worktype::getId,SettleClaims::getWorktypeId)
                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
                .leftJoin(Solutions.class,Solutions::getId,SettleClaims::getSolutionId);
        queryWrapper.eq(DispatchUnit::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(SettleClaims::getIsdeleted,Constants.ZERO);
        if(Constants.equalsInteger(user.getType(),Constants.ZERO)){
            //只能看权限范围内
            if(user.getCompanyIdList() == null || user.getCompanyIdList().size() == 0){
                queryWrapper. eq(Company::getId,-1);//设置无效访问
            }else {
                queryWrapper. in(Company::getId, user.getCompanyIdList());
            }
        } else  {
            //企业用户只看自己的数据
            pageWrap.getModel().setCompanyId(user.getCompanyId());
        }
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMemberName()),Member::getName, pageWrap.getModel().getMemberName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMemberIdcardNo()),Member::getIdcardNo, pageWrap.getModel().getMemberIdcardNo());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getDuName()),DispatchUnit::getName, pageWrap.getModel().getDuName());
        queryWrapper.eq(pageWrap.getModel().getBaseSolutionId()!=null,Solutions::getBaseId, pageWrap.getModel().getBaseSolutionId());
        queryWrapper.eq(pageWrap.getModel().getBaseDuId()!=null,DispatchUnit::getBaseId, pageWrap.getModel().getBaseDuId());

        if (pageWrap.getModel().getId() != null) {
            queryWrapper.eq(SettleClaims::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.eq(SettleClaims::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.ge(SettleClaims::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.le(SettleClaims::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.eq(SettleClaims::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.ge(SettleClaims::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.le(SettleClaims::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.eq(SettleClaims::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.eq(SettleClaims::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getSortnum() != null) {
            queryWrapper.eq(SettleClaims::getSortnum, pageWrap.getModel().getSortnum());
        }
        if (pageWrap.getModel().getSolutionId() != null) {
            queryWrapper.eq(SettleClaims::getSolutionId, pageWrap.getModel().getSolutionId());
        }
        if (pageWrap.getModel().getCompanyId() != null) {
            queryWrapper.eq(SettleClaims::getCompanyId, pageWrap.getModel().getCompanyId());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.eq(SettleClaims::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getHappenTime() != null) {
            queryWrapper.eq(SettleClaims::getHappenTime, pageWrap.getModel().getHappenTime());
        }
        if (pageWrap.getModel().getIdcardNo() != null) {
            queryWrapper.eq(SettleClaims::getIdcardNo, pageWrap.getModel().getIdcardNo());

        }
        if (pageWrap.getModel().getDuId() != null) {
            queryWrapper.eq(SettleClaims::getDuId, pageWrap.getModel().getDuId());
        }
        if (pageWrap.getModel().getWorktypeId() != null) {
            queryWrapper.eq(SettleClaims::getWorktypeId, pageWrap.getModel().getWorktypeId());
        }
        if (pageWrap.getModel().getFee() != null) {
            queryWrapper.eq(SettleClaims::getFee, pageWrap.getModel().getFee());
        }
        if (pageWrap.getModel().getCheckInfo() != null) {
            queryWrapper.eq(SettleClaims::getCheckInfo, pageWrap.getModel().getCheckInfo());
        }
        if (pageWrap.getModel().getCheckUserId() != null) {
            queryWrapper.eq(SettleClaims::getCheckUserId, pageWrap.getModel().getCheckUserId());
        }
        if (pageWrap.getModel().getCode() != null) {
            queryWrapper.eq(SettleClaims::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getStatus() != null) {
            if(pageWrap.getModel().getStatus().equals(Constants.ZERO)){
                queryWrapper.in(SettleClaims::getStatus, Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey()
                        ,Constants.SettleClaimsStatus.DEAL_ING.getKey()
                        ,Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey());
            }else{
                queryWrapper.eq(SettleClaims::getStatus, pageWrap.getModel().getStatus());
            }


        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.eq(SettleClaims::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getInHospital() != null) {
            queryWrapper.eq(SettleClaims::getInHospital, pageWrap.getModel().getInHospital());
        }
        if (pageWrap.getModel().getMedicalInsurance() != null) {
            queryWrapper.eq(SettleClaims::getMedicalInsurance, pageWrap.getModel().getMedicalInsurance());
        }
        if (pageWrap.getModel().getContent() != null) {
            queryWrapper.eq(SettleClaims::getContent, pageWrap.getModel().getContent());
        }
        if (pageWrap.getModel().getInformantName() != null) {
            queryWrapper.eq(SettleClaims::getInformantName, pageWrap.getModel().getInformantName());
        }
        if (pageWrap.getModel().getInformantPhone() != null) {
            queryWrapper.eq(SettleClaims::getInformantPhone, pageWrap.getModel().getInformantPhone());
        }
        if (pageWrap.getModel().getAreaId() != null) {
            queryWrapper.eq(SettleClaims::getAreaId, pageWrap.getModel().getAreaId());
        }
        if (pageWrap.getModel().getAreaInfo() != null) {
            queryWrapper.eq(SettleClaims::getAreaInfo, pageWrap.getModel().getAreaInfo());
        }
        if (pageWrap.getModel().getReportNum() != null) {
            queryWrapper.eq(SettleClaims::getReportNum, pageWrap.getModel().getReportNum());
        }
        if (pageWrap.getModel().getInsuranceApplyId() != null) {
            queryWrapper.eq(SettleClaims::getInsuranceApplyId, pageWrap.getModel().getInsuranceApplyId());
        }
        queryWrapper.orderByDesc(SettleClaims::getCreateDate);
        /*for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }*/
        PageData<SettleClaims> pageData = PageData.from(settleClaimsJoinMapper.selectJoinPage(page,SettleClaims.class, queryWrapper));
        return pageData;
    }

    @Override
    public long count(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectCount(wrapper);
    }


    public void saveSettleClaims(SettleClaimsDTO settleClaimsDTO){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        if(Objects.isNull(settleClaimsDTO)
            || Objects.isNull(settleClaimsDTO.getSaveType())
            || Objects.isNull(settleClaimsDTO.getMemberId())
            ||StringUtils.isBlank(settleClaimsDTO.getIdcardNo())
            || Objects.isNull(settleClaimsDTO.getInsuranceApplyId())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)){
            if(Objects.isNull(settleClaimsDTO.getSolutionId())
                    ||Objects.isNull(settleClaimsDTO.getWorktypeId())
                    ||Objects.isNull(settleClaimsDTO.getDuId())
                    ||StringUtils.isBlank(settleClaimsDTO.getHappenTime())
                    ||StringUtils.isBlank(settleClaimsDTO.getContent())
                    ||Objects.isNull(settleClaimsDTO.getType())
                    ||Objects.isNull(settleClaimsDTO.getInHospital())
                    ||Objects.isNull(settleClaimsDTO.getHurtType())
                    ||Objects.isNull(settleClaimsDTO.getMedicalInsurance())
                    ||StringUtils.isBlank(settleClaimsDTO.getInformantName())
                    ||StringUtils.isBlank(settleClaimsDTO.getInformantPhone())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveUserName())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveBank())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveAccount())
            ){
                throw new BusinessException(ResponseStatus.BAD_REQUEST);
            }
        }
        SettleClaims settleClaims = new SettleClaims();
        BeanUtils.copyProperties(settleClaimsDTO,settleClaims);
        if(Objects.nonNull(settleClaims.getId())){
            settleClaims.setEditDate(new Date());
            settleClaims.setEditor(loginUserInfo.getId());
            settleClaimsMapper.updateById(settleClaims);
        }else{
            settleClaims.setCreateDate(new Date());
            settleClaims.setIsdeleted(Constants.ZERO);
            settleClaims.setCompanyId(loginUserInfo.getCompanyId());
            settleClaims.setStatus(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)?
                    Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey():Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
            settleClaims.setCreator(loginUserInfo.getId());
            settleClaims.setCheckUserId(loginUserInfo.getId());
            settleClaimsMapper.insert(settleClaims);
        }
        this.saveFile(settleClaims,settleClaimsDTO,loginUserInfo);
        //处理风险信息


    }

    public void saveRisk(SettleClaims settleClaims, SettleClaimsDTO settleClaimsDTO, SystemDictDataServiceImpl systemDictDataService){
        //根据保单信息 查询出主方案
        InsuranceApply insuranceApply = insuranceApplyMapper.selectById(settleClaims.getInsuranceApplyId());
        if(Objects.isNull(insuranceApply)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到保单数据");
        }
        Date happenTime = DateUtil.StringToDate(settleClaims.getHappenTime());
        if(happenTime.getTime() < insuranceApply.getStartTime().getTime() || happenTime.getTime() > insuranceApply.getEndTime().getTime()){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生事件未在保单生效范围内");
        }
        Solutions solutions = solutionsMapper.selectById(insuranceApply.getSolutionId());
        if(Objects.isNull(solutions)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到子方案信息");
        }
        SolutionsBase solutionsBase = solutionsBaseMapper.selectById(solutions.getParentId());
        if(Objects.isNull(solutionsBase)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到主方案信息");
        }
        List<Map<String,String>> riskList = new ArrayList<>();
        //查询保单明细数据
        ApplyDetail applyDetail = applyDetailMapper.selectOne(new QueryWrapper<ApplyDetail>().lambda().eq(ApplyDetail::getApplyId,settleClaims.getInsuranceApplyId()).eq(ApplyDetail::getId,settleClaimsDTO.getApplyDetailId()).last("limit 1 "));
        //是否开启 新员工报案 0不允许 1允许
        if(Constants.equalsInteger(solutionsBase.getRiskNewUserStatus(),Constants.ONE)
                && Objects.nonNull(solutionsBase.getRiskNewUserUnit())
                && Objects.nonNull(solutionsBase.getRiskNewUserTime())
        ){
            if(happenTime.getTime() > applyDetail.getEndTime().getTime()){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }
            Map<String,String> map = new HashMap<>();
            map.put("title","保单已投保未生效");
            Date startDate = applyDetail.getStartTime();
            if(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.ONE)){
                startDate = DateUtil.afterMinutesByDate(-solutionsBase.getRiskNewUserTime()*60,startDate);
            }else if(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.TWO)){
                startDate = DateUtil.afterDayByDate(-solutionsBase.getRiskNewUserTime(),happenTime);
            }else{
                if(happenTime.getTime() < applyDetail.getStartTime().getTime() || happenTime.getTime() > applyDetail.getEndTime().getTime()){
                    throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
                }
            }
            if(happenTime.getTime() < startDate.getTime() ){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }else{
                map.put("info","事故发生时间早于保单生效时间"+solutionsBase.getRiskNewUserUnit()+(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.ONE)?"小时内":"天内"));
                riskList.add(map);
            }
        }else{
            if(happenTime.getTime() < applyDetail.getStartTime().getTime() || happenTime.getTime() > applyDetail.getEndTime().getTime()){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }
        }

        //是否开启 延迟报案提醒是否开启 0不允许 1允许
        if(Constants.equalsInteger(solutionsBase.getRiskDelayStatus(),Constants.ONE)){
            Map<String,String> map = new HashMap<>();
            map.put("title","延迟报案提醒");
            //根据配置 查询 延迟报案提醒时间单位 0分钟 1小时 2天
            if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.ZERO)){
                if(DateUtil.getBetweenMin(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"分钟");
                    riskList.add(map);
                }
            }else if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.ONE)){
                if(DateUtil.getBetweenHours(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"小时");
                    riskList.add(map);
                }
            }else if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.TWO)){
                if(DateUtil.getBetweenDay(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"天");
                    riskList.add(map);
                }
            }
        }

        //查询字典值配置信息
        RiskConfigVO riskConfigVO = systemDictDataService.getRiskConfig();
        //多次出险提醒
        if(StringUtils.isNotBlank(riskConfigVO.getRiskTimesOpen()) && StringUtils.equals(riskConfigVO.getRiskTimesOpen(),Constants.ONE+"")
            && StringUtils.isNotBlank(riskConfigVO.getRiskTimesReportTimes())){
            Integer cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getMemberId,settleClaimsDTO.getMemberId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(" HAPPEN_TIME > DATE_SUB(now(), INTERVAL 365 DAY)  ")
            );
            if(cxcs>Integer.valueOf(riskConfigVO.getRiskTimesReportTimes())){
                Map<String,String> map = new HashMap<>();
                map.put("title","疑似多次出险");
                map.put("info","出险人一年内已出险"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskTimesCx(Constants.ONE);
            };
        }
        //疑似重复报案
        if(StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportOpen())
                && StringUtils.equals(riskConfigVO.getRiskRepeatReportOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportTimeUnit())
                && StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportTime())){
            Integer cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getMemberId,settleClaimsDTO.getMemberId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(riskConfigVO.getRiskRepeatReportTimeUnit().equals("1")," HAPPEN_TIME > DATE_SUB(now(), INTERVAL "+riskConfigVO.getRiskRepeatReportTime()+" HOUR)  ")
                    .apply(riskConfigVO.getRiskRepeatReportTimeUnit().equals("2")," HAPPEN_TIME > DATE_SUB(now(), INTERVAL "+riskConfigVO.getRiskRepeatReportTime()+" DAY)  ")
            );
            if(cxcs > Constants.TWO){
                Map<String,String> map = new HashMap<>();
                map.put("title","疑似重复报案");
                map.put("info","该出险人在"+riskConfigVO.getRiskRepeatReportTime()+(riskConfigVO.getRiskRepeatReportTimeUnit().equals("1")?"小时":"天")+"内已报案"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskRepeat(Constants.ONE);
            }
        }


        //索赔次数过多提醒
        if(StringUtils.isNotBlank(riskConfigVO.getRiskClaimTimesOpen())
                && StringUtils.equals(riskConfigVO.getRiskClaimTimesOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskClaimTimes())){
            Integer cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getInsuranceApplyId,settleClaimsDTO.getInsuranceApplyId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(" HAPPEN_TIME > DATE_SUB(now(), INTERVAL 365 DAY)  ")
            );
            if(cxcs > Integer.valueOf(riskConfigVO.getRiskClaimTimes())){
                Map<String,String> map = new HashMap<>();
                map.put("title","该保单索赔次数过多");
                map.put("info","累计索赔次数已到达"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskTimesSp(Constants.ONE);
            }
        }

        //设计敏感词汇
        if(StringUtils.isNotBlank(riskConfigVO.getRiskSensitiveWordsOpen())
                && StringUtils.equals(riskConfigVO.getRiskSensitiveWordsOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskSensitiveWords())){
            String [] words = riskConfigVO.getRiskSensitiveWords().split(",");
            String sensitiveWord = ""; 
            for (String word:words) {
                if(settleClaims.getContent().indexOf(word)>=Constants.ZERO){
                    if(Constants.equalsInteger(sensitiveWord.length(),Constants.ZERO)){
                        sensitiveWord = word;
                    }else{
                        sensitiveWord = sensitiveWord + "、" + word ;
                    }
                } 
            }
            if(!Constants.equalsInteger(sensitiveWord.length(),Constants.ZERO)){
                Map<String,String> map = new HashMap<>();
                map.put("title","涉及敏感词");
                map.put("info","检测到敏感词："+sensitiveWord);
                riskList.add(map);
                settleClaims.setRiskSensitive(sensitiveWord);
            }
        }

        //疑似新员工出险

    }

    public void saveFile(SettleClaims settleClaims,SettleClaimsDTO settleClaimsDTO,LoginUserInfo loginUserInfo){
        multifileJoinMapper.delete(new QueryWrapper<Multifile>().lambda()
                .eq(Multifile::getObjId,settleClaims.getId())
                .in(Multifile::getObjType,
                        Constants.MultiFile.LP_SGXC_FILE.getKey(),
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_OTHER_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey()
                )
        );
        List<Multifile> reportVideo = settleClaimsDTO.getReportFileList();
        if(CollectionUtils.isNotEmpty(reportVideo)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_SGXC_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> relationFileList = settleClaimsDTO.getRelationFileList();
        if(CollectionUtils.isNotEmpty(relationFileList)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_YGGX_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> outpatientFileList = settleClaimsDTO.getOutpatientFileList();
        if(CollectionUtils.isNotEmpty(outpatientFileList)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_MZCL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> hospitalFileList = settleClaimsDTO.getHospitalFileList();
        if(CollectionUtils.isNotEmpty(hospitalFileList)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_ZYCL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> disabilityFileList = settleClaimsDTO.getDisabilityFileList();
        if(CollectionUtils.isNotEmpty(disabilityFileList)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_SCZL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> otherFileList = settleClaimsDTO.getOtherFileList();
        if(CollectionUtils.isNotEmpty(otherFileList)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_OTHER_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }




    }




}