package gudusoft.gsqlparser.ir.builder.common;

import gudusoft.gsqlparser.analyzer.v2.AnalyzerV2Config;
import gudusoft.gsqlparser.analyzer.v2.EDynamicSqlStrategy;
import gudusoft.gsqlparser.ir.bound.*;
import gudusoft.gsqlparser.ir.common.*;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TParseTreeVisitor;

import java.util.*;

/**
 * Shared base class for dialect-specific symbol collectors.
 * <p>
 * Owns mechanics only: scope stack management, routine ID tracking,
 * ref creation helpers, and source anchor utilities.
 * <p>
 * Dialect-specific behavior (which AST nodes to visit, how to classify
 * externals, how to build routine IDs) belongs in subclasses.
 */
public abstract class AbstractSymbolCollector extends TParseTreeVisitor {

    protected final BoundProgram program;
    protected final AnalyzerV2Config config;
    protected final EDynamicSqlStrategy dynamicSqlStrategy;
    protected final String fileId;

    private final Deque<BoundScope> scopeStack = new ArrayDeque<BoundScope>();
    private final Deque<String> routineIdStack = new ArrayDeque<String>();

    protected String currentPackageName;
    private String currentRoutineIdField;

    protected AbstractSymbolCollector(BoundProgram program, BoundScope globalScope,
                                      AnalyzerV2Config config, String fileId) {
        this.program = program;
        this.config = config != null ? config : AnalyzerV2Config.createDefault();
        this.dynamicSqlStrategy = this.config.dynamicSqlStrategy;
        this.fileId = fileId != null ? fileId : "";
        this.scopeStack.push(globalScope);
    }

    // ====== Scope Management ======

    protected final BoundScope currentScope() {
        return scopeStack.peek();
    }

    protected final BoundScope pushScope(EScopeKind kind, SourceAnchor anchor) {
        BoundScope scope = new BoundScope(kind, currentScope(), anchor);
        program.addScope(scope);
        scopeStack.push(scope);
        return scope;
    }

    protected final void popScope() {
        if (scopeStack.size() > 1) {
            scopeStack.pop();
        }
    }

    // ====== Routine Context ======

    protected final String currentRoutineId() {
        return currentRoutineIdField;
    }

    protected final void pushRoutineId(String routineId) {
        routineIdStack.push(routineId);
        currentRoutineIdField = routineId;
    }

    protected final void popRoutineId() {
        if (!routineIdStack.isEmpty()) {
            routineIdStack.pop();
        }
        currentRoutineIdField = routineIdStack.isEmpty() ? null : routineIdStack.peek();
    }

    // ====== Ref Creation ======

    /**
     * Creates a BoundRoutineRef and adds it to the program.
     */
    protected final BoundRoutineRef createRoutineRef(String name, List<String> parts,
                                                     Evidence evidence, Confidence confidence,
                                                     SourceAnchor anchor) {
        BoundRoutineRef ref = new BoundRoutineRef(
                name, parts,
                EBindingStatus.UNRESOLVED_SOFT, null,
                null, Collections.<BoundArgument>emptyList(),
                evidence, confidence);
        ref.setSourceAnchor(anchor);
        if (currentRoutineIdField != null) {
            ref.setProperty("owningRoutineId", currentRoutineIdField);
        }
        program.addRoutineRef(ref);
        return ref;
    }

    /**
     * Creates a BoundRoutineRef with arguments and adds it to the program.
     */
    protected final BoundRoutineRef createRoutineRef(String name, List<String> parts,
                                                     List<BoundArgument> args,
                                                     Evidence evidence, Confidence confidence,
                                                     SourceAnchor anchor) {
        BoundRoutineRef ref = new BoundRoutineRef(
                name, parts,
                EBindingStatus.UNRESOLVED_SOFT, null,
                null, args,
                evidence, confidence);
        ref.setSourceAnchor(anchor);
        if (currentRoutineIdField != null) {
            ref.setProperty("owningRoutineId", currentRoutineIdField);
        }
        program.addRoutineRef(ref);
        return ref;
    }

    /**
     * Creates a BoundObjectRef and adds it to the program.
     */
    protected final BoundObjectRef createObjectRef(String name, List<String> parts,
                                                   EObjectRefKind kind, SourceAnchor anchor) {
        BoundObjectRef ref = new BoundObjectRef(
                name, parts,
                EBindingStatus.UNRESOLVED_SOFT, null, null,
                kind, new Evidence(EvidenceKind.STATIC_RESOLVED, "Table reference"));
        ref.setSourceAnchor(anchor);
        if (currentRoutineIdField != null) {
            ref.setProperty("owningRoutineId", currentRoutineIdField);
        }
        program.addObjectRef(ref);
        return ref;
    }

    protected final void addColumnRef(BoundColumnRef ref) {
        program.addColumnRef(ref);
    }

    // ====== Utilities ======

    /**
     * Creates a SourceAnchor from an AST node, optionally including the fileId.
     */
    protected final SourceAnchor anchor(TParseTreeNode node) {
        SourceAnchor base = SourceAnchor.from(node);
        if (base != null && !fileId.isEmpty()) {
            return new SourceAnchor(fileId,
                    base.startOffset, base.endOffset,
                    base.startLine, base.startCol,
                    base.endLine, base.endCol,
                    base.statementKey, base.snippet);
        }
        return base;
    }

    /**
     * Splits a qualified name (e.g., "schema.pkg.proc") into parts.
     */
    public static List<String> splitName(String qualifiedName) {
        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return Collections.emptyList();
        }
        String[] parts = qualifiedName.split("\\.");
        List<String> result = new ArrayList<String>(parts.length);
        for (String part : parts) {
            String trimmed = part.trim();
            if (!trimmed.isEmpty()) {
                result.add(trimmed);
            }
        }
        return result;
    }

    /**
     * Builds a routine ID from name, kind code, and parameter count.
     * Uses the current package name as namespace prefix.
     */
    protected String buildRoutineId(String name, String kindCode, int paramCount) {
        StringBuilder sb = new StringBuilder();
        if (currentPackageName != null && !currentPackageName.isEmpty()) {
            sb.append(currentPackageName).append('.');
        }
        sb.append(name).append('/').append(kindCode).append('(').append(paramCount).append(')');
        return sb.toString();
    }

    // ====== Abstract Dialect Hooks ======

    /**
     * Returns true if the given name represents an external dependency
     * (built-in function, system package, etc.) for this dialect.
     */
    protected abstract boolean isExternalDependency(String name, List<String> parts);

    /**
     * Returns the routine ID string for the given routine AST node.
     */
    protected abstract String routineIdFor(Object routineNode);
}