package cn.fw.morax.server.task;

import cn.fw.common.cache.locker.DistributedLocker;
import cn.fw.morax.common.constant.Constant;
import cn.fw.morax.common.constant.TimeTaskConstant;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.eval.*;
import cn.fw.morax.domain.db.kpi.IndicatorUserValue;
import cn.fw.morax.domain.enums.*;
import cn.fw.morax.service.biz.CommonService;
import cn.fw.morax.service.data.eval.*;
import cn.fw.morax.service.data.kpi.IndicatorUserValueService;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Maps;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.YearMonth;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author : jiangchao
 * @className : KpiReportRatioTask
 * @description : 绩效报表定时器
 * @date : 2022-04-07 15:29
 */
@Component
@Slf4j
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "task", name = "switch", havingValue = "on")
public class EvalUserReportTask {

    private final EvalGroupIndicatorTargetHitLogService evalGroupIndicatorTargetHitLogService;
    private final EvalGroupIndicatorHitLogService evalGroupIndicatorHitLogService;
    private final EvalGroupIndicatorParamService evalGroupIndicatorParamService;
    private final EvalUserRankCodeReportService evalUserRankCodeReportService;
    private final EvalUserValueReportService evalUserValueReportService;
    private final EvalGroupIndicatorService evalGroupIndicatorService;
    private final IndicatorUserValueService indicatorUserValueService;
    private final EvalIndicatorValueService evalIndicatorValueService;
    private final PlatformTransactionManager platformTransactionManager;
    private final EvalUserRankReportService evalUserRankReportService;
    private final EvalUserReportService evalUserReportService;
    private final TransactionDefinition transactionDefinition;
    private final EvalUserPoolService evalUserPoolService;
    private final EvalGroupRankService evalGroupRankService;
    private final EvalGroupService evalGroupService;
    private final DistributedLocker distributedLocker;
    private final CommonService commonService;

    @Value("${spring.cache.custom.global-prefix}:eval:user:report")
    @Getter
    private String evalUserReportDistKey;

    /**
     * 考评报表定时任务
     *
     */
    @Scheduled(cron = TimeTaskConstant.EVAL_REPORT)
    @Transactional(rollbackFor = Exception.class)
    public void evalUserReportTask() {
//        this.evalUserReport(LocalDate.now().minusDays(1));
    }

    /**
     * 绩效报表定时任务
     * 1. 遍历考评排名组
     * 2. 创建考评排名组报表
     * 3. 创建考评排名组编码
     * 4. 统计数据
     *
     * @param date
     */
    public void evalUserReport(LocalDate date) {
        Lock lock = distributedLocker.lock(getEvalUserReportDistKey());
        if (! ((RLock) lock).isLocked()) {
            return;
        }
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
        try {
            log.info("定时任务【考评人员报表数据抽取】开始执行");
            Map<Long, List<EvalGroupRank>> groupEvalGroupMap = queryEffectRank(date);
            for (Map.Entry<Long, List<EvalGroupRank>> entry : groupEvalGroupMap.entrySet()) {
                for (EvalGroupRank rank : entry.getValue()) {
                    //清除当月数据（当月只有一条数据）
                    cleanRankCurMonthData(rank.getId(), date);
                    //抽取排名组数据
                    createRankReport(rank, entry.getKey(), date);
                }
            }
            platformTransactionManager.commit(transactionStatus);
        } catch (Exception e){
            platformTransactionManager.rollback(transactionStatus);
            log.error("考评人员报表数据抽取失败， " + e.getMessage(), e);
        } finally {
            lock.unlock();
        }
    }

    /**
     * 计算排名组报表数据
     * @param rank
     * @param groupId
     * @param date
     */
    public void createRankReport(EvalGroupRank rank, Long groupId, LocalDate date) {
        List<EvalGroup> evalGroups = evalGroupService.getEffectsByRankId(rank.getId(), date);
        List<Long> evalGroupIds = evalGroups.stream().map(EvalGroup::getId).collect(Collectors.toList());
        if (PublicUtil.isEmpty(evalGroupIds)) {
            return;
        }
        List<EvalUserPool> pools = evalUserPoolService.list(Wrappers.<EvalUserPool>lambdaQuery()
                .in(EvalUserPool::getEvalGroupId, evalGroupIds)
                .eq(EvalUserPool::getMonthly, YearMonth.from(date))
                .eq(EvalUserPool::getYn, Boolean.TRUE)
        );
        if (PublicUtil.isEmpty(pools)) {
            return;
        }
        List<EvalGroupIndicator> evalGroupIndicators = evalGroupIndicatorService.list(Wrappers.<EvalGroupIndicator>lambdaQuery()
                .in(EvalGroupIndicator::getEvalGroupId, evalGroupIds)
                .eq(EvalGroupIndicator::getYn, Boolean.TRUE)
                .orderByAsc(EvalGroupIndicator::getId)
        );

        //排名组
        EvalUserRankReport reportRank = this.saveRankReport(rank, evalGroupIds, evalGroups, date, groupId);
        final Long evalUserRankReportId = reportRank.getId();
        //排名组指标编码、人员、门店
        List<EvalUserRankCodeReport> rankCodes = this.saveRankCodeReports(evalGroupIndicators, evalUserRankReportId, date);
        List<EvalUserReport> evalUserReports = this.saveStaffReports(pools, date, evalUserRankReportId);
        List<EvalUserReport> evalShopReports = this.saveShopReports(pools, date, evalUserRankReportId);
        //人员维度
        List<EvalUserValueReport> reportUserValues = calcUser(pools, evalGroupIndicators, evalUserReports, date);
        //门店维度
        calcShop(evalShopReports, rankCodes, reportUserValues, evalUserReports, date);

    }
    public List<EvalUserValueReport> calcUser(List<EvalUserPool> pools,
                                              List<EvalGroupIndicator> evalGroupIndicators,
                                              List<EvalUserReport> evalUserReports,
                                              LocalDate date) {
        List<EvalUserValueReport> reportUserValues = new ArrayList<>();
        List<Long> userIds = pools.stream().map(EvalUserPool::getUserId).distinct().collect(Collectors.toList());
        List<Long> poolIds = pools.stream().map(EvalUserPool::getId).collect(Collectors.toList());
        List<Long> evalGroupIndicatorIds = evalGroupIndicators.stream().map(EvalGroupIndicator::getId).collect(Collectors.toList());
        List<EvalGroupIndicatorHitLog> hitLogs = evalGroupIndicatorHitLogService.getHitLogs(evalGroupIndicatorIds, poolIds, EvalScopeEnum.STAFF, date);
        Map<Long, List<EvalGroupIndicatorHitLog>> indicatorHitLogMap = hitLogs.stream().collect(Collectors.groupingBy(EvalGroupIndicatorHitLog::getEvalGroupIndicatorId));
        Map<Long, Long> userPoolReportIdMap = evalUserReports.stream().collect(Collectors.toMap(EvalUserReport::getEvalUserPoolId, EvalUserReport::getId, (v1, v2) -> v1));

        for (EvalGroupIndicator groupIndicator : evalGroupIndicators) {
            final ScoreWayEnum scoreWay = groupIndicator.getScoreWay();
            final IndicatorCodeTypeEnum codeType = groupIndicator.getCodeType();
            final Long evalGroupIndicatorId = groupIndicator.getId();
            List<EvalGroupIndicatorParam> params = evalGroupIndicatorParamService.list(Wrappers.<EvalGroupIndicatorParam>lambdaQuery()
                    .eq(EvalGroupIndicatorParam::getEvalGroupIndicatorId, evalGroupIndicatorId)
                    .eq(EvalGroupIndicatorParam::getYn, Boolean.TRUE)
            );

            List<EvalGroupIndicatorHitLog> userHitLogs = indicatorHitLogMap.getOrDefault(evalGroupIndicatorId, new ArrayList<>());
            Map<Long, EvalGroupIndicatorHitLog> poolHitLogMap = userHitLogs.stream()
                    .collect(Collectors.toMap(EvalGroupIndicatorHitLog::getPoolId, Function.identity(), (v1, v2) -> v1));
            for (EvalUserPool userPool : pools) {
                if (! userPool.getEvalGroupId().equals(groupIndicator.getEvalGroupId())) {
                    continue;
                }
                Optional<EvalGroupIndicatorHitLog> hitLog = Optional.ofNullable(poolHitLogMap.get(userPool.getId()));
                BigDecimal value = (ScoreWayEnum.LADDER.equals(scoreWay)) ?
                        hitLog.map(EvalGroupIndicatorHitLog::getHitLadderValue).orElse(BigDecimal.ZERO) :
                        hitLog.map(EvalGroupIndicatorHitLog::getHitCommissionValue).orElse(BigDecimal.ZERO);
                Long evalUserReportId = userPoolReportIdMap.get(userPool.getId());
                reportUserValues.add(convertDB(evalUserReportId, groupIndicator, value, date, params));
            }

            //是否有子指标
            if (IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(codeType)) {
                for (EvalGroupIndicatorParam param : params) {
                    if (TargetTypeEnum.NO.equals(param.getTargetType())) {
                        Map<Long, BigDecimal> userValueMap = queryUserOriginValue(param, userIds, date);
                        for (EvalUserPool userPool : pools) {
                            BigDecimal value = userValueMap.getOrDefault(userPool.getUserId(), BigDecimal.ZERO);
                            Long evalUserReportId = userPoolReportIdMap.get(userPool.getId());
                            reportUserValues.add(convertParamDB(evalUserReportId, param, value, date));
                        }
                    } else {
                        Map<Long, EvalGroupIndicatorTargetHitLog> hitLogMap = queryUserTargetValue(param.getId(), poolIds, date);
                        for (EvalUserPool userPool : pools) {
                            EvalGroupIndicatorTargetHitLog hitLog = hitLogMap.get(userPool.getId());
                            BigDecimal value = Optional.ofNullable(hitLog)
                                    .map(EvalGroupIndicatorTargetHitLog::getReachValue).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED);
                            Long evalUserReportId = userPoolReportIdMap.get(userPool.getId());
                            reportUserValues.add(convertParamDB(evalUserReportId, param, value, date));
                        }
                    }
                }
            }
        }
        if (PublicUtil.isNotEmpty(reportUserValues)) {
            evalUserValueReportService.saveBatch(reportUserValues);
        }
        return reportUserValues;
    }

    public void calcShop(List<EvalUserReport> evalShopReports,
                         List<EvalUserRankCodeReport> rankCodes,
                         List<EvalUserValueReport> reportUserValues,
                         List<EvalUserReport> evalUserReports,
                         LocalDate date) {
        List<EvalUserValueReport> reportShopValues = new ArrayList<>();
        for (EvalUserReport shopReport : evalShopReports) {

            Set<Long> shopReportIds = evalUserReports.stream()
                    .filter(user -> shopReport.getShopId().equals(user.getShopId()) && Boolean.TRUE.equals(user.getInclusion()))
                    .map(EvalUserReport::getId).collect(Collectors.toSet());

            final Long evalUserReportId = shopReport.getId();
            for (EvalUserRankCodeReport rankCode : rankCodes) {
                final String code = rankCode.getCode();
                final IndicatorCodeTypeEnum codeType = rankCode.getCodeType();

                Double averageRatioDouble = reportUserValues.stream()
                        .filter(user -> shopReportIds.contains(user.getEvalUserReportId()) && code.equals(user.getCode()))
                        .mapToDouble(userValue -> Optional.ofNullable(userValue.getValue()).orElse(BigDecimal.ZERO).doubleValue())
                        .average()
                        .orElse(0);
                BigDecimal value = new BigDecimal(averageRatioDouble.toString());
                EvalUserValueReport shopValue = new EvalUserValueReport(evalUserReportId, code, codeType, value, date);
                reportShopValues.add(shopValue);
            }
        }
        if (PublicUtil.isNotEmpty(reportShopValues)) {
            evalUserValueReportService.saveBatch(reportShopValues);
        }
    }

    public List<EvalUserReport> saveStaffReports(List<EvalUserPool> pools, LocalDate date, Long evalUserRankReportId) {
        List<EvalUserReport> evalUserReports = new ArrayList<>();
        for (EvalUserPool userPool : pools) {
            EvalUserReport report = new EvalUserReport();
            report.setEvalUserRankReportId(evalUserRankReportId);
            report.setDimension(ReportDimensionEnum.STAFF);
            report.setUserId(userPool.getUserId());
            report.setUserName(userPool.getUserName());
            report.setPostId(userPool.getPostId());
            report.setPostName(userPool.getPostName());
            report.setShopId(userPool.getShopId());
            report.setShopName(userPool.getShopName());
            report.setEvalUserPoolId(userPool.getId());
            report.setDataDate(date);
            report.setInclusion(userPool.getInclusion());
            evalUserReports.add(report);
        }
        evalUserReportService.saveBatch(evalUserReports);
        return evalUserReports;
    }

    public List<EvalUserReport> saveShopReports(List<EvalUserPool> pools, LocalDate date, Long evalUserRankReportId) {
        List<EvalUserReport> evalShopReports = new ArrayList<>();
        Map<Long, String> shopMap = pools.stream().collect(Collectors.toMap(EvalUserPool::getShopId, EvalUserPool::getShopName, (v1, v2) -> v1));
        for (Long shopId : shopMap.keySet()) {
            EvalUserReport report = new EvalUserReport();
            report.setDimension(ReportDimensionEnum.SHOP);
            report.setEvalUserRankReportId(evalUserRankReportId);
            report.setShopId(shopId);
            report.setShopName(shopMap.get(shopId));
            report.setDataDate(date);
            evalShopReports.add(report);
        }
        evalUserReportService.saveBatch(evalShopReports);
        return evalShopReports;
    }

    public Map<Long, BigDecimal> queryUserOriginValue(EvalGroupIndicatorParam param, List<Long> userIds, LocalDate dataDate) {
        final String code = param.getCode();
        final IndicatorCodeTypeEnum codeType = param.getCodeType();
        Map<Long, BigDecimal> referValueMap = Maps.newHashMapWithExpectedSize(userIds.size());
        //无目标
        if (IndicatorCodeTypeEnum.INDICATOR.equals(codeType)) {
            List<IndicatorUserValue> indicatorUserValues = indicatorUserValueService.list(Wrappers.<IndicatorUserValue>lambdaQuery()
                            .eq(IndicatorUserValue::getIndicatorCode, code)
                            .eq(IndicatorUserValue::getDataDate, dataDate)
                            .in(IndicatorUserValue::getUserId, userIds)
                            .eq(IndicatorUserValue::getDimensionType, DimensionTypeEnum.STAFF)
                            .eq(IndicatorUserValue::getYn, Boolean.TRUE)
            );
            for (IndicatorUserValue userValue : indicatorUserValues) {
                referValueMap.put(userValue.getUserId(), commonService.queryIndicatorValueVO(code, userValue,
                        param.getTargetType(), param.getDataType()));
            }
            return referValueMap;
        }
        for (Long userId : userIds) {
            EvalIndicatorValue evalIndicatorValue = evalIndicatorValueService.queryLastValue(userId,
                    DimensionTypeEnum.STAFF, code, dataDate);
            referValueMap.put(userId, commonService.queryEvalIndicatorValueVO(code, evalIndicatorValue, param.getTargetType(), param.getDataType()));
        }
        return referValueMap;
    }

    public Map<Long, EvalGroupIndicatorTargetHitLog> queryUserTargetValue(Long referId, List<Long> poolIds, LocalDate dataDate) {
        List<EvalGroupIndicatorTargetHitLog> targetHitLogs = evalGroupIndicatorTargetHitLogService.list(Wrappers.<EvalGroupIndicatorTargetHitLog>lambdaQuery()
                .eq(EvalGroupIndicatorTargetHitLog::getReferId, referId)
                .eq(EvalGroupIndicatorTargetHitLog::getTargetType, IndicatorTypeEnum.EXAMINE)
                .eq(EvalGroupIndicatorTargetHitLog::getDataDate, dataDate)
                .in(EvalGroupIndicatorTargetHitLog::getPoolId, poolIds)
                .eq(EvalGroupIndicatorTargetHitLog::getScopeType, EvalScopeEnum.STAFF)
                .eq(EvalGroupIndicatorTargetHitLog::getYn, Boolean.TRUE)
        );
        return targetHitLogs.stream()
                .collect(Collectors.toMap(EvalGroupIndicatorTargetHitLog::getPoolId, Function.identity(), (v1, v2) -> v1));
    }

    public void cleanTodayData(LocalDate date) {
        evalUserRankReportService.remove(Wrappers.<EvalUserRankReport>lambdaUpdate()
                .eq(EvalUserRankReport::getDataDate, date)
        );
        evalUserRankCodeReportService.remove(Wrappers.<EvalUserRankCodeReport>lambdaUpdate()
                .eq(EvalUserRankCodeReport::getDataDate, date)
        );
        evalUserValueReportService.remove(Wrappers.<EvalUserValueReport>lambdaUpdate()
                .eq(EvalUserValueReport::getDataDate, date)
        );
        evalUserReportService.remove(Wrappers.<EvalUserReport>lambdaUpdate()
                .eq(EvalUserReport::getDataDate, date)
        );
    }

    public void cleanRankCurMonthData(Long rankId, LocalDate endDate) {
        LocalDate startDate = endDate.with(TemporalAdjusters.firstDayOfMonth());
        List<EvalUserRankReport> rankReports = evalUserRankReportService.list(Wrappers.<EvalUserRankReport>lambdaQuery()
                .eq(EvalUserRankReport::getRankId, rankId)
                .ge(EvalUserRankReport::getDataDate, startDate)
                .le(EvalUserRankReport::getDataDate, endDate)
        );
        if (PublicUtil.isEmpty(rankReports)) {
            return;
        }
        List<Long> rankReportIds = rankReports.stream().map(EvalUserRankReport::getId).collect(Collectors.toList());
        evalUserRankReportService.removeByIds(rankReportIds);
        evalUserRankCodeReportService.remove(Wrappers.<EvalUserRankCodeReport>lambdaUpdate()
                .in(EvalUserRankCodeReport::getEvalUserRankReportId, rankReportIds)
        );

        List<EvalUserReport> userReports = evalUserReportService.list(Wrappers.<EvalUserReport>lambdaQuery()
                .in(EvalUserReport::getEvalUserRankReportId, rankReportIds)
        );
        List<Long> userReportIds = userReports.stream().map(EvalUserReport::getId).collect(Collectors.toList());
        if (PublicUtil.isEmpty(userReportIds)) {
            return;
        }
        evalUserReportService.removeByIds(userReportIds);
        evalUserValueReportService.remove(Wrappers.<EvalUserValueReport>lambdaUpdate()
                .in(EvalUserValueReport::getEvalUserReportId, userReportIds)
        );
    }

    public List<EvalUserRankCodeReport> saveRankCodeReports(List<EvalGroupIndicator> evalGroupIndicators, Long reportRankId, LocalDate date) {
        Set<String> codes = new HashSet<>();
        List<EvalUserRankCodeReport> rankCodes = new ArrayList<>();
        AtomicInteger order = new AtomicInteger();
        for (EvalGroupIndicator groupIndicator : evalGroupIndicators) {
            //一个编码只能展示一次
            if (! codes.add(groupIndicator.getCode())) {
                continue;
            }
            rankCodes.add(this.convertRankCodeDB(groupIndicator, date, reportRankId, order));

            //组合指标
            if (PublicUtil.isNotEmpty(groupIndicator.getCodeType()) &&
                    IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(groupIndicator.getCodeType())) {
                //子指标
                List<EvalGroupIndicatorParam> params = evalGroupIndicatorParamService.list(Wrappers.<EvalGroupIndicatorParam>lambdaQuery()
                        .eq(EvalGroupIndicatorParam::getEvalGroupIndicatorId, groupIndicator.getId())
                        .eq(EvalGroupIndicatorParam::getYn, Boolean.TRUE)
                );
                for (EvalGroupIndicatorParam indicatorParam : params) {
                    rankCodes.add(this.convertParamToRankCodeDB(indicatorParam, date, reportRankId, order, groupIndicator));
                }
            }

        }
        evalUserRankCodeReportService.saveBatch(rankCodes);
        return rankCodes;
    }

    public Map<Long, List<EvalGroupRank>> queryEffectRank(LocalDate date) {
        List<SettingStatusEnum> status = new ArrayList<SettingStatusEnum>(){{
            add(SettingStatusEnum.EFFECTIVE);
            add(SettingStatusEnum.BE_EFFECTIVE);
        }};
        List<EvalGroupRank> evalGroupRanks = evalGroupRankService.list(Wrappers.<EvalGroupRank>lambdaQuery()
                .in(EvalGroupRank::getStatus, status)
                .ge(EvalGroupRank::getOverTime, date)
                .eq(EvalGroupRank::getYn, Boolean.TRUE)
        );
        return evalGroupRanks.stream().collect(Collectors.groupingBy(EvalGroupRank::getGroupId));
    }

    public EvalUserRankReport saveRankReport(EvalGroupRank rank, List<Long> evalGroupIds, List<EvalGroup> evalGroups, LocalDate date, Long groupId) {
        List<Long> shopIds = evalGroups.stream().map(EvalGroup::getShopIds).distinct().collect(ArrayList::new, List::addAll, List::addAll);
        EvalUserRankReport reportRank = new EvalUserRankReport();
        reportRank.setRankId(rank.getId());
        reportRank.setRankName(rank.getName());
        reportRank.setEvalGroupIds(evalGroupIds);
        reportRank.setShopIds(shopIds);
        reportRank.setDataDate(date);
        reportRank.setMonthly(YearMonth.from(date));
        reportRank.setGroupId(groupId);
        evalUserRankReportService.save(reportRank);
        return reportRank;
    }

    public EvalUserValueReport convertDB(Long evalUserReportId, EvalGroupIndicator groupIndicator, BigDecimal value,
                                         LocalDate date, List<EvalGroupIndicatorParam> params) {
        EvalUserValueReport userValue = new EvalUserValueReport();
        userValue.setEvalUserReportId(evalUserReportId);
        userValue.setCode(groupIndicator.getCode());
        userValue.setCodeType(groupIndicator.getCodeType());
        userValue.setValue(Optional.ofNullable(value).orElse(BigDecimal.ZERO));
        userValue.setDataDate(date);
        if (IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(groupIndicator.getCodeType())) {
            userValue.setValue(userValue.getValue().multiply(Constant.ONE_HUNDRED));
        } else {
            Optional<EvalGroupIndicatorParam> paramOptional = params.stream().findFirst();
            if (paramOptional.isPresent()) {
                EvalGroupIndicatorParam param = paramOptional.get();
                if (DataTypeEnum.RATIO.equals(param.getDataType()) || (! TargetTypeEnum.NO.equals(param.getTargetType()))) {
                    userValue.setValue(userValue.getValue().multiply(Constant.ONE_HUNDRED));
                }
            }
        }
        return userValue;
    }

    public EvalUserValueReport convertParamDB(Long evalUserReportId, EvalGroupIndicatorParam param, BigDecimal value, LocalDate date) {
        EvalUserValueReport userValue = new EvalUserValueReport();
        userValue.setEvalUserReportId(evalUserReportId);
        userValue.setCode(param.getCode());
        userValue.setCodeType(param.getCodeType());
        userValue.setValue(Optional.ofNullable(value).orElse(BigDecimal.ZERO));
        userValue.setDataDate(date);
        return userValue;
    }

    public EvalUserRankCodeReport convertRankCodeDB(EvalGroupIndicator groupIndicator, LocalDate date, Long reportRankId, AtomicInteger order) {
        EvalUserRankCodeReport rankCode = new EvalUserRankCodeReport();
        rankCode.setEvalUserRankReportId(reportRankId);
        rankCode.setEvalGroupIndicatorId(groupIndicator.getId());
        rankCode.setCode(groupIndicator.getCode());
        rankCode.setCodeType(groupIndicator.getCodeType());
//        String indicatorName = (ScoreWayEnum.LADDER.equals(groupIndicator.getScoreWay())) ?
//                groupIndicator.getLadderParamAlias() : groupIndicator.getCommissionParamAlias();
//        if (PublicUtil.isEmpty(indicatorName)) {
//            indicatorName = groupIndicator.getName();
//        }
//        rankCode.setIndicatorName(indicatorName);
        rankCode.setIndicatorName(groupIndicator.getName());
        rankCode.setDataDate(date);
        rankCode.setOrderNum(order.incrementAndGet());
        return rankCode;
    }

    public EvalUserRankCodeReport convertParamToRankCodeDB(EvalGroupIndicatorParam indicatorParam, LocalDate date, Long reportRankId,
                                                           AtomicInteger order, EvalGroupIndicator groupIndicator) {
        EvalUserRankCodeReport rankCode = new EvalUserRankCodeReport();
        rankCode.setEvalUserRankReportId(reportRankId);
        rankCode.setEvalGroupIndicatorId(indicatorParam.getEvalGroupIndicatorId());
        rankCode.setCode(indicatorParam.getCode());
        rankCode.setCodeType(indicatorParam.getCodeType());
        rankCode.setIndicatorName(indicatorParam.getName());
        if (IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(groupIndicator.getCodeType())
                && PublicUtil.isNotEmpty(groupIndicator.getCode())) {
            rankCode.setParentCode(groupIndicator.getCode());
        }
        rankCode.setDataDate(date);
        rankCode.setOrderNum(order.incrementAndGet());
        return rankCode;
    }


}