package cn.fw.morax.service.biz.eval;

import cn.fw.common.exception.BusinessException;
import cn.fw.common.page.AppPage;
import cn.fw.common.web.annotation.DisLock;
import cn.fw.common.web.auth.LoginAuthBean;
import cn.fw.morax.common.constant.Constant;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.SettingDraft;
import cn.fw.morax.domain.db.eval.*;
import cn.fw.morax.domain.dto.eval.*;
import cn.fw.morax.domain.dto.query.EvalGroupRankQueryDTO;
import cn.fw.morax.domain.enums.*;
import cn.fw.morax.domain.vo.eval.*;
import cn.fw.morax.service.biz.ApprovalBizService;
import cn.fw.morax.service.biz.CommonService;
import cn.fw.morax.service.data.SettingDraftService;
import cn.fw.morax.service.data.eval.*;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.YearMonth;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

import static cn.fw.common.businessvalidator.Validator.BV;

@RequiredArgsConstructor
@Service
@Slf4j
public class EvalGroupRankBizService {

    private final EvalGroupRankStageService evalGroupRankStageService;
    private final EvalGroupRankService evalGroupRankService;
    private final SettingDraftService settingDraftService;
    private final ApprovalBizService approvalBizService;
    private final EvalUserPoolService evalUserPoolService;
    private final EvalShopPoolService evalShopPoolService;
    private final EvalGroupService evalGroupService;
    private final EvalService evalService;

    @Value("${spring.cache.custom.global-prefix}:eval:rank:save:")
    @Getter
    private String saveGroupPrefix;
    /**
     * 考评排名列表
     *
     * @param dto
     * @return
     */
    public AppPage<EvalGroupRankVO> evalGroupRankPage(EvalGroupRankQueryDTO dto) {
        AppPage<EvalGroupRankVO> page = AppPage.empty(dto);
        List<String> queryEgcs = getEgcsByPostId(dto);
        if (PublicUtil.isNotEmpty(dto.getPostId()) && PublicUtil.isEmpty(queryEgcs)) {
            return page;
        }
        dto.setEgcs(queryEgcs);
        Long total = evalGroupRankService.queryPageRankTotal(dto);
        if (total <= 0) {
            return page;
        }

        List<EvalGroupRankVO> evalGroupRankVOS = evalGroupRankService.queryPageRank(dto);
        List<EvalGroup> evalGroups = evalGroupService.getEvalGroups(evalGroupRankVOS.stream().map(EvalGroupRankVO::getId).collect(Collectors.toList()));
        Map<Long, List<EvalGroup>> egcGroupMap = evalGroups.stream().collect(Collectors.groupingBy(EvalGroup::getEvalGroupRankId));
        for (EvalGroupRankVO epiGroupRankVO : evalGroupRankVOS) {
            epiGroupRankVO.setPostIds(new ArrayList<>());
            epiGroupRankVO.setPostNames(new HashSet<>());
            epiGroupRankVO.setShopIds(new ArrayList<>());
            epiGroupRankVO.setShopNames(new HashSet<>());
            for (EvalGroup evalGroup : egcGroupMap.getOrDefault(epiGroupRankVO.getId(), new ArrayList<>())) {
                if (PublicUtil.isNotEmpty(evalGroup.getPostIds())) {
                    epiGroupRankVO.getPostIds().addAll(evalGroup.getPostIds());
                    epiGroupRankVO.getPostNames().addAll(evalGroup.getPostNames());
                }
                if (PublicUtil.isNotEmpty(evalGroup.getShopIds())) {
                    epiGroupRankVO.getShopIds().addAll(evalGroup.getShopIds());
                    epiGroupRankVO.getShopNames().addAll(evalGroup.getShopNames());
                }
            }
        }
        page.setTotal(total);
        page.setData(evalGroupRankVOS);
        return page;
    }

    /**
     * 根据岗位查询考评组
     *
     * @param dto
     * @return
     */
    public List<String> getEgcsByPostId(EvalGroupRankQueryDTO dto) {
        if (PublicUtil.isEmpty(dto.getPostId())) {
            return null;
        }
        List<EvalGroup> evalGroups = evalGroupService.getEffectGroups(dto.getGroupId(), LocalDate.now());
        return evalGroups.stream().map(EvalGroup::getEgc).collect(Collectors.toList());
    }

    public List<Long> getEffectEvalIds(Long groupId) {
        List<Eval> evals = evalService.list(Wrappers.<Eval>lambdaQuery()
                .eq(Eval::getStatus, groupId)
                .eq(Eval::getGroupId, Boolean.TRUE)
                .eq(Eval::getId, Boolean.TRUE)
        );
        if (PublicUtil.isEmpty(evals)) {
            return new ArrayList<>();
        }
        List<Long> evalIds = evals.stream().map(Eval::getId).collect(Collectors.toList());
        return evalIds;
    }

    /**
     * 根据id删除考评组排名包
     * @param id
     */
    public void removeById(Long id) {
        evalGroupRankService.removeById(id);
        evalGroupRankStageService.remove(Wrappers.<EvalGroupRankStage>lambdaUpdate()
                .eq(EvalGroupRankStage::getEvalGroupRankId, id)
        );
        evalGroupService.remove(Wrappers.<EvalGroup>lambdaUpdate()
                .eq(EvalGroup::getEvalGroupRankId, id)
        );
        evalUserPoolService.remove(Wrappers.<EvalUserPool>lambdaUpdate()
                .eq(EvalUserPool::getEvalGroupRankId, id)
        );
    }

    public List<EvalUserPoolVO> staffRank(EvalGroupRankQueryDto dto) {
        List<EvalUserPool> pools = evalUserPoolService.list(Wrappers.<EvalUserPool>lambdaQuery()
                .in(EvalUserPool::getEvalGroupId, dto.getEvalGroupIds())
                .eq(EvalUserPool::getYn, Boolean.TRUE)
                .eq(EvalUserPool::getMonthly, dto.getMonthly())
                .last("ORDER BY ISNULL(rank), rank ASC")
        );
        if (PublicUtil.isEmpty(pools)) {
            return new ArrayList<>();
        }
        List<EvalUserPoolVO> poolVOS = PublicUtil.copyList(pools, EvalUserPoolVO.class);
        for (EvalUserPoolVO pool : poolVOS) {
            pool.setScoreRatio(pool.getScoreRatio().multiply(Constant.ONE_HUNDRED));
        }
        return poolVOS;
    }

    public List<EvalShopPoolVO> shopRank(EvalGroupRankQueryDto dto) {
        List<EvalShopPool> pools = evalShopPoolService.list(Wrappers.<EvalShopPool>lambdaQuery()
                .in(EvalShopPool::getEvalGroupId, dto.getEvalGroupIds())
                .eq(EvalShopPool::getYn, Boolean.TRUE)
                .eq(EvalShopPool::getMonthly, dto.getMonthly())
                .last("ORDER BY ISNULL(rank), rank ASC")
        );
        if (PublicUtil.isEmpty(pools)) {
            return new ArrayList<>();
        }
        List<EvalShopPoolVO> poolVOS = PublicUtil.copyList(pools, EvalShopPoolVO.class);
        for (EvalShopPoolVO pool : poolVOS) {
            pool.setScoreRatio(pool.getScoreRatio().multiply(Constant.ONE_HUNDRED));
        }
        return poolVOS;
    }

    /**
     * 考评组保存
     *
     * @param evalGroupRankDto
     * @param user
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @DisLock(prefix = "#this.getSaveGroupPrefix()", key = "#evalGroupRankDto.getName()", message = "保存中，请勿重复操作")
    public void saveEvalGroupRank(EvalGroupRankDTO evalGroupRankDto, LoginAuthBean user, Boolean isSubmit) {
        this.checkNameRepetition(evalGroupRankDto);
        AtomicInteger evalGroupSize = new AtomicInteger();
        LocalDate lastStageOverTime = null;
        Boolean multiStage = evalGroupRankDto.getMultiStage();
        for (EvalGroupRankStageDTO stage : evalGroupRankDto.getStages()) {
            this.checkStageTime(evalGroupRankDto, stage, lastStageOverTime);
            for (EvalGroupDTO evalGroupDTO : stage.getEvalGroups()) {
                initEvalGroupDTO(evalGroupDTO);
                checkIndicator(evalGroupDTO, multiStage);
                checkEvalIndicatorLadders(evalGroupDTO.getIndicators());

                for (EvalGroupRewardDimDTO dimDTO : evalGroupDTO.getStaffRewardDims()) {
                    checkRewardDim(dimDTO, EvalScopeEnum.STAFF);
                    checkReward(dimDTO.getRewards());
                    checkEvalRewardLadders(dimDTO.getRewards());
                    sortRewardRankLadders(dimDTO.getRewards());
                }
                for (EvalGroupRewardDimDTO dimDTO : evalGroupDTO.getShopRewardDims()) {
                    checkRewardDim(dimDTO, EvalScopeEnum.SHOP);
                    checkReward(dimDTO.getRewards());
                    checkEvalRewardLadders(dimDTO.getRewards());
                    sortRewardRankLadders(dimDTO.getRewards());
                }
                this.setTargetVos(evalGroupDTO);
                evalGroupSize.incrementAndGet();
                List<Long> postIds = evalGroupDTO.getStaffRewardDims().stream().flatMap(reward -> reward.getPostIds().stream())
                        .distinct().collect(Collectors.toList());
                List<String> postNames = evalGroupDTO.getStaffRewardDims().stream().flatMap(reward -> reward.getPostNames().stream())
                        .distinct().collect(Collectors.toList());
                evalGroupDTO.setPostIds(postIds);
                evalGroupDTO.setPostNames(postNames);
            }
            lastStageOverTime = stage.getOverTime();
        }

        SettingDraft settingDraft = getSettingDraft(evalGroupRankDto, isSubmit);
        settingDraftService.saveOrUpdate(settingDraft);
        if (! isSubmit) {
            return;
        }
        approvalBizService.applyApproveEvalDraft(evalGroupRankDto, evalGroupSize.get(), settingDraft, user);
    }

    public void checkStageTime(EvalGroupRankDTO eval, EvalGroupRankStageDTO stage, LocalDate lastStageOverTime) {
        if (stage.getBeginTime().isBefore(eval.getBeginTime())) {
            throw new BusinessException("阶段开始时间不能在考评时间之前");
        }
        if (stage.getOverTime().isAfter(eval.getOverTime())) {
            throw new BusinessException("阶段结束时间不能在考评时间之前");
        }
        if (PublicUtil.isNotEmpty(lastStageOverTime)) {
            if (stage.getBeginTime().isBefore(lastStageOverTime)) {
                throw new BusinessException("阶段开始时间不能在上一个阶段结束时间之前");
            }
        }
        if (YearMonth.from(stage.getOverTime()).compareTo(YearMonth.from(eval.getOverTime())) != 0) {
            throw new BusinessException("阶段开始时间结束时间必须是同一月份");
        }
    }

    /**
     * 检查绩效组排名名称是否重复
     *
     * @param evalGroupRankDto
     */
    public void checkNameRepetition(EvalGroupRankDTO evalGroupRankDto) {
        int count = evalGroupRankService.count(Wrappers.<EvalGroupRank>lambdaQuery()
                .eq(EvalGroupRank::getName, evalGroupRankDto.getName())
                .ne(PublicUtil.isNotEmpty(evalGroupRankDto.getId()), EvalGroupRank::getId, evalGroupRankDto.getId())
                .eq(EvalGroupRank::getYn, Boolean.TRUE)
        );
        BV.isTrue(count <= 0, "考评排名组名称重复，请重新输入");
    }

    /**
     * 检查阶梯分值
     * @param indicators
     */
    private void checkEvalIndicatorLadders(List<EvalGroupIndicatorDTO> indicators) {
        Integer baseScore = null;
        for (EvalGroupIndicatorDTO indicatorDto : indicators) {
            if (ScoreWayEnum.NORMAL.equals(indicatorDto.getScoreWay())) {
                continue;
            }

            baseScore = indicatorDto.getBaseScore();
            List<EvalGroupIndicatorLaddersDTO> ladders = indicatorDto.getLadders();
            Collections.sort(ladders);

            //阶梯值校验  标准分不能超过指标基础分，阶梯值必须连续
            for (EvalGroupIndicatorLaddersDTO laddersDto : ladders) {
                BV.isTrue(PublicUtil.isNotEmpty(laddersDto.getLower()), "阶梯下限不能为空");
                BV.isTrue(PublicUtil.isNotEmpty(laddersDto.getUpper()), "阶梯上限不能为空");

                //阶梯标准分不能超过绩效分值
                if (laddersDto.getStandardScore().compareTo(baseScore) > 0) {
                    throw new BusinessException("【" + indicatorDto.getName() + "】的阶梯标准分不能超过绩效分值");
                }
            }
            //校验阶梯
            CommonService.checkLadders(ladders, indicatorDto.getName());

            //校验条件
            for (EvalGroupIndicatorPreconditionDTO condDTO : indicatorDto.getConds()) {
                CommonService.checkLadders(condDTO.getLadders(), indicatorDto.getName());
            }
        }
    }

    /**
     * 检查阶梯分值
     * @param rewards
     */
    private void checkEvalRewardLadders(List<EvalGroupRewardDTO> rewards) {
        for (EvalGroupRewardDTO reward : rewards) {

            String rewardName = reward.getName();
            List<EvalGroupRewardLaddersDTO> ladders = reward.getLadders();
            if (EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER_DOUBLE.equals(reward.getCalMethod())) {
                BV.isTrue(PublicUtil.isNotEmpty(ladders), "阶梯不能为空");
                Collections.sort(ladders);
            }

            for (EvalGroupRewardLaddersDTO ladder : ladders) {
                BV.isTrue(PublicUtil.isNotEmpty(ladder.getLower()), "阶梯下限不能为空");
                BV.isTrue(PublicUtil.isNotEmpty(ladder.getUpper()), "阶梯上限不能为空");
            }

            switch (reward.getCalMethod()) {
                case TOTAL_PROPORTION: case FIXATION:{
                    if (PublicUtil.isNotEmpty(ladders)) {
                        throw new BusinessException("计算方式【" + reward.getCalMethod().getName() + "】不能配置阶梯");
                    }
                    break;
                }
//                case RANK:
                case LADDER:
                case LADDER_DOUBLE:
                {
                    CommonService.checkLadders(ladders, rewardName);
                    break;
                }
            }

        }
    }

    /**
     * 检查阶梯分值
     * @param rewards
     */
    private void sortRewardRankLadders(List<EvalGroupRewardDTO> rewards) {
        for (EvalGroupRewardDTO reward : rewards) {
            if (! EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod())) {
                continue;
            }

            List<EvalGroupRewardLaddersDTO> ladders = reward.getLadders();
            Collections.sort(ladders, new Comparator<EvalGroupRewardLaddersDTO>() {
                @Override
                public int compare(EvalGroupRewardLaddersDTO o1, EvalGroupRewardLaddersDTO o2) {
                    if (PublicUtil.isEmpty(o1.getRankOrderType())) {
                        return -1;
                    }
                    if (PublicUtil.isEmpty(o2.getRankOrderType())) {
                        return 1;
                    }
                    //正数在前 负数在后
                    Integer order = o1.getRankOrderType().compareTo(o2.getRankOrderType());
                    if (order == 0) {
                        //大的在后
                        return o1.getLower().subtract(o2.getLower()).intValue();
                    }
                    return order;
                }
            });

        }
    }

    /**
     * 检查考评组指标
     *
     * @param evalGroupDTO
     */
    public void checkIndicator(EvalGroupDTO evalGroupDTO, Boolean multiStage) {
        for (EvalGroupIndicatorDTO indicator : evalGroupDTO.getIndicators()) {
            String indicatorName = indicator.getName();

            if (ScoreWayEnum.LADDER.equals(indicator.getScoreWay())) {
                BV.notNull(indicator.getLaddersType(), indicatorName + " 台阶数据类型不能为空");
            }

            if (PublicUtil.isNotEmpty(indicator.getLadderParams())) {
                BigDecimal proportion = indicator.getLadderParams().stream()
                        .map(EvalGroupIndicatorParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + indicator.getName() + "】台阶占比总和必须为100");

                for (EvalGroupIndicatorParamDTO paramDTO : indicator.getLadderParams()) {
                    if (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(paramDTO.getTargetType()) || PublicUtil.isEmpty(paramDTO.getTargetValue()))) {
                        paramDTO.setTargetType(TargetTypeEnum.NO);
                    }
                    if (PublicUtil.isNotEmpty(paramDTO.getTargetCalcType())) {
//                        if (multiStage) {
//                            if (TargetCalcTypeEnum.STAGE_TARGET.equals(paramDTO.getTargetCalcType()) ||
//                                    TargetCalcTypeEnum.TIME_SCHEDULE.equals(paramDTO.getTargetCalcType())) {
//                                throw new BusinessException("多阶段目标只能选择阶段目标或时间进度");
//                            }
//                        } else if (TargetCalcTypeEnum.TARGET_VALUE.equals(paramDTO.getTargetCalcType()) ||
//                                TargetCalcTypeEnum.MINIMUM.equals(paramDTO.getTargetCalcType())) {
//                            throw new BusinessException("非多阶段目标只能选择百分比或数量");
//                        }
                    }
                }
            }

            if (PublicUtil.isNotEmpty(indicator.getCommissionParams())) {
                BigDecimal proportion = indicator.getCommissionParams().stream()
                        .map(EvalGroupIndicatorParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + indicator.getName() + "】提成占比总和必须为100");

                for (EvalGroupIndicatorParamDTO paramDTO : indicator.getCommissionParams()) {
                    if (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(paramDTO.getTargetType()) || PublicUtil.isEmpty(paramDTO.getTargetValue()))) {
                        paramDTO.setTargetType(TargetTypeEnum.NO);
                        continue;
                    }
                    if (PublicUtil.isNotEmpty(paramDTO.getTargetCalcType())) {
//                        if (multiStage) {
//                            if (TargetCalcTypeEnum.STAGE_TARGET.equals(paramDTO.getTargetCalcType()) ||
//                                    TargetCalcTypeEnum.TIME_SCHEDULE.equals(paramDTO.getTargetCalcType())) {
//                                throw new BusinessException("多阶段目标只能选择阶段目标或时间进度");
//                            }
//                        } else if (TargetCalcTypeEnum.TARGET_VALUE.equals(paramDTO.getTargetCalcType()) ||
//                                TargetCalcTypeEnum.MINIMUM.equals(paramDTO.getTargetCalcType())) {
//                            throw new BusinessException("非多阶段目标只能选择百分比或数量");
//                        }
                    }
                }
            }

            if (PublicUtil.isNotEmpty(indicator.getConds())) {
                for (EvalGroupIndicatorPreconditionDTO preconditionDTO : indicator.getConds()) {
                    if (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(preconditionDTO.getTargetType()) || PublicUtil.isEmpty(preconditionDTO.getTargetValue()))) {
                        preconditionDTO.setTargetType(TargetTypeEnum.NO);
                        continue;
                    }
                }
            }

        }
    }

    public void checkRewardDim(EvalGroupRewardDimDTO dimDTO, EvalScopeEnum type) {
        if (EvalScopeEnum.STAFF.equals(type)) {
            if (PublicUtil.isEmpty(dimDTO.getPostIds()) || PublicUtil.isEmpty(dimDTO.getPostNames())) {
                throw new BusinessException("人员考评岗位信息必填");
            }
            return;
        }

        if (PublicUtil.isEmpty(dimDTO.getShopIds()) || PublicUtil.isEmpty(dimDTO.getShopNames())
                || PublicUtil.isEmpty(dimDTO.getDistRoleCode()) || PublicUtil.isEmpty(dimDTO.getDistRoleName())) {
            throw new BusinessException("门店考评门店、分配奖惩角色信息必填");
        }
    }

    /**
     * 检查考评组指标
     *
     * @param rewards
     */
    public void checkReward(List<EvalGroupRewardDTO> rewards) {
        for (EvalGroupRewardDTO reward : rewards) {
            String rewardName = reward.getName();

            if (EvalRewardCalMethodEnum.LADDER.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER_DOUBLE.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod())) {
                BV.notNull(reward.getLaddersType(), rewardName + " 台阶数据类型不能为空");
            }

            if (PublicUtil.isNotEmpty(reward.getCommissionParams())) {
                BigDecimal proportion = reward.getCommissionParams().stream()
                        .map(EvalGroupRewardParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + rewardName + "】台阶占比总和必须为100");

                for (EvalGroupRewardParamDTO commissionParam : reward.getCommissionParams()) {
                    if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&
                            (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {
                        commissionParam.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(reward.getLadderParams())) {
                BigDecimal proportion = reward.getLadderParams().stream()
                        .map(EvalGroupRewardParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + rewardName + "】提成占比总和必须为100");

                for (EvalGroupRewardParamDTO commissionParam : reward.getLadderParams()) {
                    if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&
                            (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {
                        commissionParam.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(reward.getConds())) {
                for (EvalGroupRewardPreconditionDTO preconditionDTO : reward.getConds()) {
                    if (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(preconditionDTO.getTargetType()) || PublicUtil.isEmpty(preconditionDTO.getTargetValue()))) {
                        preconditionDTO.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }
        }
    }

    /**
     * 检查时间
     *
     * @param dto
     */
    public void initEvalGroupDTO(EvalGroupDTO dto) {
        if (PublicUtil.isEmpty(dto.getIndicators())) {
            dto.setIndicators(new ArrayList<>());
        }
        if (PublicUtil.isEmpty(dto.getShopRewardDims())) {
            dto.setShopRewardDims(new ArrayList<>());
        }
        if (PublicUtil.isEmpty(dto.getStaffRewardDims())) {
            dto.setStaffRewardDims(new ArrayList<>());
        }
        for (EvalGroupIndicatorDTO indicatorDTO : dto.getIndicators()) {
            if (PublicUtil.isEmpty(indicatorDTO.getLadderParams())) {
                indicatorDTO.setLadderParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getCommissionParams())) {
                indicatorDTO.setCommissionParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getLadders())) {
                indicatorDTO.setLadders(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getConds())) {
                indicatorDTO.setConds(new ArrayList<>());
            }
        }
        for (EvalGroupRewardDimDTO dimDTO : dto.getStaffRewardDims()) {
            for (EvalGroupRewardDTO rewardDTO : dimDTO.getRewards()) {
                if (PublicUtil.isEmpty(rewardDTO.getLadderParams())) {
                    rewardDTO.setLadderParams(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getCommissionParams())) {
                    rewardDTO.setCommissionParams(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getLadders())) {
                    rewardDTO.setLadders(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getConds())) {
                    rewardDTO.setConds(new ArrayList<>());
                }
            }
        }
        for (EvalGroupRewardDimDTO dimDTO : dto.getShopRewardDims()) {
            for (EvalGroupRewardDTO rewardDTO : dimDTO.getRewards()) {
                if (PublicUtil.isEmpty(rewardDTO.getLadderParams())) {
                    rewardDTO.setLadderParams(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getCommissionParams())) {
                    rewardDTO.setCommissionParams(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getLadders())) {
                    rewardDTO.setLadders(new ArrayList<>());
                }
                if (PublicUtil.isEmpty(rewardDTO.getConds())) {
                    rewardDTO.setConds(new ArrayList<>());
                }
            }
        }
    }

    /**
     * 装换为目标对象
     *
     * @return
     */
    public void setTargetVos(EvalGroupDTO evalGroupDTO) {

        for (EvalGroupIndicatorDTO indicatorDTO : evalGroupDTO.getIndicators()) {
            List<EvalGroupIndicatorParamDTO> ladderParams = Optional.ofNullable(indicatorDTO.getLadderParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorParamDTO> commissionParams = Optional.ofNullable(indicatorDTO.getCommissionParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorPreconditionDTO> conds = Optional.ofNullable(indicatorDTO.getConds()).orElse(new ArrayList<>());

            List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
            for (EvalGroupIndicatorParamDTO paramDTO : ladderParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorParamDTO paramDTO : commissionParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorPreconditionDTO preconditionDTO : conds) {
                if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            indicatorDTO.setTargets(targetVOS);
        }

//        for (EvalGroupRewardDimDTO dimDTO : evalGroupDTO.getDims()) {
//            for (EvalGroupRewardDTO rewardDTO : dimDTO.getRewards()) {
//                List<EvalGroupRewardParamDTO> ladderParams = Optional.ofNullable(rewardDTO.getLadderParams()).orElse(new ArrayList<>());
//                List<EvalGroupRewardParamDTO> commissionParams = Optional.ofNullable(rewardDTO.getCommissionParams()).orElse(new ArrayList<>());
//                List<EvalGroupRewardPreconditionDTO> conds = Optional.ofNullable(rewardDTO.getConds()).orElse(new ArrayList<>());
//
//                List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
//                for (EvalGroupRewardParamDTO paramDTO : ladderParams) {
//                    if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
//                        EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
//                        targetVOS.add(targetVO);
//                    }
//                }
//
//                for (EvalGroupRewardParamDTO paramDTO : commissionParams) {
//                    if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
//                        EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
//                        targetVOS.add(targetVO);
//                    }
//                }
//
//                for (EvalGroupRewardPreconditionDTO preconditionDTO : conds) {
//                    if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
//                        EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
//                        targetVOS.add(targetVO);
//                    }
//                }
//                rewardDTO.setTargets(targetVOS);
//            }
//        }
    }

    /**
     * 获取草稿
     *
     * @param dto
     * @return
     */
    public SettingDraft getSettingDraft(EvalGroupRankDTO dto, Boolean submit) {
        SettingDraft settingDraft = null;
        if (PublicUtil.isEmpty(dto.getDraftId())) {
            settingDraft = new SettingDraft();
            settingDraft.setGroupId(dto.getGroupId());
            settingDraft.setYn(Boolean.TRUE);
            settingDraft.setType(SettingDraftTypeEnum.EVAL_GROUP_RANK);
        } else {
            settingDraft = settingDraftService.getById(dto.getDraftId());
            BV.notNull(settingDraft, "草稿配置不存在，请重试");
        }
        settingDraft.setStatus(submit ? SettingDraftStatusEnum.RELEASE_APPROVAL : SettingDraftStatusEnum.NO_RELEASE);
//        settingDraft.setEvalType(dto.getType());
        settingDraft.setName(dto.getName());
        settingDraft.setContent(JSONObject.toJSONString(dto));
        return settingDraft;
    }


}