package gudusoft.gsqlparser.resolver2;

import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.resolver2.namespace.OraclePackageNamespace;
import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
import gudusoft.gsqlparser.stmt.TVarDeclStmt;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;

import java.util.*;

/**
 * Registry for Oracle packages encountered during scope building.
 *
 * <p>Pre-built during the initial scan of statements to allow:
 * <ul>
 *   <li>Cross-package references (pkg1 references pkg2.constant)</li>
 *   <li>Spec/body merging for complete member visibility</li>
 *   <li>O(1) lookup of package namespaces by name</li>
 * </ul>
 *
 * <p>Usage in ScopeBuilder:
 * <pre>
 * // During build() pre-traversal:
 * packageRegistry = new OraclePackageRegistry();
 * packageRegistry.buildFromStatements(statements);
 *
 * // During visitor traversal (when entering package body):
 * OraclePackageNamespace pkgNs = packageRegistry.getPackage(packageName);
 * </pre>
 */
public class OraclePackageRegistry {

    /** Map of package name (lowercase) -> OraclePackageNamespace */
    private final Map<String, OraclePackageNamespace> packagesByName = new LinkedHashMap<>();

    /** Map of qualified name (schema.package, lowercase) -> namespace */
    private final Map<String, OraclePackageNamespace> packagesByQualifiedName = new LinkedHashMap<>();

    /** Debug flag for logging */
    private boolean debug = false;

    /**
     * Create a new package registry.
     */
    public OraclePackageRegistry() {
    }

    /**
     * Enable/disable debug logging.
     *
     * @param debug true to enable debug output
     */
    public void setDebug(boolean debug) {
        this.debug = debug;
    }

    /**
     * Build the registry from a list of statements.
     * Call this during ScopeBuilder pre-traversal.
     *
     * @param statements The statement list to scan
     */
    public void buildFromStatements(TStatementList statements) {
        if (statements == null) return;

        for (int i = 0; i < statements.size(); i++) {
            TCustomSqlStatement stmt = statements.get(i);
            if (stmt instanceof TPlsqlCreatePackage) {
                processPackage((TPlsqlCreatePackage) stmt);
            }
        }
    }

    /**
     * Process a single package statement (spec or body).
     *
     * @param pkg The package statement
     */
    private void processPackage(TPlsqlCreatePackage pkg) {
        TObjectName pkgNameNode = pkg.getPackageName();
        if (pkgNameNode == null) return;

        String packageName = pkgNameNode.getObjectString();
        if (packageName == null || packageName.isEmpty()) {
            // Try to get the string representation
            packageName = pkgNameNode.toString();
            if (packageName == null || packageName.isEmpty()) return;
        }

        String schemaName = pkgNameNode.getSchemaString();
        String nameLower = packageName.toLowerCase();
        String qualifiedName = schemaName != null && !schemaName.isEmpty()
            ? (schemaName + "." + packageName).toLowerCase()
            : nameLower;

        // Get or create namespace
        OraclePackageNamespace ns = packagesByName.get(nameLower);
        if (ns == null) {
            ns = new OraclePackageNamespace(packageName, schemaName, pkg);
            packagesByName.put(nameLower, ns);
            packagesByQualifiedName.put(qualifiedName, ns);
            if (schemaName != null && !schemaName.isEmpty()) {
                // Also register without schema for unqualified lookup
                packagesByName.putIfAbsent(nameLower, ns);
            }

            if (debug) {
                System.out.println("[OraclePackageRegistry] Created namespace for package: " + packageName);
            }
        }

        // Populate members from declarations
        populatePackageMembers(ns, pkg);
    }

    /**
     * Extract and register package members from declarations.
     *
     * @param ns The namespace to populate
     * @param pkg The package AST node
     */
    private void populatePackageMembers(OraclePackageNamespace ns, TPlsqlCreatePackage pkg) {
        TStatementList declarations = pkg.getDeclareStatements();
        if (declarations == null) return;

        for (int i = 0; i < declarations.size(); i++) {
            TCustomSqlStatement decl = declarations.get(i);

            if (decl instanceof TVarDeclStmt) {
                ns.addVariable((TVarDeclStmt) decl);
                if (debug) {
                    TVarDeclStmt varDecl = (TVarDeclStmt) decl;
                    if (varDecl.getElementName() != null) {
                        System.out.println("[OraclePackageRegistry]   Added variable: " +
                            varDecl.getElementName().toString());
                    }
                }
            } else if (decl instanceof TCursorDeclStmt) {
                ns.addCursor((TCursorDeclStmt) decl);
                if (debug) {
                    TCursorDeclStmt cursorDecl = (TCursorDeclStmt) decl;
                    if (cursorDecl.getCursorName() != null) {
                        System.out.println("[OraclePackageRegistry]   Added cursor: " +
                            cursorDecl.getCursorName().toString());
                    }
                }
            }
            // Note: Nested procedures/functions are not added as they have their own scopes
        }

        // Also check body statements for package body
        if (pkg.getKind() == TBaseType.kind_create_body) {
            TStatementList bodyStatements = pkg.getBodyStatements();
            // Body statements are usually executable code, not declarations
            // But some package variables might be declared in initialization section
            // For now, we focus on declareStatements which contains the declarations
        }

        if (debug) {
            System.out.println("[OraclePackageRegistry] Package " + ns.getPackageName() +
                " now has " + ns.getMembers().size() + " members");
        }
    }

    /**
     * Look up a package namespace by name.
     *
     * @param name Package name (can be simple or qualified)
     * @return The namespace, or null if not found
     */
    public OraclePackageNamespace getPackage(String name) {
        if (name == null) return null;
        String nameLower = name.toLowerCase();

        // Try qualified name first
        OraclePackageNamespace ns = packagesByQualifiedName.get(nameLower);
        if (ns != null) return ns;

        // Fall back to simple name
        return packagesByName.get(nameLower);
    }

    /**
     * Check if a name corresponds to a known package.
     *
     * @param name The name to check
     * @return true if this is a known package
     */
    public boolean isPackage(String name) {
        return getPackage(name) != null;
    }

    /**
     * Get all registered packages.
     *
     * @return Unmodifiable collection of all packages
     */
    public Collection<OraclePackageNamespace> getAllPackages() {
        return Collections.unmodifiableCollection(packagesByName.values());
    }

    /**
     * Get the number of registered packages.
     *
     * @return The package count
     */
    public int size() {
        return packagesByName.size();
    }

    /**
     * Clear the registry.
     * Call this at reset.
     */
    public void clear() {
        packagesByName.clear();
        packagesByQualifiedName.clear();
    }

    @Override
    public String toString() {
        return "OraclePackageRegistry(packages=" + packagesByName.size() + ")";
    }
}