package cn.iocoder.yudao.module.qcreport.engine;

import java.math.BigDecimal;
import java.time.temporal.TemporalAccessor;
import java.time.format.DateTimeFormatter;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 上下文取值。
 * <p>
 * 只做白名单式的属性导航，不解析、不执行任何代码：
 * 支持 a.b.c 与 a.b[0].c 两种写法，路径在数组上继续取属性时按元素逐个取值（pluck）。
 * <p>
 * 与前端 {@code src/components/quality/engine/path.ts} 一一对应，两边必须同语义。
 */
public final class Paths {

    /** 路径片段：普通属性名或数组下标 */
    private static final Pattern TOKEN_PATTERN = Pattern.compile("[^.\\[\\]]+");

    /** 禁止访问的属性名，避免顺着原型链读到构造器 */
    private static final Set<String> BLOCKED_KEYS = Set.of("__proto__", "constructor", "prototype");

    private static final Pattern INTEGER_TEXT = Pattern.compile("^\\d+$");

    private static final DateTimeFormatter DATE_TIME_FORMAT =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private Paths() {
    }

    /**
     * 把路径拆成片段：inspectionItems[0].actualValue → [inspectionItems, 0, actualValue]
     */
    public static List<String> parsePath(String path) {
        List<String> tokens = new ArrayList<>();
        if (path == null) {
            return tokens;
        }
        Matcher matcher = TOKEN_PATTERN.matcher(path);
        while (matcher.find()) {
            tokens.add(matcher.group());
        }
        return tokens;
    }

    /**
     * 按路径取值，取不到返回 null。
     */
    public static Object readPath(Object source, String path) {
        return readTokens(source, parsePath(path), 0);
    }

    private static Object readTokens(Object source, List<String> tokens, int start) {
        Object current = source;
        for (int index = start; index < tokens.size(); index++) {
            String token = tokens.get(index);
            if (current == null) {
                return null;
            }
            if (current instanceof List<?> list) {
                Integer arrayIndex = toIndex(token);
                if (arrayIndex == null) {
                    // 数组上继续取属性：逐元素取值，得到同长度的数组
                    List<Object> plucked = new ArrayList<>(list.size());
                    for (Object element : list) {
                        plucked.add(readTokens(element, tokens, index));
                    }
                    return plucked;
                }
                current = arrayIndex < list.size() ? list.get(arrayIndex) : null;
                continue;
            }
            if (current instanceof Map<?, ?> map) {
                if (BLOCKED_KEYS.contains(token)) {
                    return null;
                }
                current = map.get(token);
                continue;
            }
            // 标量后面还有路径片段，说明路径写错了
            return null;
        }
        return current;
    }

    private static Integer toIndex(String token) {
        return INTEGER_TEXT.matcher(token).matches() ? Integer.valueOf(token) : null;
    }

    /**
     * 展示用格式化：空值渲染为空字符串，布尔值转中文，日期只保留到秒。
     * <p>
     * 整数值的双精度数（如 60.0）按整数输出，与 JS 的 {@code String(60)} 保持一致，
     * 否则报告上会出现「标准值 60.0」这种不该有的尾数。
     */
    public static String formatValue(Object value) {
        if (value == null) {
            return "";
        }
        if (value instanceof Boolean bool) {
            return bool ? "是" : "否";
        }
        if (value instanceof Date date) {
            return DATE_TIME_FORMAT.format(date.toInstant().atZone(ZoneId.systemDefault()));
        }
        if (value instanceof TemporalAccessor temporal) {
            return DATE_TIME_FORMAT.format(temporal);
        }
        if (value instanceof Collection<?> collection) {
            List<String> parts = new ArrayList<>(collection.size());
            for (Object element : collection) {
                parts.add(formatValue(element));
            }
            return String.join("、", parts);
        }
        return formatNumberAware(value);
    }

    private static String formatNumberAware(Object value) {
        if (value instanceof Double || value instanceof Float || value instanceof BigDecimal) {
            return Numbers.toString(((Number) value).doubleValue());
        }
        return String.valueOf(value);
    }

    /**
     * 数值化：非数值返回 NaN，由调用方决定如何处理。
     */
    public static double toNumber(Object value) {
        if (value instanceof Number number) {
            return number.doubleValue();
        }
        if (value instanceof Boolean bool) {
            return bool ? 1D : 0D;
        }
        if (value instanceof String text && !text.isBlank()) {
            try {
                return Double.parseDouble(text.trim());
            } catch (NumberFormatException ignored) {
                return Double.NaN;
            }
        }
        return Double.NaN;
    }

    /**
     * 把任意取值收敛成数值数组，供统计函数使用。
     */
    public static List<Double> toNumberArray(Object value) {
        List<Double> numbers = new ArrayList<>();
        if (value instanceof Collection<?> collection) {
            flattenInto(collection, numbers);
            return numbers;
        }
        double single = toNumber(value);
        if (Double.isFinite(single)) {
            numbers.add(single);
        }
        return numbers;
    }

    private static void flattenInto(Object value, List<Double> target) {
        if (value instanceof Collection<?> collection) {
            for (Object element : collection) {
                flattenInto(element, target);
            }
            return;
        }
        double numeric = toNumber(value);
        if (Double.isFinite(numeric)) {
            target.add(numeric);
        }
    }

    /**
     * 把任意取值按一层一层摊平成列表，保留原始元素（不做数值转换），供 PASS_RATE 这类函数使用。
     */
    public static List<Object> flatten(Object value) {
        List<Object> result = new ArrayList<>();
        if (value instanceof Collection<?> collection) {
            for (Object element : collection) {
                result.addAll(flatten(element));
            }
            return result;
        }
        result.add(value);
        return result;
    }

}