package com.xiaopeng.map.utils;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 围栏运营策略时间范围索引工具类
 */
public final class OperationStrategyIndex {
    private final List<List<TimeInterval>> strategyIntervals;

    /**
     * 构造索引（内部使用）。
     *
     * @param strategyIntervals 策略组时间区间列表（每个策略组已 merge）
     */
    private OperationStrategyIndex(List<List<TimeInterval>> strategyIntervals) {
        this.strategyIntervals = strategyIntervals == null ? Collections.emptyList() : strategyIntervals;
    }

    /**
     * 解析围栏 {@code operation_strategy} JSON 字符串为运营时间范围索引。
     * <p>
     * 说明：会按“策略组”聚合并合并时间段；点位只要被任意一个策略组的时间段完整覆盖，则为正常。
     * </p>
     *
     * @param operationStrategyJson 围栏运营策略 JSON（数组字符串）
     * @return 索引对象；解析失败/空入参返回空索引
     */
    public static OperationStrategyIndex parse(String operationStrategyJson) {
        if (operationStrategyJson == null || operationStrategyJson.isEmpty()) {
            return new OperationStrategyIndex(Collections.emptyList());
        }
        try {
            JSONArray jsonArray = JSONArray.parseArray(operationStrategyJson);
            if (jsonArray == null || jsonArray.isEmpty()) {
                return new OperationStrategyIndex(Collections.emptyList());
            }
            List<List<TimeInterval>> groups = new java.util.ArrayList<>();
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject obj = jsonArray.getJSONObject(i);
                if (obj == null) {
                    continue;
                }
                JSONArray timeArray = obj.getJSONArray("time");
                if (timeArray == null || timeArray.isEmpty()) {
                    continue;
                }
                List<TimeInterval> intervals = TimeInterval.parseRangesDedup(timeArray);
                List<TimeInterval> merged = TimeInterval.merge(intervals);
                if (!merged.isEmpty()) {
                    groups.add(merged);
                }
            }
            return new OperationStrategyIndex(groups);
        } catch (Exception e) {
            return new OperationStrategyIndex(Collections.emptyList());
        }
    }

    /**
     * 解析点位 {@code effective_time_period} JSON 数组字符串为时间区间列表（并合并）。
     *
     * @param jsonArrayStr 点位生效时间段 JSON（数组字符串）
     * @return 时间区间列表；解析失败返回空列表
     */
    public static List<TimeInterval> parsePointEffectiveTimePeriod(String jsonArrayStr) {
        return TimeInterval.parseJsonRangesDedup(jsonArrayStr);
    }

    /**
     * 判断两个围栏策略索引的 Union 运营时间覆盖范围是否一致。
     * <p>
     * 注意：不关心 JSON 的原始顺序与分组，只比较合并后的 Union 覆盖范围是否相同。
     * </p>
     *
     * @param other 待比较索引
     * @return true 表示 Union 覆盖范围一致
     */
    public boolean equalsNormalized(OperationStrategyIndex other) {
        if (other == null) {
            return false;
        }
        return equalsIntervals(this.unionAllowed(), other.unionAllowed());
    }

    /**
     * 判断相对新索引是否发生“运营时间范围缩短”。
     * <p>
     * 缩短定义：新 Union 覆盖范围被旧 Union 完整覆盖，且与旧 Union 不相等（newUnion ⊂ oldUnion）。
     * </p>
     *
     * @param newIndex 新索引（编辑后的围栏策略）
     * @return true 表示发生缩短
     */
    public boolean hasAnyShrinkComparedTo(OperationStrategyIndex newIndex) {
        if (newIndex == null) {
            return false;
        }
        List<TimeInterval> oldUnion = this.unionAllowed();
        List<TimeInterval> newUnion = newIndex.unionAllowed();
        if (equalsIntervals(oldUnion, newUnion)) {
            return false;
        }
        return TimeInterval.isWithin(newUnion, oldUnion);
    }

    /**
     * 获取当前索引的 Union 运营时间覆盖范围（合并后的时间区间列表）。
     *
     * @return Union 区间列表（已 merge 并排序）
     */
    public List<TimeInterval> unionAllowed() {
        if (strategyIntervals == null || strategyIntervals.isEmpty()) {
            return Collections.emptyList();
        }
        List<TimeInterval> union = strategyIntervals.stream()
                .filter(Objects::nonNull)
                .flatMap(List::stream)
                .collect(Collectors.toList());
        return TimeInterval.merge(union);
    }

    /**
     * 判断点位的时间段是否为正常。
     * <p>
     * 规则：只要点位的全部运营时间段被围栏“任意一个策略组”的时间段范围完整覆盖，则为正常。
     * </p>
     *
     * @param pointIntervals 点位时间区间列表
     * @return true 表示正常；false 表示不在任何一个策略组覆盖范围内
     */
    public boolean isPointScheduleWithin(List<TimeInterval> pointIntervals) {
        if (pointIntervals == null || pointIntervals.isEmpty()) {
            return true;
        }
        if (strategyIntervals == null || strategyIntervals.isEmpty()) {
            return false;
        }
        for (List<TimeInterval> groupIntervals : strategyIntervals) {
            if (TimeInterval.isWithin(pointIntervals, groupIntervals)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 兼容旧接口：忽略 {@code effectivePeriod}，统一按每日（Union 覆盖范围）判断。
     *
     * @param effectivePeriod 点位生效周期（不再使用）
     * @param pointIntervals  点位时间区间列表
     * @return true 表示点位时间段被围栏 Union 覆盖
     */
    public boolean isPointScheduleWithin(Integer effectivePeriod, List<TimeInterval> pointIntervals) {
        return isPointScheduleWithin(pointIntervals);
    }

    /**
     * 区间列表归一化：merge 合并并排序。
     */
    private static List<TimeInterval> normalizeIntervals(List<TimeInterval> intervals) {
        return TimeInterval.merge(intervals);
    }

    /**
     * 比较两组区间在归一化（merge）后的覆盖范围是否完全一致。
     */
    private static boolean equalsIntervals(List<TimeInterval> a, List<TimeInterval> b) {
        List<TimeInterval> x = normalizeIntervals(a);
        List<TimeInterval> y = normalizeIntervals(b);
        if (x.size() != y.size()) {
            return false;
        }
        for (int i = 0; i < x.size(); i++) {
            TimeInterval xi = x.get(i);
            TimeInterval yi = y.get(i);
            if (xi.startMinute != yi.startMinute || xi.endMinute != yi.endMinute) {
                return false;
            }
        }
        return true;
    }

    public static final class TimeInterval {
        private final int startMinute; // inclusive
        private final int endMinute;   // inclusive

        /**
         * 构造时间区间（闭区间，单位：分钟）。
         */
        private TimeInterval(int startMinute, int endMinute) {
            this.startMinute = startMinute;
            this.endMinute = endMinute;
        }

        /**
         * 解析 JSON 数组字符串为时间区间列表，并做 merge 合并。
         *
         * @param jsonArrayStr JSON 数组字符串（例如 ["08:00-12:00","13:00-18:00"]）
         * @return merge 后的区间列表；解析失败返回空列表
         */
        static List<TimeInterval> parseJsonRangesDedup(String jsonArrayStr) {
            if (jsonArrayStr == null || jsonArrayStr.isEmpty()) {
                return Collections.emptyList();
            }
            try {
                JSONArray arr = JSONArray.parseArray(jsonArrayStr);
                if (arr == null || arr.isEmpty()) {
                    return Collections.emptyList();
                }
                return merge(parseRangesDedup(arr));
            } catch (Exception e) {
                return Collections.emptyList();
            }
        }

        /**
         * 解析 JSONArray 中的时间段为区间列表（不做 merge）。
         *
         * @param timeArray 时间段数组（元素形如 "HH:mm-HH:mm"）
         * @return 区间列表
         */
        static List<TimeInterval> parseRanges(JSONArray timeArray) {
            List<TimeInterval> result = new java.util.ArrayList<>();
            for (int i = 0; i < timeArray.size(); i++) {
                String range = timeArray.getString(i);
                result.addAll(parseRange(range));
            }
            return result;
        }

        /**
         * 解析 JSONArray 中的时间段为区间列表（先按字符串去重，再解析；不做 merge）。
         */
        static List<TimeInterval> parseRangesDedup(JSONArray timeArray) {
            if (timeArray == null || timeArray.isEmpty()) {
                return Collections.emptyList();
            }
            Set<String> uniq = new LinkedHashSet<>();
            for (int i = 0; i < timeArray.size(); i++) {
                String range = timeArray.getString(i);
                if (range != null && !range.isEmpty()) {
                    uniq.add(range);
                }
            }
            List<TimeInterval> result = new java.util.ArrayList<>();
            for (String range : uniq) {
                result.addAll(parseRange(range));
            }
            return result;
        }

        /**
         * 解析单个时间段字符串为区间列表。
         * <p>
         * 注意：业务约束不会出现跨天时间段；若出现 end &lt; start，则视为非法配置并忽略该时间段。
         * </p>
         */
        private static List<TimeInterval> parseRange(String range) {
            if (range == null || !range.contains("-")) {
                return Collections.emptyList();
            }
            String[] parts = range.split("-");
            if (parts.length != 2) {
                return Collections.emptyList();
            }
            Integer start = parseMinute(parts[0].trim());
            Integer end = parseMinute(parts[1].trim());
            if (start == null || end == null) {
                return Collections.emptyList();
            }
            if (end < start) {
                return Collections.emptyList();
            }
            return java.util.Collections.singletonList(new TimeInterval(start, end));
        }

        /**
         * 将 HH:mm 解析为分钟数（0-1439），非法格式返回 null。
         */
        private static Integer parseMinute(String hhmm) {
            if (hhmm == null || hhmm.length() != 5 || hhmm.charAt(2) != ':') {
                return null;
            }
            try {
                int hour = Integer.parseInt(hhmm.substring(0, 2));
                int minute = Integer.parseInt(hhmm.substring(3, 5));
                if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
                    return null;
                }
                return hour * 60 + minute;
            } catch (Exception e) {
                return null;
            }
        }

        /**
         * 合并重叠/相邻区间，并按起始分钟排序。
         */
        static List<TimeInterval> merge(List<TimeInterval> intervals) {
            if (intervals == null || intervals.isEmpty()) {
                return Collections.emptyList();
            }
            List<TimeInterval> sorted = intervals.stream()
                    .filter(Objects::nonNull)
                    .sorted(java.util.Comparator.comparingInt(a -> a.startMinute))
                    .collect(Collectors.toList());
            if (sorted.isEmpty()) {
                return Collections.emptyList();
            }
            List<TimeInterval> merged = new java.util.ArrayList<>();
            TimeInterval cur = sorted.get(0);
            for (int i = 1; i < sorted.size(); i++) {
                TimeInterval next = sorted.get(i);
                if (next.startMinute <= cur.endMinute + 1) {
                    cur = new TimeInterval(cur.startMinute, Math.max(cur.endMinute, next.endMinute));
                } else {
                    merged.add(cur);
                    cur = next;
                }
            }
            merged.add(cur);
            return merged;
        }

        /**
         * 判断 pointIntervals 是否完全被 allowedIntervals 覆盖（每段都需被某个 allowed 段完全包含）。
         */
        static boolean isWithin(List<TimeInterval> pointIntervals, List<TimeInterval> allowedIntervals) {
            if (pointIntervals == null || pointIntervals.isEmpty()) {
                return true;
            }
            List<TimeInterval> allowed = merge(allowedIntervals);
            if (allowed.isEmpty()) {
                return false;
            }
            for (TimeInterval p : pointIntervals) {
                boolean covered = false;
                for (TimeInterval a : allowed) {
                    if (a.startMinute <= p.startMinute && a.endMinute >= p.endMinute) {
                        covered = true;
                        break;
                    }
                }
                if (!covered) {
                    return false;
                }
            }
            return true;
        }

        /**
         * 字符串化：便于 main 输出与排查（格式：startMinute-endMinute）。
         */
        @Override
        public String toString() {
            return startMinute + "-" + endMinute;
        }
    }

    /**
     * main 自测：使用固定样例打印 old/new Union、是否修改/缩短，以及点位在旧/新范围内判断结果。
     */
    public static void main(String[] args) {
        String pointJson = "[\"05:00-12:00\", \"13:00-21:59\"]";
        String strategyJson = "[{\"name\": \"策略组1\", \"time\": [\"06:00-22:00\", \"22:00-23:59\"], \"type\": 0, \"typeStr\": []}, {\"name\": \"策略组2\", \"time\": [\"06:00-12:00\", \"12:00-23:00\"], \"type\": 2, \"typeStr\": \"\"}, {\"name\": \"策略组3\", \"time\": [\"09:00-23:59\"], \"type\": 1, \"typeStr\": \"\"}]";

        OperationStrategyIndex index = OperationStrategyIndex.parse(strategyJson);
        List<TimeInterval> pointIntervals = OperationStrategyIndex.parsePointEffectiveTimePeriod(pointJson);

        System.out.println("pointIntervals=" + pointIntervals);
        System.out.println("fenceUnion=" + index.unionAllowed());
        boolean ok = index.isPointScheduleWithin(pointIntervals);
        System.out.println("isNormal=" + ok);
    }
}