package com.doumee.service.business.impl;

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.Utils;
import com.doumee.dao.business.MultifileMapper;
import com.doumee.dao.business.SettleClaimsLogMapper;
import com.doumee.dao.business.SettleClaimsMapper;
import com.doumee.dao.business.dto.SCSupplementDTO;
import com.doumee.dao.business.join.SettleClaimsJoinMapper;
import com.doumee.dao.business.model.*;
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.github.xiaoymin.knife4j.core.util.CollectionUtils;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.util.Objects;

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

    @Autowired
    private SettleClaimsMapper settleClaimsMapper;

    @Autowired
    private SettleClaimsLogMapper settleClaimsLogMapper;

    @Autowired
    private MultifileMapper multifileMapper;

    @Autowired
    private SettleClaimsJoinMapper settleClaimsJoinMapper;

    @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.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())
                ){
                    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);
                multifileMapper.insert(multifile);
            }
        }
        //记录日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.UPLOAD,null);
        return settleClaims.getId();
    }


    public SettleClaims getSettleClaimsDetail(Integer id){
        SettleClaims settleClaims = settleClaimsJoinMapper.selectJoinOne(SettleClaims.class,new MPJLambdaWrapper<SettleClaims>()
                .selectAll(SettleClaims.class)
                .leftJoin(Member.class,Member::getId,SettleClaims::getMemberId)
                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)

        );


        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)
                || oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION))){
            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)
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION))){
            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.getSupplement())
                || Objects.isNull(scSupplementDTO.getObjType())
                || Objects.isNull(scSupplementDTO.getFileUrl())
                || Objects.isNull(scSupplementDTO.getFileType())
                || scSupplementDTO.getObjType().equals(Constants.ZERO)
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims settleClaims  = settleClaimsMapper.selectById(scSupplementDTO.getId());
        if(!(settleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE)
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION))){
            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.setObjId(scSupplementDTO.getId());
        multifile.setName(scSupplementDTO.getFileUrl().substring(scSupplementDTO.getFileUrl().lastIndexOf("/") + 1));
        multifile.setType(scSupplementDTO.getFileType());
        multifileMapper.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());
        QueryWrapper<SettleClaims> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.lambda().eq(SettleClaims::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.lambda().ge(SettleClaims::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.lambda().le(SettleClaims::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.lambda().eq(SettleClaims::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.lambda().ge(SettleClaims::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.lambda().le(SettleClaims::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.lambda().eq(SettleClaims::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(SettleClaims::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getSortnum() != null) {
            queryWrapper.lambda().eq(SettleClaims::getSortnum, pageWrap.getModel().getSortnum());
        }
        if (pageWrap.getModel().getSolutionId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getSolutionId, pageWrap.getModel().getSolutionId());
        }
        if (pageWrap.getModel().getCompanyId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getCompanyId, pageWrap.getModel().getCompanyId());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getHappenTime() != null) {
            queryWrapper.lambda().eq(SettleClaims::getHappenTime, pageWrap.getModel().getHappenTime());
        }
        if (pageWrap.getModel().getIdcardNo() != null) {
            queryWrapper.lambda().ge(SettleClaims::getIdcardNo, Utils.Date.getStart(pageWrap.getModel().getIdcardNo()));
            queryWrapper.lambda().le(SettleClaims::getIdcardNo, Utils.Date.getEnd(pageWrap.getModel().getIdcardNo()));
        }
        if (pageWrap.getModel().getDuId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getDuId, pageWrap.getModel().getDuId());
        }
        if (pageWrap.getModel().getWorktypeId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getWorktypeId, pageWrap.getModel().getWorktypeId());
        }
        if (pageWrap.getModel().getFee() != null) {
            queryWrapper.lambda().eq(SettleClaims::getFee, pageWrap.getModel().getFee());
        }
        if (pageWrap.getModel().getCheckInfo() != null) {
            queryWrapper.lambda().eq(SettleClaims::getCheckInfo, pageWrap.getModel().getCheckInfo());
        }
        if (pageWrap.getModel().getCheckUserId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getCheckUserId, pageWrap.getModel().getCheckUserId());
        }
        if (pageWrap.getModel().getCode() != null) {
            queryWrapper.lambda().eq(SettleClaims::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(SettleClaims::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(SettleClaims::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getInHospital() != null) {
            queryWrapper.lambda().eq(SettleClaims::getInHospital, pageWrap.getModel().getInHospital());
        }
        if (pageWrap.getModel().getMedicalInsurance() != null) {
            queryWrapper.lambda().eq(SettleClaims::getMedicalInsurance, pageWrap.getModel().getMedicalInsurance());
        }
        if (pageWrap.getModel().getContent() != null) {
            queryWrapper.lambda().eq(SettleClaims::getContent, pageWrap.getModel().getContent());
        }
        if (pageWrap.getModel().getInformantName() != null) {
            queryWrapper.lambda().eq(SettleClaims::getInformantName, pageWrap.getModel().getInformantName());
        }
        if (pageWrap.getModel().getInformantPhone() != null) {
            queryWrapper.lambda().eq(SettleClaims::getInformantPhone, pageWrap.getModel().getInformantPhone());
        }
        if (pageWrap.getModel().getAreaId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getAreaId, pageWrap.getModel().getAreaId());
        }
        if (pageWrap.getModel().getAreaInfo() != null) {
            queryWrapper.lambda().eq(SettleClaims::getAreaInfo, pageWrap.getModel().getAreaInfo());
        }
        if (pageWrap.getModel().getReportNum() != null) {
            queryWrapper.lambda().eq(SettleClaims::getReportNum, pageWrap.getModel().getReportNum());
        }
        if (pageWrap.getModel().getInsuranceApplyId() != null) {
            queryWrapper.lambda().eq(SettleClaims::getInsuranceApplyId, pageWrap.getModel().getInsuranceApplyId());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(settleClaimsMapper.selectPage(page, queryWrapper));
    }

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