package gudusoft.gsqlparser.sqlenv.unicode;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * GSP-pinned Unicode case operations — the JVM-independent fold engine of the
 * persistent canonical-identity program
 * (docs/designs/persistent-canonical-identity-implementation-plan.md §3).
 *
 * <p>All data comes from the committed binary resource {@code gsp-case-data.bin},
 * generated from vendored UCD {@value #UNICODE_VERSION} files. Nothing here consults
 * {@code String.toUpperCase}/{@code toLowerCase} or any other JVM Unicode table, so the
 * results are identical on every JVM — the whole point: JDK 8 ships Unicode 6.2 while
 * JDK 21 ships 15.x, and identifier identity must not depend on which one happens to
 * run the export.
 *
 * <p>Three operations, deliberately nothing else:
 * <ul>
 *   <li>{@link #toUpperFull}/{@link #toLowerFull} — FULL case mappings (length may
 *       change: {@code ß→SS}), plus Final_Sigma as the single context rule, implemented
 *       per the UCD definition (NOT any JDK's quirk — the JDKs disagree with each other
 *       on Case_Ignorable contexts, so "match the JVM" is not even well-defined).
 *       Locale-conditional rules (tr/az/lt) are excluded by design: no database folds
 *       identifiers by session locale, and including them corrupts catalog identity.</li>
 *   <li>{@link #simpleFoldCollapse} — CaseFolding.txt C+S simple fold, code-point-wise.
 *       Successor of the char-wise {@code caseCollapse} (fixes supplementary planes).</li>
 * </ul>
 *
 * <p>Unpaired surrogates pass through unchanged in every operation — identity must be
 * total on arbitrary UTF-16, and substitution would merge distinct malformed inputs.
 * Inputs the operation does not change are returned as the SAME instance, including
 * surrogate-bearing ones (zero allocation).
 *
 * <p>Thread-safe: one immutable table holder, safely published via the class
 * initializer, whose body is straight-line code delegating to ordinary methods.
 * (Historical note: this class's first obfuscated build failed verification because
 * proguard.cfg once disabled preverification while emitting v52 class files — that
 * affected EVERY branchy method product-wide and was fixed by re-enabling
 * preverification; the branch-free initializer is retained as cheap hygiene.)
 * Deployment notes: the resource is looked up relative to this class, so package
 * RELOCATION (consumer-side shading) relocates the lookup with it, but the relocator
 * must also move the resource directory; GraalVM native-image users must register
 * {@code gudusoft/gsqlparser/sqlenv/unicode/gsp-case-data.bin} as a resource.
 * Missing/corrupt resource fails fast with {@link ExceptionInInitializerError} on
 * first use.
 */
public final class GspCaseData {

    /** Exact UCD version the tables are generated from. Part of every policyId. */
    public static final String UNICODE_VERSION = "16.0.0";

    /** Bumped on ANY behavioral change of these operations. Part of every policyId. */
    public static final int ALGORITHM_REV = 1;

    private static final int SIGMA = 0x03A3;        // Σ
    private static final int FINAL_SIGMA = 0x03C2;  // ς

    // value 0 = no mapping (identity); MULTI = consult the sorted arrays.
    // U+FFFF is a noncharacter and never a mapping target (asserted by the
    // conformance suite against the audit dump), so it is a safe sentinel.
    private static final char MULTI = (char) 0xFFFF;

    /** Immutable table holder — loaded by ordinary (verifiable) methods; the
     *  initializer below is pure straight-line code (no branches, no frames), and the
     *  static-final aliases restore JIT constant folding lost to instance-field
     *  indirection. */
    private static final Data D = Data.load();
    private static final int[] UPPER_KEYS = D.upperKeys;
    private static final String[] UPPER_VALUES = D.upperValues;
    private static final int[] LOWER_KEYS = D.lowerKeys;
    private static final String[] LOWER_VALUES = D.lowerValues;
    private static final int[] FOLD_KEYS = D.foldKeys;
    private static final String[] FOLD_VALUE_STRINGS = D.foldValueStrings;
    private static final int[] UPPER_BLOCKS = D.upperBlocks;
    private static final int[] LOWER_BLOCKS = D.lowerBlocks;
    private static final int[] FOLD_BLOCKS = D.foldBlocks;

    /**
     * Reusable mapping buffer for the 1:1 fast path (U5 fork-pair benchmark:
     * the per-call {@code char[n]} plus {@code String}'s internal copy tripled
     * allocation vs the JDK's in-{@code java.lang} zero-copy path). The buffer
     * never escapes — {@code new String(buf, 0, n)} copies — and {@code map}
     * neither recurses nor calls back into itself, so per-thread reuse is
     * safe. Inputs longer than the buffer allocate as before.
     */
    private static final int SCRATCH_LIMIT = 256;
    private static final ThreadLocal<char[]> SCRATCH = new ThreadLocal<char[]>() {
        @Override
        protected char[] initialValue() {
            return new char[SCRATCH_LIMIT];
        }
    };
    private static final char[] UPPER_BMP = D.upperBmp;
    private static final char[] LOWER_BMP = D.lowerBmp;
    private static final char[] FOLD_BMP = D.foldBmp;
    private static final int[] CASED_STARTS = D.casedStarts;
    private static final int[] CASED_ENDS = D.casedEnds;
    private static final int[] IGNORABLE_STARTS = D.ignorableStarts;
    private static final int[] IGNORABLE_ENDS = D.ignorableEnds;

    private GspCaseData() {
    }

    /** Full uppercase mapping (unconditional UCD data; length may grow, e.g. ß→SS). */
    public static String toUpperFull(String s) {
        return map(s, UPPER_BMP, UPPER_KEYS, UPPER_BLOCKS, UPPER_VALUES, false);
    }

    /**
     * Full lowercase mapping with the UCD Final_Sigma rule: Σ lowers to ς iff preceded
     * by a Cased code point (skipping Case_Ignorable) and NOT followed by one (skipping
     * Case_Ignorable). Everything else uses unconditional data.
     */
    public static String toLowerFull(String s) {
        return map(s, LOWER_BMP, LOWER_KEYS, LOWER_BLOCKS, LOWER_VALUES, true);
    }

    /**
     * CaseFolding C+S simple fold applied per code point — the canonical-equality
     * collapse for INSENSITIVE + no-fold cells. Code-point-wise, so supplementary-plane
     * pairs fold correctly (unlike the char-wise legacy collapse).
     */
    public static String simpleFoldCollapse(String s) {
        return map(s, FOLD_BMP, FOLD_KEYS, FOLD_BLOCKS, FOLD_VALUE_STRINGS, false);
    }

    // ---- the mapper: ASCII tight path, then general code-point path ----

    /**
     * One mapper for all three operations; {@code finalSigma} enables the Σ context
     * rule (lowercasing only). Two-tier shape (U5 gate 3): fixed points (nothing
     * maps — the dominant identifier case) return the SAME instance with zero
     * allocation, including surrogate-bearing inputs (valid pairs are probed
     * against the supplementary keys; unpaired units are passthrough by policy).
     * Strings whose mappings are all 1:1 in UTF-16 units — BMP single-char
     * mappings, supplementary pairs mapping to one code point, and Σ (σ and ς are
     * both one unit; the context scan reads the ORIGINAL string, so mapped output
     * never affects it) — are built in a fixed {@code char[n]}. Only a length-
     * changing mapping (MULTI expansions like ß→SS) drops to the StringBuilder
     * walk, resuming exactly where the fast loop stopped.
     */
    private static String map(String s, char[] bmp, int[] keys, int[] blocks,
                              String[] values, boolean finalSigma) {
        if (s == null || s.isEmpty()) {
            return s;
        }
        int n = s.length();
        int first = firstMappedIndex(s, 0, bmp, keys, blocks);
        if (first == n) {
            return s; // fixed point: same instance, zero allocation
        }
        char[] out = n <= SCRATCH_LIMIT ? SCRATCH.get() : new char[n];
        s.getChars(0, first, out, 0);
        int j = first;
        while (j < n) {
            char d = s.charAt(j);
            if (d < Character.MIN_SURROGATE || d > Character.MAX_SURROGATE) {
                if (finalSigma && d == (char) SIGMA && isFinalSigmaContext(s, j)) {
                    out[j] = (char) FINAL_SIGMA;
                    j++;
                    continue;
                }
                char md = bmp[d];
                if (md == MULTI) {
                    break; // length-changing expansion: finish on the slow path
                }
                out[j] = md == 0 ? d : md;
                j++;
                continue;
            }
            int cp = codePointOrUnit(s, j);
            if (cp <= 0xFFFF) {
                out[j] = d; // unpaired surrogate passthrough
                j++;
                continue;
            }
            int idx = lookup(keys, blocks, cp);
            if (idx < 0) {
                out[j] = d;
                out[j + 1] = s.charAt(j + 1);
                j += 2;
                continue;
            }
            String v = values[idx];
            if (v.length() != 2) {
                break; // supplementary mapping that changes unit count: slow path
            }
            out[j] = v.charAt(0);
            out[j + 1] = v.charAt(1);
            j += 2;
        }
        if (j == n) {
            return new String(out, 0, n);
        }
        StringBuilder b = new StringBuilder(n + 4);
        b.append(out, 0, j);
        return mapTail(s, j, b, bmp, keys, blocks, values, finalSigma);
    }

    /**
     * Code-point lookup in a sorted keys table via its per-256-codepoint block
     * index: jump straight to the (contiguous, cache-local) block slice and
     * binary-search only inside it — replaces full-table binary search, whose
     * ~11 scattered probes dominated supplementary-plane rows in the U5
     * fork-pair benchmark (the "sparse per-plane lookup" review round 2
     * suggested).
     */
    private static int lookup(int[] keys, int[] blocks, int cp) {
        int b = cp >>> 8;
        return java.util.Arrays.binarySearch(keys, blocks[b], blocks[b + 1], cp);
    }

    /** General walk from {@code i} appending to {@code b} (the pre-{@code i} text is
     *  already appended). Handles MULTI expansions, supplementary keys, unpaired
     *  surrogates, and — when {@code finalSigma} — the Σ context rule. */
    private static String mapTail(String s, int i, StringBuilder b,
                                  char[] bmp, int[] keys, int[] blocks,
                                  String[] values, boolean finalSigma) {
        int n = s.length();
        while (i < n) {
            char c = s.charAt(i);
            if (c < Character.MIN_SURROGATE || c > Character.MAX_SURROGATE) {
                if (finalSigma && c == (char) SIGMA && isFinalSigmaContext(s, i)) {
                    b.append((char) FINAL_SIGMA);
                    i++;
                    continue;
                }
                char m = bmp[c];
                if (m == 0) {
                    b.append(c);
                } else if (m != MULTI) {
                    b.append(m);
                } else {
                    b.append(values[lookup(keys, blocks, c)]);
                }
                i++;
                continue;
            }
            int cp = codePointOrUnit(s, i);
            if (cp > 0xFFFF) {
                int idx = lookup(keys, blocks, cp);
                if (idx >= 0) {
                    b.append(values[idx]);
                } else {
                    b.appendCodePoint(cp);
                }
                i += 2;
            } else {
                b.append((char) cp); // unpaired surrogate passthrough
                i++;
            }
        }
        return b.toString();
    }

    /**
     * Index of the first UTF-16 position at or after {@code from} whose content the
     * operation would map, or {@code s.length()} when the rest is a fixed point.
     * Σ needs no special case: {@code LOWER_BMP[Σ]} is non-zero (σ), so a Σ always
     * reports as mapped and the tail walk decides between σ and ς.
     */
    private static int firstMappedIndex(String s, int from, char[] bmp, int[] keys,
                                        int[] blocks) {
        int n = s.length();
        int i = from;
        while (i < n) {
            char c = s.charAt(i);
            if (c < Character.MIN_SURROGATE || c > Character.MAX_SURROGATE) {
                if (bmp[c] != 0) {
                    return i;
                }
                i++;
                continue;
            }
            int cp = codePointOrUnit(s, i);
            if (cp > 0xFFFF) {
                if (lookup(keys, blocks, cp) >= 0) {
                    return i;
                }
                i += 2;
            } else {
                i++; // unpaired surrogate: passthrough, keep scanning
            }
        }
        return n;
    }

    // ---- Final_Sigma context (UCD definition, Cased/Case_Ignorable from DCP) ----

    private static boolean isFinalSigmaContext(String s, int sigmaIndex) {
        // Before: scanning backwards, skip Case_Ignorable; require Cased. Note the
        // sets OVERLAP (U+0345 is both) — per the spec's possessive skipping, a
        // code point that is Case_Ignorable is skipped regardless of Cased-ness.
        int i = sigmaIndex;
        boolean casedBefore = false;
        while (i > 0) {
            int cp = codePointBefore(s, i);
            i -= cp > 0xFFFF ? 2 : 1;
            if (isCaseIgnorable(cp)) {
                continue;
            }
            casedBefore = isCased(cp);
            break;
        }
        if (!casedBefore) {
            return false;
        }
        // After: scanning forwards, skip Case_Ignorable; require NOT Cased.
        i = sigmaIndex + 1; // Σ is a BMP char
        while (i < s.length()) {
            int cp = codePointOrUnit(s, i);
            i += cp > 0xFFFF ? 2 : 1;
            if (isCaseIgnorable(cp)) {
                continue;
            }
            return !isCased(cp);
        }
        return true; // end of string after skipping ignorables
    }

    static boolean isCased(int cp) {
        return inRanges(cp, CASED_STARTS, CASED_ENDS);
    }

    static boolean isCaseIgnorable(int cp) {
        return inRanges(cp, IGNORABLE_STARTS, IGNORABLE_ENDS);
    }

    private static boolean inRanges(int cp, int[] starts, int[] ends) {
        int idx = java.util.Arrays.binarySearch(starts, cp);
        if (idx >= 0) {
            return true;
        }
        int insertion = -idx - 2; // candidate range that starts before cp
        return insertion >= 0 && cp <= ends[insertion];
    }

    // ---- UTF-16 walking that is total on malformed input ----

    /** Code point at i, or the lone surrogate unit itself when unpaired. */
    private static int codePointOrUnit(String s, int i) {
        char c = s.charAt(i);
        if (Character.isHighSurrogate(c) && i + 1 < s.length()
                && Character.isLowSurrogate(s.charAt(i + 1))) {
            return Character.toCodePoint(c, s.charAt(i + 1));
        }
        return c; // BMP char, or unpaired surrogate passed through as its unit value
    }

    private static int codePointBefore(String s, int i) {
        char c = s.charAt(i - 1);
        if (Character.isLowSurrogate(c) && i - 2 >= 0
                && Character.isHighSurrogate(s.charAt(i - 2))) {
            return Character.toCodePoint(s.charAt(i - 2), c);
        }
        return c;
    }

    // ---- the table holder: loaded by ordinary (verifiable) methods ----

    private static final class Data {
        final int[] upperKeys;
        final String[] upperValues;
        final int[] lowerKeys;
        final String[] lowerValues;
        final int[] foldKeys;
        final String[] foldValueStrings;
        final char[] upperBmp = new char[0x10000];
        final char[] lowerBmp = new char[0x10000];
        final char[] foldBmp = new char[0x10000];
        final int[] casedStarts;
        final int[] casedEnds;
        final int[] ignorableStarts;
        final int[] ignorableEnds;
        final int[] upperBlocks;
        final int[] lowerBlocks;
        final int[] foldBlocks;

        private Data(int[] upperKeys, String[] upperValues,
                     int[] lowerKeys, String[] lowerValues,
                     int[] foldKeys, int[] foldValues,
                     int[] casedStarts, int[] casedEnds,
                     int[] ignorableStarts, int[] ignorableEnds) {
            this.upperKeys = upperKeys;
            this.upperValues = upperValues;
            this.lowerKeys = lowerKeys;
            this.lowerValues = lowerValues;
            this.foldKeys = foldKeys;
            this.casedStarts = casedStarts;
            this.casedEnds = casedEnds;
            this.ignorableStarts = ignorableStarts;
            this.ignorableEnds = ignorableEnds;
            this.foldValueStrings = new String[foldValues.length];
            for (int i = 0; i < foldValues.length; i++) {
                StringBuilder fv = new StringBuilder(2);
                fv.appendCodePoint(foldValues[i]);
                this.foldValueStrings[i] = fv.toString();
            }
            deriveBmp(upperKeys, upperValues, upperBmp);
            deriveBmp(lowerKeys, lowerValues, lowerBmp);
            for (int i = 0; i < foldKeys.length; i++) {
                if (foldKeys[i] <= 0xFFFF) {
                    foldBmp[foldKeys[i]] = foldValues[i] <= 0xFFFF
                            ? (char) foldValues[i] : MULTI;
                }
            }
            this.upperBlocks = blockIndex(upperKeys);
            this.lowerBlocks = blockIndex(lowerKeys);
            this.foldBlocks = blockIndex(foldKeys);
        }

        /** blocks[b] = index of the first key >= b<<8; blocks[b+1] bounds the
         *  slice, so a lookup binary-searches only its own 256-codepoint block. */
        private static int[] blockIndex(int[] keys) {
            int blockCount = (0x110000 >>> 8);
            int[] blocks = new int[blockCount + 1];
            int k = 0;
            for (int b = 0; b <= blockCount; b++) {
                int floor = b << 8;
                while (k < keys.length && keys[k] < floor) {
                    k++;
                }
                blocks[b] = k;
            }
            return blocks;
        }

        private static void deriveBmp(int[] keys, String[] values, char[] bmp) {
            for (int i = 0; i < keys.length; i++) {
                if (keys[i] <= 0xFFFF) {
                    String v = values[i];
                    bmp[keys[i]] = v.length() == 1 ? v.charAt(0) : MULTI;
                }
            }
        }

        /** All loading logic lives here, in ordinary verifiable methods. */
        static Data load() {
            InputStream raw = GspCaseData.class.getResourceAsStream("gsp-case-data.bin");
            if (raw == null) {
                throw new IllegalStateException("Missing case-data resource "
                        + "gsp-case-data.bin next to " + GspCaseData.class.getName());
            }
            try {
                DataInputStream in = new DataInputStream(raw);
                try {
                    byte[] magic = new byte[8];
                    in.readFully(magic);
                    if (!"GSPCASE1".equals(new String(magic, "US-ASCII"))) {
                        throw new IllegalStateException("Bad case-data magic");
                    }
                    String version = in.readUTF();
                    if (!UNICODE_VERSION.equals(version)) {
                        throw new IllegalStateException("Case-data version " + version
                                + " does not match compiled-in " + UNICODE_VERSION);
                    }
                    int rev = in.readInt();
                    if (rev != ALGORITHM_REV) {
                        throw new IllegalStateException("Case-data algorithm rev " + rev
                                + " does not match compiled-in " + ALGORITHM_REV);
                    }
                    int n = in.readInt();
                    int[] upperKeys = new int[n];
                    String[] upperValues = new String[n];
                    readMappingTable(in, n, upperKeys, upperValues);
                    n = in.readInt();
                    int[] lowerKeys = new int[n];
                    String[] lowerValues = new String[n];
                    readMappingTable(in, n, lowerKeys, lowerValues);
                    n = in.readInt();
                    int[] foldKeys = new int[n];
                    int[] foldValues = new int[n];
                    for (int i = 0; i < n; i++) {
                        foldKeys[i] = in.readInt();
                        foldValues[i] = in.readInt();
                    }
                    n = in.readInt();
                    int[] casedStarts = new int[n];
                    int[] casedEnds = new int[n];
                    for (int i = 0; i < n; i++) {
                        casedStarts[i] = in.readInt();
                        casedEnds[i] = in.readInt();
                    }
                    n = in.readInt();
                    int[] ignorableStarts = new int[n];
                    int[] ignorableEnds = new int[n];
                    for (int i = 0; i < n; i++) {
                        ignorableStarts[i] = in.readInt();
                        ignorableEnds[i] = in.readInt();
                    }
                    return new Data(upperKeys, upperValues, lowerKeys, lowerValues,
                            foldKeys, foldValues, casedStarts, casedEnds,
                            ignorableStarts, ignorableEnds);
                } finally {
                    in.close();
                }
            } catch (IOException e) {
                throw new IllegalStateException("Failed to load gsp-case-data.bin", e);
            }
        }

        private static void readMappingTable(DataInputStream in, int n,
                                             int[] keys, String[] values) throws IOException {
            for (int i = 0; i < n; i++) {
                keys[i] = in.readInt();
                int len = in.readUnsignedByte();
                char[] chars = new char[len];
                for (int j = 0; j < len; j++) {
                    chars[j] = in.readChar();
                }
                values[i] = new String(chars);
            }
        }
    }
}