package gudusoft.gsqlparser.resolver2;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.scope.GlobalScope;
import gudusoft.gsqlparser.resolver2.scope.IScope;
import gudusoft.gsqlparser.resolver2.scope.SelectScope;
import gudusoft.gsqlparser.resolver2.scope.FromScope;
import gudusoft.gsqlparser.resolver2.scope.CTEScope;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.resolver2.namespace.CTENamespace;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.namespace.PivotNamespace;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

import java.util.*;

/**
 * Result of scope building by ScopeBuilder.
 * Contains the complete scope tree and column mappings.
 */
public class ScopeBuildResult {

    /** Global scope (root of scope tree) */
    private final GlobalScope globalScope;

    /** Column reference -> Scope mapping */
    private final Map<TObjectName, IScope> columnToScopeMap;

    /** All column references in order */
    private final List<TObjectName> allColumnReferences;

    /** Statement -> SelectScope mapping */
    private final Map<TSelectSqlStatement, SelectScope> statementScopeMap;

    /** USING column -> right-side TTable mapping for JOIN...USING resolution priority */
    private final Map<TObjectName, TTable> usingColumnToRightTable;

    /** USING column -> left-side TTable mapping (for reporting both tables in USING) */
    private final Map<TObjectName, TTable> usingColumnToLeftTable;

    /** TTable -> INamespace mapping for legacy compatibility (filling TTable.getAttributes()) */
    private final Map<TTable, INamespace> tableToNamespaceMap;

    /** CTAS target tables (tables being created by CREATE TABLE AS SELECT) */
    private final Set<TTable> ctasTargetTables;

    public ScopeBuildResult(GlobalScope globalScope,
                           Map<TObjectName, IScope> columnToScopeMap,
                           List<TObjectName> allColumnReferences,
                           Map<TSelectSqlStatement, SelectScope> statementScopeMap,
                           Map<TObjectName, TTable> usingColumnToRightTable) {
        this(globalScope, columnToScopeMap, allColumnReferences, statementScopeMap,
             usingColumnToRightTable, Collections.emptyMap(), Collections.emptyMap(), Collections.emptySet());
    }

    public ScopeBuildResult(GlobalScope globalScope,
                           Map<TObjectName, IScope> columnToScopeMap,
                           List<TObjectName> allColumnReferences,
                           Map<TSelectSqlStatement, SelectScope> statementScopeMap,
                           Map<TObjectName, TTable> usingColumnToRightTable,
                           Map<TObjectName, TTable> usingColumnToLeftTable) {
        this(globalScope, columnToScopeMap, allColumnReferences, statementScopeMap,
             usingColumnToRightTable, usingColumnToLeftTable, Collections.emptyMap(), Collections.emptySet());
    }

    public ScopeBuildResult(GlobalScope globalScope,
                           Map<TObjectName, IScope> columnToScopeMap,
                           List<TObjectName> allColumnReferences,
                           Map<TSelectSqlStatement, SelectScope> statementScopeMap,
                           Map<TObjectName, TTable> usingColumnToRightTable,
                           Map<TObjectName, TTable> usingColumnToLeftTable,
                           Map<TTable, INamespace> tableToNamespaceMap) {
        this(globalScope, columnToScopeMap, allColumnReferences, statementScopeMap,
             usingColumnToRightTable, usingColumnToLeftTable, tableToNamespaceMap, Collections.emptySet());
    }

    public ScopeBuildResult(GlobalScope globalScope,
                           Map<TObjectName, IScope> columnToScopeMap,
                           List<TObjectName> allColumnReferences,
                           Map<TSelectSqlStatement, SelectScope> statementScopeMap,
                           Map<TObjectName, TTable> usingColumnToRightTable,
                           Map<TObjectName, TTable> usingColumnToLeftTable,
                           Map<TTable, INamespace> tableToNamespaceMap,
                           Set<TTable> ctasTargetTables) {
        this.globalScope = globalScope;
        this.columnToScopeMap = new HashMap<>(columnToScopeMap);
        this.allColumnReferences = new ArrayList<>(allColumnReferences);
        this.statementScopeMap = new HashMap<>(statementScopeMap);
        this.usingColumnToRightTable = new HashMap<>(usingColumnToRightTable);
        this.usingColumnToLeftTable = new HashMap<>(usingColumnToLeftTable);
        this.tableToNamespaceMap = new HashMap<>(tableToNamespaceMap);
        this.ctasTargetTables = new HashSet<>(ctasTargetTables);
    }

    public GlobalScope getGlobalScope() {
        return globalScope;
    }

    public Map<TObjectName, IScope> getColumnToScopeMap() {
        return Collections.unmodifiableMap(columnToScopeMap);
    }

    public List<TObjectName> getAllColumnReferences() {
        return Collections.unmodifiableList(allColumnReferences);
    }

    /**
     * Add column references to the internal list.
     * Used by TSQLResolver2 to add cloned columns for star column tracing.
     *
     * @param columns the column references to add
     */
    public void addColumnReferences(List<TObjectName> columns) {
        allColumnReferences.addAll(columns);
    }

    public Map<TSelectSqlStatement, SelectScope> getStatementScopeMap() {
        return Collections.unmodifiableMap(statementScopeMap);
    }

    /**
     * Get the scope for a specific column reference
     */
    public IScope getScopeForColumn(TObjectName column) {
        return columnToScopeMap.get(column);
    }

    /**
     * Get the SelectScope for a specific statement
     */
    public SelectScope getScopeForStatement(TSelectSqlStatement stmt) {
        return statementScopeMap.get(stmt);
    }

    /**
     * Get the right-side table for a USING column.
     * In JOIN...USING syntax, USING columns should preferentially resolve
     * to the right-side (physical) table.
     *
     * @param column the USING column TObjectName
     * @return the right-side TTable, or null if not a USING column
     */
    public TTable getUsingColumnRightTable(TObjectName column) {
        return usingColumnToRightTable.get(column);
    }

    /**
     * Get all USING column -> right-side table mappings
     */
    public Map<TObjectName, TTable> getUsingColumnToRightTable() {
        return Collections.unmodifiableMap(usingColumnToRightTable);
    }

    /**
     * Get the left-side table for a USING column.
     * In JOIN...USING syntax, the USING column also applies to the left-side table.
     *
     * @param column the USING column TObjectName
     * @return the left-side TTable, or null if not a USING column
     */
    public TTable getUsingColumnLeftTable(TObjectName column) {
        return usingColumnToLeftTable.get(column);
    }

    /**
     * Get all USING column -> left-side table mappings
     */
    public Map<TObjectName, TTable> getUsingColumnToLeftTable() {
        return Collections.unmodifiableMap(usingColumnToLeftTable);
    }

    /**
     * Get the namespace for a specific table.
     * Used for legacy compatibility to fill TTable.getAttributes().
     *
     * @param table the TTable to look up
     * @return the INamespace for this table, or null if not found
     */
    public INamespace getNamespaceForTable(TTable table) {
        return tableToNamespaceMap.get(table);
    }

    /**
     * Get all TTable -> INamespace mappings
     */
    public Map<TTable, INamespace> getTableToNamespaceMap() {
        return Collections.unmodifiableMap(tableToNamespaceMap);
    }

    /**
     * Check if a table is a CTAS target table (table being created by CREATE TABLE AS SELECT).
     * CTAS target tables are DDL targets, not existing physical tables.
     *
     * @param table the TTable to check
     * @return true if this is a CTAS target table
     */
    public boolean isCTASTargetTable(TTable table) {
        return ctasTargetTables.contains(table);
    }

    /**
     * Get all CTAS target tables
     */
    public Set<TTable> getCTASTargetTables() {
        return Collections.unmodifiableSet(ctasTargetTables);
    }

    /**
     * Get all CTENamespaces from the scope tree.
     * Searches through all scopes to find CTE namespaces.
     *
     * @return Map of CTE name -> CTENamespace
     */
    public Map<String, CTENamespace> getCTENamespaces() {
        Map<String, CTENamespace> result = new HashMap<>();
        collectCTENamespaces(globalScope, result, new HashSet<>());
        return result;
    }

    /**
     * Recursively collect CTE namespaces from the scope tree
     */
    private void collectCTENamespaces(IScope scope, Map<String, CTENamespace> result, Set<IScope> visited) {
        if (scope == null || visited.contains(scope)) {
            return;
        }
        visited.add(scope);

        // Check if this scope has CTE namespaces as children
        for (ScopeChild child : scope.getChildren()) {
            INamespace ns = child.getNamespace();
            if (ns instanceof CTENamespace) {
                CTENamespace cteNs = (CTENamespace) ns;
                result.put(cteNs.getDisplayName(), cteNs);
            }
        }

        // If this is a SelectScope, also check FromScope
        if (scope instanceof SelectScope) {
            SelectScope selectScope = (SelectScope) scope;
            if (selectScope.getFromScope() != null) {
                collectCTENamespaces(selectScope.getFromScope(), result, visited);
            }
        }

        // Check all statementScopes
        for (SelectScope selectScope : statementScopeMap.values()) {
            if (!visited.contains(selectScope)) {
                collectCTENamespaces(selectScope, result, visited);
            }
        }
    }

    /**
     * Get all PivotNamespaces from the scope tree.
     * Searches through all scopes to find PIVOT namespaces.
     *
     * @return List of PivotNamespace objects
     */
    public List<PivotNamespace> getPivotNamespaces() {
        List<PivotNamespace> result = new ArrayList<>();
        collectPivotNamespaces(globalScope, result, new HashSet<>());
        return result;
    }

    /**
     * Recursively collect PIVOT namespaces from the scope tree
     */
    private void collectPivotNamespaces(IScope scope, List<PivotNamespace> result, Set<IScope> visited) {
        if (scope == null || visited.contains(scope)) {
            return;
        }
        visited.add(scope);

        // Check if this scope has PIVOT namespaces as children
        for (ScopeChild child : scope.getChildren()) {
            INamespace ns = child.getNamespace();
            if (ns instanceof PivotNamespace) {
                PivotNamespace pivotNs = (PivotNamespace) ns;
                result.add(pivotNs);
            }
        }

        // If this is a SelectScope, also check FromScope
        if (scope instanceof SelectScope) {
            SelectScope selectScope = (SelectScope) scope;
            if (selectScope.getFromScope() != null) {
                collectPivotNamespaces(selectScope.getFromScope(), result, visited);
            }
        }

        // Check all statementScopes
        for (SelectScope selectScope : statementScopeMap.values()) {
            if (!visited.contains(selectScope)) {
                collectPivotNamespaces(selectScope, result, visited);
            }
        }
    }

    /**
     * Get statistics about the build result
     */
    public String getStatistics() {
        return String.format(
            "ScopeBuildResult{statements=%d, columns=%d, scopes=%d}",
            statementScopeMap.size(),
            allColumnReferences.size(),
            countTotalScopes()
        );
    }

    /**
     * Count total scopes in the tree
     */
    private int countTotalScopes() {
        Set<IScope> visited = new HashSet<>();
        countScopesRecursive(globalScope, visited);
        return visited.size();
    }

    private void countScopesRecursive(IScope scope, Set<IScope> visited) {
        if (scope == null || visited.contains(scope)) {
            return;
        }
        visited.add(scope);

        // Count children from statementScopeMap
        for (SelectScope selectScope : statementScopeMap.values()) {
            if (!visited.contains(selectScope)) {
                visited.add(selectScope);
                if (selectScope.getFromScope() != null) {
                    visited.add(selectScope.getFromScope());
                }
            }
        }
    }

    /**
     * Dump scope tree for debugging
     */
    public String dumpScopeTree() {
        StringBuilder sb = new StringBuilder();
        sb.append("=== Scope Tree ===\n");
        dumpScope(globalScope, sb, 0, new HashSet<>());
        return sb.toString();
    }

    private void dumpScope(IScope scope, StringBuilder sb, int indent, Set<IScope> visited) {
        if (scope == null || visited.contains(scope)) {
            return;
        }
        visited.add(scope);

        String prefix = repeatString("  ", indent);
        sb.append(prefix).append(scope.toString()).append("\n");

        // Dump children
        for (ScopeChild child : scope.getChildren()) {
            sb.append(prefix).append("  └─ ")
              .append(child.getAlias()).append(": ")
              .append(child.getNamespace().toString()).append("\n");
        }

        // Dump nested scopes (SelectScope has FromScope)
        if (scope instanceof SelectScope) {
            SelectScope selectScope = (SelectScope) scope;
            if (selectScope.getFromScope() != null) {
                dumpScope(selectScope.getFromScope(), sb, indent + 1, visited);
            }
        }
    }

    /**
     * Dump all column references for debugging
     */
    public String dumpColumnReferences() {
        StringBuilder sb = new StringBuilder();
        sb.append("=== Column References ===\n");
        for (TObjectName col : allColumnReferences) {
            IScope scope = columnToScopeMap.get(col);
            sb.append(String.format("  %s -> %s\n",
                col.toString(),
                scope != null ? scope.getScopeType() : "null"));
        }
        return sb.toString();
    }

    @Override
    public String toString() {
        return getStatistics();
    }

    /**
     * Repeat a string n times (JDK 1.8 compatible alternative to String.repeat())
     */
    private static String repeatString(String str, int count) {
        if (count <= 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder(str.length() * count);
        for (int i = 0; i < count; i++) {
            sb.append(str);
        }
        return sb.toString();
    }
}