package com.xiaopeng.map.utils;

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

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

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

    /**
     * 构造索引（内部使用）。
     *
     * @param allowedByType 按 type 聚合后的允许时间区间
     */
    private OperationStrategyIndex(Map<Integer, List<TimeInterval>> allowedByType) {
        this.allowedByType = allowedByType;
    }

    /**
     * 解析围栏 {@code operation_strategy} JSON 字符串为运营时间范围索引。
     * <p>
     * 说明：会按 {@code type} 聚合并合并时间段，最终用于“时间覆盖范围”判断。
     * </p>
     *
     * @param operationStrategyJson 围栏运营策略 JSON（数组字符串）
     * @return 索引对象；解析失败/空入参返回空索引
     */
    public static OperationStrategyIndex parse(String operationStrategyJson) {
        if (operationStrategyJson == null || operationStrategyJson.isEmpty()) {
            return new OperationStrategyIndex(Collections.emptyMap());
        }
        try {
            JSONArray jsonArray = JSONArray.parseArray(operationStrategyJson);
            if (jsonArray == null || jsonArray.isEmpty()) {
                return new OperationStrategyIndex(Collections.emptyMap());
            }
            Map<Integer, List<TimeInterval>> map = new java.util.HashMap<>();
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject obj = jsonArray.getJSONObject(i);
                if (obj == null) {
                    continue;
                }
                Integer type = obj.getInteger("type");
                JSONArray timeArray = obj.getJSONArray("time");
                if (type == null || timeArray == null || timeArray.isEmpty()) {
                    continue;
                }
                List<TimeInterval> intervals = TimeInterval.parseRanges(timeArray);
                if (intervals.isEmpty()) {
                    continue;
                }
                map.merge(type, intervals, (a, b) -> {
                    List<TimeInterval> merged = new java.util.ArrayList<>(a.size() + b.size());
                    merged.addAll(a);
                    merged.addAll(b);
                    return TimeInterval.merge(merged);
                });
            }
            map.replaceAll((k, v) -> TimeInterval.merge(v));
            return new OperationStrategyIndex(map);
        } catch (Exception e) {
            return new OperationStrategyIndex(Collections.emptyMap());
        }
    }

    /**
     * 解析点位 {@code effective_time_period} JSON 数组字符串为时间区间列表（并合并）。
     *
     * @param jsonArrayStr 点位生效时间段 JSON（数组字符串）
     * @return 时间区间列表；解析失败返回空列表
     */
    public static List<TimeInterval> parsePointEffectiveTimePeriod(String jsonArrayStr) {
        return TimeInterval.parseJsonRanges(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 (allowedByType == null || allowedByType.isEmpty()) {
            return Collections.emptyList();
        }
        List<TimeInterval> union = allowedByType.values().stream()
                .filter(Objects::nonNull)
                .flatMap(List::stream)
                .collect(Collectors.toList());
        return TimeInterval.merge(union);
    }

    /**
     * 判断点位的时间段是否完全落在围栏 Union 运营时间覆盖范围内。
     *
     * @param pointIntervals 点位时间区间列表
     * @return true 表示点位每段时间都被围栏 Union 覆盖
     */
    public boolean isPointScheduleWithin(List<TimeInterval> pointIntervals) {
        if (pointIntervals == null || pointIntervals.isEmpty()) {
            return true;
        }
        return TimeInterval.isWithin(pointIntervals, this.unionAllowed());
    }

    /**
     * 兼容旧接口：忽略 {@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> parseJsonRanges(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(parseRanges(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;
        }

        /**
         * 解析单个时间段字符串为区间列表（支持跨天拆分：如 22:00-02:00）。
         */
        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) {
                List<TimeInterval> list = new java.util.ArrayList<>(2);
                list.add(new TimeInterval(start, 23 * 60 + 59));
                list.add(new TimeInterval(0, end));
                return list;
            }
            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 oldJson = "[{\"name\": \"策略组1\", \"time\": [\"08:00-23:59\"], \"type\": 0, \"typeStr\": []}, {\"name\": \"策略组2\", \"time\": [\"07:00-23:59\"], \"type\": 2, \"typeStr\": \"\"}, {\"name\": \"策略组3\", \"time\": [\"02:00-23:59\"], \"type\": 1, \"typeStr\": \"\"}]";
        String newJson = "[{\"name\": \"策略组1\", \"time\": [\"08:00-23:59\"], \"type\": 0, \"typeStr\": []}, {\"name\": \"策略组2\", \"time\": [\"07:00-23:59\"], \"type\": 2, \"typeStr\": \"\"}, {\"name\": \"策略组3\", \"time\": [\"02:00-20:59\"], \"type\": 1, \"typeStr\": \"\"}]";
        String pointJson = "[\"07:00-13:00\", \"13:00-23:59\"]";

        OperationStrategyIndex oldIndex = OperationStrategyIndex.parse(oldJson);
        OperationStrategyIndex newIndex = OperationStrategyIndex.parse(newJson);
        List<TimeInterval> pointIntervals = OperationStrategyIndex.parsePointEffectiveTimePeriod(pointJson);

        System.out.println("oldUnion=" + oldIndex.unionAllowed());
        System.out.println("newUnion=" + newIndex.unionAllowed());
        System.out.println("equalsNormalized=" + oldIndex.equalsNormalized(newIndex));
        System.out.println("hasAnyShrinkComparedTo=" + oldIndex.hasAnyShrinkComparedTo(newIndex));
        boolean inOld = oldIndex.isPointScheduleWithin(pointIntervals);
        boolean inNew = newIndex.isPointScheduleWithin(pointIntervals);
        System.out.println("point(inOld,inNew)=(" + inOld + "," + inNew + ")");
        boolean shouldDisable = !newIndex.isPointScheduleWithin(pointIntervals);
        System.out.println("shouldDisableByUnion=" + shouldDisable);
    }
}