package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETableKind;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;

import java.util.Collection;
import java.util.Collections;

/**
 * Who can see a temporary table's definition, per vendor and declaration form.
 *
 * <p>This is the one place that decides it. resolver2 binds each table reference to the
 * definition this rule makes visible there, and the lineage model shares a table model exactly
 * when resolver2 bound two references to the same definition, so lookup and publish follow one
 * rule.</p>
 *
 * <p>A table whose definition is {@linkplain #isTransient transient} belongs to the routine body
 * (or the top-level script) that creates it. Parsing a routine is not running it, so another
 * routine never sees that definition unless a call in the analyzed SQL proves it can:</p>
 * <ul>
 *   <li>{@link Scope#CALL}: the routine that creates the table and the routines it calls, until it
 *   returns.</li>
 *   <li>{@link Scope#SESSION}: as {@code CALL}, and the table also outlives the routine, so after
 *   the call its caller sees it too.</li>
 * </ul>
 * <p>{@link Scope#CATALOG} and {@link Scope#GLOBAL} definitions are shared by every routine, as a
 * permanent table's is.</p>
 *
 * <p>Vendor rules, from each vendor's documentation:</p>
 * <ul>
 *   <li>SQL Server, Azure SQL: {@code #name} is {@code CALL} ("Temporary tables" in CREATE
 *   TABLE); {@code ##name} is {@code GLOBAL}, one live object for every session.</li>
 *   <li>SAP ASE: {@code #name} is {@code CALL}; ASE has no {@code ##} form, so {@code ##name} is
 *   another {@code #} table. {@code CREATE GLOBAL TEMPORARY TABLE} is {@code CATALOG}.</li>
 *   <li>SAP IQ, SQL Anywhere: a {@code #name} table created in a procedure outlives it (running
 *   the procedure again fails with "table already exists"), so it is {@code SESSION}, as is
 *   {@code CREATE LOCAL TEMPORARY TABLE}. {@code CREATE GLOBAL TEMPORARY TABLE} is
 *   {@code CATALOG}. {@code dbvsybase} names no single product and follows IQ.</li>
 *   <li>SAP HANA: a local temporary table ({@code #name}) is {@code SESSION}; a global temporary
 *   table is {@code CATALOG}.</li>
 *   <li>PostgreSQL, Greenplum, Redshift: {@code TEMP}/{@code TEMPORARY} is {@code SESSION};
 *   {@code GLOBAL} and {@code LOCAL} are accepted and ignored, so they are {@code SESSION} too.
 *   Redshift {@code #name} is {@code SESSION}.</li>
 *   <li>MySQL, BigQuery, Netezza: {@code TEMPORARY}/{@code TEMP} is {@code SESSION}.</li>
 *   <li>Snowflake: {@code TEMPORARY} and its synonyms ({@code LOCAL}, {@code GLOBAL},
 *   {@code VOLATILE}) are {@code SESSION}. A procedure's {@code CREATE PROCEDURE SCOPED TEMP TABLE}
 *   is not classified: GSP does not parse it yet.</li>
 *   <li>Teradata: {@code VOLATILE} is {@code SESSION}; {@code GLOBAL TEMPORARY} is
 *   {@code CATALOG}.</li>
 *   <li>Oracle: {@code GLOBAL TEMPORARY} is {@code CATALOG}; {@code PRIVATE TEMPORARY} is
 *   {@code SESSION}.</li>
 *   <li>Vertica: {@code LOCAL TEMPORARY} is {@code SESSION}; {@code GLOBAL TEMPORARY} is
 *   {@code CATALOG}, and so is plain {@code TEMPORARY}, which is global under Vertica's default
 *   {@code DefaultTempTableLocal = 0} (a server configured with 1 makes it local).</li>
 *   <li>Db2: {@code CREATE GLOBAL TEMPORARY TABLE} is {@code CATALOG}.</li>
 *   <li>GaussDB, EDB: {@code TEMP}/{@code LOCAL TEMP} is {@code SESSION}; {@code GLOBAL
 *   TEMPORARY} is {@code CATALOG}.</li>
 * </ul>
 * <p>Any other vendor or form is not classified ({@code null}): its tables are analyzed as
 * permanent tables are.</p>
 */
public final class TemporaryTableSemantics {

    /** Who can see a temporary table's definition. */
    public enum Scope {
        /** The routine that creates it and the routines it calls, until it returns. */
        CALL,
        /** As {@link #CALL}, and it outlives the routine: after the call, the caller sees it too. */
        SESSION,
        /** A persistent catalog definition that every routine and session shares; rows are per session. */
        CATALOG,
        /** One live object that every routine and session shares. */
        GLOBAL
    }

    private TemporaryTableSemantics() {
    }

    /** Whether a definition of this scope belongs to the body that creates it. */
    public static boolean isTransient(Scope scope) {
        return scope == Scope.CALL || scope == Scope.SESSION;
    }

    /** The scope a table's name alone gives it, from its SQL-lexical object segment. */
    public static Scope ofName(EDbVendor vendor, TObjectName name) {
        return name == null ? null : ofNameSegment(vendor, name.getObjectString());
    }

    /** The scope a table's name alone gives it, from one SQL-lexical object segment. */
    public static Scope ofNameSegment(EDbVendor vendor, String lexicalObjectSegment) {
        if (vendor == null || lexicalObjectSegment == null || lexicalObjectSegment.indexOf('#') < 0) {
            return null;
        }
        // The decoded object's prefix is what the vendor reads, whether or not it was delimited.
        return ofStoredName(vendor, IdentifierCodec.decodeLexical(IdentifierProfile.forVendor(vendor,
                IdentifierProfile.VendorFlags.defaults()), ESQLDataObjectType.dotTable, lexicalObjectSegment));
    }

    /** The scope a stored (decoded) table name alone gives it, or null when the name says nothing. */
    public static Scope ofStoredName(EDbVendor vendor, String storedName) {
        if (vendor == null || storedName == null || !storedName.startsWith("#")) {
            return null;
        }
        switch (vendor) {
            case dbvmssql:
            case dbvazuresql:
                return storedName.startsWith("##") ? Scope.GLOBAL : Scope.CALL;
            case dbvsybasease:
                return Scope.CALL;
            case dbvsybase:
            case dbvsybaseiq:
            case dbvsqlanywhere:
            case dbvhana:
            case dbvredshift:
                return Scope.SESSION;
            default:
                return null;
        }
    }

    /** The scope the declaration keywords ({@code TEMPORARY}, {@code VOLATILE} ...) give a table. */
    public static Scope ofKinds(EDbVendor vendor, Collection<ETableKind> kinds) {
        if (vendor == null || kinds == null || kinds.isEmpty()) {
            return null;
        }
        boolean global = kinds.contains(ETableKind.etkGlobalTemporary) || kinds.contains(ETableKind.etkGlobalTemp);
        boolean local = kinds.contains(ETableKind.etkLocalTemporary) || kinds.contains(ETableKind.etkLocalTemp);
        boolean plain = kinds.contains(ETableKind.etkTemporary) || kinds.contains(ETableKind.etkTemp);
        boolean volatileKind = kinds.contains(ETableKind.etkVolatile) || kinds.contains(ETableKind.etkLocalVolatile)
                || kinds.contains(ETableKind.etkGlobalVolatile);
        switch (vendor) {
            case dbvpostgresql:
            case dbvgreenplum:
            case dbvredshift:
                return global || local || plain ? Scope.SESSION : null;
            case dbvmysql:
            case dbvbigquery:
            case dbvnetezza:
                return local || plain ? Scope.SESSION : null;
            case dbvsnowflake:
                return global || local || plain || volatileKind ? Scope.SESSION : null;
            case dbvteradata:
                if (volatileKind) return Scope.SESSION;
                return global ? Scope.CATALOG : null;
            case dbvoracle:
                if (kinds.contains(ETableKind.etkPrivateTemporary)) return Scope.SESSION;
                return global ? Scope.CATALOG : null;
            case dbvvertica:
                if (local) return Scope.SESSION;
                return global || plain ? Scope.CATALOG : null;
            case dbvdb2:
            case dbvsybasease:
                return global ? Scope.CATALOG : null;
            case dbvhana:
            case dbvgaussdb:
            case dbvedb:
            case dbvsybase:
            case dbvsybaseiq:
            case dbvsqlanywhere:
                if (global) return Scope.CATALOG;
                return local || plain ? Scope.SESSION : null;
            default:
                return null;
        }
    }

    /** The scope of the table a CREATE TABLE statement declares, or null for a permanent table. */
    public static Scope ofDeclaration(TCreateTableSqlStatement create) {
        if (create == null || create.getTableName() == null) {
            return null;
        }
        Scope byName = ofName(create.dbvendor, create.getTableName());
        return byName != null ? byName : ofKinds(create.dbvendor, create.getTableKinds());
    }

    /**
     * The scope of the table a {@code SELECT ... INTO} target creates ({@code INTO #t},
     * {@code INTO TEMP t}), or null for a permanent table. SAP HANA's {@code SELECT ... INTO}
     * assigns variables and creates no table, so a HANA target never has one.
     */
    public static Scope ofSelectInto(EDbVendor vendor, TObjectName target) {
        if (target == null || vendor == EDbVendor.dbvhana) {
            return null;
        }
        Scope byName = ofName(vendor, target);
        if (byName != null || target.getTableKind() == null) {
            return byName;
        }
        return ofKinds(vendor, Collections.singleton(target.getTableKind()));
    }

    /** Whether a table name alone makes it transient ({@code #name} in the vendors that read it so). */
    public static boolean isTransientName(EDbVendor vendor, TObjectName name) {
        return isTransient(ofName(vendor, name));
    }

    /** Whether {@code vendor} has any transient temporary tables, so routine bodies need their own scope. */
    public static boolean hasTransientTables(EDbVendor vendor) {
        if (vendor == null) {
            return false;
        }
        switch (vendor) {
            case dbvmssql:
            case dbvazuresql:
            case dbvsybase:
            case dbvsybasease:
            case dbvsybaseiq:
            case dbvsqlanywhere:
            case dbvhana:
            case dbvredshift:
            case dbvpostgresql:
            case dbvgreenplum:
            case dbvmysql:
            case dbvbigquery:
            case dbvnetezza:
            case dbvsnowflake:
            case dbvteradata:
            case dbvoracle:
            case dbvvertica:
            case dbvgaussdb:
            case dbvedb:
                return true;
            default:
                return false;
        }
    }
}