package cn.iocoder.yudao.module.iot.service.rule.scene.matcher;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
import cn.iocoder.yudao.module.iot.dal.dataobject.rule.IotSceneRuleDO;
import cn.iocoder.yudao.module.iot.enums.rule.IotSceneRuleConditionTypeEnum;
import cn.iocoder.yudao.module.iot.enums.rule.IotSceneRuleTriggerTypeEnum;
import cn.iocoder.yudao.module.iot.service.rule.scene.matcher.condition.IotSceneRuleConditionMatcher;
import cn.iocoder.yudao.module.iot.service.rule.scene.matcher.trigger.IotSceneRuleTriggerMatcher;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.function.Function;

import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap;

/**
 * IoT 场景规则匹配器统一管理器：负责管理所有匹配器（触发器匹配器和条件匹配器），并提供统一的匹配入口
 *
 * @author HUIHUI
 */
@Component
@Slf4j
public class IotSceneRuleMatcherManager {

    /**
     * 触发器匹配器映射表
     */
    private final Map<IotSceneRuleTriggerTypeEnum, IotSceneRuleTriggerMatcher> triggerMatchers;

    /**
     * 条件匹配器映射表
     */
    private final Map<IotSceneRuleConditionTypeEnum, IotSceneRuleConditionMatcher> conditionMatchers;

    public IotSceneRuleMatcherManager(List<IotSceneRuleMatcher> matchers) {
        if (CollUtil.isEmpty(matchers)) {
            log.warn("[IotSceneRuleMatcherManager][没有找到任何匹配器]");
            this.triggerMatchers = new HashMap<>();
            this.conditionMatchers = new HashMap<>();
            return;
        }

        // 1.1 按优先级排序并过滤启用的匹配器
        List<IotSceneRuleMatcher> allMatchers = matchers.stream()
                .filter(IotSceneRuleMatcher::isEnabled)
                .sorted(Comparator.comparing(IotSceneRuleMatcher::getPriority))
                .toList();
        // 1.2 分离触发器匹配器和条件匹配器
        List<IotSceneRuleTriggerMatcher> triggerMatchers = allMatchers.stream()
                .filter(matcher -> matcher instanceof IotSceneRuleTriggerMatcher)
                .map(matcher -> (IotSceneRuleTriggerMatcher) matcher)
                .toList();
        List<IotSceneRuleConditionMatcher> conditionMatchers = allMatchers.stream()
                .filter(matcher -> matcher instanceof IotSceneRuleConditionMatcher)
                .map(matcher -> (IotSceneRuleConditionMatcher) matcher)
                .toList();

        // 2.1 构建触发器匹配器映射表
        this.triggerMatchers = convertMap(triggerMatchers, IotSceneRuleTriggerMatcher::getSupportedTriggerType,
                Function.identity(),
                (existing, replacement) -> {
                    log.warn("[IotSceneRuleMatcherManager][触发器类型({})存在多个匹配器，使用优先级更高的: {}]",
                            existing.getSupportedTriggerType(),
                            existing.getPriority() <= replacement.getPriority() ?
                                    existing.getSupportedTriggerType() : replacement.getSupportedTriggerType());
                    return existing.getPriority() <= replacement.getPriority() ? existing : replacement;
                }, LinkedHashMap::new);
        // 2.2 构建条件匹配器映射表
        this.conditionMatchers = convertMap(conditionMatchers, IotSceneRuleConditionMatcher::getSupportedConditionType,
                Function.identity(),
                (existing, replacement) -> {
                    log.warn("[IotSceneRuleMatcherManager][条件类型({})存在多个匹配器，使用优先级更高的: {}]",
                            existing.getSupportedConditionType(),
                            existing.getPriority() <= replacement.getPriority() ?
                                    existing.getSupportedConditionType() : replacement.getSupportedConditionType());
                    return existing.getPriority() <= replacement.getPriority() ? existing : replacement;
                },
                LinkedHashMap::new);

        // 3. 日志输出初始化信息
        log.info("[IotSceneRuleMatcherManager][初始化完成，共加载({})个匹配器，其中触发器匹配器({})个，条件匹配器({})个]",
                allMatchers.size(), this.triggerMatchers.size(), this.conditionMatchers.size());
        this.triggerMatchers.forEach((type, matcher) ->
                log.info("[IotSceneRuleMatcherManager][触发器匹配器类型: ({}), 优先级: ({})] ", type, matcher.getPriority()));
        this.conditionMatchers.forEach((type, matcher) ->
                log.info("[IotSceneRuleMatcherManager][条件匹配器类型: ({}), 优先级: ({})]", type, matcher.getPriority()));
    }

    /**
     * 检查触发器是否匹配消息（主条件匹配）
     *
     * @param message 设备消息
     * @param trigger 触发器配置
     * @return 是否匹配
     */
    public boolean isMatched(IotDeviceMessage message, IotSceneRuleDO.Trigger trigger) {
        if (message == null || trigger == null || trigger.getType() == null) {
            log.debug("[isMatched][message({}) trigger({}) 参数无效]", message, trigger);
            return false;
        }
        IotSceneRuleTriggerTypeEnum triggerType = IotSceneRuleTriggerTypeEnum.typeOf(trigger.getType());
        if (triggerType == null) {
            log.warn("[isMatched][triggerType({}) 未知的触发器类型]", trigger.getType());
            return false;
        }
        IotSceneRuleTriggerMatcher matcher = triggerMatchers.get(triggerType);
        if (matcher == null) {
            log.warn("[isMatched][triggerType({}) 没有对应的匹配器]", triggerType);
            return false;
        }

        try {
            return matcher.matches(message, trigger);
        } catch (Exception e) {
            log.error("[isMatched][触发器匹配异常] message: {}, trigger: {}", message, trigger, e);
            return false;
        }
    }

    /**
     * 检查子条件是否匹配消息
     *
     * @param message   设备消息
     * @param condition 触发条件
     * @return 是否匹配
     */
    public boolean isConditionMatched(IotDeviceMessage message, IotSceneRuleDO.TriggerCondition condition) {
        if (message == null || condition == null || condition.getType() == null) {
            log.debug("[isConditionMatched][message({}) condition({}) 参数无效]", message, condition);
            return false;
        }

        // 1. 根据条件类型查找对应的匹配器
        IotSceneRuleConditionTypeEnum conditionType = IotSceneRuleConditionTypeEnum.typeOf(condition.getType());
        if (conditionType == null) {
            log.warn("[isConditionMatched][conditionType({}) 未知的条件类型]", condition.getType());
            return false;
        }
        IotSceneRuleConditionMatcher matcher = conditionMatchers.get(conditionType);
        if (matcher == null) {
            log.warn("[isConditionMatched][conditionType({}) 没有对应的匹配器]", conditionType);
            return false;
        }

        // 2. 执行匹配逻辑
        try {
            return matcher.matches(message, condition);
        } catch (Exception e) {
            log.error("[isConditionMatched][message({}) condition({}) 条件匹配异常]", message, condition, e);
            return false;
        }
    }

}