package gudusoft.gsqlparser.pp2.token;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.pp.para.styleenums.TCaseOption;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;

/**
 * Compares two SQL inputs for token-level equivalence modulo formatting.
 *
 * <p>The contract — verified by 12 hand-built cases in
 * {@code TokenEquivalenceTest} — is that two SQL strings are equivalent
 * when:
 *
 * <ul>
 *   <li>Their <i>solid + comment</i> token sequences (in order) are equal
 *       character-by-character.</li>
 *   <li>Whitespace differences (spaces, tabs, linebreaks, indent) are
 *       ignored.</li>
 *   <li>Comment position may shift between the two streams — the comments
 *       must appear in the same relative order, but their surrounding
 *       whitespace does not matter.</li>
 *   <li>Case differences on keywords and unquoted identifiers are tolerated
 *       when {@code caseInsensitive=true}. Quoted identifiers, string
 *       literals, and operator/punctuation tokens are always compared
 *       byte-exact because case changes there alter semantics.</li>
 * </ul>
 *
 * <p>This helper is the safety net for several downstream slices:
 * <ul>
 *   <li><b>S13</b> ({@code GuardedAstDelegate}) — verifies that
 *       {@code FormatterFactory.pp()}'s output preserves every solid
 *       input token.</li>
 *   <li><b>S32</b> golden tests — sanity-checks goldens against their
 *       inputs.</li>
 *   <li><b>S33</b> overlay annotator — exercises the equivalence helper
 *       on real corpus inputs.</li>
 *   <li><b>S34</b> content-preservation — the strongest property test on
 *       the 50-SQL corpus.</li>
 *   <li><b>S35</b> per-vendor smoke — confirms every vendor preserves
 *       content through the pp2 pipeline.</li>
 * </ul>
 *
 * <p>The helper deliberately operates on raw SQL strings (not
 * {@link Pp2TokenStream} instances) because the comparison is between an
 * arbitrary input and an arbitrary output — there is no single pp2 stream
 * shared between the two. The internal tokenization uses the GSP lexer
 * directly with the same overlap-skip discipline as
 * {@link Pp2TokenStreamBuilder}.
 *
 * <p>Changes the user explicitly asked for (variable or delimited-name case,
 * compact mode's comment rewrite, comment removal) are accepted in their exact
 * expected form when a {@link TransformPolicy} allows them; see that class.
 * {@code Pp2FormatOptions.transformPolicy} carries it to pp2's guards.
 *
 * <p>Plan reference: §7.3/S10, §7.4/S10, Q8.
 */
public final class TokenEquivalence {

    private TokenEquivalence() {
        // utility class
    }

    /**
     * Case-insensitive comparison using the default Oracle dialect. The
     * "case insensitive" mode tolerates case differences on keywords and
     * unquoted identifiers; literals and quoted identifiers are always
     * byte-exact.
     */
    public static boolean equalsModuloFormatting(String left, String right,
                                                 Pp2FormatOptions opts) {
        return equalsModuloFormatting(left, right, opts,
            EDbVendor.dbvoracle, true);
    }

    /**
     * Full-control comparison.
     *
     * @param left  first SQL string; must not be null
     * @param right second SQL string; must not be null
     * @param opts  pp2 options; its {@code transformPolicy} allows the
     *              requested transformations; may be null (none allowed)
     * @param vendor dialect to tokenize with; must not be null
     * @param caseInsensitive when {@code true}, keyword and unquoted
     *                        identifier comparisons are case-insensitive;
     *                        when {@code false}, all comparisons are
     *                        byte-exact on text
     * @return {@code true} iff the two strings have the same token
     *         sequence under the rules described in the class Javadoc
     * @throws NullPointerException if {@code left}, {@code right}, or
     *         {@code vendor} is null
     */
    public static boolean equalsModuloFormatting(String left, String right,
                                                 Pp2FormatOptions opts,
                                                 EDbVendor vendor,
                                                 boolean caseInsensitive) {
        return equalsModuloFormatting(left, right, opts, vendor, caseInsensitive, false);
    }

    /**
     * {@link #equalsModuloFormatting(String, String, Pp2FormatOptions, EDbVendor, boolean)} for two
     * texts that follow other statements: {@code stringsAtStart} is true when one of those turned
     * the quoted-identifier option off, so that every double-quoted text of both may be a string
     * (see {@link DoubleQuotedStrings}).
     */
    public static boolean equalsModuloFormatting(String left, String right,
                                                 Pp2FormatOptions opts,
                                                 EDbVendor vendor,
                                                 boolean caseInsensitive,
                                                 boolean stringsAtStart) {
        if (left == null) throw new NullPointerException("left");
        if (right == null) throw new NullPointerException("right");
        if (vendor == null) throw new NullPointerException("vendor");
        TransformPolicy policy = opts == null || opts.transformPolicy == null
            ? TransformPolicy.NONE : opts.transformPolicy;
        SplitTokens a = tokenizeSplit(left, vendor, stringsAtStart);
        SplitTokens b = tokenizeSplit(right, vendor, stringsAtStart);
        // Solid (non-comment) tokens must match in order.
        if (!compareSolids(a.solids, b.solids, caseInsensitive, policy, vendor)) {
            return false;
        }
        // Comments must appear in the same relative order, and each
        // comment's text must be byte-exact. Position may shift relative
        // to the solid tokens (plan §16 Q8).
        return compareComments(a.comments, b.comments, policy);
    }

    /**
     * The solid-token half of {@link #equalsModuloFormatting(String, String,
     * Pp2FormatOptions, EDbVendor, boolean)}: every non-comment token of
     * {@code left} appears in {@code right} once, in order, with the same
     * type and (case-insensitively for keywords and unquoted identifiers
     * when {@code caseInsensitive}) the same text. Exposed so that callers
     * reporting the two invariants separately (the format worker) apply the
     * same policy as the combined check.
     */
    public static boolean solidTokensEquivalent(String left, String right,
                                                EDbVendor vendor,
                                                boolean caseInsensitive) {
        return solidTokensEquivalent(left, right, vendor, caseInsensitive, TransformPolicy.NONE);
    }

    /**
     * {@link #solidTokensEquivalent(String, String, EDbVendor, boolean)} that
     * also accepts the solid-token transformations {@code policy} allows.
     */
    public static boolean solidTokensEquivalent(String left, String right,
                                                EDbVendor vendor,
                                                boolean caseInsensitive,
                                                TransformPolicy policy) {
        if (left == null) throw new NullPointerException("left");
        if (right == null) throw new NullPointerException("right");
        if (vendor == null) throw new NullPointerException("vendor");
        return compareSolids(tokenizeSplit(left, vendor, false).solids,
            tokenizeSplit(right, vendor, false).solids, caseInsensitive,
            policy == null ? TransformPolicy.NONE : policy, vendor);
    }

    /**
     * The comment half of {@link #equalsModuloFormatting(String, String,
     * Pp2FormatOptions, EDbVendor, boolean)}: the comments of {@code left}
     * appear in {@code right} in the same relative order with byte-exact
     * text; their position relative to the solid tokens may differ.
     */
    public static boolean commentsPreserved(String left, String right,
                                            EDbVendor vendor) {
        return commentsPreserved(left, right, vendor, TransformPolicy.NONE);
    }

    /**
     * {@link #commentsPreserved(String, String, EDbVendor)} that also accepts
     * the comment transformations {@code policy} allows.
     */
    public static boolean commentsPreserved(String left, String right,
                                            EDbVendor vendor,
                                            TransformPolicy policy) {
        if (left == null) throw new NullPointerException("left");
        if (right == null) throw new NullPointerException("right");
        if (vendor == null) throw new NullPointerException("vendor");
        return compareComments(tokenizeSplit(left, vendor, false).comments,
            tokenizeSplit(right, vendor, false).comments,
            policy == null ? TransformPolicy.NONE : policy);
    }

    private static boolean compareSolids(List<TokenInfo> a, List<TokenInfo> b,
                                         boolean caseInsensitive, TransformPolicy policy,
                                         EDbVendor vendor) {
        if (a.size() != b.size()) return false;
        for (int i = 0; i < a.size(); i++) {
            TokenInfo x = a.get(i);
            TokenInfo y = b.get(i);
            if (tokensEquivalent(x, y, caseInsensitive)) continue;
            if (!policy.isNone() && transformedAsRequested(x, y, policy, vendor)) continue;
            return false;
        }
        return true;
    }

    /** Dialects in which a bracketed token is a delimited name. */
    private static final java.util.Set<String> BRACKETS_ARE_NAMES = new java.util.HashSet<String>(Arrays.asList(
        "dbvmssql", "dbvazuresql", "dbvsybase", "dbvsybasease", "dbvsybaseiq", "dbvsqlanywhere",
        "dbvaccess", "dbvsqlite"));

    /** Solid-token transformations: the output token is exactly the expected one. */
    private static boolean transformedAsRequested(TokenInfo x, TokenInfo y, TransformPolicy policy,
                                                  EDbVendor vendor) {
        if (x.type != y.type) return false;
        switch (x.type) {
            case ttsqlvar:
                // The classic formatter's variable case covers @variables only.
                return policy.getVariableCase() != null
                    && y.text.equals(variableWithCase(x.text, policy.getVariableCase()));
            case ttdqstring:
                // a double-quoted text that may be a string keeps its case (DoubleQuotedStrings)
                return policy.getQuotedIdentifierCase() != null
                    && !x.mayBeString && !y.mayBeString
                    && x.text.startsWith("\"") && x.text.endsWith("\"")
                    && delimitedWithCase(x.text, policy.getQuotedIdentifierCase()).contains(y.text);
            case ttdbstring:
                return policy.getQuotedIdentifierCase() != null
                    && BRACKETS_ARE_NAMES.contains(vendor.name())
                    && x.text.startsWith("[") && x.text.endsWith("]")
                    && delimitedWithCase(x.text, policy.getQuotedIdentifierCase()).contains(y.text);
            default:
                // {...} is an ODBC escape, never a name; everything else is
                // outside every policy.
                return false;
        }
    }

    /**
     * The variable as the classic formatter cases it: the first character (the
     * {@code @} sigil) kept, the case applied to the rest; InitCap lowercases the
     * rest and then capitalizes its first character only if it is an ASCII
     * letter ({@code @@ROWCOUNT} becomes {@code @@rowcount}).
     */
    static String variableWithCase(String text, TCaseOption c) {
        if (text.isEmpty()) return text;
        String prefix = text.substring(0, 1);
        String rest = text.substring(1);
        switch (c) {
            case CoUppercase:
                return prefix + rest.toUpperCase(Locale.ROOT);
            case CoLowercase:
                return prefix + rest.toLowerCase(Locale.ROOT);
            case CoInitCap: {
                String lower = rest.toLowerCase(Locale.ROOT);
                if (!lower.isEmpty() && lower.charAt(0) >= 'a' && lower.charAt(0) <= 'z') {
                    lower = Character.toUpperCase(lower.charAt(0)) + lower.substring(1);
                }
                return prefix + lower;
            }
            default:
                return text;
        }
    }

    /**
     * The delimited name with {@code c} applied inside its delimiters. For
     * InitCap the two engines differ, so both forms are accepted: the classic
     * formatter capitalizes the first letter inside the delimiters; GSP's
     * {@code CapitalisationProcessor} capitalizes the first character of the
     * token (the delimiter) and each character after a space.
     */
    static List<String> delimitedWithCase(String text, TCaseOption c) {
        if (text.length() < 2) return new ArrayList<String>();
        String inner = text.substring(1, text.length() - 1);
        String classic = text.charAt(0) + withCase(inner, c) + text.charAt(text.length() - 1);
        if (c != TCaseOption.CoInitCap) return Arrays.asList(classic);
        StringBuilder gsp = new StringBuilder(text.length());
        char prev = ' ';
        for (char ch : text.toCharArray()) {
            gsp.append(ch != ' ' && prev == ' ' ? Character.toUpperCase(ch) : Character.toLowerCase(ch));
            prev = ch;
        }
        return Arrays.asList(classic, gsp.toString());
    }

    private static String withCase(String s, TCaseOption c) {
        switch (c) {
            case CoUppercase:
                return s.toUpperCase(Locale.ROOT);
            case CoLowercase:
                return s.toLowerCase(Locale.ROOT);
            case CoInitCap:
                return s.isEmpty() ? s
                    : s.substring(0, 1).toUpperCase(Locale.ROOT) + s.substring(1).toLowerCase(Locale.ROOT);
            default:
                return s;
        }
    }

    /**
     * Comments that are code, not commentary: optimizer hints ({@code /*+},
     * Oracle {@code --+}) and MySQL executable comments ({@code /*!}). No
     * policy lets them change or disappear.
     */
    private static boolean isProtectedComment(TokenInfo t) {
        return t.text.startsWith("/*+") || t.text.startsWith("--+") || t.text.startsWith("/*!");
    }

    /**
     * Comments: byte-exact and in order, unless the policy allows compact
     * mode's rewrite of ordinary {@code --} comments or the removal of every
     * comment that is not code.
     */
    private static boolean compareComments(List<TokenInfo> a, List<TokenInfo> b, TransformPolicy policy) {
        if (compareSequences(a, b, false)) return true;
        if (policy.isRemoveComments()) {
            List<TokenInfo> kept = new ArrayList<TokenInfo>();
            for (TokenInfo t : a) {
                if (isProtectedComment(t)) kept.add(t);
            }
            if (compareSequences(kept, b, false)) return true;
        }
        if (policy.isCompactComments() && a.size() == b.size()) {
            for (int i = 0; i < a.size(); i++) {
                TokenInfo x = a.get(i);
                TokenInfo y = b.get(i);
                if (x.type == y.type && x.text.equals(y.text)) continue;
                if (!compactRewrite(x, y)) return false;
            }
            return true;
        }
        return false;
    }

    /**
     * Whether {@code y} is compact mode's rewrite of the line comment {@code x}:
     * {@code -- body} as {@code /* -- body *}{@code /} or {@code /* -- body*}{@code /},
     * with the body as written or without its trailing blanks. Only ordinary
     * {@code --} comments qualify: not hints ({@code --+}), not {@code #} or
     * {@code //} comments, and not a body that would close the block early.
     */
    private static boolean compactRewrite(TokenInfo x, TokenInfo y) {
        if (x.type != ETokenType.ttsimplecomment || y.type != ETokenType.ttbracketedcomment) return false;
        if (!x.text.startsWith("--") || isProtectedComment(x) || x.text.contains("*/")) return false;
        String body = x.text;
        int end = body.length();
        while (end > 0 && (body.charAt(end - 1) == '\n' || body.charAt(end - 1) == '\r')) end--;
        body = body.substring(0, end);
        for (String b : Arrays.asList(body, rtrim(body))) {
            if (y.text.equals("/* " + b + " */") || y.text.equals("/* " + b + "*/")) return true;
        }
        return false;
    }

    private static String rtrim(String s) {
        int end = s.length();
        while (end > 0 && Character.isWhitespace(s.charAt(end - 1))) end--;
        return s.substring(0, end);
    }

    private static boolean compareSequences(List<TokenInfo> a, List<TokenInfo> b,
                                            boolean caseInsensitive) {
        if (a.size() != b.size()) return false;
        for (int i = 0; i < a.size(); i++) {
            if (!tokensEquivalent(a.get(i), b.get(i), caseInsensitive)) {
                return false;
            }
        }
        return true;
    }

    /** Lightweight value carrier for comparable tokens. */
    private static final class TokenInfo {
        final ETokenType type;
        final String text;
        /** A double-quoted text that may be a string rather than a name. */
        final boolean mayBeString;
        TokenInfo(ETokenType type, String text, boolean mayBeString) {
            this.type = type;
            this.text = text;
            this.mayBeString = mayBeString;
        }
    }

    /** Tokenization result split into solid tokens and comments. */
    private static final class SplitTokens {
        final List<TokenInfo> solids;
        final List<TokenInfo> comments;
        SplitTokens(List<TokenInfo> solids, List<TokenInfo> comments) {
            this.solids = solids;
            this.comments = comments;
        }
    }

    private static SplitTokens tokenizeSplit(String sql, EDbVendor vendor, boolean stringsAtStart) {
        TGSqlParser parser = new TGSqlParser(vendor);
        parser.sqltext = sql;
        parser.tokenizeSqltext();
        TSourceTokenList list = parser.getSourcetokenlist();
        List<TokenInfo> solids = new ArrayList<TokenInfo>(list.size());
        List<TokenInfo> comments = new ArrayList<TokenInfo>();
        long lastEmittedEnd = -1L;
        // the lexer types a double-quoted text as a delimited name even where it may be a string
        long stringsAfter = stringsAtStart ? DoubleQuotedStrings.ALL : DoubleQuotedStrings.stringsAfter(vendor, list);
        for (int i = 0; i < list.size(); i++) {
            TSourceToken t = list.get(i);
            if (t == null) continue;
            String text = t.toString();
            if (text == null || text.isEmpty()) continue;
            // Skip phantom shadowed tokens (GSP "${name}" overlap quirk —
            // see TokenCoverage Javadoc and slice S9 resume doc).
            if (TokenCoverage.isFullyShadowed(t, lastEmittedEnd)) {
                continue;
            }
            ETokenType type = t.tokentype;
            // Skip whitespace entirely.
            if (Pp2TokenStreamBuilder.isFoldable(type)) {
                continue;
            }
            TokenInfo info = new TokenInfo(type, text,
                type == ETokenType.ttdqstring && t.offset > stringsAfter);
            if (isCommentType(type)) {
                comments.add(info);
            } else {
                solids.add(info);
            }
            lastEmittedEnd = TokenCoverage.endOffset(t);
        }
        return new SplitTokens(solids, comments);
    }

    private static boolean isCommentType(ETokenType type) {
        if (type == null) return false;
        switch (type) {
            case ttsimplecomment:
            case ttbracketedcomment:
            case ttCPPComment:
                return true;
            default:
                return false;
        }
    }

    private static boolean tokensEquivalent(TokenInfo a, TokenInfo b,
                                            boolean caseInsensitive) {
        if (a.type != b.type) {
            // The Oracle lexer classifies a word at column 0 as a SQL*Plus
            // command (EXIT, SET ...) and the same word, once indented by the
            // formatter, as the PL/SQL keyword it really is: same text, only
            // the lexer's guess changed (sqllog corpus, oracle/020).
            boolean sqlplusVsKeyword = (a.type == ETokenType.ttsqlpluscmd && b.type == ETokenType.ttkeyword)
                || (a.type == ETokenType.ttkeyword && b.type == ETokenType.ttsqlpluscmd);
            return sqlplusVsKeyword && a.text.equalsIgnoreCase(b.text);
        }
        if (caseInsensitive && typeAllowsCaseChange(a.type)) {
            return a.text.equalsIgnoreCase(b.text);
        }
        return a.text.equals(b.text);
    }

    /**
     * Token types whose case may legitimately change between input and
     * output: keywords and unquoted identifiers. Everything else
     * (literals, quoted identifiers, comments, punctuation, operators)
     * is compared byte-exact even in case-insensitive mode.
     */
    private static boolean typeAllowsCaseChange(ETokenType type) {
        if (type == null) return false;
        switch (type) {
            case ttkeyword:
            case ttnonreservedkeyword:
            case ttidentifier:
                return true;
            default:
                return false;
        }
    }
}