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

import cn.fw.common.exception.BusinessException;
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.pojo.event.ApprovalResultEvent;
import cn.fw.morax.common.pojo.event.KpiStarAdjustmentEvent;
import cn.fw.morax.common.utils.EventBusUtil;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.ApprovalRecord;
import cn.fw.morax.domain.db.kpi.KpiPool;
import cn.fw.morax.domain.db.kpi.KpiStarSpecialRule;
import cn.fw.morax.domain.db.salary.SalaryClosure;
import cn.fw.morax.domain.dto.kpi.KpiStarSpecialRuleDTO;
import cn.fw.morax.domain.dto.query.SalaryGroupStaffQueryDTO;
import cn.fw.morax.domain.enums.SettingStatusEnum;
import cn.fw.morax.domain.enums.StarLevelEnum;
import cn.fw.morax.domain.vo.kpi.KpiStarSpecialRuleVO;
import cn.fw.morax.domain.vo.salary.StaffSelectVO;
import cn.fw.morax.rpc.ehr.EhrRpcService;
import cn.fw.morax.rpc.ehr.dto.PerformanceStaffDTO;
import cn.fw.morax.rpc.ehr.dto.StaffBaseInfoDTO;
import cn.fw.morax.service.biz.ApprovalBizService;
import cn.fw.morax.service.biz.salary.SalaryGeneralSettinBizService;
import cn.fw.morax.service.biz.salary.SalarySettingCommonService;
import cn.fw.morax.service.data.ApprovalRecordService;
import cn.fw.morax.service.data.kpi.KpiPoolService;
import cn.fw.morax.service.data.kpi.KpiStarSpecialRuleService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
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.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

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

@RequiredArgsConstructor
@Service
@Slf4j
public class KpiStarSpecialRuleBizService {

    private final SalarySettingCommonService salarySettingCommonService;
    private final SalaryGeneralSettinBizService salaryGeneralSettinBizService;
    private final KpiStarSpecialRuleService kpiStarSpecialRuleService;
    private final ApprovalRecordService approvalRecordService;
    private final ApprovalBizService approvalBizService;
    private final KpiPoolService kpiPoolService;
    private final KpiPoolBizService kpiPoolBizService;
    private final EhrRpcService ehrRpcService;

    @Value("${spring.cache.custom.global-prefix}:kpi:star:adjustment:")
    @Getter
    private String savePrefix;

    /**
     * 申请绩效星级特殊调整
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    @DisLock(prefix = "#this.getSavePrefix()", key = "#dto.getUserId()", message = "保存中，请勿重复操作")
    public void applyKpiStarAdjustment(KpiStarSpecialRuleDTO dto, LoginAuthBean user) {
        Date expTime = this.checkAppealDate(dto.getUserId());
        this.checkAdjustment(dto.getUserId());
        KpiStarSpecialRule specialRule = this.convertToPo(dto);
        Boolean result = kpiStarSpecialRuleService.save(specialRule);
        BV.isTrue(result, Constant.SAVE_FAIL_RETRY_PROMPT);
        approvalBizService.applyKpiStarAdjustment(specialRule, user, expTime);
    }

    /**
     * 查询薪酬系统配置
     *
     * @param
     * @return
     */
    public Date checkAppealDate(Long userId) {
        StaffBaseInfoDTO staffBaseInfo = ehrRpcService.queryStaffBaseInfo(userId);
        BV.notNull(staffBaseInfo, "员工信息为空");
        SalaryClosure salaryClosure = salarySettingCommonService.queryShopClosure(staffBaseInfo.getShopId(), YearMonth.now().minusMonths(1));
        if (PublicUtil.isEmpty(salaryClosure)) {
            throw new BusinessException("上月还未关单，不能申请");
        }

        LocalDateTime expTime = salaryClosure.getApproveEndTime().atTime(23,59,59);
        return Date.from(expTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 检查是否有审批中的星级特殊调整
     *
     * @param userId
     */
    public void checkAdjustment(Long userId) {
        Integer approvingRecords = kpiStarSpecialRuleService.count(Wrappers.<KpiStarSpecialRule>lambdaQuery()
                .eq(KpiStarSpecialRule::getStatus, SettingStatusEnum.APPROVING)
                .eq(KpiStarSpecialRule::getUserId, userId)
                .eq(KpiStarSpecialRule::getYn, Boolean.TRUE)
        );
        BV.isFalse(approvingRecords > 0, "已有申请中的星级考核调整");
    }

    /**
     * 检查并转换dto
     *
     * @param dto
     * @return
     */
    private KpiStarSpecialRule convertToPo(KpiStarSpecialRuleDTO dto) {
        Long groupId = dto.getGroupId();

        KpiStarSpecialRule kpiStarSpecialRule = new KpiStarSpecialRule();
        kpiStarSpecialRule.setUserId(dto.getUserId());
        kpiStarSpecialRule.setUserName(dto.getUserName());
        //几月开始绩效考核
        if (PublicUtil.isNotEmpty(dto.getStartingKpiEnum())) {
            switch (dto.getStartingKpiEnum()) {
                case CURRENT_MONTH: {
                    kpiStarSpecialRule.setEarliestStartingMonthly(PublicUtil.getCurMonthFirstDay());
                    break;
                }
                case NEXT_MONTH: {
                    kpiStarSpecialRule.setEarliestStartingMonthly(PublicUtil.getNextMonthFirstDay());
                    break;
                }
            }
        }

        //未核发工资月度星级调整
        if (PublicUtil.isNotEmpty(dto.getRevisedMonthly())) {
            kpiStarSpecialRule.setRevisedMonthly(dto.getRevisedMonthly().atDay(1));
            kpiStarSpecialRule.setRevisedLevel(dto.getRevisedLevel());
        }

        //上个月绩效考核不算，按C级计算工资
        if (PublicUtil.isNotEmpty(dto.getExclusionLastMonth()) && dto.getExclusionLastMonth()) {
            kpiStarSpecialRule.setExclusionMonthly(PublicUtil.getCurMonthEndDay().plusMonths(-1));
        }

        //免除D级次数
        if (PublicUtil.isNotEmpty(dto.getRevokedTimes())) {
            Boolean revokedCorrect = dto.getRevokedTimes() >= 1 && dto.getRevokedTimes() <= 3;
            BV.isTrue(revokedCorrect, "免除D级次数只能在1-3次之间");
            kpiStarSpecialRule.setRevokedTimes(dto.getRevokedTimes());
        }
        kpiStarSpecialRule.setReason(dto.getReason());
        kpiStarSpecialRule.setAttachment(dto.getAttachment());
        kpiStarSpecialRule.setGroupId(groupId);
        kpiStarSpecialRule.setStatus(SettingStatusEnum.APPROVING);
        return kpiStarSpecialRule;
    }

    /**
     * 绩效星级考核调整审批
     *
     * @param approvalRecord
     * @param resultEvent
     */
    @Transactional(rollbackFor = Exception.class)
    public void approvalKpiStarAdjustment(ApprovalRecord approvalRecord, ApprovalResultEvent resultEvent) {
        log.info("收到绩效星级考核调整审批信息：{}", JSON.toJSONString(resultEvent));
        boolean agree = Boolean.TRUE.equals(resultEvent.getAgree());
        KpiStarSpecialRule specialRule = kpiStarSpecialRuleService.getById(approvalRecord.getDataId());
        if (Objects.isNull(specialRule)) {
            return;
        }
        if (!agree) {
            specialRule.setStatus(SettingStatusEnum.INEFFECTIVE);
        } else {
            specialRule.setStatus(SettingStatusEnum.EFFECTIVE);
        }
        kpiStarSpecialRuleService.updateById(specialRule);
        this.adjustmentKpiData(specialRule);
    }

    /**
     * 调整绩效星级
     * 1. 开始绩效考核月度
     * 2. 未核发工资月度星级调整
     * 3. 上个月绩效考核不算，按C级计算工资
     * 4. 免除D级次数
     *
     * @param specialRule
     */
    @Transactional(rollbackFor = Exception.class)
    public void adjustmentKpiData(KpiStarSpecialRule specialRule) {
        if (!SettingStatusEnum.EFFECTIVE.equals(specialRule.getStatus())) {
            return;
        }
        Long userId = specialRule.getUserId();
        //未设置开始绩效考核月度
        Boolean noSetKpiStartMonthRule = true;
        //开始考核日期
        if (PublicUtil.isNotEmpty(specialRule.getEarliestStartingMonthly())) {
            noSetKpiStartMonthRule = false;
            this.resetKpiDate(userId, YearMonth.from(specialRule.getEarliestStartingMonthly()));
        }
        //修正未核发工资月度星级
        if (PublicUtil.isNotEmpty(specialRule.getRevisedMonthly())) {
            this.starAdjustmentEvent(specialRule.getRevisedLevel(), userId, YearMonth.from(specialRule.getRevisedMonthly()));
        }
        //哪个月绩效考核不算，按C级计算工资（只能算上月）
        if (PublicUtil.isNotEmpty(specialRule.getExclusionMonthly())) {
            this.starAdjustmentEvent(StarLevelEnum.C, userId, YearMonth.from(specialRule.getExclusionMonthly()));
        }
        //免除D级次数
        if (PublicUtil.isNotEmpty(specialRule.getRevokedTimes())) {
            this.revokedKpiTimes(specialRule);
        }

        //没有开始绩效考核月度设置，就将绩效星级规则状态设置为失效
        if (noSetKpiStartMonthRule) {
            kpiStarSpecialRuleService.update(Wrappers.<KpiStarSpecialRule>lambdaUpdate()
                    .set(KpiStarSpecialRule::getStatus, SettingStatusEnum.INEFFECTIVE)
                    .eq(KpiStarSpecialRule::getId, specialRule.getId())
            );
        }
    }

    /**
     * 失效旧绩效星级特殊规则（开始绩效考核月度设置 使用）
     *
     * @param userId
     */
    @Transactional(rollbackFor = Exception.class)
    public void inEffectiveOldSpecialRule(Long userId, Long specialRuleId) {
        List<KpiStarSpecialRule> specialRules = kpiStarSpecialRuleService.list(Wrappers.<KpiStarSpecialRule>lambdaQuery()
                .eq(KpiStarSpecialRule::getStatus, SettingStatusEnum.EFFECTIVE)
                .eq(KpiStarSpecialRule::getUserId, userId)
                .eq(KpiStarSpecialRule::getYn, Boolean.TRUE)
                .ne(KpiStarSpecialRule::getId, specialRuleId)
        );
        if (PublicUtil.isEmpty(specialRules)) {
            return;
        }
        List<Long> inEffectiveRulesIds = Lists.newArrayList();
        for (KpiStarSpecialRule rule : specialRules) {
            if (PublicUtil.isNotEmpty(rule.getEarliestStartingMonthly())) {
                inEffectiveRulesIds.add(rule.getId());
            }
        }
        if (PublicUtil.isNotEmpty(inEffectiveRulesIds)) {
            kpiStarSpecialRuleService.update(Wrappers.<KpiStarSpecialRule>lambdaUpdate()
                    .set(KpiStarSpecialRule::getStatus, SettingStatusEnum.INEFFECTIVE)
                    .in(KpiStarSpecialRule::getId, inEffectiveRulesIds)
            );
        }
    }


    /**
     * 免除D级次数（最近一年之内）
     *
     * @param specialRule
     */
    @Transactional(rollbackFor = Exception.class)
    public void revokedKpiTimes(KpiStarSpecialRule specialRule) {
        Long userId = specialRule.getUserId();
        int revokedTimes = specialRule.getRevokedTimes();

        YearMonth yearMonth = YearMonth.now().minusMonths(1L);
        List<KpiPool> list = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getGroupId, specialRule.getGroupId())
                .eq(KpiPool::getUserId, userId)
                .eq(KpiPool::getInclusion, Boolean.TRUE)
                .eq(KpiPool::getYn, Boolean.TRUE)
                .le(KpiPool::getMonthly, yearMonth)
                .orderByDesc(KpiPool::getMonthly)
                .last(" limit 12 ")
        );

        for (KpiPool kpiPool : list) {
            if (StarLevelEnum.D.equals(kpiPool.getStarLevel()) && revokedTimes > 0) {
                kpiPool.setRevoked(Boolean.TRUE);
                revokedTimes--;
            }
        }
        kpiPoolService.updateBatchById(list);
    }

    /**
     * 绩效星级特殊规则详情
     *
     * @param kpiStarSpecialRuleId
     * @return
     */
    public KpiStarSpecialRuleVO getKpiStarSpecialRuleDetail(Long kpiStarSpecialRuleId) {
        KpiStarSpecialRule kpiStarSpecialRule = kpiStarSpecialRuleService.getById(kpiStarSpecialRuleId);
        BV.notNull(kpiStarSpecialRule, "绩效星级特殊规则不存在");
        KpiStarSpecialRuleVO kpiStarSpecialRuleVo = PublicUtil.copy(kpiStarSpecialRule, KpiStarSpecialRuleVO.class);
        KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaUpdate()
                        .eq(KpiPool::getUserId, kpiStarSpecialRule.getUserId())
                        .eq(KpiPool::getYn, Boolean.TRUE)
                        .orderByDesc(KpiPool::getId)
                        .last("limit 1")
//                .ge(KpiPool::getMonthly, kpiStarSpecialRule.getRevisedMonthly())
        );
        kpiStarSpecialRuleVo.setRevisedMonthLevel(kpiPool.getStarLevel());
        return kpiStarSpecialRuleVo;
    }

    /**
     * 绩效星级特殊调整人员
     *
     * @param dto
     * @return
     */
    public List<StaffSelectVO> queryStarAdjustmentStaffs(SalaryGroupStaffQueryDTO dto) {
        List<PerformanceStaffDTO> staffs = ehrRpcService.queryKpiStaffByName(dto.getPostId(), dto.getShopIds(), dto.getStaffName());
        LocalDate lastMonth = LocalDate.now().plusMonths(-1);
        List<KpiPool> poolList = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getPostId, dto.getPostId())
                .in(KpiPool::getShopId, dto.getShopIds())
                .eq(KpiPool::getMonthly, lastMonth)
                .like(PublicUtil.isNotEmpty(dto.getStaffName()), KpiPool::getUserName, dto.getStaffName())
                .eq(KpiPool::getYn, Boolean.TRUE)
        );
        Set<Long> staffIds = Sets.newHashSetWithExpectedSize(staffs.size() + poolList.size());
        List<StaffSelectVO> selectVOS = staffs.stream().map(staffDTO -> {
            StaffSelectVO staffSelectVO = new StaffSelectVO();
            staffIds.add(staffDTO.getId());
            staffSelectVO.setId(staffDTO.getId());
            staffSelectVO.setName(staffDTO.getName());
            return staffSelectVO;
        }).collect(Collectors.toList());

        poolList.forEach(pool -> {
            if (staffIds.contains(pool.getUserId())) {
                return;
            }
            StaffSelectVO staffSelectVO = new StaffSelectVO();
            staffIds.add(pool.getUserId());
            staffSelectVO.setId(pool.getUserId());
            staffSelectVO.setName(pool.getUserName());
            selectVOS.add(staffSelectVO);
        });
        return selectVOS;
    }

    /**
     * 绩效星级特殊调整人员
     *
     * @param user
     * @return
     */
    public List<StaffSelectVO> queryLastMonthManageStaffs(LoginAuthBean user) {
        Long userId = user.getUserId();
        this.checkAppealDate(userId);
        List<StaffBaseInfoDTO> managerStaffs = ehrRpcService.queryManageStaffs(userId);
        if (PublicUtil.isEmpty(managerStaffs)) {
            managerStaffs = new ArrayList<>();
        }
        LocalDateTime lastMonth = LocalDateTime.now().minusMonths(1);
        Date firstDayOfLastMonth = Date.from(lastMonth.with(TemporalAdjusters.firstDayOfMonth()).atZone(ZoneId.systemDefault()).toInstant());
        Date endDayOfLastMonth = Date.from(lastMonth.with(TemporalAdjusters.lastDayOfMonth()).atZone(ZoneId.systemDefault()).toInstant());
        List<StaffBaseInfoDTO> leaveManagerStaffs = ehrRpcService.queryLeaveManageStaffs(userId, firstDayOfLastMonth, endDayOfLastMonth);
        if (PublicUtil.isNotEmpty(leaveManagerStaffs)) {
            managerStaffs.addAll(leaveManagerStaffs);
        }
        List<StaffSelectVO> selectVOS = managerStaffs.stream()
                .filter(staff -> (!staff.getId().equals(userId)))
                .map(staff -> new StaffSelectVO(staff.getId(), staff.getName())).collect(Collectors.toList());
        return selectVOS;
    }

    /**
     * 查询员工绩效星级
     *
     * @param userId
     * @return
     */
    public String getStaffKpiStar(Long userId, YearMonth yearMonth) {
        KpiPool pool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                .eq(KpiPool::getMonthly, yearMonth)
                .eq(KpiPool::getUserId, userId)
                .eq(KpiPool::getInclusion, Boolean.TRUE)
                .eq(KpiPool::getYn, Boolean.TRUE)
                .orderByAsc(KpiPool::getId)
                .last("limit 1")
        );
        if (PublicUtil.isEmpty(pool)) {
            return null;
        }
        //当实际星级 和  绩效星级不一致，可能绩效星级已经被调整，返回实际星级
        if (PublicUtil.isNotEmpty(pool.getActualStar()) && (!pool.getStarLevel().equals(pool.getActualStar()))) {
            return pool.getActualStar().getName();
        }
        return pool.getStarLevel().getName();
    }

    /**
     * 绩效星级特殊调整详情
     *
     * @param approvalNo
     */
    public KpiStarSpecialRuleVO getKpiStarAdjustment(String approvalNo) {
        ApprovalRecord approvalRecord = approvalRecordService.getOne(Wrappers.<ApprovalRecord>lambdaQuery()
                .eq(ApprovalRecord::getApprovalNo, approvalNo));
        BV.notNull(approvalRecord, "绩效星级特殊调整审批不存在");
        KpiStarSpecialRule specialRule = kpiStarSpecialRuleService.getById(approvalRecord.getDataId());
        BV.notNull(specialRule, "绩效星级特殊调整审批不存在");
        KpiStarSpecialRuleVO kpiStarSpecialRuleVO = PublicUtil.copy(specialRule, KpiStarSpecialRuleVO.class);
        if (PublicUtil.isNotEmpty(specialRule.getRevisedMonthly())) {
            KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaUpdate()
                            .eq(KpiPool::getUserId, specialRule.getUserId())
                            .eq(KpiPool::getMonthly, YearMonth.from(specialRule.getRevisedMonthly()))
                            .eq(KpiPool::getYn, Boolean.TRUE)
                            .orderByDesc(KpiPool::getId)
                            .last("limit 1")
//                .ge(KpiPool::getMonthly, kpiStarSpecialRule.getRevisedMonthly())
            );
            if (PublicUtil.isNotEmpty(kpiPool)) {
                kpiStarSpecialRuleVO.setRevisedMonthLevel(kpiPool.getStarLevel());
            }
        }
        return kpiStarSpecialRuleVO;
    }

    /**
     * 修正未核发工资月度星级
     *
     * @param revisedLevel
     * @param userId
     * @param monthly
     */
    @Transactional(rollbackFor = Exception.class)
    public void starAdjustmentEvent(StarLevelEnum revisedLevel, Long userId, YearMonth monthly) {
        kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()
                .set(KpiPool::getActualStar, revisedLevel)
                .eq(KpiPool::getUserId, userId)
                .eq(KpiPool::getMonthly, monthly)
        );
        EventBusUtil.asyncPost(KpiStarAdjustmentEvent.builder()
                .userId(userId)
                .yearMonth(monthly)
                .build());
    }

    /**
     * 几月开始考核，将几月之前绩效设置为不参与计算
     *
     * @param userId
     * @param monthly
     */
    @Transactional(rollbackFor = Exception.class)
    public void resetKpiDate(Long userId, YearMonth monthly) {
        kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()
                .set(KpiPool::getInclusion, Boolean.FALSE)
                .eq(KpiPool::getUserId, userId)
                .lt(KpiPool::getMonthly, monthly)
                .eq(KpiPool::getYn, Boolean.TRUE)
        );
    }

}