package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.nodes.TBlockSqlNode;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.namespace.PlsqlVariableNamespace;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Scope for PL/SQL blocks (Oracle, PostgreSQL PL/pgSQL).
 *
 * <p>PL/SQL blocks can have labels (<<label_name>>) that allow referencing
 * variables declared within the block using the 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 references the block variable
 * END;
 * </pre>
 *
 * <p>This scope:
 * <ul>
 *   <li>Contains a PlsqlVariableNamespace for declared variables</li>
 *   <li>Uses the block label as the namespace alias</li>
 *   <li>Allows name resolution to distinguish block variables from table columns</li>
 * </ul>
 */
public class PlsqlBlockScope extends AbstractScope {

    /** The block node (may be null for stored procedures) */
    private final TBlockSqlNode blockNode;

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

    /** Namespace containing declared PL/SQL variables */
    private final PlsqlVariableNamespace variableNamespace;

    /** Child scopes (for nested statements) */
    private final List<ScopeChild> children = new ArrayList<>();

    /** Counter for child ordinals */
    private int childOrdinal = 0;

    /**
     * Create a new PL/SQL block scope for a labeled block.
     *
     * @param parent The parent scope
     * @param blockNode The block AST node (TBlockSqlNode)
     */
    public PlsqlBlockScope(IScope parent, TBlockSqlNode blockNode) {
        super(parent, blockNode, ScopeType.PLSQL_BLOCK);
        this.blockNode = blockNode;

        // Extract block label from the node
        String label = null;
        TObjectName labelName = blockNode.getLabelName();
        if (labelName != null) {
            label = labelName.toString();
            // Remove angle brackets if present (e.g., "<<main>>" -> "main")
            if (label != null) {
                if (label.startsWith("<<") && label.endsWith(">>")) {
                    label = label.substring(2, label.length() - 2);
                }
                // Also handle case where it might just be the label without brackets
                label = label.trim();
            }
        }
        this.blockLabel = label;
        this.variableNamespace = new PlsqlVariableNamespace(blockLabel);
    }

    /**
     * Create a new PL/SQL block scope for a stored procedure or function.
     * This constructor is used when there's no TBlockSqlNode (e.g., CREATE PROCEDURE).
     *
     * @param parent The parent scope
     * @param stmt The stored procedure/function statement
     * @param procedureName The name of the procedure/function (used as the block label)
     */
    public PlsqlBlockScope(IScope parent, TCustomSqlStatement stmt, String procedureName) {
        super(parent, stmt, ScopeType.PLSQL_BLOCK);
        this.blockNode = null;
        this.blockLabel = procedureName;
        this.variableNamespace = new PlsqlVariableNamespace(procedureName);
    }

    /**
     * Get the block label.
     *
     * @return The block label, or null for anonymous blocks
     */
    public String getBlockLabel() {
        return blockLabel;
    }

    /**
     * Get the variable namespace for this block.
     *
     * @return The PlsqlVariableNamespace containing declared variables
     */
    public PlsqlVariableNamespace getVariableNamespace() {
        return variableNamespace;
    }

    /**
     * Get the block node.
     *
     * @return The TBlockSqlNode AST node
     */
    public TBlockSqlNode getBlockNode() {
        return blockNode;
    }

    @Override
    public void addChild(INamespace namespace, String alias, boolean nullable) {
        children.add(new ScopeChild(childOrdinal++, alias, namespace, nullable));
    }

    @Override
    public List<ScopeChild> getChildren() {
        return children;
    }

    @Override
    public INamespace resolveTable(String tableName) {
        // First check if the table name matches our block label
        // If so, return the variable namespace
        if (blockLabel != null && blockLabel.equalsIgnoreCase(tableName)) {
            return variableNamespace;
        }

        // Otherwise delegate to parent
        return parent.resolveTable(tableName);
    }

    @Override
    public void resolve(List<String> names,
                        INameMatcher matcher,
                        boolean deep,
                        IResolved resolved) {
        // Handle unqualified variable references (e.g., dte_start_dte)
        if (names.size() == 1) {
            String name = names.get(0);
            if (variableNamespace.hasColumn(name) == gudusoft.gsqlparser.resolver2.ColumnLevel.EXISTS) {
                // This is a PL/SQL variable - mark it as resolved.
                // Pass the variable name in remainingNames so NameResolver can resolve it
                // to a ColumnSource from the PlsqlVariableNamespace.
                resolved.found(variableNamespace, false, this, null, names);
                return;
            }
        }

        // Handle qualified variable references (e.g., main.ename)
        if (names.size() >= 2 && blockLabel != null) {
            String firstName = names.get(0);
            if (matcher.matches(firstName, blockLabel)) {
                // This is a qualified reference like main.ename
                // The column name is the second part
                String columnName = names.get(1);
                if (variableNamespace.hasColumn(columnName) == gudusoft.gsqlparser.resolver2.ColumnLevel.EXISTS) {
                    // Found the variable - mark as resolved.
                    // Pass the column name in remainingNames so NameResolver can resolve it
                    // to a ColumnSource from the PlsqlVariableNamespace.
                    resolved.found(variableNamespace, false, this, null, Collections.singletonList(columnName));
                    return;
                }
            }
        }

        // Otherwise delegate to parent
        parent.resolve(names, matcher, deep, resolved);
    }

    @Override
    public List<INamespace> getVisibleNamespaces() {
        List<INamespace> namespaces = new ArrayList<>();
        namespaces.add(variableNamespace);
        namespaces.addAll(parent.getVisibleNamespaces());
        return namespaces;
    }

    @Override
    public String toString() {
        return "PlsqlBlockScope(" + (blockLabel != null ? blockLabel : "anonymous") +
               ", vars=" + variableNamespace.getVariables().size() + ")";
    }
}