package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.QualifiedName;
import gudusoft.gsqlparser.resolver2.model.QualifiedNameResolver;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

import java.util.*;

/**
 * Global scope - contains session-level objects and metadata.
 * This is typically the root of the scope tree.
 *
 * <p>Responsibilities:
 * <ol>
 *   <li>Access to global metadata (SQLEnv)</li>
 *   <li>Database/schema context with proper qualified name resolution</li>
 *   <li>Session variables and settings</li>
 * </ol>
 *
 * <h3>Qualified Name Resolution</h3>
 * <p>When resolving table names, this scope uses {@link QualifiedNameResolver}
 * to properly handle partial names (e.g., just "table" or "schema.table")
 * by applying default catalog/schema from {@link TSQLEnv}.
 *
 * <p>Example: With default catalog="mydb" and schema="dbo":
 * <ul>
 *   <li>"users" matches "mydb.dbo.users"</li>
 *   <li>"hr.employees" matches "mydb.hr.employees"</li>
 *   <li>"otherdb.hr.employees" matches exactly</li>
 * </ul>
 *
 * @see QualifiedNameResolver
 * @see QualifiedName
 */
public class GlobalScope extends AbstractScope {

    /** Global context from parser */
    private final TContext globalContext;

    /** Name matcher for this session */
    private final INameMatcher nameMatcher;

    /** SQL environment containing default catalog/schema */
    private TSQLEnv sqlEnv;

    /** Database vendor for qualified name parsing */
    private EDbVendor vendor;

    /** Qualified name resolver for normalizing table references */
    private QualifiedNameResolver qualifiedNameResolver;

    /** Schema-qualified tables available globally, keyed by normalized qualified name */
    private final Map<String, INamespace> globalTables = new HashMap<>();

    /** Maps normalized qualified names to their QualifiedName objects for matching */
    private final Map<String, QualifiedName> globalTableQualifiedNames = new HashMap<>();

    public GlobalScope(TContext globalContext, INameMatcher nameMatcher) {
        super(EmptyScope.INSTANCE, null, ScopeType.GLOBAL);
        this.globalContext = globalContext;
        this.nameMatcher = nameMatcher;
        this.vendor = EDbVendor.dbvoracle; // Default
    }

    /**
     * Create a GlobalScope with SQL environment for qualified name resolution.
     *
     * @param globalContext The global parser context
     * @param nameMatcher The name matcher for case sensitivity
     * @param sqlEnv The SQL environment with default catalog/schema
     * @param vendor The database vendor
     */
    public GlobalScope(TContext globalContext, INameMatcher nameMatcher,
                       TSQLEnv sqlEnv, EDbVendor vendor) {
        super(EmptyScope.INSTANCE, null, ScopeType.GLOBAL);
        this.globalContext = globalContext;
        this.nameMatcher = nameMatcher;
        this.sqlEnv = sqlEnv;
        this.vendor = vendor;
        this.qualifiedNameResolver = new QualifiedNameResolver(sqlEnv, vendor);
    }

    /**
     * Set the SQL environment for qualified name resolution.
     *
     * @param sqlEnv The SQL environment with default catalog/schema
     */
    public void setSqlEnv(TSQLEnv sqlEnv) {
        this.sqlEnv = sqlEnv;
        this.qualifiedNameResolver = new QualifiedNameResolver(sqlEnv, vendor);
    }

    /**
     * Get the SQL environment.
     */
    public TSQLEnv getSqlEnv() {
        return sqlEnv;
    }

    /**
     * Set the database vendor.
     */
    public void setVendor(EDbVendor vendor) {
        this.vendor = vendor;
        if (sqlEnv != null) {
            this.qualifiedNameResolver = new QualifiedNameResolver(sqlEnv, vendor);
        }
    }

    /**
     * Get the database vendor.
     */
    public EDbVendor getVendor() {
        return vendor;
    }

    /**
     * Add a globally accessible table (from metadata).
     *
     * <p>The qualified name should be in the format "catalog.schema.table"
     * or "schema.table" or just "table". The name will be parsed and stored
     * for proper matching later.
     *
     * @param qualifiedNameStr The qualified table name string
     * @param tableNamespace The namespace representing the table
     */
    public void addGlobalTable(String qualifiedNameStr, INamespace tableNamespace) {
        globalTables.put(qualifiedNameStr, tableNamespace);

        // Parse the qualified name string for proper matching
        QualifiedName qName = parseQualifiedNameString(qualifiedNameStr);
        if (qName != null) {
            globalTableQualifiedNames.put(qualifiedNameStr, qName);
        }
    }

    /**
     * Add a globally accessible table with explicit catalog/schema/name.
     *
     * @param catalog The catalog name (nullable)
     * @param schema The schema name (nullable)
     * @param tableName The table name (required)
     * @param tableNamespace The namespace representing the table
     */
    public void addGlobalTable(String catalog, String schema, String tableName,
                               INamespace tableNamespace) {
        QualifiedName qName = QualifiedName.forTable(catalog, schema, tableName);
        String key = qName.toString();
        globalTables.put(key, tableNamespace);
        globalTableQualifiedNames.put(key, qName);
    }

    /**
     * Parse a qualified name string into a QualifiedName object.
     */
    private QualifiedName parseQualifiedNameString(String qualifiedNameStr) {
        if (qualifiedNameStr == null || qualifiedNameStr.isEmpty()) {
            return null;
        }

        // Use QualifiedNameResolver if available
        if (qualifiedNameResolver != null) {
            return qualifiedNameResolver.resolve(qualifiedNameStr);
        }

        // Fallback: simple dot-split parsing
        String[] parts = qualifiedNameStr.split("\\.");
        if (parts.length == 1) {
            return QualifiedName.forTable(parts[0]);
        } else if (parts.length == 2) {
            return QualifiedName.forTable(parts[0], parts[1]);
        } else if (parts.length >= 3) {
            return QualifiedName.forTable(parts[0], parts[1], parts[2]);
        }
        return null;
    }

    @Override
    public INamespace resolveTable(String tableName) {
        if (tableName == null || tableName.isEmpty()) {
            return super.resolveTable(tableName);
        }

        // Parse the input table name into a QualifiedName
        QualifiedName inputQName = parseQualifiedNameString(tableName);
        if (inputQName == null) {
            return super.resolveTable(tableName);
        }

        // Apply defaults to get the fully qualified search name
        String defaultCatalog = getDefaultCatalog();
        String defaultSchema = getDefaultSchema();
        QualifiedName normalizedInput = inputQName.withDefaults(defaultCatalog, defaultSchema);

        // Look for matching table in global tables
        for (Map.Entry<String, QualifiedName> entry : globalTableQualifiedNames.entrySet()) {
            String key = entry.getKey();
            QualifiedName storedQName = entry.getValue();

            // Apply defaults to stored name for comparison
            QualifiedName normalizedStored = storedQName.withDefaults(defaultCatalog, defaultSchema);

            // Check for match using proper qualified name comparison
            if (matchesQualifiedName(normalizedInput, normalizedStored)) {
                return globalTables.get(key);
            }
        }

        // Fallback: legacy matching for backward compatibility
        for (Map.Entry<String, INamespace> entry : globalTables.entrySet()) {
            String qualifiedName = entry.getKey();
            if (nameMatcher.matches(qualifiedName, tableName)) {
                return entry.getValue();
            }
        }

        // Not found in global scope
        return super.resolveTable(tableName);
    }

    /**
     * Check if two qualified names match.
     *
     * <p>Matching rules:
     * <ul>
     *   <li>Table names must match (case-insensitive by default)</li>
     *   <li>If both have schemas, schemas must match</li>
     *   <li>If both have catalogs, catalogs must match</li>
     * </ul>
     */
    private boolean matchesQualifiedName(QualifiedName input, QualifiedName stored) {
        // Table names must match
        String inputName = input.getTableName();
        String storedName = stored.getTableName();
        if (inputName == null || storedName == null) {
            return false;
        }
        if (!nameMatcher.matches(inputName, storedName)) {
            return false;
        }

        // If both have schemas, they must match
        String inputSchema = input.getSchema();
        String storedSchema = stored.getSchema();
        if (inputSchema != null && storedSchema != null) {
            if (!nameMatcher.matches(inputSchema, storedSchema)) {
                return false;
            }
        }

        // If both have catalogs, they must match
        String inputCatalog = input.getCatalog();
        String storedCatalog = stored.getCatalog();
        if (inputCatalog != null && storedCatalog != null) {
            if (!nameMatcher.matches(inputCatalog, storedCatalog)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Get the default catalog from SQL environment.
     */
    public String getDefaultCatalog() {
        if (sqlEnv != null) {
            return sqlEnv.getDefaultCatalogName();
        }
        return null;
    }

    /**
     * Get the default schema from SQL environment.
     */
    public String getDefaultSchema() {
        if (sqlEnv != null) {
            return sqlEnv.getDefaultSchemaName();
        }
        return null;
    }

    @Override
    public void resolve(List<String> names,
                       INameMatcher matcher,
                       boolean deep,
                       IResolved resolved) {
        if (names == null || names.isEmpty()) {
            super.resolve(names, matcher, deep, resolved);
            return;
        }

        // Build a qualified name from the parts
        String tableName;
        if (names.size() == 1) {
            tableName = names.get(0);
        } else if (names.size() == 2) {
            tableName = names.get(0) + "." + names.get(1);
        } else {
            tableName = names.get(0) + "." + names.get(1) + "." + names.get(2);
        }

        // Try to resolve as a table
        INamespace tableNs = resolveTable(tableName);
        if (tableNs != null) {
            // Report found with proper parameters
            resolved.found(tableNs, false, this, null, java.util.Collections.emptyList());
            return;
        }

        // Not found - delegate to parent
        super.resolve(names, matcher, deep, resolved);
    }

    @Override
    public List<INamespace> getVisibleNamespaces() {
        return new ArrayList<>(globalTables.values());
    }

    public TContext getGlobalContext() {
        return globalContext;
    }

    public INameMatcher getNameMatcher() {
        return nameMatcher;
    }

    /**
     * Get the qualified name resolver.
     */
    public QualifiedNameResolver getQualifiedNameResolver() {
        return qualifiedNameResolver;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("GlobalScope(tables=");
        sb.append(globalTables.size());
        if (sqlEnv != null) {
            String defCatalog = getDefaultCatalog();
            String defSchema = getDefaultSchema();
            if (defCatalog != null || defSchema != null) {
                sb.append(", defaults=");
                sb.append(defCatalog != null ? defCatalog : "*");
                sb.append(".");
                sb.append(defSchema != null ? defSchema : "*");
            }
        }
        sb.append(")");
        return sb.toString();
    }
}