package gudusoft.gsqlparser.lineage.v2.identity;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import gudusoft.gsqlparser.lineage.v2.SqllrResources;
import gudusoft.gsqlparser.lineage.v2.json.CanonicalJson;
import gudusoft.gsqlparser.sqlenv.unicode.GspCaseData;

/**
 * {@code CanonicalSegmentKeyV1} and the decoding of a delimited SQL spelling
 * ({@code lineage-spec/identifier-rules/FORMAT.md}, Sections 7.1 and 9) for one dialect's rule set under fixed
 * effective flags and collations.
 *
 * <p>The key is what a SQL-LR document carries as a segment's {@code canonicalKey}; it is an encoding of the
 * standard's rule data, not GSP's name equality. Binding decisions keep going through
 * {@code IdentifierService}; a producer compares the two and refuses a portable identity where they disagree.</p>
 *
 * <p>Instances are immutable and thread-safe.</p>
 *
 * @since 4.2.17
 */
public final class SegmentKeyV1 {

    /** The path of the dependency snapshot the jar ships. */
    public static final String DRAFT_SNAPSHOT = "snapshots/snapshot-0.1.0-draft.json";

    public static final String SQL_LEXICAL = "SQL_LEXICAL";
    public static final String CATALOG_STORED = "CATALOG_STORED";
    public static final String QUOTED = "QUOTED";
    public static final String UNQUOTED = "UNQUOTED";

    /** The outcome of {@link #key}: a canonical segment key, or {@code UNAVAILABLE_COLLATION}. */
    public static final class Result {
        public static final String KEY = "KEY";
        public static final String UNAVAILABLE_COLLATION = "UNAVAILABLE_COLLATION";

        private final String status;
        private final String key;

        private Result(String status, String key) {
            this.status = status;
            this.key = key;
        }

        /** {@link #KEY} or {@link #UNAVAILABLE_COLLATION}. */
        public String getStatus() {
            return status;
        }

        /** The key; {@code null} unless the status is {@link #KEY}. */
        public String getKey() {
            return key;
        }

        public boolean isKey() {
            return key != null;
        }

        @Override
        public String toString() {
            return key != null ? KEY + " " + key : status;
        }
    }

    /** The outcome of {@link #decode}: a segment's {@code text} and {@code quoteState}, or malformed. */
    public static final class Decoded {
        private final String quoteState;
        private final String text;

        private Decoded(String quoteState, String text) {
            this.quoteState = quoteState;
            this.text = text;
        }

        /** True when the spelling is recognized as delimited but violates its escape rules. */
        public boolean isMalformed() {
            return quoteState == null;
        }

        /** {@link #QUOTED} or {@link #UNQUOTED}; {@code null} when malformed. */
        public String getQuoteState() {
            return quoteState;
        }

        /** The decoded text; {@code null} when malformed. */
        public String getText() {
            return text;
        }

        @Override
        public String toString() {
            return isMalformed() ? "MALFORMED" : quoteState + " " + text;
        }
    }

    private static final Decoded MALFORMED = new Decoded(null, null);

    private final String dialect;
    private final Map<?, ?> rules;
    private final Map<String, Object> flags;
    private final Map<String, String> collations;

    private SegmentKeyV1(Map<?, ?> rules, Map<String, Object> flags, Map<String, String> collations) {
        this.dialect = (String) rules.get("dialect");
        this.rules = rules;
        this.flags = flags;
        this.collations = collations;
    }

    /**
     * The key function of a rule set.
     *
     * @param rules               a rule set file, parsed
     * @param effectiveFlags      flag values; a declared flag that is absent takes its {@code default}
     * @param effectiveCollations collation scope ({@code INSTANCE}, {@code DATABASE}) to vendor collation name; an
     *                            absent scope means no collation is declared for it
     * @throws IllegalArgumentException when the rule set is for another Unicode version than the case operations,
     *                                  a flag is not declared, or its value is not an exact value of its domain
     */
    public static SegmentKeyV1 of(Map<?, ?> rules, Map<String, ?> effectiveFlags,
            Map<String, String> effectiveCollations) {
        if (!GspCaseData.UNICODE_VERSION.equals(rules.get("unicodeVersion"))) {
            throw new IllegalArgumentException("the " + rules.get("dialect") + " rule set is for Unicode "
                    + rules.get("unicodeVersion") + "; the case operations implement " + GspCaseData.UNICODE_VERSION);
        }
        Map<?, ?> copy = (Map<?, ?>) CanonicalJson.immutableCopy(rules);
        Map<String, Object> flags = new LinkedHashMap<String, Object>();
        Map<?, ?> declared = map(copy.get("flags"));
        for (Map.Entry<?, ?> flag : declared.entrySet()) {
            Map<?, ?> declaration = map(flag.getValue());
            flags.put((String) flag.getKey(), checkedFlag((String) flag.getKey(), declaration, declaration.get("default")));
        }
        if (effectiveFlags != null) {
            for (Map.Entry<String, ?> flag : effectiveFlags.entrySet()) {
                Map<?, ?> declaration = map(declared.get(flag.getKey()));
                if (declaration.isEmpty()) {
                    throw new IllegalArgumentException("flag " + flag.getKey() + " is not declared by the "
                            + copy.get("dialect") + " rule set");
                }
                flags.put(flag.getKey(), checkedFlag(flag.getKey(), declaration, flag.getValue()));
            }
        }
        Map<String, String> scopes = new LinkedHashMap<String, String>();
        if (effectiveCollations != null) {
            scopes.putAll(effectiveCollations);
        }
        return new SegmentKeyV1(copy, Collections.unmodifiableMap(flags), Collections.unmodifiableMap(scopes));
    }

    /** A flag value within its declared domain: a boolean, or an exact integer among the declared values (as Long). */
    private static Object checkedFlag(String name, Map<?, ?> declaration, Object value) {
        if ("boolean".equals(declaration.get("type"))) {
            if (value instanceof Boolean) {
                return value;
            }
        } else if ("integer".equals(declaration.get("type"))) {
            Long exact = exactLong(value);
            if (exact != null && containsNumber((List<?>) declaration.get("values"), exact)) {
                return exact;
            }
        }
        throw new IllegalArgumentException("flag " + name + " = " + value + " is outside its domain");
    }

    /** The value as a Long when it is an exact integer of an integral type; otherwise null. */
    private static Long exactLong(Object value) {
        if (value instanceof Long || value instanceof Integer || value instanceof Short || value instanceof Byte) {
            return Long.valueOf(((Number) value).longValue());
        }
        if (value instanceof java.math.BigInteger && ((java.math.BigInteger) value).bitLength() < 64) {
            return Long.valueOf(((java.math.BigInteger) value).longValue());
        }
        return null;
    }

    /**
     * The key function a dependency snapshot declares for a dialect: its rule set with its effective flags and
     * collations. The rule set is read from the files the jar ships.
     *
     * @return {@code null} when the snapshot does not list the dialect
     * @throws IllegalArgumentException when the entry's dialect, rule set version, digest or Unicode version does
     *                                  not match the rule set it names
     */
    public static SegmentKeyV1 forSnapshot(Map<?, ?> snapshot, String dialect) {
        Object entries = snapshot.get("identifierRules");
        if (!(entries instanceof List<?>)) {
            return null;
        }
        for (Object item : (List<?>) entries) {
            Map<?, ?> entry = map(item);
            if (dialect.equals(entry.get("dialect"))) {
                Map<?, ?> rules = map(SqllrResources.json((String) entry.get("path")));
                String digest = "sha256:" + SqllrResources.sha256Hex(CanonicalJson.jcsBytes(rules));
                if (!dialect.equals(rules.get("dialect")) || !sameValue(entry.get("ruleSetVersion"),
                        rules.get("ruleSetVersion")) || !digest.equals(entry.get("digest"))
                        || !sameValue(snapshot.get("unicodeVersion"), rules.get("unicodeVersion"))) {
                    throw new IllegalArgumentException("the snapshot's " + dialect + " entry does not match the rule set "
                            + entry.get("path") + " (dialect " + rules.get("dialect") + ", version "
                            + rules.get("ruleSetVersion") + ", digest " + digest + ")");
                }
                Map<String, Object> flags = new LinkedHashMap<String, Object>();
                for (Map.Entry<?, ?> flag : map(entry.get("effectiveFlags")).entrySet()) {
                    flags.put((String) flag.getKey(), flag.getValue());
                }
                Map<String, String> scopes = new LinkedHashMap<String, String>();
                for (Map.Entry<?, ?> scope : map(entry.get("collations")).entrySet()) {
                    scopes.put((String) scope.getKey(), (String) scope.getValue());
                }
                return of(rules, flags, scopes);
            }
        }
        return null;
    }

    /** {@link #forSnapshot} of the snapshot the jar ships ({@link #DRAFT_SNAPSHOT}). */
    public static SegmentKeyV1 draft(String dialect) {
        return forSnapshot(map(SqllrResources.json(DRAFT_SNAPSHOT)), dialect);
    }

    public String getDialect() {
        return dialect;
    }

    /** The effective flags, every declared flag included. */
    public Map<String, Object> getFlags() {
        return flags;
    }

    /** The effective collations, by scope. */
    public Map<String, String> getCollations() {
        return collations;
    }

    /** Whether the rule set defines the object type. */
    public boolean definesObjectType(String objectType) {
        return map(rules.get("objectTypes")).containsKey(objectType);
    }

    /**
     * {@code CanonicalSegmentKeyV1}.
     *
     * @param objectType an object type code of FORMAT.md, Section 4
     * @param inputForm  {@link #SQL_LEXICAL} or {@link #CATALOG_STORED}
     * @param quoteState {@link #QUOTED} or {@link #UNQUOTED}; read for {@link #SQL_LEXICAL} only
     * @param text       the decoded text (Section 3)
     * @throws IllegalArgumentException on an input error: unknown object type or input form, missing or invalid
     *                                  quote state, or text with an unpaired surrogate
     */
    public Result key(String objectType, String inputForm, String quoteState, String text) {
        if (text == null || !isScalarValues(text)) {
            throw new IllegalArgumentException("text is not a string of Unicode scalar values");
        }
        boolean lexical = SQL_LEXICAL.equals(inputForm);
        if (!lexical && !CATALOG_STORED.equals(inputForm)) {
            throw new IllegalArgumentException("unknown input form " + inputForm);
        }
        if (lexical && !QUOTED.equals(quoteState) && !UNQUOTED.equals(quoteState)) {
            throw new IllegalArgumentException("SQL_LEXICAL needs quoteState QUOTED or UNQUOTED, not " + quoteState);
        }
        Map<?, ?> cell = map(map(rules.get("cells")).get(resolve(objectType)[0]));
        Map<?, ?> unquoted = map(cell.get("unquoted"));
        Map<?, ?> quoted = map(cell.get("quoted"));
        String k;
        if ("COLLATION".equals(quoted.get("compare"))) {
            String name = collations.get((String) cell.get("collationScope"));
            Object label = name == null ? null : map(rules.get("collations")).get(name);
            if (label == null) {
                return new Result(Result.UNAVAILABLE_COLLATION, null);
            }
            Map<?, ?> profile = map(map(rules.get("collationProfiles")).get(label));
            if (!withinProfile(profile, text)) {
                return new Result(Result.UNAVAILABLE_COLLATION, null);
            }
            k = "IDENTITY".equals(profile.get("key")) ? text : GspCaseData.simpleFoldCollapse(text);
        } else if (lexical) {
            Map<?, ?> branch = QUOTED.equals(quoteState) ? quoted : unquoted;
            String fold = (String) branch.get("fold");
            k = "NONE".equals(fold) ? text : fold(fold, text);
            if ("INSENSITIVE".equals(branch.get("compare")) && "NONE".equals(fold)) {
                k = GspCaseData.simpleFoldCollapse(k);
            }
        } else if ("SENSITIVE".equals(quoted.get("compare"))) {
            k = text;
        } else {
            String fold = !"NONE".equals(unquoted.get("fold")) ? (String) unquoted.get("fold") : (String) quoted.get("fold");
            k = "NONE".equals(fold) ? GspCaseData.simpleFoldCollapse(text) : fold(fold, text);
        }
        return new Result(Result.KEY, truncate(k));
    }

    /**
     * FORMAT.md, Section 7.1: the {@code text} and {@code quoteState} of one identifier token's spelling, using
     * the delimiter set the effective flags resolve for the object type.
     *
     * @throws IllegalArgumentException when the object type is not defined
     */
    public Decoded decode(String objectType, String spelling) {
        List<?> entries = (List<?>) map(rules.get("delimiterSets")).get(resolve(objectType)[1]);
        if (spelling == null) {
            throw new IllegalArgumentException("no spelling");
        }
        if (!spelling.isEmpty()) {
            for (Object item : entries) {
                Map<?, ?> entry = map(item);
                String open = (String) entry.get("open");
                if (spelling.startsWith(open)) {
                    String text = decodeBody(spelling.substring(open.length()), (String) entry.get("close"),
                            (String) entry.get("escape"));
                    return text == null ? MALFORMED : new Decoded(QUOTED, text);
                }
            }
        }
        return new Decoded(UNQUOTED, spelling);
    }

    /**
     * The preferred delimiters for writing a name of the object type back into SQL (the first entry of its delimiter
     * set, FORMAT.md Section 7): {open, close}, or {@code null} when the type has no delimited form.
     */
    public String[] preferredDelimiters(String objectType) {
        List<?> entries = (List<?>) map(rules.get("delimiterSets")).get(resolve(objectType)[1]);
        if (entries == null || entries.isEmpty()) {
            return null;
        }
        Map<?, ?> first = map(entries.get(0));
        return new String[] {(String) first.get("open"), (String) first.get("close")};
    }

    /** Whether a delimited form exists for the object type (its delimiter set is not empty). */
    public boolean hasQuotedForm(String objectType) {
        List<?> entries = (List<?>) map(rules.get("delimiterSets")).get(resolve(objectType)[1]);
        return entries != null && !entries.isEmpty();
    }

    /** {cell label, delimiter set label} of an object type under the effective flags (FORMAT.md, Section 8.3). */
    private String[] resolve(String objectType) {
        Map<?, ?> types = map(rules.get("objectTypes"));
        Map<?, ?> entry = map(types.get(objectType));
        if (entry.isEmpty()) {
            throw new IllegalArgumentException("object type " + objectType + " is not defined by the " + dialect
                    + " rule set");
        }
        String type = objectType;
        if (entry.containsKey("sameRulesAs")) {
            type = (String) entry.get("sameRulesAs");
            entry = map(types.get(type));
        }
        String cell = (String) entry.get("cell");
        String delimiters = (String) entry.get("delimiters");
        Object variants = rules.get("variants");
        if (variants instanceof List<?>) {
            for (Object item : (List<?>) variants) {
                Map<?, ?> variant = map(item);
                boolean applies = true;
                for (Map.Entry<?, ?> when : map(variant.get("when")).entrySet()) {
                    applies &= sameValue(flags.get(when.getKey()), when.getValue());
                }
                Map<?, ?> override = map(map(variant.get("objectTypes")).get(type));
                if (applies && !override.isEmpty()) {
                    if (override.get("cell") != null) {
                        cell = (String) override.get("cell");
                    }
                    if (override.get("delimiters") != null) {
                        delimiters = (String) override.get("delimiters");
                    }
                }
            }
        }
        return new String[] {cell, delimiters};
    }

    private static boolean sameValue(Object a, Object b) {
        Long x = exactLong(a);
        Long y = exactLong(b);
        if (x != null || y != null) {
            return x != null && x.equals(y);
        }
        return a == null ? b == null : a.equals(b);
    }

    private static boolean containsNumber(List<?> values, Object value) {
        if (values == null) {
            return false;
        }
        for (Object candidate : values) {
            if (sameValue(candidate, value)) {
                return true;
            }
        }
        return false;
    }

    private static String fold(String fold, String text) {
        if ("UPPER".equals(fold)) {
            return GspCaseData.toUpperFull(text);
        }
        if ("UPPER_SIMPLE".equals(fold)) {
            return GspCaseData.toUpperSimple(text);
        }
        if ("LOWER_SIMPLE".equals(fold)) {
            return GspCaseData.toLowerSimple(text);
        }
        if ("LOWER_ASCII".equals(fold)) {
            return GspCaseData.toLowerAscii(text);
        }
        throw new IllegalStateException("unknown fold " + fold);
    }

    private static boolean withinProfile(Map<?, ?> profile, String text) {
        List<?> ranges = (List<?>) profile.get("repertoire");
        int last = -1;
        for (int i = 0; i < text.length(); ) {
            int cp = text.codePointAt(i);
            boolean inside = false;
            for (Object range : ranges) {
                List<?> pair = (List<?>) range;
                if (Integer.parseInt((String) pair.get(0), 16) <= cp && cp <= Integer.parseInt((String) pair.get(1), 16)) {
                    inside = true;
                    break;
                }
            }
            if (!inside) {
                return false;
            }
            last = cp;
            i += Character.charCount(cp);
        }
        Object excluded = profile.get("excludedLast");
        if (last >= 0 && excluded instanceof List<?>) {
            for (Object code : (List<?>) excluded) {
                if (Integer.parseInt((String) code, 16) == last) {
                    return false;
                }
            }
        }
        return true;
    }

    /** FORMAT.md, Section 5.1: the longest prefix of whole code points within the byte limit. */
    private String truncate(String key) {
        Map<?, ?> truncation = map(rules.get("truncation"));
        if (truncation.isEmpty()) {
            return key;
        }
        if (!"UTF8_BYTES".equals(truncation.get("unit"))) {
            throw new IllegalStateException("unknown truncation unit " + truncation.get("unit"));
        }
        long max = ((Number) truncation.get("maxLength")).longValue();
        long bytes = 0;
        for (int i = 0; i < key.length(); ) {
            int cp = key.codePointAt(i);
            int length = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
            if (bytes + length > max) {
                return key.substring(0, i);
            }
            bytes += length;
            i += Character.charCount(cp);
        }
        return key;
    }

    private static String decodeBody(String body, String close, String escape) {
        if ("DOUBLE_CLOSE".equals(escape)) {
            return doubleClose(body, close);
        }
        if ("GOOGLESQL_BACKSLASH".equals(escape)) {
            return googleSql(body, close);
        }
        if ("UNICODE_ESCAPE_BACKSLASH".equals(escape)) {
            return unicodeEscape(body, close);
        }
        throw new IllegalStateException("unknown escape kind " + escape);
    }

    private static String doubleClose(String body, String close) {
        StringBuilder out = new StringBuilder(body.length());
        int i = 0;
        while (i < body.length()) {
            if (body.startsWith(close, i)) {
                if (i + close.length() == body.length()) {
                    return out.toString();
                }
                if (!body.startsWith(close, i + close.length())) {
                    return null;
                }
                out.append(close);
                i += 2 * close.length();
            } else {
                int cp = body.codePointAt(i);
                out.appendCodePoint(cp);
                i += Character.charCount(cp);
            }
        }
        return null;
    }

    private static String googleSql(String body, String close) {
        StringBuilder out = new StringBuilder(body.length());
        int i = 0;
        while (i < body.length()) {
            if (body.startsWith(close, i)) {
                return i + close.length() == body.length() ? out.toString() : null;
            }
            char c = body.charAt(i);
            if (c != '\\') {
                int cp = body.codePointAt(i);
                out.appendCodePoint(cp);
                i += Character.charCount(cp);
                continue;
            }
            if (i + 1 >= body.length()) {
                return null;
            }
            char e = body.charAt(i + 1);
            switch (e) {
                case 'a': out.append('\u0007'); i += 2; continue;
                case 'b': out.append('\b'); i += 2; continue;
                case 'f': out.append('\f'); i += 2; continue;
                case 'n': out.append('\n'); i += 2; continue;
                case 'r': out.append('\r'); i += 2; continue;
                case 't': out.append('\t'); i += 2; continue;
                case 'v': out.append('\u000B'); i += 2; continue;
                case '\\': case '?': case '"': case '\'': case '`': out.append(e); i += 2; continue;
                default:
                    break;
            }
            int value;
            if (e == 'x' || e == 'X') {
                value = hex(body, i + 2, 2);
                i += 4;
            } else if (e >= '0' && e <= '7') {
                value = octal(body, i + 1);
                i += 4;
            } else if (e == 'u') {
                value = hex(body, i + 2, 4);
                i += 6;
            } else if (e == 'U') {
                value = hex(body, i + 2, 8);
                i += 10;
            } else {
                return null;
            }
            if (value < 0 || value > 0x10FFFF || (value >= 0xD800 && value <= 0xDFFF)) {
                return null;
            }
            out.appendCodePoint(value);
        }
        return null;
    }

    private static String unicodeEscape(String body, String close) {
        StringBuilder units = new StringBuilder(body.length());
        int i = 0;
        while (i < body.length()) {
            if (body.startsWith(close, i)) {
                if (i + close.length() == body.length()) {
                    return isScalarValues(units.toString()) ? units.toString() : null;
                }
                if (!body.startsWith(close, i + close.length())) {
                    return null;
                }
                units.append(close);
                i += 2 * close.length();
                continue;
            }
            char c = body.charAt(i);
            if (c != '\\') {
                int cp = body.codePointAt(i);
                units.appendCodePoint(cp);
                i += Character.charCount(cp);
                continue;
            }
            if (body.startsWith("\\\\", i)) {
                units.append('\\');
                i += 2;
                continue;
            }
            if (body.startsWith("\\+", i)) {
                int value = hex(body, i + 2, 6);
                if (value < 0 || value > 0x10FFFF) {
                    return null;
                }
                if (value <= 0xFFFF) {
                    units.append((char) value);
                } else {
                    units.appendCodePoint(value);
                }
                i += 8;
                continue;
            }
            int unit = hex(body, i + 1, 4);
            if (unit < 0) {
                return null;
            }
            units.append((char) unit);
            i += 5;
        }
        return null;
    }

    /** The value of {@code count} ASCII hex digits at {@code start}, or -1. */
    private static int hex(String s, int start, int count) {
        if (start + count > s.length()) {
            return -1;
        }
        long value = 0;
        for (int j = start; j < start + count; j++) {
            int d = Character.digit(s.charAt(j), 16);
            if (d < 0 || s.charAt(j) > 'f') {
                return -1;
            }
            value = value * 16 + d;
        }
        return value > Integer.MAX_VALUE ? -1 : (int) value;
    }

    /** The value of exactly three octal digits at {@code start}, at most 377 octal, or -1. */
    private static int octal(String s, int start) {
        if (start + 3 > s.length()) {
            return -1;
        }
        int value = 0;
        for (int j = start; j < start + 3; j++) {
            char c = s.charAt(j);
            if (c < '0' || c > '7') {
                return -1;
            }
            value = value * 8 + (c - '0');
        }
        return value <= 0377 ? value : -1;
    }

    private static boolean isScalarValues(String s) {
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isHighSurrogate(c)) {
                if (i + 1 >= s.length() || !Character.isLowSurrogate(s.charAt(i + 1))) {
                    return false;
                }
                i++;
            } else if (Character.isLowSurrogate(c)) {
                return false;
            }
        }
        return true;
    }

    private static Map<?, ?> map(Object value) {
        return value instanceof Map<?, ?> ? (Map<?, ?>) value : Collections.emptyMap();
    }
}