package com.ydtech.modules.protocols.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.core.page.HttpResult;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.protocol.entity.po.PtlAreaLicense;
import com.ydtech.modules.protocol.service.PtlAreaLicenseService;
import com.ydtech.modules.protocols.dao.PtlAgreementUndwrtRulesNewMapper;
import com.ydtech.modules.protocols.entity.po.*;
import com.ydtech.modules.protocols.entity.vo.AgreementUndwrtRules;
import com.ydtech.modules.protocols.entity.vo.AgreementUndwrtRulesSave;
import com.ydtech.modules.protocols.service.*;
import com.ydtech.utils.idgen.IdGenerate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.crypto.spec.PSource;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @description 协议承保规则属性 service实现类
 * @createDate 2024-2-22 15:44:29
 * @Entity com.ydtech.modules.protocol.entity.po.PtlAgreementUndwrtRulesAttrMapper
 */
@Service
public class PtlAgreementUndwrtRulesNewServiceImpl extends ServiceImpl<PtlAgreementUndwrtRulesNewMapper, PtlAgreementUndwrtRulesNew>
        implements PtlAgreementUndwrtRulesNewService {

    @Autowired
    private PtlAgreementUndwrtRulesAttrLinkService ptlAgreementUndwrtRulesAttrLinkService;

    @Autowired
    private PtlAreaLicenseService ptlAreaLicenseService;

    @Autowired
    private PtlAgreementUndwrtRulesAttrService ptlAgreementUndwrtRulesAttrService;

    @Autowired
    private PtlAgreementUndwrtRulesNewHistoryService ptlAgreementUndwrtRulesNewHistoryService;

    @Autowired
    private PtlAgreementUndwrtRulesAttrLinkHistoryService ptlAgreementUndwrtRulesAttrLinkHistoryService;

    @Override
    public AgreementUndwrtRulesSave rulesGet(String ruleId, List<PtlAgreementUndwrtRulesAttr> undwrtRulesAttrList) {
        //设置费用入口信息
        PtlAgreementUndwrtRulesNew ptlAgreementUndwrtRulesNew = baseMapper.selectOne(new LambdaQueryWrapper<PtlAgreementUndwrtRulesNew>().eq(PtlAgreementUndwrtRulesNew::getId, ruleId));
        AgreementUndwrtRulesSave agreementUndwrtRulesSave = new AgreementUndwrtRulesSave();
        BeanUtils.copyProperties(ptlAgreementUndwrtRulesNew, agreementUndwrtRulesSave);

        //设置费用因子属性
        List<PtlAgreementUndwrtRulesAttr> ptlAgreementUndwrtRulesAttrs = new ArrayList<>();
        List<PtlAgreementUndwrtRulesAttrLink> list = ptlAgreementUndwrtRulesAttrLinkService.list(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>()
                .eq(PtlAgreementUndwrtRulesAttrLink::getRulesId, ruleId));

        undwrtRulesAttrList.stream().forEach(x -> {
            //处理多选和下拉
            if ("checkbox".equals(x.getAttrType()) || "select".equals(x.getAttrType())) {
                //处理车牌
                if ("select".equals(x.getAttrType()) && "LicenseNo".equals(x.getAttrCode())) {
                    PtlAgreementUndwrtRulesAttrLink licenseNo = list.stream().filter(l -> l.getAttrCode().equals("LicenseNo")).findFirst().orElse(null);
                    if (licenseNo != null) {
                        //根据operator 获取车牌的地区id
                        List<PtlAreaLicense> byParentNumber = ptlAreaLicenseService.getByParentNumber(licenseNo.getOperator());
                        List<PtlAgreementUndwrtRulesDictLabal> dictLabal = byParentNumber.stream().map(y -> {
                            PtlAgreementUndwrtRulesDictLabal ptlAgreementUndwrtRulesDictLabal = new PtlAgreementUndwrtRulesDictLabal();
                            ptlAgreementUndwrtRulesDictLabal.setDictId(y.getId());
                            ptlAgreementUndwrtRulesDictLabal.setCode(y.getAreaNumber());
                            ptlAgreementUndwrtRulesDictLabal.setName(y.getLicense());
                            return ptlAgreementUndwrtRulesDictLabal;
                        }).collect(Collectors.toList());
                        x.setDictLabal(dictLabal);
                    }
                }
                x.setMinArray(new String[]{});
                list.stream().filter(y -> y.getAttrCode().equals(x.getAttrCode())).findFirst().ifPresent(z -> {
                    if (null != z.getMin()) {
                        x.setId(z.getId());
                        x.setMinArray(z.getMin().split(","));
                        x.setMax(z.getMax());
                        x.setOperator(z.getOperator());
                    }
                });
            } else {
                list.stream().filter(y -> y.getAttrCode().equals(x.getAttrCode())).findFirst().ifPresent(z -> {
                    x.setId(z.getId());
                    x.setMin(z.getMin());
                    x.setMax(z.getMax());
                    x.setOperator(z.getOperator());
                });
            }

            ptlAgreementUndwrtRulesAttrs.add(x);
        });

        agreementUndwrtRulesSave.setCostsAttrLinks(ptlAgreementUndwrtRulesAttrs);

        return agreementUndwrtRulesSave;
    }

    @Override
    public List<PtlAgreementUndwrtRulesNew> rulesList(String agreementId) {
        LocalDateTime now = LocalDateTime.now();
        List<PtlAgreementUndwrtRulesNew> rulesList = baseMapper.selectList(new LambdaQueryWrapper<PtlAgreementUndwrtRulesNew>()
                .eq(PtlAgreementUndwrtRulesNew::getAgreementId, agreementId)
                .eq(PtlAgreementUndwrtRulesNew::getValidInd, "1")
                .le(PtlAgreementUndwrtRulesNew::getRulesStartDate, now)
                .ge(PtlAgreementUndwrtRulesNew::getRulesEndDate, now));

        List<PtlAgreementUndwrtRulesAttrLink> ptlAgreementUndwrtRulesAttrLinkList = ptlAgreementUndwrtRulesAttrLinkService.list();
        rulesList.forEach(item -> {
            List<PtlAgreementUndwrtRulesAttrLink> collect = ptlAgreementUndwrtRulesAttrLinkList.stream().filter(x -> Objects.equals(x.getRulesId(), item.getId())).collect(Collectors.toList());
            item.setRulesAttrList(collect);
        });
        return rulesList;
    }

    @Override
    public Page rulesPage(Page page, String agreementId) {

        Page<PtlAgreementUndwrtRulesNew> rulesPage = baseMapper.selectPage(page, new LambdaQueryWrapper<PtlAgreementUndwrtRulesNew>()
                .eq(PtlAgreementUndwrtRulesNew::getAgreementId, agreementId));

//        List<PtlAgreementUndwrtRulesAttrLink> ptlAgreementUndwrtRulesAttrLinkList = ptlAgreementUndwrtRulesAttrLinkService.list();
        List<PtlAgreementUndwrtRulesNew> records = rulesPage.getRecords();
        //遍历费用列表
        List<String> ids = new ArrayList<>();
        records.forEach(x -> {
            ids.add(x.getId());
        });

        //获取费用属性
        List<PtlAgreementUndwrtRulesAttr> undwrtRulesAttrList = ptlAgreementUndwrtRulesAttrService.getUndwrtRulesAttrList();
        if (ids.isEmpty()) {
            throw new SystemException("该协议暂无承保规则");
        }
        List<PtlAgreementUndwrtRulesAttrLink> list = ptlAgreementUndwrtRulesAttrLinkService.list(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>()
                .in(PtlAgreementUndwrtRulesAttrLink::getRulesId, ids));

        Map<String, List<PtlAgreementUndwrtRulesAttrLink>> groupedByCostsId = list.stream()
                .collect(Collectors.groupingBy(PtlAgreementUndwrtRulesAttrLink::getRulesId));
        groupedByCostsId.forEach((k, v) -> {
            records.stream().filter(x -> x.getId().equals(k)).findFirst().ifPresent(x -> x.setDesc(buildDesc(v, undwrtRulesAttrList)));
        });

//        records.forEach(item -> {
//            List<PtlAgreementUndwrtRulesAttrLink> collect = ptlAgreementUndwrtRulesAttrLinkList.stream().filter(x -> Objects.equals(x.getRulesId(), item.getId())).collect(Collectors.toList());
//            item.setRulesAttrList(collect);
//        });
        rulesPage.setRecords(records);
        return rulesPage;
    }

    /**
     * 遍历费用属性描述文字
     * @param v
     * @param undwrtRulesAttrList
     * @return
     */
    private String buildDesc(List<PtlAgreementUndwrtRulesAttrLink> v, List<PtlAgreementUndwrtRulesAttr> undwrtRulesAttrList) {
        String desc = "";
        for (int i = 0; i < v.size(); i++) {
            int finalI = i;
            PtlAgreementUndwrtRulesAttr ptlAgreementUndwrtRulesAttr = undwrtRulesAttrList.stream().filter(x -> x.getAttrCode().equals(v.get(finalI).getAttrCode())).findAny().get();
            //数值范围判断
            if ("inputNumber".equals(ptlAgreementUndwrtRulesAttr.getAttrType())) {
                desc += inputNumberIdentifying(ptlAgreementUndwrtRulesAttr, v.get(i)) + "\n";
            }
            if ("radio".equals(ptlAgreementUndwrtRulesAttr.getAttrType())) {
                desc += radioIdentifying(ptlAgreementUndwrtRulesAttr, v.get(i)) + "\n";
            }
            if ("checkbox".equals(ptlAgreementUndwrtRulesAttr.getAttrType()) || "select".equals(ptlAgreementUndwrtRulesAttr.getAttrType())) {
                desc += ptlAgreementUndwrtRulesAttr.getAttrName() + "包含" + v.get(i).getMin() + "\n";
            }
            if ("input".equals(ptlAgreementUndwrtRulesAttr.getAttrType())){
                if(v.get(i).getOperator() != null && v.get(i).getOperator().equals("1")) {
                    desc += ptlAgreementUndwrtRulesAttr.getAttrName() + "包含" + v.get(i).getMin() + "\n";
                }else{
                    desc += ptlAgreementUndwrtRulesAttr.getAttrName() + "不包含" + v.get(i).getMin() + "\n";
                }
            }
        }
        return desc;
    }

    private String radioIdentifying(PtlAgreementUndwrtRulesAttr ptlAgreementUndwrtRulesAttr, PtlAgreementUndwrtRulesAttrLink ptlAgreementProductCostsAttrLink) {
        PtlAgreementUndwrtRulesDictLabal ptlAgreementUndwrtRulesDictLabal = ptlAgreementUndwrtRulesAttr.getDictLabal().stream().filter(x ->
                x.getCode().equals(ptlAgreementProductCostsAttrLink.getMin())).findAny().get();
        return ptlAgreementUndwrtRulesAttr.getAttrName() + "为" + ptlAgreementUndwrtRulesDictLabal.getName();
    }

    private String inputNumberIdentifying(PtlAgreementUndwrtRulesAttr ptlAgreementUndwrtRulesAttr, PtlAgreementUndwrtRulesAttrLink ptlAgreementProductCostsAttrLink) {
        if ("1".equals(ptlAgreementProductCostsAttrLink.getOperator())) {
            return ptlAgreementUndwrtRulesAttr.getAttrName() + "范围值" + ptlAgreementProductCostsAttrLink.getMin() + "到" + ptlAgreementProductCostsAttrLink.getMax();
        } else if ("2".equals(ptlAgreementProductCostsAttrLink.getOperator())) {
            return ptlAgreementUndwrtRulesAttr.getAttrName() + "小于" + ptlAgreementProductCostsAttrLink.getMin();
        } else if ("3".equals(ptlAgreementProductCostsAttrLink.getOperator())) {
            return ptlAgreementUndwrtRulesAttr.getAttrName() + "小于等于" + ptlAgreementProductCostsAttrLink.getMin();
        } else if ("4".equals(ptlAgreementProductCostsAttrLink.getOperator())) {
            return ptlAgreementUndwrtRulesAttr.getAttrName() + "大于" + ptlAgreementProductCostsAttrLink.getMax();
        } else if ("5".equals(ptlAgreementProductCostsAttrLink.getOperator())) {
            return ptlAgreementUndwrtRulesAttr.getAttrName() + "大于等于" + ptlAgreementProductCostsAttrLink.getMax();
        }
        return "";
    }

    /**
     * 验证承保规则表单
     */
    private void validateRules(AgreementUndwrtRules agreementUndwrtRules){
        if(agreementUndwrtRules.getValidInd() == null)
        {
            throw new RuntimeException("有效标志不能为空");
        }
    }

    @Transactional
    @Override
    public boolean rulesAdd(AgreementUndwrtRules agreementUndwrtRules) {
        validateRules(agreementUndwrtRules);
        //添加承保规则主表信息
        PtlAgreementUndwrtRulesNew ptlAgreementUndwrtRulesNew = new PtlAgreementUndwrtRulesNew();
        BeanUtils.copyProperties(agreementUndwrtRules, ptlAgreementUndwrtRulesNew);
        ptlAgreementUndwrtRulesNew.setId(null);
        int insert = baseMapper.insert(ptlAgreementUndwrtRulesNew);
        agreementUndwrtRules.setId(ptlAgreementUndwrtRulesNew.getId());
        //保存承包规则历史记录
        PtlAgreementUndwrtRulesNewHistory ptlAgreementUndwrtRulesNewHistory = new PtlAgreementUndwrtRulesNewHistory();
        BeanUtils.copyProperties(agreementUndwrtRules, ptlAgreementUndwrtRulesNewHistory);
        //添加承包规则ID
        ptlAgreementUndwrtRulesNewHistory.setRulesId(ptlAgreementUndwrtRulesNew.getId());
        //生成批次ID
        String uuid = IdGenerate.nextId();
        ptlAgreementUndwrtRulesNewHistory.setBatch(uuid);
        ptlAgreementUndwrtRulesNewHistory.setId(IdGenerate.nextId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorType("add");
        ptlAgreementUndwrtRulesNewHistory.setModifier(BaseController.getUser().getId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorTime(LocalDateTime.now());
        ptlAgreementUndwrtRulesNewHistoryService.save(ptlAgreementUndwrtRulesNewHistory);
        //创建承包规则费用因子历史记录容器
        List<PtlAgreementUndwrtRulesAttrLinkHistory> undwrtRulesAttrLinkHistories = new ArrayList<>();

        //遍历承保规则属性
        List<PtlAgreementUndwrtRulesAttrLink> rulesAttrList = agreementUndwrtRules.getRulesAttrList();
        List<PtlAgreementUndwrtRulesAttrLink> costsAttrLink = new ArrayList<>();
        rulesAttrList.forEach(x -> {
            //单独处理车牌号
            if ("LicenseNo".equals(x.getAttrCode()) && (x.getMin() != null && !x.getMin().equals(""))) {
                x.setOperator(x.getDictLabal().getJSONObject(0).getString("parentNumber"));
                x.setRulesId(ptlAgreementUndwrtRulesNew.getId());
                x.setId("0");
                costsAttrLink.add(x);
                PtlAgreementUndwrtRulesAttrLinkHistory undwrtRulesAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                BeanUtils.copyProperties(x, undwrtRulesAttrLinkHistory);
                //设置承包规则费用因子历史记录
                undwrtRulesAttrLinkHistory.setBatch(uuid);
                undwrtRulesAttrLinkHistory.setId(null);
                undwrtRulesAttrLinkHistory.setOperatorType("add");
                undwrtRulesAttrLinkHistory.setModifier(BaseController.getUser().getId());
                undwrtRulesAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                undwrtRulesAttrLinkHistories.add(undwrtRulesAttrLinkHistory);
            } else {
                if ((!"0".equals(x.getMin()) && null != x.getMin()) || (!"0".equals(x.getMax()) && null != x.getMax())) {

                    x.setRulesId(ptlAgreementUndwrtRulesNew.getId());
                    x.setId("0");
                    costsAttrLink.add(x);
                    PtlAgreementUndwrtRulesAttrLinkHistory undwrtRulesAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                    BeanUtils.copyProperties(x, undwrtRulesAttrLinkHistory);
                    //设置承包规则费用因子历史记录
                    undwrtRulesAttrLinkHistory.setBatch(uuid);
                    undwrtRulesAttrLinkHistory.setId(null);
                    undwrtRulesAttrLinkHistory.setOperatorType("add");
                    undwrtRulesAttrLinkHistory.setModifier(BaseController.getUser().getId());
                    undwrtRulesAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                    undwrtRulesAttrLinkHistories.add(undwrtRulesAttrLinkHistory);
                }
            }
        });
        ptlAgreementUndwrtRulesAttrLinkHistoryService.saveBatch(undwrtRulesAttrLinkHistories);
        ptlAgreementUndwrtRulesAttrLinkService.saveBatch(costsAttrLink);
        return true;
    }

    @Transactional
    @Override
    public boolean rulesUpdate(AgreementUndwrtRules agreementUndwrtRules) {
        //更新费用主表信息
        PtlAgreementUndwrtRulesNew ptlAgreementUndwrtRulesNew = new PtlAgreementUndwrtRulesNew();
        BeanUtils.copyProperties(agreementUndwrtRules, ptlAgreementUndwrtRulesNew);
        int update = baseMapper.updateById(ptlAgreementUndwrtRulesNew);

        //保存承包规则历史记录
        PtlAgreementUndwrtRulesNewHistory ptlAgreementUndwrtRulesNewHistory = new PtlAgreementUndwrtRulesNewHistory();
        BeanUtils.copyProperties(agreementUndwrtRules, ptlAgreementUndwrtRulesNewHistory);
        //添加承包规则ID
        ptlAgreementUndwrtRulesNewHistory.setRulesId(ptlAgreementUndwrtRulesNew.getId());
        //生成批次ID
        String uuid = IdGenerate.nextId();
        ptlAgreementUndwrtRulesNewHistory.setBatch(uuid);
        ptlAgreementUndwrtRulesNewHistory.setId(IdGenerate.nextId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorType("update");
        ptlAgreementUndwrtRulesNewHistory.setModifier(BaseController.getUser().getId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorTime(LocalDateTime.now());
        ptlAgreementUndwrtRulesNewHistoryService.save(ptlAgreementUndwrtRulesNewHistory);
        //创建承包规则费用因子历史记录容器
        List<PtlAgreementUndwrtRulesAttrLinkHistory> undwrtRulesAttrLinkHistories = new ArrayList<>();

        //设置费用因子属性
        //先删除属性值
        ptlAgreementUndwrtRulesAttrLinkService.remove(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>()
                .eq(PtlAgreementUndwrtRulesAttrLink::getRulesId, ptlAgreementUndwrtRulesNew.getId()));
        List<PtlAgreementUndwrtRulesAttr> undwrtRulesAttrList = ptlAgreementUndwrtRulesAttrService.getUndwrtRulesAttrList();
        //再添加属性值
        List<PtlAgreementUndwrtRulesAttrLink> costsAttrLinks = agreementUndwrtRules.getRulesAttrList();
        List<PtlAgreementUndwrtRulesAttrLink> costsAttrLink = new ArrayList<>();
        costsAttrLinks.forEach(x -> {
            //转换数组
            if(x.getMinArray() != null && x.getMinArray().length > 0){
                x.setMin(String.join(",",x.getMinArray()));
            }

            //处理中文逗号
            if(x.getMin() != null && x.getMin().contains("，"))
            {
                x.setMin(x.getMin().replace("，",","));
            }
            //单独处理车牌号
            if ("LicenseNo".equals(x.getAttrCode()) && (x.getMin() != null && x.getMin() != "")) {
                x.setOperator(x.getDictLabal().getJSONObject(0).getString("parentNumber"));
                x.setRulesId(ptlAgreementUndwrtRulesNew.getId());
                x.setId("0");
                costsAttrLink.add(x);
                PtlAgreementUndwrtRulesAttrLinkHistory undwrtRulesAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                BeanUtils.copyProperties(x, undwrtRulesAttrLinkHistory);
                //设置承包规则费用因子历史记录
                undwrtRulesAttrLinkHistory.setBatch(uuid);
                undwrtRulesAttrLinkHistory.setId(null);
                undwrtRulesAttrLinkHistory.setOperatorType("update");
                undwrtRulesAttrLinkHistory.setModifier(BaseController.getUser().getId());
                undwrtRulesAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                undwrtRulesAttrLinkHistories.add(undwrtRulesAttrLinkHistory);
            } else {
                PtlAgreementUndwrtRulesAttr ptlAgreementUndwrtRulesAttr = undwrtRulesAttrList.stream().filter(y -> y.getAttrCode().equals(x.getAttrCode())).findFirst().orElse(null);
                //单独判断radio  radio中存在0的属性值
                if ("radio".equals(ptlAgreementUndwrtRulesAttr.getAttrType())) {
                    if (null != x.getMin()) {
                        x.setRulesId(ptlAgreementUndwrtRulesNew.getId());
                        x.setId("0");
                        costsAttrLink.add(x);
                        PtlAgreementUndwrtRulesAttrLinkHistory undwrtRulesAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                        BeanUtils.copyProperties(x, undwrtRulesAttrLinkHistory);
                        //设置承包规则费用因子历史记录
                        undwrtRulesAttrLinkHistory.setBatch(uuid);
                        undwrtRulesAttrLinkHistory.setId(null);
                        undwrtRulesAttrLinkHistory.setOperatorType("update");
                        undwrtRulesAttrLinkHistory.setModifier(BaseController.getUser().getId());
                        undwrtRulesAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                        undwrtRulesAttrLinkHistories.add(undwrtRulesAttrLinkHistory);
                    }
                } else {
                    if ((!"0".equals(x.getMin()) && null != x.getMin()) || (!"0".equals(x.getMax()) && null != x.getMax())) {
                        x.setRulesId(ptlAgreementUndwrtRulesNew.getId());
                        x.setId("0");
                        costsAttrLink.add(x);
                        PtlAgreementUndwrtRulesAttrLinkHistory undwrtRulesAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                        BeanUtils.copyProperties(x, undwrtRulesAttrLinkHistory);
                        //设置承包规则费用因子历史记录
                        undwrtRulesAttrLinkHistory.setBatch(uuid);
                        undwrtRulesAttrLinkHistory.setId(null);
                        undwrtRulesAttrLinkHistory.setOperatorType("update");
                        undwrtRulesAttrLinkHistory.setModifier(BaseController.getUser().getId());
                        undwrtRulesAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                        undwrtRulesAttrLinkHistories.add(undwrtRulesAttrLinkHistory);
                    }
                }
            }
        });
        ptlAgreementUndwrtRulesAttrLinkHistoryService.saveBatch(undwrtRulesAttrLinkHistories);
        ptlAgreementUndwrtRulesAttrLinkService.saveBatch(costsAttrLink);
        return true;
    }

    @Transactional
    @Override
    public boolean rulesDelete(String rulesId) {

        //获取承包规则
        PtlAgreementUndwrtRulesNew ptlAgreementUndwrtRulesNew = baseMapper.selectById(rulesId);

        //保存承包规则历史记录
        PtlAgreementUndwrtRulesNewHistory ptlAgreementUndwrtRulesNewHistory = new PtlAgreementUndwrtRulesNewHistory();
        BeanUtils.copyProperties(ptlAgreementUndwrtRulesNew, ptlAgreementUndwrtRulesNewHistory);
        //添加费用ID
        ptlAgreementUndwrtRulesNewHistory.setRulesId(ptlAgreementUndwrtRulesNew.getId());
        //生成批次ID
        String uuid = IdGenerate.nextId();
        ptlAgreementUndwrtRulesNewHistory.setBatch(uuid);
        ptlAgreementUndwrtRulesNewHistory.setId(IdGenerate.nextId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorType("delete");
        ptlAgreementUndwrtRulesNewHistory.setModifier(BaseController.getUser().getId());
        ptlAgreementUndwrtRulesNewHistory.setOperatorTime(LocalDateTime.now());
        ptlAgreementUndwrtRulesNewHistoryService.save(ptlAgreementUndwrtRulesNewHistory);

        //创建承包规则费用因子历史记录容器
        List< PtlAgreementUndwrtRulesAttrLinkHistory> costsAttrLinkHistories = new ArrayList<>();

        //获取承包规则费用因子出口历史记
        List<PtlAgreementUndwrtRulesAttrLink> costsAttrLinks = ptlAgreementUndwrtRulesAttrLinkService.list(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>()
                .eq(PtlAgreementUndwrtRulesAttrLink::getRulesId, rulesId));

        costsAttrLinks.forEach(x -> {
            PtlAgreementUndwrtRulesAttrLinkHistory costsAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
            BeanUtils.copyProperties(x, costsAttrLinkHistory);
            //设置承包规则费用因子历史记录
            costsAttrLinkHistory.setBatch(uuid);
            costsAttrLinkHistory.setId(null);
            costsAttrLinkHistory.setOperatorType("add");
            costsAttrLinkHistory.setModifier(BaseController.getUser().getId());
            costsAttrLinkHistory.setOperatorTime(LocalDateTime.now());
            costsAttrLinkHistories.add(costsAttrLinkHistory);
        });
        //保存产品费用因子历史记录
        ptlAgreementUndwrtRulesAttrLinkHistoryService.saveBatch(costsAttrLinkHistories);


        baseMapper.deleteById(rulesId);
        ptlAgreementUndwrtRulesAttrLinkService.remove(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>().eq(PtlAgreementUndwrtRulesAttrLink::getRulesId, rulesId));

        return true;
    }

    @Transactional
    @Override
    public boolean copyRules(AgreementUndwrtRules agreementUndwrtRules) {
        List<PtlAgreementUndwrtRulesNew> list = baseMapper.selectBatchIds(Arrays.asList(agreementUndwrtRules.getIds()));
        for (PtlAgreementUndwrtRulesNew originalRule  : list) {
            PtlAgreementUndwrtRulesNew clonedRule = new PtlAgreementUndwrtRulesNew();
            BeanUtils.copyProperties(originalRule, clonedRule, "id","agreementId");

            clonedRule.setId(null);
            clonedRule.setAgreementId(agreementUndwrtRules.getAgreementId());

            AgreementUndwrtRules convertedAgreementUndwrtRules = convertToAgreementUndwrtRules(clonedRule);

            convertedAgreementUndwrtRules.setRulesAttrList(agreementUndwrtRules.getRulesAttrList());

            //调用承保规则新增方法
            rulesAdd(convertedAgreementUndwrtRules);
            List<PtlAgreementUndwrtRulesAttrLink> attrLinks =
                    ptlAgreementUndwrtRulesAttrLinkService.list(new LambdaQueryWrapper<PtlAgreementUndwrtRulesAttrLink>().eq(PtlAgreementUndwrtRulesAttrLink::getRulesId, originalRule.getId()));

            List<PtlAgreementUndwrtRulesAttrLinkHistory> undwrtRulesAttrLinkHistories = new ArrayList<>();
            String uuid = IdGenerate.nextId();
            attrLinks.forEach(x -> {
                x.setId(null);
                x.setRulesId(convertedAgreementUndwrtRules.getId());
                PtlAgreementUndwrtRulesAttrLinkHistory costsAttrLinkHistory = new PtlAgreementUndwrtRulesAttrLinkHistory();
                BeanUtils.copyProperties(x, costsAttrLinkHistory);
                //设置承包规则费用因子历史记录
                costsAttrLinkHistory.setBatch(uuid);
                costsAttrLinkHistory.setId(null);
                costsAttrLinkHistory.setOperatorType("add");
                costsAttrLinkHistory.setModifier(BaseController.getUser().getId());
                costsAttrLinkHistory.setOperatorTime(LocalDateTime.now());
                undwrtRulesAttrLinkHistories.add(costsAttrLinkHistory);
            });
            ptlAgreementUndwrtRulesAttrLinkHistoryService.saveBatch(undwrtRulesAttrLinkHistories);
            ptlAgreementUndwrtRulesAttrLinkService.saveBatch(attrLinks);
        }
        return true;
    }
    private AgreementUndwrtRules convertToAgreementUndwrtRules(PtlAgreementUndwrtRulesNew rule) {
        AgreementUndwrtRules agreementUndwrtRules = new AgreementUndwrtRules();
        BeanUtils.copyProperties(rule, agreementUndwrtRules,"ids");
        return agreementUndwrtRules;
    }
}