package gudusoft.gsqlparser.stmt.snowflake;

import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;

/**
 * Which object a keyword-less Snowflake {@code USE} switches — MantisBT 4677.
 *
 * <p>Snowflake makes the object keyword optional on both sides, so
 * {@code USE a} and {@code USE a.b} must be told apart without one. The rule
 * comes from the USE SCHEMA reference: <em>"The SCHEMA keyword is optional if
 * the schema name is fully qualified (in the form of db_name.schema_name)"</em>.
 * Combined with USE DATABASE's own optional keyword:
 *
 * <ul>
 *   <li>unqualified name → {@link #DATABASE}</li>
 *   <li>qualified name   → {@link #SCHEMA}</li>
 * </ul>
 *
 * <p><b>Why this lives in one class.</b> Two independent code paths need the
 * answer: the statement splitter picks the statement class <em>before</em>
 * parsing, and the grammar action stamps the {@code EDbObjectType} that drives
 * {@code TUseDatabase.isSchema()} and resolver2's {@code DatabaseContextTracker}.
 * Two separate implementations drifted apart twice during this fix (once via a
 * part-count that is never populated, once on the {@code IDENTIFIER(...)}
 * form), and a disagreement is invisible through the public API — the class
 * says one thing, the node says another, and nothing reports it. Both callers
 * now pass the same evidence (the token list plus the position of the
 * {@code USE} token) to {@link #of}, so there is exactly one rule.
 */
public enum SnowflakeUseTarget {
    DATABASE,
    SCHEMA;

    /**
     * Classify a keyword-less {@code USE}. Callers must have already ruled out
     * the explicit forms ({@code USE DATABASE/SCHEMA/ROLE/WAREHOUSE ...}).
     *
     * @param tokens the statement's token list
     * @param usePos position of the {@code USE} token within {@code tokens}
     * @return {@link #SCHEMA} when the name is qualified, else {@link #DATABASE}
     */
    public static SnowflakeUseTarget of(TSourceTokenList tokens, int usePos) {
        if (tokens == null) {
            return DATABASE;
        }
        TSourceToken first = tokens.nextsolidtoken(usePos, 1, false);
        if (first == null) {
            return DATABASE;
        }
        if ("IDENTIFIER".equalsIgnoreCase(first.toString())) { // non-identifier-compare: function keyword token text, not an object name
            return ofIdentifierCall(tokens, usePos);
        }
        // Plain name. A qualified one separates its parts with a dot TOKEN, so a
        // delimited identifier that merely CONTAINS a dot ("my.db") is a single
        // token and correctly stays unqualified.
        TSourceToken afterName = tokens.nextsolidtoken(usePos, 2, false);
        return (afterName != null && ".".equals(afterName.toString()))
                ? SCHEMA : DATABASE;
    }

    /**
     * {@code USE IDENTIFIER(<arg>)} — Snowflake's way of supplying an object
     * name as a value, so the name can be computed rather than written out.
     *
     * <p>The dot that would qualify the name lives INSIDE the argument, not in
     * the token stream, so the plain-name rule cannot see it and would call
     * every such statement a database switch.
     *
     * <ul>
     *   <li>A string literal argument is known at parse time and is decided
     *       properly: {@code IDENTIFIER('D1.S2')} is a schema switch.</li>
     *   <li>A session variable or bind ({@code IDENTIFIER($db)},
     *       {@code IDENTIFIER(?)}) has no value until run time, so the form is
     *       genuinely undecidable statically. It falls back to
     *       {@link #DATABASE} — the documented limitation, matching the bare
     *       {@code USE <name>} default rather than inventing a guess.</li>
     * </ul>
     */
    private static SnowflakeUseTarget ofIdentifierCall(TSourceTokenList tokens, int usePos) {
        TSourceToken open = tokens.nextsolidtoken(usePos, 2, false);
        TSourceToken arg = tokens.nextsolidtoken(usePos, 3, false);
        if (open == null || arg == null || !"(".equals(open.toString())) {
            return DATABASE;
        }
        String body = literalBody(arg.toString());
        if (body == null) {
            // Not a literal: value unknown until run time.
            return DATABASE;
        }
        return nameIsQualified(body) ? SCHEMA : DATABASE;
    }

    /**
     * Strip a string literal's delimiters and return its content, or
     * {@code null} when the token is not a literal at all (a session variable
     * or a bind, whose value only exists at run time).
     *
     * <p>Snowflake accepts both spellings, and the dollar-quoted forms are just
     * as knowable at parse time as the single-quoted one:
     * {@code 'D1.S2'}, {@code $$D1.S2$$}, and the tagged {@code $tag$D1.S2$tag$}.
     * Testing only for a leading quote would send every dollar-quoted name down
     * the "unknown at parse time" path and misclassify it as a database.
     */
    private static String literalBody(String text) {
        if (text == null || text.length() < 2) {
            return null;
        }
        if (text.charAt(0) == '\'' && text.charAt(text.length() - 1) == '\'') {
            return text.substring(1, text.length() - 1);
        }
        if (text.charAt(0) == '$') {
            // $tag$...$tag$ (tag may be empty, giving $$...$$).
            int open = text.indexOf('$', 1);
            if (open < 0) {
                return null;
            }
            String delimiter = text.substring(0, open + 1);
            if (text.length() >= 2 * delimiter.length()
                    && text.endsWith(delimiter)) {
                return text.substring(delimiter.length(),
                        text.length() - delimiter.length());
            }
        }
        return null;
    }

    /**
     * Is a bare name qualified? Scans for a dot outside any delimited
     * identifier, so {@code "my.db"} stays unqualified for the same reason
     * {@code USE "my.db"} does.
     */
    private static boolean nameIsQualified(String body) {
        boolean inQuotes = false;
        for (int i = 0; i < body.length(); i++) {
            char c = body.charAt(i);
            if (c == '"') {
                inQuotes = !inQuotes;
            } else if (c == '.' && !inQuotes) {
                return true;
            }
        }
        return false;
    }
}