package gudusoft.gsqlparser.sqlenv;

import java.text.CollationKey;
import java.text.Collator;
import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Collator 提供者（SQL Server COLLATION_BASED 专用）
 *
 * <p><strong>关键设计：</strong>
 * <ul>
 * <li>{@link Collator} 非线程安全，使用 {@link ThreadLocal} 缓存
 * <li>按 collation 名称缓存实例（每个 collation 一个 ThreadLocal）
 * <li>支持常见 SQL Server collation（CI_AS, CS_AS 等）
 * </ul>
 *
 * <p>使用示例：
 * <pre>
 * CollatorProvider provider = new CollatorProvider();
 *
 * // 获取 Collator（自动 ThreadLocal 缓存）
 * Collator collator = provider.getCollator("SQL_Latin1_General_CP1_CI_AS");
 *
 * // 比较标识符
 * int result = collator.compare("MyTable", "MYTABLE");
 * // CI (Case Insensitive): result == 0
 * // CS (Case Sensitive): result != 0
 * </pre>
 *
 * <p><strong>性能特性：</strong>
 * <ul>
 * <li>首次访问：创建 Collator 实例（~100μs）
 * <li>后续访问：ThreadLocal.get()（~10ns）
 * <li>内存开销：每线程每 collation 一个实例（~1KB）
 * </ul>
 *
 * @since 3.1.0.9
 */
public class CollatorProvider {

    // Per-collation 的 ThreadLocal 缓存
    // Key: collation 名称（如 "SQL_Latin1_General_CP1_CI_AS"）
    // Value: ThreadLocal<Collator>（每线程独立实例）
    private final ConcurrentHashMap<String, ThreadLocal<Collator>> collatorCache =
        new ConcurrentHashMap<>();

    // ===== 公共接口 =====

    /**
     * 获取 Collator 实例（ThreadLocal 缓存）
     *
     * <p>此方法线程安全，每个线程获得独立的 Collator 实例。
     *
     * @param collationName SQL Server collation 名称（例如：SQL_Latin1_General_CP1_CI_AS）
     * @return Collator 实例（线程本地）
     */
    public Collator getCollator(String collationName) {
        if (collationName == null || collationName.isEmpty()) {
            // 默认：当前 Locale 的 Collator
            return Collator.getInstance();
        }

        // 为每个 collation 名称创建一个 ThreadLocal
        ThreadLocal<Collator> tl = collatorCache.computeIfAbsent(collationName, key ->
            ThreadLocal.withInitial(() -> createCollator(key))
        );

        return tl.get();
    }

    /**
     * 清理缓存（用于测试或内存管理）
     *
     * <p>警告：调用此方法后，所有线程的 Collator 实例将失效，下次访问时重新创建。
     */
    public void clearCache() {
        collatorCache.clear();
    }

    // ===== 内部实现 =====

    /**
     * 根据 SQL Server collation 名称创建 Collator
     *
     * <p>SQL Server collation 名称格式：
     * <pre>
     * {Language}_{Region}_CP{CodePage}_{CaseSensitivity}_{AccentSensitivity}
     *
     * 例如：
     * - SQL_Latin1_General_CP1_CI_AS  (Case Insensitive, Accent Sensitive)
     * - SQL_Latin1_General_CP1_CS_AS  (Case Sensitive, Accent Sensitive)
     * - Chinese_PRC_CI_AS             (简体中文, Case Insensitive)
     * </pre>
     *
     * @param collationName SQL Server collation 名称
     * @return 配置好的 Collator 实例
     */
    private Collator createCollator(String collationName) {
        // 解析 collation 名称
        Locale locale = parseLocale(collationName);
        Collator collator = Collator.getInstance(locale);

        // Accent-insensitive (_AI) collations whose accent equivalence was measured on the engine
        // (SqlServerAccentFolding: Latin1_General_CI_AI / _CS_AI, SQL_Latin1_General_CP1_CI_AI).
        // SQL Server 2022: under Latin1_General_CI_AI `FROM CAFE` finds the table café; under
        // Latin1_General_CS_AI `FROM cafe` finds café while `Cafe` stays a different name; o/ø,
        // l/ł, d/đ, i/ı are equal under both, U+AC00 and its jamo U+1100 U+1161 are not. Java's
        // Collator cannot say that at any strength (PRIMARY also equates `a b`/`ab`, `a-b`/`ab`),
        // and stripping combining marks after NFD gets ø/ł/đ/ı wrong and merges the Hangul pair.
        // So the name is first folded by the measured table, then compared exactly as the
        // sibling _AS collation is compared: CI_AI by the CI_AS collator, CS_AI exactly (a _CS_AS
        // cell is SENSITIVE). Every other _AI collation keeps the shape below.
        if (SqlServerAccentFolding.isMeasured(collationName)) {
            if (SqlServerAccentFolding.isCaseSensitive(collationName)) {
                return new AccentInsensitiveCollator(collationName, null);
            }
            // The sibling _CI_AS collation, spelled with upper-case CI/AS: collation names are
            // case-insensitive, and the strength/decomposition checks below match upper case.
            String sibling = collationName.replaceAll("(?i)(?<=_)AI(?=_|$)", "AS")
                    .replaceAll("(?i)(?<=_)CI(?=_|$)", "CI");
            return new AccentInsensitiveCollator(collationName, createCollator(sibling));
        }

        // 设置强度（Strength）
        if (collationName.contains("_CI_") || collationName.contains("_CI")) {
            // Case Insensitive（CI）
            collator.setStrength(Collator.SECONDARY);  // 忽略大小写
        } else if (collationName.contains("_CS_") || collationName.contains("_CS")) {
            // Case Sensitive（CS）
            collator.setStrength(Collator.TERTIARY);   // 区分大小写
        } else {
            // 默认：根据 Locale 决定（通常是 TERTIARY）
            collator.setStrength(Collator.TERTIARY);
        }

        // 设置分解模式（Decomposition）
        if (collationName.contains("_AS")) {
            // Accent Sensitive（AS）
            collator.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
        } else if (collationName.contains("_AI")) {
            // Accent Insensitive（AI）
            collator.setDecomposition(Collator.NO_DECOMPOSITION);
        } else {
            // 默认：Canonical Decomposition
            collator.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
        }

        return collator;
    }

    /**
     * 从 collation 名称解析 Locale
     *
     * <p>这是简化实现，仅支持常见 collation。
     * 生产环境需要完整的 SQL Server collation → Java Locale 映射表。
     *
     * @param collationName SQL Server collation 名称
     * @return 对应的 Java Locale
     */
    private Locale parseLocale(String collationName) {
        String lowerName = collationName.toLowerCase(Locale.ROOT);

        // SQL Server 常见 collation 映射
        if (lowerName.contains("latin1") || lowerName.contains("sql_")) {
            // Latin1 / SQL_ 前缀 → 英语（美国）
            return new Locale("en", "US");
        } else if (lowerName.contains("chinese_prc") || lowerName.contains("chinese_simplified")) {
            // 简体中文
            return new Locale("zh", "CN");
        } else if (lowerName.contains("chinese_taiwan") || lowerName.contains("chinese_traditional")) {
            // 繁体中文（台湾）
            return new Locale("zh", "TW");
        } else if (lowerName.contains("chinese_hong_kong")) {
            // 繁体中文（香港）
            return new Locale("zh", "HK");
        } else if (lowerName.contains("japanese")) {
            // 日语
            return new Locale("ja", "JP");
        } else if (lowerName.contains("korean")) {
            // 韩语
            return new Locale("ko", "KR");
        } else if (lowerName.contains("arabic")) {
            // 阿拉伯语
            return new Locale("ar");
        } else if (lowerName.contains("french")) {
            // 法语
            return new Locale("fr", "FR");
        } else if (lowerName.contains("german")) {
            // 德语
            return new Locale("de", "DE");
        } else if (lowerName.contains("spanish")) {
            // 西班牙语
            return new Locale("es", "ES");
        } else if (lowerName.contains("italian")) {
            // 意大利语
            return new Locale("it", "IT");
        } else if (lowerName.contains("russian")) {
            // 俄语
            return new Locale("ru", "RU");
        } else {
            // 默认：英语（美国）
            return Locale.US;
        }

        // 生产环境实现：
        // 1. 维护完整的 SQL Server collation → Locale 映射表
        // 2. 解析 collation 名称的各个组成部分
        // 3. 根据 Language 和 Region 构造 Locale
        // 4. 参考：https://docs.microsoft.com/en-us/sql/relational-databases/collations/collation-and-unicode-support
    }

    /**
     * Whether a SQL Server collation name says accent-insensitive: one of its underscore-separated
     * parts is {@code AI} ({@code Latin1_General_CI_AI}, {@code Latin1_General_100_CS_AI_SC},
     * {@code SQL_Latin1_General_CP1_CI_AI}). Collation names are case-insensitive.
     *
     * @param collationName the collation name; null is not accent-insensitive
     * @return true for an {@code _AI} collation
     */
    public static boolean isAccentInsensitive(String collationName) {
        return hasToken(collationName, "AI");
    }

    /**
     * Whether a SQL Server collation compares case-sensitively, from its name: a {@code _CS}
     * part ({@code Latin1_General_CS_AS}, {@code Latin1_General_CS_AI}) or a binary collation
     * ({@code _BIN}, {@code _BIN2}) says yes, anything else ({@code _CI}, or no collation, which
     * means the case-insensitive default) says no.
     *
     * <p>The one answer to "is this collation case-sensitive" for a
     * {@link IdentifierRules.CaseCompare#COLLATION_BASED} cell, whose compare kind alone does not
     * say it: {@code Latin1_General_CS_AI} and {@code Latin1_General_BIN2} are collation-based and
     * case-sensitive, {@code SQL_Latin1_General_CP1_CI_AS} is collation-based and not.
     *
     * @param collationName the collation name; null or empty is the case-insensitive default
     * @return true when names that differ only in case are different names
     */
    public static boolean isCaseSensitiveCollation(String collationName) {
        return hasToken(collationName, "CS") || hasToken(collationName, "BIN")
                || hasToken(collationName, "BIN2");
    }

    private static boolean hasToken(String collationName, String token) {
        if (collationName == null) {
            return false;
        }
        int n = collationName.length();
        int start = 0;
        while (start <= n) {
            int end = collationName.indexOf('_', start);
            if (end < 0) {
                end = n;
            }
            if (end - start == token.length()
                    && collationName.regionMatches(true, start, token, 0, token.length())) {
                return true;
            }
            start = end + 1;
        }
        return false;
    }

    /**
     * Whether GSP compares this collation with a MEASURED accent equivalence
     * ({@link SqlServerAccentFolding}): {@code Latin1_General_CI_AI}, {@code Latin1_General_CS_AI}
     * and {@code SQL_Latin1_General_CP1_CI_AI}. Other {@code _AI} collations were not measured and
     * keep the comparison they had before (a {@code _CS_AI} one is then exact).
     *
     * @param collationName the collation name; null is not measured
     * @return true when the measured accent table applies
     */
    public static boolean hasMeasuredAccentFolding(String collationName) {
        return SqlServerAccentFolding.isMeasured(collationName);
    }

    /**
     * A measured accent-insensitive collation: both names are folded by
     * {@link SqlServerAccentFolding} (accents mapped to their base or deleted, as measured on the
     * engine), then compared as the sibling {@code _AS} collation compares — by the case-insensitive
     * {@code _CI_AS} collator ({@code _CI_AI}), or exactly ({@code _CS_AI}, as a {@code _CS_AS}
     * cell compares). Its collation keys are built from the same folded text, so key equality is
     * exactly {@code compare == 0}.
     *
     * <p>Like every {@link Collator} it is not thread-safe; {@link CollatorProvider} hands each
     * thread its own instance.
     */
    static final class AccentInsensitiveCollator extends Collator {

        /** The measured collation whose table folds the text. */
        private final String collationName;
        /** The sibling _CI_AS collator; null for _CS_AI, which compares the folded text exactly. */
        private final Collator caseInsensitiveBase;

        AccentInsensitiveCollator(String collationName, Collator caseInsensitiveBase) {
            if ((caseInsensitiveBase == null) != SqlServerAccentFolding.isCaseSensitive(collationName)) {
                throw new IllegalArgumentException("a _CI_AI collator needs its _CI_AS base, a _CS_AI one none");
            }
            this.collationName = collationName;
            this.caseInsensitiveBase = caseInsensitiveBase;
        }

        /** The text with the measured accent equivalence applied; the same instance when unchanged. */
        String fold(String s) {
            return SqlServerAccentFolding.fold(s, collationName);
        }

        @Override
        public int compare(String source, String target) {
            String a = fold(source);
            String b = fold(target);
            return caseInsensitiveBase != null ? caseInsensitiveBase.compare(a, b) : a.compareTo(b);
        }

        @Override
        public CollationKey getCollationKey(String source) {
            if (source == null) {
                return null;
            }
            String folded = fold(source);
            byte[] bytes;
            if (caseInsensitiveBase != null) {
                bytes = caseInsensitiveBase.getCollationKey(folded).toByteArray();
            } else {
                // UTF-16 code units, big-endian: unsigned byte order is String.compareTo order.
                bytes = new byte[folded.length() * 2];
                for (int i = 0; i < folded.length(); i++) {
                    char c = folded.charAt(i);
                    bytes[2 * i] = (byte) (c >>> 8);
                    bytes[2 * i + 1] = (byte) c;
                }
            }
            return new BytesKey(source, bytes);
        }

        @Override
        public boolean equals(Object that) {
            if (this == that) {
                return true;
            }
            if (!(that instanceof AccentInsensitiveCollator)) {
                return false;
            }
            AccentInsensitiveCollator other = (AccentInsensitiveCollator) that;
            return collationName.equalsIgnoreCase(other.collationName) // non-identifier-compare: collation name
                    && (caseInsensitiveBase == null ? other.caseInsensitiveBase == null
                        : caseInsensitiveBase.equals(other.caseInsensitiveBase));
        }

        @Override
        public int hashCode() {
            return collationName.toLowerCase(Locale.ROOT).hashCode() ^ 0x5A1;
        }

        /** Collation key over precomputed bytes, ordered as unsigned byte strings. */
        private static final class BytesKey extends CollationKey {
            private final byte[] bytes;

            BytesKey(String source, byte[] bytes) {
                super(source);
                this.bytes = bytes;
            }

            @Override
            public int compareTo(CollationKey target) {
                byte[] other = target.toByteArray();
                int len = Math.min(bytes.length, other.length);
                for (int i = 0; i < len; i++) {
                    int d = (bytes[i] & 0xFF) - (other[i] & 0xFF);
                    if (d != 0) {
                        return d;
                    }
                }
                return bytes.length - other.length;
            }

            @Override
            public byte[] toByteArray() {
                return bytes.clone();
            }
        }
    }

    // ===== 调试方法 =====

    /**
     * 获取缓存大小（不同 collation 的数量）
     *
     * @return 缓存的 collation 数量
     */
    public int getCacheSize() {
        return collatorCache.size();
    }

    /**
     * 测试 collation 比较（用于调试）
     *
     * @param collationName collation 名称
     * @param str1 字符串 1
     * @param str2 字符串 2
     * @return 比较结果（0: 相等, <0: str1 < str2, >0: str1 > str2）
     */
    public int testCompare(String collationName, String str1, String str2) {
        Collator collator = getCollator(collationName);
        return collator.compare(str1, str2);
    }
}