package gudusoft.gsqlparser.ir.bound;

import gudusoft.gsqlparser.ir.builder.common.DynamicSqlExtraction;

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

/**
 * Aggregation root for the Bound IR phase output.
 * <p>
 * Contains all scopes, symbols, and references produced by the bound IR builder.
 */
public class BoundProgram {

    /** All scopes in the program (root scope first). */
    private final List<BoundScope> scopes;

    /** Global routine symbol table indexed by routine ID (deterministic iteration order). */
    private final Map<String, BoundRoutineSymbol> routineIndex;

    /** Multi-value index: uppercase routine name → list of routines with that name. */
    private final Map<String, List<BoundRoutineSymbol>> routinesByName;

    /** All object references found during binding. */
    private final List<BoundObjectRef> allObjectRefs;

    /** All column references found during binding. */
    private final List<BoundColumnRef> allColumnRefs;

    /** All routine references found during binding. */
    private final List<BoundRoutineRef> allRoutineRefs;

    /** Dynamic SQL extractions (sidecar collection). */
    private final List<DynamicSqlExtraction> dynamicSqlExtractions;

    /** Unsupported construct counter (dialect/feature → count). */
    private final Map<String, Integer> unsupportedCounters;

    public BoundProgram() {
        this.scopes = new ArrayList<BoundScope>();
        this.routineIndex = new LinkedHashMap<String, BoundRoutineSymbol>();
        this.routinesByName = new LinkedHashMap<String, List<BoundRoutineSymbol>>();
        this.allObjectRefs = new ArrayList<BoundObjectRef>();
        this.allColumnRefs = new ArrayList<BoundColumnRef>();
        this.allRoutineRefs = new ArrayList<BoundRoutineRef>();
        this.dynamicSqlExtractions = new ArrayList<DynamicSqlExtraction>();
        this.unsupportedCounters = new LinkedHashMap<String, Integer>();
    }

    public BoundProgram(List<BoundScope> scopes,
                        Map<String, BoundRoutineSymbol> routineIndex,
                        List<BoundObjectRef> allObjectRefs,
                        List<BoundColumnRef> allColumnRefs,
                        List<BoundRoutineRef> allRoutineRefs) {
        this.scopes = scopes != null ? scopes : new ArrayList<BoundScope>();
        this.routineIndex = routineIndex != null
                ? new LinkedHashMap<String, BoundRoutineSymbol>(routineIndex)
                : new LinkedHashMap<String, BoundRoutineSymbol>();
        this.routinesByName = new LinkedHashMap<String, List<BoundRoutineSymbol>>();
        // Rebuild the by-name index from routineIndex
        for (BoundRoutineSymbol sym : this.routineIndex.values()) {
            addToNameIndex(sym);
        }
        this.allObjectRefs = allObjectRefs != null ? allObjectRefs : new ArrayList<BoundObjectRef>();
        this.allColumnRefs = allColumnRefs != null ? allColumnRefs : new ArrayList<BoundColumnRef>();
        this.allRoutineRefs = allRoutineRefs != null ? allRoutineRefs : new ArrayList<BoundRoutineRef>();
        this.dynamicSqlExtractions = new ArrayList<DynamicSqlExtraction>();
        this.unsupportedCounters = new LinkedHashMap<String, Integer>();
    }

    public List<BoundScope> getScopes() { return scopes; }
    public Map<String, BoundRoutineSymbol> getRoutineIndex() {
        return Collections.unmodifiableMap(routineIndex);
    }
    public Map<String, List<BoundRoutineSymbol>> getRoutinesByName() {
        return Collections.unmodifiableMap(routinesByName);
    }
    public List<BoundObjectRef> getAllObjectRefs() { return allObjectRefs; }
    public List<BoundColumnRef> getAllColumnRefs() { return allColumnRefs; }
    public List<BoundRoutineRef> getAllRoutineRefs() { return allRoutineRefs; }

    public void addScope(BoundScope scope) { scopes.add(scope); }

    public void registerRoutine(BoundRoutineSymbol routine) {
        routineIndex.put(routine.getRoutineId(), routine);
        addToNameIndex(routine);
    }

    /**
     * Removes a routine by its ID. Used to merge forward declarations
     * with their implementations.
     */
    public void unregisterRoutine(String routineId) {
        BoundRoutineSymbol removed = routineIndex.remove(routineId);
        if (removed != null) {
            removeFromNameIndex(removed);
        }
    }

    private void removeFromNameIndex(BoundRoutineSymbol routine) {
        String nameKey = routine.getRoutineName().toUpperCase();
        List<BoundRoutineSymbol> list = routinesByName.get(nameKey);
        if (list != null) {
            list.remove(routine);
            if (list.isEmpty()) {
                routinesByName.remove(nameKey);
            }
        }
    }

    private void addToNameIndex(BoundRoutineSymbol routine) {
        String nameKey = routine.getRoutineName().toUpperCase();
        List<BoundRoutineSymbol> list = routinesByName.get(nameKey);
        if (list == null) {
            list = new ArrayList<BoundRoutineSymbol>();
            routinesByName.put(nameKey, list);
        }
        list.add(routine);
    }

    public void addObjectRef(BoundObjectRef ref) { allObjectRefs.add(ref); }
    public void addColumnRef(BoundColumnRef ref) { allColumnRefs.add(ref); }
    public void addRoutineRef(BoundRoutineRef ref) { allRoutineRefs.add(ref); }

    // ---- Dynamic SQL Extractions ----

    public List<DynamicSqlExtraction> getDynamicSqlExtractions() {
        return Collections.unmodifiableList(dynamicSqlExtractions);
    }

    public void addDynamicSqlExtraction(DynamicSqlExtraction extraction) {
        dynamicSqlExtractions.add(extraction);
    }

    // ---- Unsupported Construct Counters ----

    public Map<String, Integer> getUnsupportedCounters() {
        return Collections.unmodifiableMap(unsupportedCounters);
    }

    public void incrementUnsupported(String key) {
        Integer count = unsupportedCounters.get(key);
        unsupportedCounters.put(key, count != null ? count + 1 : 1);
    }

    /**
     * Looks up a routine by its ID.
     */
    public BoundRoutineSymbol lookupRoutine(String routineId) {
        return routineIndex.get(routineId);
    }

    /**
     * Replaces the entire routine ref list (used after post-resolution pass).
     */
    public void replaceRoutineRefs(List<BoundRoutineRef> resolved) {
        allRoutineRefs.clear();
        allRoutineRefs.addAll(resolved);
    }

    @Override
    public String toString() {
        return "BoundProgram{scopes=" + scopes.size()
                + ", routines=" + routineIndex.size()
                + ", objectRefs=" + allObjectRefs.size()
                + ", columnRefs=" + allColumnRefs.size()
                + ", routineRefs=" + allRoutineRefs.size()
                + ", dynamicSql=" + dynamicSqlExtractions.size() + "}";
    }
}