package gudusoft.gsqlparser.resolver2.metadata;

import gudusoft.gsqlparser.EResolverType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.resolver.TMetadataCollector;
import gudusoft.gsqlparser.resolver2.context.DatabaseContextTracker;
import gudusoft.gsqlparser.sqlenv.TSQLCatalog;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLSchema;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.sqlenv.TemporaryTableSemantics;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * The tables a script declares, as the parse of each later statement sees them (Mantis 4797).
 *
 * <p>Phase 1 links a statement's columns as soon as the statement is parsed, but RESOLVER and resolver2 put the
 * script's {@code CREATE TABLE} statements into the parser's catalog only after every statement was parsed, and
 * {@link EResolverType#NONE} never does. This catalog takes each declaration when it is parsed, so Phase 1 of the
 * statements after it reads it in every resolver type. It places a declaration where resolver2 does
 * ({@link StatementMetadata}): in the context of the {@code USE} statements before it, and a routine's transient
 * table in that routine's own catalog (Mantis 4715). A {@code CREATE TABLE ... AS SELECT} has the columns of its
 * query, and a name temporary by its spelling ({@code #t}) is the same table in every database and schema.</p>
 *
 * <p>Only Phase 1 reads it, before the parser's catalog, and the parser drops it when the statements are parsed: the
 * later passes register the declarations at their positions themselves, so a {@code CREATE OR REPLACE} never takes the
 * place of a catalog table ahead of them. With no later pass the parser publishes into its catalog what resolver2
 * would ({@link #publish}). A declaration of a table the parser's catalog already holds where it would put it (caller
 * metadata, a DDL preload) is not copied unless it replaces it: Phase 1 reads that table, as resolver2 keeps it.</p>
 */
public final class ParseTimeCatalog {
    private final TSQLEnv shared;
    private final TStatementList statements;
    /** The context after the top-level statements before {@link #parsed}. */
    private final DatabaseContextTracker tracker;
    private final Set<TCustomSqlStatement> seen =
            Collections.newSetFromMap(new IdentityHashMap<TCustomSqlStatement, Boolean>());
    private int parsed;
    /** The walk of the top-level statement being parsed; null until a statement in it asks for its context. */
    private Cursor cursor;
    /** The script's declarations outside a routine's transient tables; created on the first one. */
    private TSQLEnv declared;
    private final Map<TStoredProcedureSqlStatement, TSQLEnv> routines = new IdentityHashMap<>();
    /** What {@link #publish} replays into the parser's catalog, in order. */
    private final List<TCreateTableSqlStatement> publishable = new ArrayList<>();
    private final Map<TCreateTableSqlStatement, StatementMetadata.Context> contexts = new IdentityHashMap<>();

    /**
     * @param shared     the parser's catalog
     * @param statements the parser's statements, parsed in this order
     * @param catalog    the database the script starts in, before any of its {@code USE} statements
     * @param schema     the schema the script starts in
     */
    public ParseTimeCatalog(TSQLEnv shared, TStatementList statements, String catalog, String schema) {
        this.shared = shared;
        this.statements = statements;
        this.tracker = new DatabaseContextTracker(catalog, schema);
    }

    /** The catalog of the parse {@code statement} belongs to while it is running, or null. */
    private static ParseTimeCatalog of(TCustomSqlStatement statement) {
        TGSqlParser parser = statement == null ? null : statement.getGsqlparser();
        return parser == null ? null : parser.getParseTimeCatalog();
    }

    /** Called before the top-level statement at {@code index} is parsed: the statements before it set the context. */
    public void advanceTo(int index) {
        for (; parsed < index && parsed < statements.size(); parsed++) {
            cursor = null;
            replay(statements.get(parsed));
        }
    }

    /** Feed a parsed top-level statement and the statements under it to the tracker, depth first in source order. */
    private void replay(TCustomSqlStatement root) {
        Deque<TCustomSqlStatement> pending = new ArrayDeque<>();
        pending.push(root);
        while (!pending.isEmpty()) {
            TCustomSqlStatement current = pending.pop();
            if (!seen.add(current)) continue;
            tracker.processStatement(current);
            TStatementList children = current.getStatements();
            for (int i = children.size() - 1; i >= 0; i--) {
                if (children.get(i) != null) pending.push(children.get(i));
            }
        }
    }

    /**
     * Phase 1 of a {@code CREATE TABLE}: register the declared table where the statements after it look it up.
     */
    public static void declare(TCreateTableSqlStatement create) {
        ParseTimeCatalog catalog = of(create);
        if (catalog != null && create.getTableName() != null) catalog.add(create);
    }

    /**
     * Whether {@code SELECT ... INTO target} creates a transient table of the routine it is in ({@code INTO #t}), which
     * resolver2 keeps in the routine's own catalog: a named routine's, not an anonymous block's, which runs as part of
     * the script around it.
     */
    public static boolean isRoutineTransient(TSelectSqlStatement select, TObjectName target) {
        return (target != null) && TemporaryTableSemantics.hasTransientTables(select.dbvendor)
                && TemporaryTableSemantics.isTransient(TemporaryTableSemantics.ofSelectInto(select.dbvendor, target))
                && (StatementMetadata.procedureOwner(select) != null);
    }

    /**
     * Phase 1 of {@code SELECT ... INTO} a routine's transient table ({@link #isRoutineTransient}): register it in the
     * routine's own catalog, as resolver2 does. Any other target is the parser's catalog's, where the statement
     * registers it.
     */
    public static void declareSelectInto(TSelectSqlStatement select, TObjectName target) {
        ParseTimeCatalog catalog = of(select);
        if (catalog == null || !isRoutineTransient(select, target)) return;
        StatementMetadata.Context context = catalog.contextAt(select);
        TSQLEnv local = catalog.routineCatalog(StatementMetadata.procedureOwner(select), context);
        StatementMetadata.declareQueryTable(local, target, select, context.catalog, context.schema, false);
    }

    /**
     * The table Phase 1 of {@code statement} reads under {@code database.schema.table} (the qualifiers may be empty)
     * before the parser's catalog: a transient table its routine declared before it, or a table the script declared
     * before it. Null when there is none or no parse is running.
     */
    public static TSQLTable searchTable(TCustomSqlStatement statement, String database, String schema, String table) {
        ParseTimeCatalog catalog = of(statement);
        return (catalog == null || table == null) ? null : catalog.search(statement, database, schema, table);
    }

    /**
     * Put the declarations into the parser's catalog at their positions, as resolver2 would, for a parse with no
     * later pass ({@link EResolverType#NONE}): a table declared with its columns, and a top-level {@code #t}.
     * resolver2 reads a plain {@code CREATE TABLE ... AS SELECT} from the statement, never from its catalog.
     */
    public void publish() {
        if (!shared.isEnableGetMetadataFromDDL()) return;
        for (TCreateTableSqlStatement create : publishable) {
            StatementMetadata.Context context = contexts.get(create);
            if (TMetadataCollector.registerDeclaredTable(create, shared, context.catalog, context.schema) != null) continue;
            if (isTransient(create) && (TemporaryTableSemantics.ofName(create.dbvendor, create.getTableName()) != null)) {
                StatementMetadata.declareQueryTable(shared, create.getTableName(), create.getSubQuery(),
                        context.catalog, context.schema, false);
            }
        }
    }

    private void add(TCreateTableSqlStatement create) {
        StatementMetadata.Context context = contextAt(create);
        boolean transientTable = isTransient(create);
        TStoredProcedureSqlStatement routine = transientTable ? StatementMetadata.procedureOwner(create) : null;
        if (routine != null) {
            declareInto(routineCatalog(routine, context), create, context, true);
            return;
        }
        // The recovery that parses a CREATE TABLE again declares it again.
        if (contexts.put(create, context) == null) publishable.add(create);
        if (!TMetadataCollector.replacesTable(create)
                && TMetadataCollector.findDeclaredTable(create, shared, context.catalog, context.schema) != null) {
            return;
        }
        declareInto(declaredCatalog(), create, context, transientTable);
    }

    /**
     * Put a declaration into {@code target}, a catalog of this one: the columns it declares, else the columns of its
     * query; a transient table with neither ({@code LIKE}, a copy) is a table of its own whose shape is not known.
     */
    private static void declareInto(TSQLEnv target, TCreateTableSqlStatement create, StatementMetadata.Context context,
            boolean transientTable) {
        if (TMetadataCollector.addDeclaredTable(create, target, context.catalog, context.schema) != null) return;
        boolean replace = TMetadataCollector.replacesTable(create);
        if (create.getSubQuery() == null && !transientTable) return;
        if (!replace && TMetadataCollector.findDeclaredTable(create, target, context.catalog, context.schema) != null) {
            return;
        }
        StatementMetadata.declareQueryTable(target, create.getTableName(), create.getSubQuery(), context.catalog,
                context.schema, replace);
    }

    private TSQLTable search(TCustomSqlStatement statement, String database, String schema, String table) {
        if (declared == null && routines.isEmpty()) return null;
        // A name temporary by its spelling is the same table whatever qualifies it, as resolver2 keys it.
        boolean anywhere = TemporaryTableSemantics.ofNameSegment(statement.dbvendor, table) != null;
        StatementMetadata.Context context = anywhere ? null : contextAt(statement);
        String name = nullToEmpty(database) + "." + nullToEmpty(schema) + "." + table;
        TSQLTable found = null;
        if (!routines.isEmpty()) {
            TStoredProcedureSqlStatement routine = StatementMetadata.procedureOwner(statement);
            TSQLEnv local = routine == null ? null : routines.get(routine);
            if (local != null) found = anywhere ? findAnywhere(local, table) : lookUp(local, context, name);
        }
        if (found == null && declared != null) {
            found = anywhere ? findAnywhere(declared, table) : lookUp(declared, context, name);
        }
        return found;
    }

    /** A lookup in {@code env}, a catalog of this one, in the context of the statement that reads it. */
    private static TSQLTable lookUp(TSQLEnv env, StatementMetadata.Context context, String qualifiedName) {
        env.setDefaultCatalogName(context.catalog);
        env.setDefaultSchemaName(context.schema);
        return env.searchTable(qualifiedName);
    }

    private static TSQLTable findAnywhere(TSQLEnv env, String table) {
        for (TSQLCatalog catalog : env.getCatalogList()) {
            for (TSQLSchema schema : catalog.getSchemaList()) {
                TSQLTable found = schema.findTable(table);
                if (found != null) return found;
            }
        }
        return null;
    }

    private static String nullToEmpty(String s) {
        return s == null ? "" : s;
    }

    private static boolean isTransient(TCreateTableSqlStatement create) {
        return TemporaryTableSemantics.hasTransientTables(create.dbvendor)
                && TemporaryTableSemantics.isTransient(TemporaryTableSemantics.ofDeclaration(create));
    }

    private TSQLEnv declaredCatalog() {
        if (declared == null) {
            // Not a routine's catalog: a plain environment under the parser catalog's rules and DDL gate.
            declared = new TSQLEnv(shared.getDBVendor(), shared.getIdentifierProfile()) {
                @Override public void initSQLEnv() { }
            };
            declared.setEnableGetMetadataFromDDL(shared.isEnableGetMetadataFromDDL());
        }
        return declared;
    }

    private TSQLEnv routineCatalog(TStoredProcedureSqlStatement routine, StatementMetadata.Context context) {
        TSQLEnv local = routines.get(routine);
        if (local == null) {
            local = StatementMetadata.newProcedureEnvironment(shared, context);
            routines.put(routine, local);
        }
        local.setDefaultCatalogName(context.catalog);
        local.setDefaultSchemaName(context.schema);
        return local;
    }

    /**
     * The context {@code statement} runs in: the top-level statements before it, and the statements of its own
     * top-level statement before it, in the order {@link StatementMetadata#collect} walks them.
     */
    private StatementMetadata.Context contextAt(TCustomSqlStatement statement) {
        TCustomSqlStatement top = statement.getAncestorStmt();
        if (cursor == null || cursor.root != top) cursor = new Cursor(top);
        return cursor.contextOf(statement);
    }

    /** A statement whose child statements the walk is in, with the index of the next one. */
    private static final class Frame {
        final TCustomSqlStatement statement;
        int next;

        Frame(TCustomSqlStatement statement) {
            this.statement = statement;
        }
    }

    /**
     * The walk of a top-level statement {@link StatementMetadata#collect} makes, depth first in source order, taken as
     * far as its statements are parsed and resumed as more are. A statement keeps the context the walk reached it in,
     * so the walk is made once however often its statements ask.
     */
    private final class Cursor {
        final TCustomSqlStatement root;
        /** The context after the statements visited so far. */
        private final DatabaseContextTracker at =
                new DatabaseContextTracker(tracker.getCurrentDatabase(), tracker.getCurrentSchemaComponent());
        /** The statements from the root down to the last one visited. */
        private final List<Frame> path = new ArrayList<>();
        private final Map<TCustomSqlStatement, StatementMetadata.Context> reached = new IdentityHashMap<>();
        private StatementMetadata.Context current;

        Cursor(TCustomSqlStatement root) {
            this.root = root;
            visit(root);
        }

        StatementMetadata.Context contextOf(TCustomSqlStatement statement) {
            StatementMetadata.Context context = reached.get(statement);
            while (context == null && advance()) context = reached.get(statement);
            // A statement the walk cannot reach yet runs after every statement parsed so far.
            return context != null ? context : current;
        }

        /** Visit the next statement parsed so far; false when the walk has reached every one. */
        boolean advance() {
            for (int depth = path.size() - 1; depth >= 0; depth--) {
                Frame frame = path.get(depth);
                TStatementList children = frame.statement.getStatements();
                while (frame.next < children.size()) {
                    TCustomSqlStatement child = children.get(frame.next++);
                    if (child == null || reached.containsKey(child)) continue;
                    // A later sibling is parsed after the statements under the one before it.
                    while (path.size() > depth + 1) path.remove(path.size() - 1);
                    visit(child);
                    return true;
                }
            }
            return false;
        }

        private void visit(TCustomSqlStatement statement) {
            // A statement an earlier top-level statement holds too was walked there.
            if (!seen.contains(statement)) at.processStatement(statement);
            current = StatementMetadata.contextOf(at, statement.dbvendor, shared);
            reached.put(statement, current);
            path.add(new Frame(statement));
        }
    }
}