package cn.iocoder.yudao.module.mes.service.pro.wage;

import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pro.wage.vo.MesProProcessWageRulePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.wage.vo.MesProProcessWageRuleResolveRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.wage.vo.MesProProcessWageRuleSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.process.MesProProcessDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.wage.MesProProcessWageRuleDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.wage.MesProProcessWageRuleMapper;
import cn.iocoder.yudao.module.mes.service.dv.machinery.MesDvMachineryService;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES 工序工资单价规则 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class MesProProcessWageRuleServiceImpl implements MesProProcessWageRuleService {

    @Resource
    private MesProProcessWageRuleMapper ruleMapper;
    @Resource
    private MesProProcessService processService;
    @Resource
    private MesProRouteService routeService;
    @Resource
    private MesDvMachineryService machineryService;

    @Override
    public PageResult<MesProProcessWageRuleDO> getRulePage(MesProProcessWageRulePageReqVO pageReqVO) {
        return ruleMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesProProcessWageRuleDO> getRuleListByProcessId(Long processId) {
        return ruleMapper.selectListByProcessId(processId);
    }

    @Override
    public Long createRule(MesProProcessWageRuleSaveReqVO createReqVO) {
        validateRule(createReqVO);
        MesProProcessWageRuleDO rule = BeanUtils.toBean(createReqVO, MesProProcessWageRuleDO.class)
                .setId(null)
                .setStatus(ObjUtil.defaultIfNull(createReqVO.getStatus(), CommonStatusEnum.ENABLE.getStatus()))
                .setPriority(ObjUtil.defaultIfNull(createReqVO.getPriority(), 0));
        ruleMapper.insert(rule);
        return rule.getId();
    }

    @Override
    public void updateRule(MesProProcessWageRuleSaveReqVO updateReqVO) {
        validateRuleExists(updateReqVO.getId());
        validateRule(updateReqVO);
        ruleMapper.updateById(BeanUtils.toBean(updateReqVO, MesProProcessWageRuleDO.class));
    }

    @Override
    public void deleteRule(Long id) {
        validateRuleExists(id);
        ruleMapper.deleteById(id);
    }

    @Override
    public MesProProcessWageRuleResolveRespVO resolve(Long processId, Long routeId, Long machineryId,
                                                       Integer billingType, LocalDate date) {
        MesProProcessDO process = processService.getProcess(processId);
        if (process == null) {
            throw exception(PRO_FEEDBACK_PROCESS_NOT_EXISTS, processId);
        }
        LocalDate matchDate = date != null ? date : LocalDate.now();
        List<MesProProcessWageRuleDO> candidates = ruleMapper.selectListByProcessId(processId).stream()
                .filter(rule -> Objects.equals(rule.getStatus(), CommonStatusEnum.ENABLE.getStatus()))
                .filter(rule -> billingType == null || Objects.equals(rule.getBillingType(), billingType))
                .filter(rule -> matchEffective(rule, matchDate))
                .filter(rule -> rule.getRouteId() == null || Objects.equals(rule.getRouteId(), routeId))
                .filter(rule -> rule.getMachineryId() == null || Objects.equals(rule.getMachineryId(), machineryId))
                .sorted(Comparator
                        .comparingInt((MesProProcessWageRuleDO rule) -> matchScore(rule, routeId, machineryId)).reversed()
                        .thenComparing(Comparator.comparingInt(
                                (MesProProcessWageRuleDO rule) -> ObjUtil.defaultIfNull(rule.getPriority(), 0)).reversed())
                        .thenComparing(Comparator.comparing(
                                MesProProcessWageRuleDO::getEffectiveFrom,
                                Comparator.nullsLast(Comparator.reverseOrder())))
                        .thenComparing(Comparator.comparing(MesProProcessWageRuleDO::getId).reversed()))
                .toList();

        MesProProcessWageRuleResolveRespVO resp = new MesProProcessWageRuleResolveRespVO()
                .setProcessId(processId).setRouteId(routeId).setMachineryId(machineryId)
                .setBillingType(billingType != null ? billingType : process.getBillingType());
        if (candidates.isEmpty()) {
            resp.setWageRate(process.getWageRate() != null ? process.getWageRate() : BigDecimal.ZERO)
                    .setMatchLevel("DEFAULT");
            return resp;
        }
        MesProProcessWageRuleDO rule = candidates.get(0);
        resp.setWageRate(rule.getWageRate()).setRuleId(rule.getId())
                .setMatchLevel(matchLevel(rule, routeId, machineryId));
        return resp;
    }

    private static boolean matchEffective(MesProProcessWageRuleDO rule, LocalDate date) {
        if (rule.getEffectiveFrom() != null && date.isBefore(rule.getEffectiveFrom())) {
            return false;
        }
        return rule.getEffectiveTo() == null || !date.isAfter(rule.getEffectiveTo());
    }

    private static int matchScore(MesProProcessWageRuleDO rule, Long routeId, Long machineryId) {
        int score = 0;
        if (rule.getRouteId() != null && Objects.equals(rule.getRouteId(), routeId)) {
            score += 2;
        }
        if (rule.getMachineryId() != null && Objects.equals(rule.getMachineryId(), machineryId)) {
            score += 1;
        }
        return score;
    }

    private static String matchLevel(MesProProcessWageRuleDO rule, Long routeId, Long machineryId) {
        boolean routeMatched = rule.getRouteId() != null && Objects.equals(rule.getRouteId(), routeId);
        boolean machineryMatched = rule.getMachineryId() != null && Objects.equals(rule.getMachineryId(), machineryId);
        if (routeMatched && machineryMatched) {
            return "EXACT";
        }
        if (routeMatched) {
            return "ROUTE";
        }
        if (machineryMatched) {
            return "MACHINERY";
        }
        return "DEFAULT";
    }

    private MesProProcessWageRuleDO validateRuleExists(Long id) {
        MesProProcessWageRuleDO rule = ruleMapper.selectById(id);
        if (rule == null) {
            throw exception(PRO_PROCESS_WAGE_RULE_NOT_EXISTS);
        }
        return rule;
    }

    private void validateRule(MesProProcessWageRuleSaveReqVO reqVO) {
        MesProProcessDO process = processService.getProcess(reqVO.getProcessId());
        if (process == null) {
            throw exception(PRO_FEEDBACK_PROCESS_NOT_EXISTS, reqVO.getProcessId());
        }
        if (reqVO.getRouteId() != null) {
            MesProRouteDO route = routeService.getRoute(reqVO.getRouteId());
            if (route == null) {
                throw new ServiceException(PRO_ROUTE_NOT_EXISTS.getCode(),
                        StrUtil.format("工序[{}]的工资规则引用的工艺路线 ID={} 不存在；请重新选择工艺路线",
                                process.getName(), reqVO.getRouteId()));
            }
        }
        if (reqVO.getMachineryId() != null) {
            MesDvMachineryDO machinery = machineryService.getMachinery(reqVO.getMachineryId());
            if (machinery == null) {
                throw new ServiceException(DV_MACHINERY_NOT_EXISTS.getCode(),
                        StrUtil.format("工序[{}]的工资规则引用的设备 ID={} 不存在；请重新选择设备",
                                process.getName(), reqVO.getMachineryId()));
            }
        }
        if (reqVO.getEffectiveFrom() != null && reqVO.getEffectiveTo() != null
                && reqVO.getEffectiveFrom().isAfter(reqVO.getEffectiveTo())) {
            throw new ServiceException(PRO_PROCESS_WAGE_RULE_DUPLICATE.getCode(),
                    StrUtil.format("工序[{}]的工资规则生效开始日期[{}]晚于结束日期[{}]；请调整生效区间后重试",
                            process.getName(), reqVO.getEffectiveFrom(), reqVO.getEffectiveTo()));
        }
    }

}