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

import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.CharPool;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.module.iot.enums.rule.IotSceneRuleConditionOperatorEnum;
import cn.iocoder.yudao.module.iot.service.rule.scene.matcher.condition.IotCurrentTimeConditionMatcher;
import cn.iocoder.yudao.module.iot.service.rule.scene.timer.IotTimerConditionEvaluator;
import lombok.experimental.UtilityClass;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.List;

/**
 * IoT 场景规则时间匹配工具类
 * <p>
 * 提供时间条件匹配的通用方法，供 {@link IotCurrentTimeConditionMatcher} 和 {@link IotTimerConditionEvaluator} 共同使用。
 *
 * @author HUIHUI
 */
@Slf4j
@UtilityClass
public class IotSceneRuleTimeHelper {

    /**
     * 时间格式化器 - HH:mm:ss
     */
    private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");

    /**
     * 时间格式化器 - HH:mm
     */
    private static final DateTimeFormatter TIME_FORMATTER_SHORT = DateTimeFormatter.ofPattern("HH:mm");

    /**
     * 判断是否为日期时间操作符
     *
     * @param operatorEnum 操作符枚举
     * @return 是否为日期时间操作符
     */
    public static boolean isDateTimeOperator(IotSceneRuleConditionOperatorEnum operatorEnum) {
        return operatorEnum == IotSceneRuleConditionOperatorEnum.DATE_TIME_GREATER_THAN
                || operatorEnum == IotSceneRuleConditionOperatorEnum.DATE_TIME_LESS_THAN
                || operatorEnum == IotSceneRuleConditionOperatorEnum.DATE_TIME_BETWEEN;
    }

    /**
     * 判断是否为时间操作符（包括日期时间操作符和当日时间操作符）
     *
     * @param operatorEnum 操作符枚举
     * @return 是否为时间操作符
     */
    public static boolean isTimeOperator(IotSceneRuleConditionOperatorEnum operatorEnum) {
        return operatorEnum != IotSceneRuleConditionOperatorEnum.TIME_GREATER_THAN
                && operatorEnum != IotSceneRuleConditionOperatorEnum.TIME_LESS_THAN
                && operatorEnum != IotSceneRuleConditionOperatorEnum.TIME_BETWEEN
                && !isDateTimeOperator(operatorEnum);
    }

    /**
     * 执行时间匹配逻辑
     *
     * @param operatorEnum 操作符枚举
     * @param param        参数值
     * @return 是否匹配
     */
    public static boolean executeTimeMatching(IotSceneRuleConditionOperatorEnum operatorEnum, String param) {
        try {
            LocalDateTime now = LocalDateTime.now();
            if (isDateTimeOperator(operatorEnum)) {
                // 日期时间匹配（时间戳，秒级）
                long currentTimestamp = now.atZone(ZoneId.systemDefault()).toEpochSecond();
                return matchDateTime(currentTimestamp, operatorEnum, param);
            } else {
                // 当日时间匹配（HH:mm:ss）
                return matchTime(now.toLocalTime(), operatorEnum, param);
            }
        } catch (Exception e) {
            log.error("[executeTimeMatching][operatorEnum({}) param({}) 时间匹配异常]", operatorEnum, param, e);
            return false;
        }
    }

    /**
     * 匹配日期时间（时间戳，秒级）
     *
     * @param currentTimestamp 当前时间戳
     * @param operatorEnum     操作符枚举
     * @param param            参数值
     * @return 是否匹配
     */
    @SuppressWarnings("EnhancedSwitchMigration")
    public static boolean matchDateTime(long currentTimestamp, IotSceneRuleConditionOperatorEnum operatorEnum,
                                        String param) {
        try {
            // DATE_TIME_BETWEEN 需要解析两个时间戳，单独处理
            if (operatorEnum == IotSceneRuleConditionOperatorEnum.DATE_TIME_BETWEEN) {
                return matchDateTimeBetween(currentTimestamp, param);
            }
            // 其他操作符只需要解析一个时间戳
            long targetTimestamp = Long.parseLong(param);
            switch (operatorEnum) {
                case DATE_TIME_GREATER_THAN:
                    return currentTimestamp > targetTimestamp;
                case DATE_TIME_LESS_THAN:
                    return currentTimestamp < targetTimestamp;
                default:
                    log.warn("[matchDateTime][operatorEnum({}) 不支持的日期时间操作符]", operatorEnum);
                    return false;
            }
        } catch (Exception e) {
            log.error("[matchDateTime][operatorEnum({}) param({}) 日期时间匹配异常]", operatorEnum, param, e);
            return false;
        }
    }

    /**
     * 匹配日期时间区间
     *
     * @param currentTimestamp 当前时间戳
     * @param param            参数值（格式：startTimestamp,endTimestamp）
     * @return 是否匹配
     */
    public static boolean matchDateTimeBetween(long currentTimestamp, String param) {
        List<String> timestampRange = StrUtil.splitTrim(param, CharPool.COMMA);
        if (timestampRange.size() != 2) {
            log.warn("[matchDateTimeBetween][param({}) 时间戳区间参数格式错误]", param);
            return false;
        }
        long startTimestamp = Long.parseLong(timestampRange.get(0).trim());
        long endTimestamp = Long.parseLong(timestampRange.get(1).trim());
        return currentTimestamp >= startTimestamp && currentTimestamp <= endTimestamp;
    }

    /**
     * 匹配当日时间（HH:mm:ss 或 HH:mm）
     *
     * @param currentTime  当前时间
     * @param operatorEnum 操作符枚举
     * @param param        参数值
     * @return 是否匹配
     */
    @SuppressWarnings("EnhancedSwitchMigration")
    public static boolean matchTime(LocalTime currentTime, IotSceneRuleConditionOperatorEnum operatorEnum,
                                    String param) {
        try {
            // TIME_BETWEEN 需要解析两个时间，单独处理
            if (operatorEnum == IotSceneRuleConditionOperatorEnum.TIME_BETWEEN) {
                return matchTimeBetween(currentTime, param);
            }
            // 其他操作符只需要解析一个时间
            LocalTime targetTime = parseTime(param);
            switch (operatorEnum) {
                case TIME_GREATER_THAN:
                    return currentTime.isAfter(targetTime);
                case TIME_LESS_THAN:
                    return currentTime.isBefore(targetTime);
                default:
                    log.warn("[matchTime][operatorEnum({}) 不支持的时间操作符]", operatorEnum);
                    return false;
            }
        } catch (Exception e) {
            log.error("[matchTime][operatorEnum({}) param({}) 时间解析异常]", operatorEnum, param, e);
            return false;
        }
    }

    /**
     * 匹配时间区间
     *
     * @param currentTime 当前时间
     * @param param       参数值（格式：startTime,endTime）
     * @return 是否匹配
     */
    public static boolean matchTimeBetween(LocalTime currentTime, String param) {
        List<String> timeRange = StrUtil.splitTrim(param, CharPool.COMMA);
        if (timeRange.size() != 2) {
            log.warn("[matchTimeBetween][param({}) 时间区间参数格式错误]", param);
            return false;
        }
        LocalTime startTime = parseTime(timeRange.get(0).trim());
        LocalTime endTime = parseTime(timeRange.get(1).trim());
        return !currentTime.isBefore(startTime) && !currentTime.isAfter(endTime);
    }

    /**
     * 解析时间字符串
     * 支持 HH:mm 和 HH:mm:ss 两种格式
     *
     * @param timeStr 时间字符串
     * @return 解析后的 LocalTime
     */
    public static LocalTime parseTime(String timeStr) {
        Assert.isFalse(StrUtil.isBlank(timeStr), "时间字符串不能为空");
        try {
            // 尝试不同的时间格式
            if (timeStr.length() == 5) { // HH:mm
                return LocalTime.parse(timeStr, TIME_FORMATTER_SHORT);
            } else if (timeStr.length() == 8) { // HH:mm:ss
                return LocalTime.parse(timeStr, TIME_FORMATTER);
            } else {
                throw new IllegalArgumentException("时间格式长度不正确，期望 HH:mm 或 HH:mm:ss 格式");
            }
        } catch (Exception e) {
            log.error("[parseTime][timeStr({}) 时间格式解析失败]", timeStr, e);
            throw new IllegalArgumentException("时间格式无效: " + timeStr, e);
        }
    }

}