package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
import gudusoft.gsqlparser.stmt.TVarDeclStmt;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;

import java.util.*;

/**
 * Namespace representing Oracle PL/SQL package members (variables, constants, cursors).
 *
 * <p>Package members declared in PACKAGE or PACKAGE BODY can be referenced:
 * <ul>
 *   <li>Unqualified (within package body): {@code gn_err_no}</li>
 *   <li>Qualified (anywhere): {@code pkg_name.gn_err_no}</li>
 *   <li>Schema-qualified: {@code schema.pkg_name.gn_err_no}</li>
 * </ul>
 *
 * <p>This namespace returns {@code getFinalTable() == null} since package members
 * are not table columns.
 */
public class OraclePackageNamespace implements INamespace {

    /**
     * Represents the kind of package member.
     */
    public enum MemberKind {
        VARIABLE,       // Regular variable
        CONSTANT,       // CONSTANT declaration
        CURSOR,         // Explicit cursor
        REF_CURSOR,     // REF CURSOR type/variable
        EXCEPTION       // User-defined exception
    }

    /**
     * Represents a single package member (variable, constant, cursor, etc.)
     */
    public static class PackageMember {
        public final String name;
        public final MemberKind kind;
        public final Object definitionNode;  // TVarDeclStmt, TCursorDeclStmt, etc.
        public final double confidence;
        public final String evidence;

        public PackageMember(String name, MemberKind kind, Object defNode) {
            this.name = name;
            this.kind = kind;
            this.definitionNode = defNode;
            this.confidence = 1.0;  // Always high confidence for declared members
            this.evidence = "oracle_package_" + kind.name().toLowerCase();
        }

        @Override
        public String toString() {
            return name + ":" + kind;
        }
    }

    /** Package name (simple name, e.g., "PACK_DAMAGE_AUTO_SAVE") */
    private final String packageName;

    /** Schema name (if known) */
    private final String schemaName;

    /** AST node for the package (spec or body) */
    private final TPlsqlCreatePackage packageNode;

    /** Map of member name (lowercase) -> PackageMember */
    private final Map<String, PackageMember> members = new LinkedHashMap<>();

    /** Map of column name (lowercase) -> ColumnSource for the variables */
    private final Map<String, ColumnSource> columnSources = new LinkedHashMap<>();

    /** Validation flag */
    private boolean validated = false;

    /**
     * Create a new Oracle package namespace.
     *
     * @param packageName The simple package name
     * @param schemaName The schema name (may be null)
     * @param packageNode The AST node for the package
     */
    public OraclePackageNamespace(String packageName, String schemaName,
                                   TPlsqlCreatePackage packageNode) {
        this.packageName = packageName;
        this.schemaName = schemaName;
        this.packageNode = packageNode;
    }

    /**
     * Add a variable/constant member from TVarDeclStmt.
     *
     * @param varDecl The variable declaration statement
     */
    public void addVariable(TVarDeclStmt varDecl) {
        if (varDecl == null || varDecl.getElementName() == null) return;

        String name = varDecl.getElementName().toString();
        String nameLower = name.toLowerCase();

        // Determine if it's a constant (check if declaration contains CONSTANT keyword)
        MemberKind kind = isConstantDeclaration(varDecl)
            ? MemberKind.CONSTANT
            : MemberKind.VARIABLE;

        PackageMember member = new PackageMember(name, kind, varDecl);
        members.put(nameLower, member);

        // Create ColumnSource for resolution
        ColumnSource source = new ColumnSource(this, name,
            varDecl.getElementName(), member.confidence, member.evidence);
        columnSources.put(nameLower, source);
    }

    /**
     * Add a cursor member from TCursorDeclStmt.
     *
     * @param cursorDecl The cursor declaration statement
     */
    public void addCursor(TCursorDeclStmt cursorDecl) {
        if (cursorDecl == null || cursorDecl.getCursorName() == null) return;

        String name = cursorDecl.getCursorName().toString();
        String nameLower = name.toLowerCase();

        // Determine cursor kind
        MemberKind kind = (cursorDecl.getKind() == TCursorDeclStmt.kind_ref_cursor_type_definition)
            ? MemberKind.REF_CURSOR
            : MemberKind.CURSOR;

        PackageMember member = new PackageMember(name, kind, cursorDecl);
        members.put(nameLower, member);

        ColumnSource source = new ColumnSource(this, name,
            cursorDecl.getCursorName(), member.confidence, member.evidence);
        columnSources.put(nameLower, source);
    }

    /**
     * Add a member directly by name and kind.
     * Used for adding members discovered through other means (e.g., exception declarations).
     *
     * @param name The member name
     * @param kind The member kind
     * @param definitionNode The AST node where this member is defined
     */
    public void addMember(String name, MemberKind kind, Object definitionNode) {
        if (name == null || name.isEmpty()) return;

        String nameLower = name.toLowerCase();
        PackageMember member = new PackageMember(name, kind, definitionNode);
        members.put(nameLower, member);

        // Create ColumnSource - use TObjectName if available, otherwise null
        Object defNode = null;
        if (definitionNode instanceof TObjectName) {
            defNode = definitionNode;
        }
        ColumnSource source = new ColumnSource(this, name,
            (defNode instanceof gudusoft.gsqlparser.nodes.TParseTreeNode)
                ? (gudusoft.gsqlparser.nodes.TParseTreeNode) defNode
                : null,
            member.confidence, member.evidence);
        columnSources.put(nameLower, source);
    }

    /**
     * Merge members from another package namespace (spec + body merging).
     *
     * @param other The other namespace to merge from
     */
    public void mergeFrom(OraclePackageNamespace other) {
        if (other == null) return;
        members.putAll(other.members);
        columnSources.putAll(other.columnSources);
    }

    /**
     * Check if a declaration is a CONSTANT.
     * This is a heuristic based on the variable declaration's attributes.
     */
    private boolean isConstantDeclaration(TVarDeclStmt varDecl) {
        // Check if the declaration has the isConstant flag set
        // The TVarDeclStmt may have an isConstant() method or we can check the tokens
        try {
            // Try to check via reflection or known API
            // For now, check the toString() for CONSTANT keyword
            String declText = varDecl.toString();
            if (declText != null) {
                String upperText = declText.toUpperCase();
                // Look for CONSTANT keyword after the variable name
                int nameEnd = declText.indexOf(varDecl.getElementName().toString());
                if (nameEnd > 0) {
                    String afterName = upperText.substring(nameEnd);
                    return afterName.contains("CONSTANT");
                }
            }
        } catch (Exception e) {
            // Ignore and default to VARIABLE
        }
        return false;
    }

    // === INamespace Implementation ===

    @Override
    public String getDisplayName() {
        return schemaName != null
            ? schemaName + "." + packageName
            : packageName;
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        return members.containsKey(columnName.toLowerCase())
            ? ColumnLevel.EXISTS
            : ColumnLevel.NOT_EXISTS;
    }

    @Override
    public ColumnSource resolveColumn(String columnName) {
        return columnSources.get(columnName.toLowerCase());
    }

    @Override
    public Map<String, ColumnSource> getAllColumnSources() {
        return Collections.unmodifiableMap(columnSources);
    }

    @Override
    public TTable getFinalTable() {
        return null;  // Package members are NOT table columns
    }

    @Override
    public List<TTable> getAllFinalTables() {
        return Collections.emptyList();
    }

    @Override
    public boolean isValidated() {
        return validated;
    }

    @Override
    public void validate() {
        validated = true;
    }

    @Override
    public Object getNode() {
        return packageNode;
    }

    // === Accessors ===

    /**
     * Get the package name.
     *
     * @return The simple package name
     */
    public String getPackageName() {
        return packageName;
    }

    /**
     * Get the schema name.
     *
     * @return The schema name, or null if not specified
     */
    public String getSchemaName() {
        return schemaName;
    }

    /**
     * Get all members in this package.
     *
     * @return Unmodifiable map of member name (lowercase) -> PackageMember
     */
    public Map<String, PackageMember> getMembers() {
        return Collections.unmodifiableMap(members);
    }

    /**
     * Check if this package has a member with the given name.
     *
     * @param name The member name to check
     * @return true if the member exists
     */
    public boolean hasMember(String name) {
        return name != null && members.containsKey(name.toLowerCase());
    }

    /**
     * Get a specific member by name.
     *
     * @param name The member name
     * @return The PackageMember, or null if not found
     */
    public PackageMember getMember(String name) {
        return name != null ? members.get(name.toLowerCase()) : null;
    }

    @Override
    public String toString() {
        return "OraclePackageNamespace(" + getDisplayName() +
               ", members=" + members.size() + ")";
    }
}