package gudusoft.gsqlparser.pp2.token;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierCodec;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * Which double-quoted texts may be character strings rather than delimited names. Changing the case
 * of a delimited name is a formatting choice; changing the case of a string changes the data. So the
 * formatter leaves every double-quoted text this class reports as written, and pp2's content checks
 * refuse any change to one.
 *
 * <p>A double-quoted text may be a string
 * <ul>
 *   <li>anywhere, in a dialect whose identifier rules do not make a double quote a name delimiter
 *       (MDX, for one), or in which a setting the SQL does not show can make it a string: MySQL and its
 *       relatives without ANSI_QUOTES, BigQuery, Hive, Spark, Databricks, Impala, Flink, Couchbase,
 *       Informix without DELIMIDENT, Sybase with quoted_identifier off (its default), SQLite (which
 *       falls back to a string), SOQL, and Access (whose criteria take {@code "Smith"});</li>
 *   <li>after the statement that turns the quoted-identifier option off: {@code SET QUOTED_IDENTIFIER OFF},
 *       {@code SET ANSI_NULLS, QUOTED_IDENTIFIER OFF} or {@code SET ANSI_DEFAULTS OFF} (which sets
 *       QUOTED_IDENTIFIER with it) in SQL Server, Azure SQL and SQL Anywhere,
 *       {@code SET [TEMPORARY] OPTION quoted_identifier = 'Off'} in SQL Anywhere, and
 *       {@code SET SQL DIALECT 1} in Firebird, whose dialects before 3 read double quotes as strings.</li>
 * </ul>
 *
 * <p>Only the SQL text is seen. A setting it does not show is the dialect's default, which is how GSP's
 * parser reads the text too: in SQL Server and Azure SQL QUOTED_IDENTIFIER is on (Microsoft's ODBC and
 * OLE DB drivers turn it on when they connect), in SQL Anywhere quoted_identifier is on, and Firebird
 * uses dialect 3. A script for a connection that has the option off must turn it off itself; without
 * that, its double-quoted texts are names here.
 *
 * <p>A later statement that turns the option back on is not followed. In a SQL Server routine body it
 * does not change how the body is read (the setting of the batch that created the routine does), and
 * the tokens alone cannot tell a routine body from a batch; leaving a name's case as written is safe,
 * re-casing a string is not. A script that never turns the option off keeps the identifier reading.
 */
public final class DoubleQuotedStrings {

    /** No double-quoted text may be a string. */
    public static final long NONE = Long.MAX_VALUE;

    /** Every double-quoted text may be a string. */
    public static final long ALL = -1L;

    /**
     * Dialects in which a double-quoted text may be a string although their identifier profile reads it
     * as a name: a setting outside the SQL decides.
     */
    private static final Set<EDbVendor> DOUBLE_QUOTE_MAY_BE_STRING = new HashSet<EDbVendor>(Arrays.asList(
        EDbVendor.dbvmysql, EDbVendor.dbvdoris, EDbVendor.dbvstarrocks, EDbVendor.dbvoceanbase,
        EDbVendor.dbvbigquery, EDbVendor.dbvhive, EDbVendor.dbvsparksql, EDbVendor.dbvdatabricks,
        EDbVendor.dbvimpala, EDbVendor.dbvflink, EDbVendor.dbvcouchbase, EDbVendor.dbvinformix,
        EDbVendor.dbvsybase, EDbVendor.dbvsybasease, EDbVendor.dbvsybaseiq, EDbVendor.dbvsqlite,
        EDbVendor.dbvsoql, EDbVendor.dbvaccess));

    /** Dialects in which a SET statement can make the double-quoted texts after it strings. */
    private static final Set<EDbVendor> QUOTED_IDENTIFIER_OPTION = new HashSet<EDbVendor>(Arrays.asList(
        EDbVendor.dbvmssql, EDbVendor.dbvazuresql, EDbVendor.dbvsqlanywhere, EDbVendor.dbvfirebird));

    /** Per vendor ordinal: whether every double-quoted text may be a string. */
    private static volatile boolean[] everywhere;

    private DoubleQuotedStrings() {
    }

    /**
     * The offset after which every double-quoted text of {@code tokens} may be a string:
     * {@link #ALL}, the offset of the value that turns the quoted-identifier option off, or
     * {@link #NONE}. A double-quoted token may be a string when its offset is greater.
     */
    public static long stringsAfter(EDbVendor vendor, TSourceTokenList tokens) {
        if (vendor == null || tokens == null) return NONE;
        if (everywhere(vendor)) return ALL;
        if (!QUOTED_IDENTIFIER_OPTION.contains(vendor)) return NONE;
        OptionReader reader = new OptionReader();
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (t != null && reader.turnsOff(t)) return t.offset;
        }
        return NONE;
    }

    /** {@link #stringsAfter(EDbVendor, TSourceTokenList)} over a pp2 token stream. */
    public static long stringsAfter(EDbVendor vendor, Pp2TokenStream stream) {
        if (vendor == null || stream == null) return NONE;
        if (everywhere(vendor)) return ALL;
        if (!QUOTED_IDENTIFIER_OPTION.contains(vendor)) return NONE;
        OptionReader reader = new OptionReader();
        for (int i = 0; i < stream.size(); i++) {
            TSourceToken t = stream.get(i).getSourceToken();
            if (t != null && reader.turnsOff(t)) return t.offset;
        }
        return NONE;
    }

    private static boolean everywhere(EDbVendor vendor) {
        boolean[] known = everywhere;
        if (known == null) {
            EDbVendor[] all = EDbVendor.values();
            known = new boolean[all.length];
            for (EDbVendor v : all) {
                known[v.ordinal()] = DOUBLE_QUOTE_MAY_BE_STRING.contains(v) || !doubleQuoteDelimitsNames(v);
            }
            everywhere = known;
        }
        return known[vendor.ordinal()];
    }

    private static boolean doubleQuoteDelimitsNames(EDbVendor vendor) {
        try {
            IdentifierProfile profile = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
            return IdentifierCodec.isQuoted(profile, ESQLDataObjectType.dotColumn, "\"x\"");
        } catch (RuntimeException e) {
            return false;
        }
    }

    /**
     * Reads the statements that set the quoted-identifier option, one solid token at a time:
     * {@code SET option [, option ...] ON|OFF}, where QUOTED_IDENTIFIER or ANSI_DEFAULTS sets it,
     * {@code SET [EXISTING] [TEMPORARY] OPTION [owner.]option = value} and {@code SET SQL DIALECT n}.
     */
    private static final class OptionReader {
        private static final int IDLE = 0;
        /** After SET, or after SET EXISTING or SET TEMPORARY. */
        private static final int AFTER_SET = 1;
        /** After an option name of the ON|OFF form. */
        private static final int AFTER_NAME = 2;
        /** After a comma of that form's option list. */
        private static final int AFTER_COMMA = 3;
        /** After SET ... OPTION, or after the dot of a qualified option name. */
        private static final int AFTER_OPTION = 4;
        /** After the option name of the SET OPTION form. */
        private static final int AFTER_OPTION_NAME = 5;
        /** After its equals sign. */
        private static final int AFTER_EQUALS = 6;
        /** After SET SQL. */
        private static final int AFTER_SQL = 7;
        /** After SET SQL DIALECT. */
        private static final int AFTER_DIALECT = 8;

        private int state = IDLE;
        private boolean quotedIdentifier;

        /** True when {@code t} is the value that turns the quoted-identifier option off. */
        boolean turnsOff(TSourceToken t) {
            if (!t.issolidtoken()) return false;
            String text = t.toString();
            boolean word = t.tokentype == ETokenType.ttkeyword || t.tokentype == ETokenType.ttidentifier;
            switch (state) {
                case AFTER_SET:
                    if (word && (same("existing", text) || same("temporary", text))) return false;
                    if (word && same("option", text)) {
                        state = AFTER_OPTION;
                        return false;
                    }
                    if (word && same("sql", text)) {
                        state = AFTER_SQL;
                        return false;
                    }
                    if (word) {
                        quotedIdentifier = setsQuotedIdentifier(text);
                        state = AFTER_NAME;
                        return false;
                    }
                    break;
                case AFTER_SQL:
                    if (word && same("dialect", text)) {
                        state = AFTER_DIALECT;
                        return false;
                    }
                    break;
                case AFTER_DIALECT:
                    state = IDLE;
                    // dialects 1 and 2 read a double-quoted text as a string, or refuse it
                    return t.tokentype == ETokenType.ttnumber && !same("3", text);
                case AFTER_NAME:
                    if (same(",", text)) {
                        state = AFTER_COMMA;
                        return false;
                    }
                    if (word && (same("on", text) || same("off", text))) {
                        state = IDLE;
                        return quotedIdentifier && same("off", text);
                    }
                    break;
                case AFTER_COMMA:
                    if (word) {
                        quotedIdentifier |= setsQuotedIdentifier(text);
                        state = AFTER_NAME;
                        return false;
                    }
                    break;
                case AFTER_OPTION:
                    if (word) {
                        quotedIdentifier = same("quoted_identifier", text);
                        state = AFTER_OPTION_NAME;
                        return false;
                    }
                    break;
                case AFTER_OPTION_NAME:
                    if (same(".", text)) {
                        state = AFTER_OPTION;
                        return false;
                    }
                    if (same("=", text)) {
                        state = AFTER_EQUALS;
                        return false;
                    }
                    break;
                case AFTER_EQUALS:
                    state = IDLE;
                    // no value resets the option to its default, on
                    return quotedIdentifier && isValue(t) && !turnsOn(text);
                default:
                    break;
            }
            state = IDLE;
            quotedIdentifier = false;
            if (word && (t.tokencode == TBaseType.rrw_set || same("set", text))) {
                state = AFTER_SET;
            }
            return false;
        }

        /** QUOTED_IDENTIFIER, or ANSI_DEFAULTS, which sets QUOTED_IDENTIFIER with the other ISO options. */
        private static boolean setsQuotedIdentifier(String option) {
            return same("quoted_identifier", option) || same("ansi_defaults", option);
        }

        private static boolean isValue(TSourceToken t) {
            return t.tokentype == ETokenType.ttkeyword || t.tokentype == ETokenType.ttidentifier
                || t.tokentype == ETokenType.ttsqstring || t.tokentype == ETokenType.ttnumber;
        }

        /** On, Yes, True or 1, in quotes or not, turn a switch on; any other value turns it off. */
        private static boolean turnsOn(String value) {
            String v = value;
            if (v.length() >= 2 && v.charAt(0) == '\'' && v.charAt(v.length() - 1) == '\'') {
                v = v.substring(1, v.length() - 1);
            }
            return same("on", v) || same("yes", v) || same("true", v) || same("1", v);
        }

        private static boolean same(String a, String b) {
            return a.equalsIgnoreCase(b); // non-identifier-compare: keywords and option values
        }
    }
}