KPI / fw-morax

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

import cn.fw.common.cache.CacheExtender;
import cn.fw.common.cache.locker.DistributedLocker;
import cn.fw.morax.common.utils.MessageFormatUtil;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.UserResignExamine;
import cn.fw.morax.domain.db.kpi.KpiGroupUser;
import cn.fw.morax.domain.db.kpi.KpiPool;
import cn.fw.morax.domain.db.kpi.KpiStarRule;
import cn.fw.morax.domain.db.salary.SalaryGroupUser;
import cn.fw.morax.domain.db.salary.SalaryPool;
import cn.fw.morax.domain.db.salary.SalaryClosure;
import cn.fw.morax.domain.enums.ResignExamineStatusEnum;
import cn.fw.morax.domain.enums.StarLevelEnum;
import cn.fw.morax.service.biz.salary.SalarySettingCommonService;
import cn.fw.morax.service.data.UserResignExamineService;
import cn.fw.morax.service.data.kpi.KpiPoolService;
import cn.fw.morax.service.data.kpi.KpiStarRuleService;
import cn.fw.morax.service.data.salary.SalaryGeneralSettinService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.locks.Lock;
import java.util.stream.Collectors;

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

/**
 * @author : kurisu
 * @version : 1.0
 * @className : KpiPoolCommonService
 * @description : 绩效池公用方法
 * @date : 2022-09-27 11:40
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class KpiPoolCommonService {

    public static final CacheKeyFunction<YearMonth, Long, String> KPI_GROUP_AVERAGE_RATIO_CACHE_NAME = (month, groupId) -> String.format("kpi-group:average-ratio:%s:%s", month.toString(), groupId);
    private final KpiPoolService kpiPoolService;
    private final DistributedLocker distributedLocker;
    private final SalaryGeneralSettinService salaryGeneralSettinService;
    private final UserResignExamineService userResignExamineService;
    private final KpiStarRuleService kpiStarRuleService;
    private final CacheExtender cacheExtender;
    private final SalarySettingCommonService salarySettingCommonService;

    @Value("${spring.cache.custom.global-prefix}:forced:resign")
    @Getter
    private String forcedResignLockKey;

    /**
     * 查询绩效池
     *
     * @param user
     * @return
     */
    public Optional<KpiPool> queryPool(SalaryGroupUser user) {
        KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                        .eq(KpiPool::getUserId, user.getUserId())
                        .eq(KpiPool::getPostId, user.getPostId())
                        .eq(KpiPool::getShopId, user.getShopId())
                        .eq(KpiPool::getMonthly, YearMonth.from(user.getDataDate()))
                        .eq(KpiPool::getYn, Boolean.TRUE)
                , Boolean.FALSE);
        if (PublicUtil.isEmpty(kpiPool)) {
            log.error("绩效数据不存在，用户：{}", JSON.toJSONString(user));
//            throw new BusinessException("用户[" + user.getUserId() + "]的绩效数据不存在");
        }
        return Optional.ofNullable(kpiPool);
    }

    /**
     * 查询绩效池
     *
     * @param pool
     * @return
     */
    public KpiPool queryPool(SalaryPool pool) {
        KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                        .eq(KpiPool::getUserId, pool.getUserId())
                        .eq(KpiPool::getPostId, pool.getPostId())
                        .eq(KpiPool::getShopId, pool.getShopId())
                        .eq(KpiPool::getMonthly, pool.getMonthly())
                        .eq(KpiPool::getYn, Boolean.TRUE)
                , Boolean.FALSE);
        if (PublicUtil.isEmpty(kpiPool)) {
            log.error("绩效数据不存在，薪酬池：{}", JSON.toJSONString(pool));
//            throw new BusinessException("用户[" + pool.getUserId() + "]的绩效数据不存在");
        }
        return kpiPool;
    }

    /**
     * 查询绩效池（上报绩效、计算绩效得分用）
     *
     * @param user
     * @return
     */
    public KpiPool inspectionPool(KpiGroupUser user) {
        KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                        .eq(KpiPool::getKpiGroupId, user.getKpiGroupId())
                        .eq(KpiPool::getUserId, user.getUserId())
                        .eq(KpiPool::getMonthly, YearMonth.from(user.getDataDate()))
                        .eq(KpiPool::getYn, Boolean.TRUE)
                , Boolean.FALSE);

        if (Objects.isNull(kpiPool)) {
            kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                            .eq(KpiPool::getPostId, user.getPostId())
                            .eq(KpiPool::getShopId, user.getShopId())
                            .eq(KpiPool::getUserId, user.getUserId())
                            .eq(KpiPool::getMonthly, YearMonth.from(user.getDataDate()))
                            .eq(KpiPool::getYn, Boolean.TRUE)
                    , Boolean.FALSE);

            if (Objects.isNull(kpiPool)) {
                kpiPool = createPoolData(user);
            } else {
                kpiPool = this.modifyPoolData(kpiPool, user);
            }
        } else if ((!kpiPool.getShopId().equals(user.getShopId())) ||
                (!kpiPool.getKpiGroupId().equals(user.getKpiGroupId()))) {
            //若门店信息与员工在职门店不匹配，说明员工是调门店，绩效组没变
            //若绩效组id不匹配，说明绩效组编辑生成了新绩效组，对应绩效池中的绩效组id修改
            kpiPool = this.modifyPoolData(kpiPool, user);
        }
        return kpiPool;
    }

    /**
     * 固定绩效数据
     *
     * @param groupId
     */
    public void regularKpiStar(Long groupId) {
        String key = String.format("%s:%s", ":regular:kpi-start:group:", groupId);
        Lock lock = distributedLocker.lock(key);
        if (!((RLock) lock).isLocked()) {
            return;
        }
        try {
            LocalDate current = LocalDate.now();
            List<SalaryClosure> salaryClosures = salarySettingCommonService.queryNoClosureKpis(groupId);
            for (SalaryClosure salaryClosure : salaryClosures) {
                //当前时间在申述时间之后
                if (current.compareTo(salaryClosure.getAppealEndTime()) > 0) {
                    regularStarAndExamineUser(groupId, YearMonth.now().minusMonths(1L));
                    salarySettingCommonService.updateClosureKpi(salaryClosure);
                }
            }
        } finally {
            lock.unlock();
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void forcedResign() {
        Lock lock = distributedLocker.lock(getForcedResignLockKey());
        if (!((RLock) lock).isLocked()) {
            return;
        }
        try {
            List<UserResignExamine> list = userResignExamineService.list(Wrappers.<UserResignExamine>lambdaQuery()
                    .eq(UserResignExamine::getStatus, ResignExamineStatusEnum.WAITING)
            );
            if (CollectionUtils.isEmpty(list)) {
                return;
            }
            for (UserResignExamine examine : list) {
                examine.setStatus(ResignExamineStatusEnum.COMPLETE);
                // todo 对接人事员工离职接口
            }
            userResignExamineService.updateBatchById(list);
        } finally {
            lock.unlock();
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public KpiPool modifyPoolData(KpiPool pool, KpiGroupUser user) {
        pool.setKpiGroupId(user.getKpiGroupId());
        pool.setShopId(user.getShopId());
        pool.setShopName(user.getShopName());
        pool.setKgc(user.getKgc());
        kpiPoolService.updateById(pool);
        return pool;
    }

    @Transactional(rollbackFor = Exception.class)
    public KpiPool createPoolData(KpiGroupUser groupUser) {
        KpiPool pool = new KpiPool();
        pool.setKpiGroupId(groupUser.getKpiGroupId());
        pool.setKgc(groupUser.getKgc());
        pool.setUserId(groupUser.getUserId());
        pool.setUserName(groupUser.getUserName());
        pool.setPostId(groupUser.getPostId());
        pool.setPostName(groupUser.getPostName());
        pool.setShopId(groupUser.getShopId());
        pool.setShopName(groupUser.getShopName());
        pool.setStarLevel(StarLevelEnum.C);
        pool.setActualStar(StarLevelEnum.C);
        pool.setRevoked(Boolean.FALSE);
        pool.setInclusion(!Boolean.TRUE.equals(groupUser.getIgnored()));
        pool.setRegular(Boolean.FALSE);
        pool.setMonthly(YearMonth.from(groupUser.getDataDate()));
        pool.setGroupId(groupUser.getGroupId());
        pool.setYn(Boolean.TRUE);
        pool.setKpiScore(BigDecimal.ZERO);
        pool.setKpiScoreRatio(BigDecimal.ZERO);
        pool.setAverageKpiScoreRatio(BigDecimal.ZERO);
        kpiPoolService.save(pool);
        return pool;
    }

    /**
     * 固定星级
     *
     * @param groupId
     * @param yearMonth
     */
    @Transactional(rollbackFor = Exception.class)
    public void regularStarAndExamineUser(Long groupId, YearMonth yearMonth) {
        List<KpiPool> list = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getGroupId, groupId)
                .eq(KpiPool::getMonthly, yearMonth)
                .eq(KpiPool::getYn, Boolean.TRUE)
                .ne(KpiPool::getRegular, Boolean.TRUE)
                .last(" limit 2000 ")
        );
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        final KpiStarRule starRule = kpiStarRuleService.getOne(Wrappers.<KpiStarRule>lambdaQuery()
                        .eq(KpiStarRule::getGroupId, groupId)
                        .eq(KpiStarRule::getYn, Boolean.TRUE)
                , Boolean.FALSE);
        BV.notNull(starRule, () -> MessageFormatUtil.MessageFormatTransfer("集团[{0}]为配置星级规则", groupId));
        String cacheName = KPI_GROUP_AVERAGE_RATIO_CACHE_NAME.apply(yearMonth, groupId);
        for (KpiPool kpiPool : list) {
            kpiPool.setRegular(Boolean.TRUE);
            examineUser(kpiPool, starRule);
            cacheExtender.evictCache(cacheName, kpiPool.getKpiGroupId());
        }
        kpiPoolService.updateBatchById(list);
    }

    /**
     * 校验用户是否触发离职
     *
     * @param kpiPool
     * @param starRule
     */
    private void examineUser(KpiPool kpiPool, KpiStarRule starRule) {
        if (!Boolean.TRUE.equals(kpiPool.getInclusion())) {
            return;
        }
        int maxUnqualifiedTimes = Optional.ofNullable(starRule.getMaxUnqualifiedTimes()).orElse(12);
        int forcedTurnoverCycle = Optional.ofNullable(starRule.getForcedTurnoverCycle()).orElse(3);
        Long userId = kpiPool.getUserId();
        List<KpiPool> list = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getGroupId, kpiPool.getGroupId())
                .eq(KpiPool::getUserId, userId)
                .eq(KpiPool::getInclusion, Boolean.TRUE)
                .eq(KpiPool::getYn, Boolean.TRUE)
                .eq(KpiPool::getRegular, Boolean.TRUE)
                .lt(KpiPool::getMonthly, kpiPool.getMonthly())
                .orderByDesc(KpiPool::getMonthly)
                .last(" limit " + (maxUnqualifiedTimes - 1))
        );
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        list.add(kpiPool);
        revokedKpiTimes(list, starRule);
        forcedTurnover(list, forcedTurnoverCycle);
    }


    /**
     * 减少D级判断
     *
     * @param list
     * @param starRule
     */
    private void revokedKpiTimes(List<KpiPool> list, KpiStarRule starRule) {
        int continuousMonthly = Optional.ofNullable(starRule.getContinuousMonthly()).orElse(2);
        BigDecimal minScoreRatio = Optional.ofNullable(starRule.getMinScoreRatio()).orElse(BigDecimal.valueOf(0.5));
        if (list.size() == 0 || list.size() < continuousMonthly) {
            return;
        }
        KpiPool current = list.get(list.size() - 1);
        if (Objects.isNull(current)) {
            return;
        }
        BigDecimal averageRatio = kpiGroupAverageRatio(current.getKpiGroupId(), current.getMonthly(), current.getGroupId());
        if (BigDecimal.ZERO.compareTo(averageRatio) >= 0) {
            return;
        }
        BigDecimal kpiScoreRatio = current.getKpiScoreRatio();
        if (averageRatio.compareTo(kpiScoreRatio) >= 0) {
            return;
        }
        boolean revokeAble = Boolean.TRUE;
        for (int i = 1; i <= continuousMonthly; i++) {
            KpiPool pool = list.get(list.size() - i);
            BigDecimal scoreRatio = pool.getKpiScoreRatio();
            revokeAble = revokeAble && minScoreRatio.compareTo(scoreRatio) < 0;
        }
        if (!revokeAble) {
            return;
        }
        for (KpiPool pool : list) {
            if (StarLevelEnum.D.equals(pool.getActualStar()) && !Boolean.TRUE.equals(pool.getRevoked())) {
                pool.setRevoked(Boolean.TRUE);
                kpiPoolService.updateById(pool);
                break;
            }
        }
    }

    /**
     * 强制离职判断
     *
     * @param list
     * @param forcedTurnoverCycle
     */
    private void forcedTurnover(List<KpiPool> list, int forcedTurnoverCycle) {
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        int count = (int) list.stream()
                .filter(r -> StarLevelEnum.D.equals(r.getActualStar()))
                .filter(p -> !Boolean.TRUE.equals(p.getRevoked()))
                .count();
        if (forcedTurnoverCycle > count) {
            return;
        }
        KpiPool pool = list.get(list.size() - 1);
        UserResignExamine examine = new UserResignExamine();
        examine.setUserId(pool.getUserId());
        examine.setUserName(pool.getUserName());
        examine.setShopId(pool.getShopId());
        examine.setMonthly(pool.getMonthly());
//      examine.setStatus(ResignExamineStatusEnum.IGNORE); fixme 等稳定了使用这行代码
        examine.setStatus(ResignExamineStatusEnum.IGNORE);
        userResignExamineService.save(examine);
    }

    /**
     * calculate kpi group's specified month average score ratio
     *
     * @param kpiGroupId
     * @param yearMonth
     * @param groupId
     * @return average score ratio
     */
    private BigDecimal kpiGroupAverageRatio(Long kpiGroupId, YearMonth yearMonth, Long groupId) {
        String cacheName = KPI_GROUP_AVERAGE_RATIO_CACHE_NAME.apply(yearMonth, groupId);
        BigDecimal averageRatio = cacheExtender.getCache(cacheName, kpiGroupId, BigDecimal.class);
        if (Objects.nonNull(averageRatio)) {
            return averageRatio;
        }
        List<KpiPool> list = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getGroupId, groupId)
                .eq(KpiPool::getKpiGroupId, kpiGroupId)
                .eq(KpiPool::getInclusion, Boolean.TRUE)
                .eq(KpiPool::getYn, Boolean.TRUE)
                .eq(KpiPool::getMonthly, yearMonth)
        );
        if (CollectionUtils.isEmpty(list)) {
            return BigDecimal.ZERO;
        }
        Double averaging = list.stream().map(KpiPool::getKpiScoreRatio).filter(Objects::nonNull).collect(Collectors.averagingDouble(BigDecimal::doubleValue));
        averageRatio = BigDecimal.valueOf(averaging);
        cacheExtender.putCache(cacheName, kpiGroupId, averageRatio);
        return averageRatio;
    }

    @FunctionalInterface
    interface CacheKeyFunction<T, U, R> {

        /**
         * Applies this function to the given arguments.
         *
         * @param t the function argument1
         * @param u the function argument2
         * @return the function result
         */
        R apply(T t, U u);
    }
}