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>The 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>
 *   <li>{@link #toUpperSimple}/{@link #toLowerSimple} — SIMPLE case mappings
 *       (UnicodeData.txt fields 12/13), one code point to one, no context: the mappings
 *       Oracle (unquoted names) and MySQL (table, column and routine names) actually apply.
 *       Derived from the same resource plus a small checked override table, so they add no
 *       resource and change none of the operations above.</li>
 *   <li>{@link #toLowerAscii} and {@link #clipUtf8Bytes} — PostgreSQL's identifier
 *       downcasing in a UTF8 database and its NAMEDATALEN truncation; no Unicode data.</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 char[] UPPER_SIMPLE_BMP = D.upperSimpleBmp;
    private static final char[] LOWER_SIMPLE_BMP = D.lowerSimpleBmp;
    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);
    }

    /**
     * Simple uppercase mapping, code point by code point: each code point becomes its
     * Simple_Uppercase_Mapping (UnicodeData.txt field 12) or stays itself. One code point in,
     * one code point out, no context, no locale ({@code ß} is kept, unlike {@link #toUpperFull}).
     *
     * <p>This is the per-character mapping Oracle applies to an unquoted name
     * ({@code straße} is stored as {@code STRAßE}) and MySQL applies when it compares routine
     * names ({@code ı} and {@code i} are one function). It is the SQL-LR {@code UPPER_SIMPLE}
     * operation (lineage-spec/identifier-rules/FORMAT.md section 6).
     */
    public static String toUpperSimple(String s) {
        return map(s, UPPER_SIMPLE_BMP, UPPER_KEYS, UPPER_BLOCKS, UPPER_VALUES, false);
    }

    /**
     * Simple lowercase mapping, code point by code point: each code point becomes its
     * Simple_Lowercase_Mapping (UnicodeData.txt field 13) or stays itself. No Final_Sigma
     * context ({@code Σ} always becomes {@code σ}), and {@code İ} becomes {@code i}.
     *
     * <p>This is MySQL's one-to-one lowercase mapping for table names under
     * {@code lower_case_table_names} 1 and 2 and for column names. It is the SQL-LR
     * {@code LOWER_SIMPLE} operation.
     */
    public static String toLowerSimple(String s) {
        return map(s, LOWER_SIMPLE_BMP, LOWER_KEYS, LOWER_BLOCKS, LOWER_VALUES, false);
    }

    /**
     * ASCII-only lowercase: {@code A}..{@code Z} become {@code a}..{@code z}, every other code
     * unit is kept. PostgreSQL's {@code downcase_identifier} in a multibyte server encoding
     * (UTF8): {@code ÄBC} is stored as {@code Äbc}. Consults no Unicode data. Returns the same
     * instance when nothing changes.
     */
    public static String toLowerAscii(String s) {
        if (s == null) {
            return null;
        }
        int n = s.length();
        int i = 0;
        while (i < n) {
            char c = s.charAt(i);
            if (c >= 'A' && c <= 'Z') {
                break;
            }
            i++;
        }
        if (i == n) {
            return s;
        }
        char[] out = s.toCharArray();
        for (; i < n; i++) {
            char c = out[i];
            if (c >= 'A' && c <= 'Z') {
                out[i] = (char) (c + ('a' - 'A'));
            }
        }
        return new String(out);
    }

    /**
     * The longest prefix of {@code s} whose UTF-8 encoding has at most {@code maxBytes} bytes,
     * cut on a whole code point (PostgreSQL's {@code pg_mbcliplen} in a UTF8 database). Returns
     * the same instance when it already fits. An unpaired surrogate counts as three bytes (its
     * CESU form): it never occurs in a name a server stored, and counting it keeps the
     * operation total on arbitrary UTF-16.
     *
     * @param s the text; null returns null
     * @param maxBytes the byte limit; zero or negative means no limit
     */
    public static String clipUtf8Bytes(String s, int maxBytes) {
        if (s == null || maxBytes <= 0) {
            return s;
        }
        int n = s.length();
        // Every UTF-16 unit encodes to at most 3 UTF-8 bytes (a surrogate pair, 2 units, to 4).
        if ((long) n * 3 <= maxBytes) {
            return s;
        }
        int bytes = 0;
        int i = 0;
        while (i < n) {
            char c = s.charAt(i);
            int units = 1;
            int width;
            if (c < 0x80) {
                width = 1;
            } else if (c < 0x800) {
                width = 2;
            } else if (Character.isHighSurrogate(c) && i + 1 < n
                    && Character.isLowSurrogate(s.charAt(i + 1))) {
                width = 4;
                units = 2;
            } else {
                width = 3;
            }
            if (bytes + width > maxBytes) {
                return s.substring(0, i);
            }
            bytes += width;
            i += units;
        }
        return s;
    }

    // ---- 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 char[] upperSimpleBmp;
        final char[] lowerSimpleBmp;
        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);
            this.upperSimpleBmp = deriveSimpleBmp(upperBmp, SIMPLE_UPPER_OVERRIDES, "upper");
            this.lowerSimpleBmp = deriveSimpleBmp(lowerBmp, SIMPLE_LOWER_OVERRIDES, "lower");
        }

        /**
         * The simple (one code point to one code point) mapping differs from the full mapping
         * of the binary resource exactly where SpecialCasing.txt has an unconditional entry; in
         * UCD {@value GspCaseData#UNICODE_VERSION} every such entry is a length-changing ({@link #MULTI})
         * slot of the BMP table. These pairs give the UnicodeData.txt simple value of each of
         * those code points (a value equal to its key means "no simple mapping"). Every other
         * code point's full mapping already is its simple mapping, including all supplementary
         * ones (SpecialCasing has no supplementary entries). Generated from the vendored UCD
         * files and checked against UnicodeData.txt for every code point by
         * {@code GspCaseDataSimpleMappingTest}.
         */
        private static final char[] SIMPLE_UPPER_OVERRIDES = {
            0x00DF, 0x00DF, 0x0149, 0x0149, 0x01F0, 0x01F0, 0x0390, 0x0390, 0x03B0, 0x03B0,
            0x0587, 0x0587, 0x1E96, 0x1E96, 0x1E97, 0x1E97, 0x1E98, 0x1E98, 0x1E99, 0x1E99,
            0x1E9A, 0x1E9A, 0x1F50, 0x1F50, 0x1F52, 0x1F52, 0x1F54, 0x1F54, 0x1F56, 0x1F56,
            0x1F80, 0x1F88, 0x1F81, 0x1F89, 0x1F82, 0x1F8A, 0x1F83, 0x1F8B, 0x1F84, 0x1F8C,
            0x1F85, 0x1F8D, 0x1F86, 0x1F8E, 0x1F87, 0x1F8F, 0x1F88, 0x1F88, 0x1F89, 0x1F89,
            0x1F8A, 0x1F8A, 0x1F8B, 0x1F8B, 0x1F8C, 0x1F8C, 0x1F8D, 0x1F8D, 0x1F8E, 0x1F8E,
            0x1F8F, 0x1F8F, 0x1F90, 0x1F98, 0x1F91, 0x1F99, 0x1F92, 0x1F9A, 0x1F93, 0x1F9B,
            0x1F94, 0x1F9C, 0x1F95, 0x1F9D, 0x1F96, 0x1F9E, 0x1F97, 0x1F9F, 0x1F98, 0x1F98,
            0x1F99, 0x1F99, 0x1F9A, 0x1F9A, 0x1F9B, 0x1F9B, 0x1F9C, 0x1F9C, 0x1F9D, 0x1F9D,
            0x1F9E, 0x1F9E, 0x1F9F, 0x1F9F, 0x1FA0, 0x1FA8, 0x1FA1, 0x1FA9, 0x1FA2, 0x1FAA,
            0x1FA3, 0x1FAB, 0x1FA4, 0x1FAC, 0x1FA5, 0x1FAD, 0x1FA6, 0x1FAE, 0x1FA7, 0x1FAF,
            0x1FA8, 0x1FA8, 0x1FA9, 0x1FA9, 0x1FAA, 0x1FAA, 0x1FAB, 0x1FAB, 0x1FAC, 0x1FAC,
            0x1FAD, 0x1FAD, 0x1FAE, 0x1FAE, 0x1FAF, 0x1FAF, 0x1FB2, 0x1FB2, 0x1FB3, 0x1FBC,
            0x1FB4, 0x1FB4, 0x1FB6, 0x1FB6, 0x1FB7, 0x1FB7, 0x1FBC, 0x1FBC, 0x1FC2, 0x1FC2,
            0x1FC3, 0x1FCC, 0x1FC4, 0x1FC4, 0x1FC6, 0x1FC6, 0x1FC7, 0x1FC7, 0x1FCC, 0x1FCC,
            0x1FD2, 0x1FD2, 0x1FD3, 0x1FD3, 0x1FD6, 0x1FD6, 0x1FD7, 0x1FD7, 0x1FE2, 0x1FE2,
            0x1FE3, 0x1FE3, 0x1FE4, 0x1FE4, 0x1FE6, 0x1FE6, 0x1FE7, 0x1FE7, 0x1FF2, 0x1FF2,
            0x1FF3, 0x1FFC, 0x1FF4, 0x1FF4, 0x1FF6, 0x1FF6, 0x1FF7, 0x1FF7, 0x1FFC, 0x1FFC,
            0xFB00, 0xFB00, 0xFB01, 0xFB01, 0xFB02, 0xFB02, 0xFB03, 0xFB03, 0xFB04, 0xFB04,
            0xFB05, 0xFB05, 0xFB06, 0xFB06, 0xFB13, 0xFB13, 0xFB14, 0xFB14, 0xFB15, 0xFB15,
            0xFB16, 0xFB16, 0xFB17, 0xFB17
        };

        /** See {@link #SIMPLE_UPPER_OVERRIDES}: only U+0130 (full lowercase {@code i̇}). */
        private static final char[] SIMPLE_LOWER_OVERRIDES = {
            0x0130, 0x0069
        };

        /**
         * A copy of a full-mapping BMP table whose length-changing slots carry the simple
         * mapping instead, so the simple operations run through the same 1:1 fast path. Fails
         * fast when the override table and the resource disagree about which slots expand —
         * that would mean the resource was regenerated from another UCD without this table.
         */
        private static char[] deriveSimpleBmp(char[] fullBmp, char[] overrides, String which) {
            char[] simple = fullBmp.clone();
            for (int i = 0; i < overrides.length; i += 2) {
                char key = overrides[i];
                char value = overrides[i + 1];
                if (simple[key] != MULTI) {
                    throw new IllegalStateException("Simple " + which + " override U+"
                            + Integer.toHexString(key) + " is not an expanding slot of the "
                            + UNICODE_VERSION + " case data");
                }
                simple[key] = value == key ? 0 : value;
            }
            for (int cp = 0; cp < simple.length; cp++) {
                if (simple[cp] == MULTI) {
                    throw new IllegalStateException("Expanding " + which + " slot U+"
                            + Integer.toHexString(cp) + " has no simple override");
                }
            }
            return simple;
        }

        /** 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);
            }
        }
    }
}