package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.stmt.TVarDeclStmt;

import java.util.*;

/**
 * Namespace representing PL/SQL variables declared in a block.
 *
 * <p>PL/SQL blocks (<<label>>) can declare variables in their DECLARE section.
 * These variables can be referenced using the block label as a qualifier:
 * <pre>
 * &lt;&lt;main&gt;&gt;
 * DECLARE
 *   ename VARCHAR2(10) := 'KING';
 * BEGIN
 *   DELETE FROM emp WHERE ename = main.ename;  -- main.ename is the variable
 * END;
 * </pre>
 *
 * <p>This namespace allows the resolver to distinguish between PL/SQL variables
 * (like main.ename) and table columns (like emp.ename) by registering the
 * block's variables as a namespace that can be queried by the block's label.
 */
public class PlsqlVariableNamespace implements INamespace {

    /** The block label (e.g., "main" from <<main>>) */
    private final String blockLabel;

    /** Map of variable name (lowercase) -> variable declaration */
    private final Map<String, TVarDeclStmt> variables = new LinkedHashMap<>();

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

    /** Set of parameter names (lowercase) for procedure/function parameters */
    private final Set<String> parameterNames = new HashSet<>();

    /** Whether this namespace has been validated */
    private boolean validated = false;

    /**
     * Create a new PL/SQL variable namespace for a labeled block.
     *
     * @param blockLabel The block label (e.g., "main" from <<main>>)
     */
    public PlsqlVariableNamespace(String blockLabel) {
        this.blockLabel = blockLabel;
    }

    /**
     * Add a variable declaration to this namespace.
     *
     * @param varDecl The variable declaration statement
     */
    public void addVariable(TVarDeclStmt varDecl) {
        if (varDecl != null && varDecl.getElementName() != null) {
            String varName = varDecl.getElementName().toString();
            // Strip quotes from variable names (e.g., "myvar" -> myvar)
            String varNameNormalized = TBaseType.getTextWithoutQuoted(varName);
            String varNameLower = varNameNormalized.toLowerCase();
            variables.put(varNameLower, varDecl);
            // Create a ColumnSource with the variable declaration as the definition node
            // This marks the source as coming from a PL/SQL block, not a table
            ColumnSource source = new ColumnSource(this, varNameNormalized, varDecl.getElementName(), 1.0, "plsql_variable");
            columnSources.put(varNameLower, source);
        }
    }

    /**
     * Add a procedure/function parameter to this namespace.
     * Parameters are tracked separately from variables since they don't need
     * ColumnSource lineage - we only need to know if a name is a parameter
     * to filter it from column reference collection.
     *
     * @param paramName The parameter name (as String)
     */
    public void addParameter(String paramName) {
        if (paramName != null && !paramName.isEmpty()) {
            // Strip quotes from parameter names (e.g., "A1" -> A1)
            String normalized = TBaseType.getTextWithoutQuoted(paramName).toLowerCase();
            parameterNames.add(normalized);
        }
    }

    /**
     * Check if a variable with the given name exists in this block.
     *
     * @param variableName The variable name to check
     * @return true if the variable exists
     */
    public boolean hasVariable(String variableName) {
        String normalized = TBaseType.getTextWithoutQuoted(variableName).toLowerCase();
        return variables.containsKey(normalized);
    }

    @Override
    public String getDisplayName() {
        return blockLabel != null ? blockLabel : "(anonymous block)";
    }

    /**
     * Check if a name is a parameter.
     *
     * @param name The name to check
     * @return true if the name is a registered parameter
     */
    public boolean hasParameter(String name) {
        String normalized = TBaseType.getTextWithoutQuoted(name).toLowerCase();
        return parameterNames.contains(normalized);
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        // Strip quotes and normalize to lowercase for comparison
        String nameLower = TBaseType.getTextWithoutQuoted(columnName).toLowerCase();
        // Check variables, parameters, and columnSources
        if (variables.containsKey(nameLower) || parameterNames.contains(nameLower)) {
            return ColumnLevel.EXISTS;
        }
        return ColumnLevel.NOT_EXISTS;
    }

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

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

    @Override
    public TTable getFinalTable() {
        // PL/SQL variables don't have a physical table
        return null;
    }

    @Override
    public List<TTable> getAllFinalTables() {
        // PL/SQL variables don't have physical tables
        return Collections.emptyList();
    }

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

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

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

    /**
     * Get the block label.
     *
     * @return The block label
     */
    public String getBlockLabel() {
        return blockLabel;
    }

    /**
     * Get all variable declarations in this block.
     *
     * @return Unmodifiable map of variable name -> declaration
     */
    public Map<String, TVarDeclStmt> getVariables() {
        return Collections.unmodifiableMap(variables);
    }

    @Override
    public String toString() {
        return "PlsqlVariableNamespace(" + getDisplayName() +
               ", vars=" + variables.size() +
               ", params=" + parameterNames.size() + ")";
    }
}