package gudusoft.gsqlparser.resolver2.result;

import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.ETableSource;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TCTE;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.resolver2.ScopeBuildResult;
import gudusoft.gsqlparser.resolver2.scope.IScope;
import gudusoft.gsqlparser.resolver2.scope.SelectScope;
import gudusoft.gsqlparser.resolver2.namespace.CTENamespace;
import gudusoft.gsqlparser.resolver2.model.ResolutionStatistics;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

import java.util.*;

/**
 * Default implementation of IResolutionResult.
 * Provides statement-centric query access based on ScopeBuildResult.
 */
public class ResolutionResultImpl implements IResolutionResult {

    private final ScopeBuildResult scopeBuildResult;
    private final TStatementList statements;
    private final Map<TObjectName, IScope> columnToScopeMap;
    private final List<TObjectName> allColumnReferences;

    // Lazy-initialized caches
    private Set<String> cachedTableNames;
    private Set<String> cachedFieldNames;
    private Set<String> cachedCTENames;
    private ResolutionStatistics cachedStatistics;

    public ResolutionResultImpl(ScopeBuildResult scopeBuildResult,
                                TStatementList statements) {
        this.scopeBuildResult = scopeBuildResult;
        this.statements = statements;
        this.columnToScopeMap = scopeBuildResult.getColumnToScopeMap();
        this.allColumnReferences = scopeBuildResult.getAllColumnReferences();
    }

    // ==================== Statement-level query methods ====================

    @Override
    public IScope getScope(TCustomSqlStatement stmt) {
        if (stmt instanceof TSelectSqlStatement) {
            return scopeBuildResult.getScopeForStatement((TSelectSqlStatement) stmt);
        }
        return null;
    }

    @Override
    public List<TTable> getTables(TCustomSqlStatement stmt) {
        return getTables(stmt, TableFilterOptions.DEFAULT);
    }

    @Override
    public List<TTable> getTables(TCustomSqlStatement stmt, TableFilterOptions options) {
        List<TTable> result = new ArrayList<>();

        if (stmt == null || stmt.tables == null) {
            return result;
        }

        for (int i = 0; i < stmt.tables.size(); i++) {
            TTable table = stmt.tables.getTable(i);
            if (table == null) continue;

            if (shouldIncludeTable(table, options)) {
                result.add(table);
            }
        }

        return result;
    }

    private boolean shouldIncludeTable(TTable table, TableFilterOptions options) {
        ETableSource type = table.getTableType();

        // Skip JOIN (they are containers, not actual tables)
        if (type == ETableSource.join) {
            return false;
        }

        // Subquery filter
        if (type == ETableSource.subquery && !options.isIncludeSubqueries()) {
            return false;
        }

        // CTE filter
        if (table.isCTEName() && !options.isIncludeCTEs()) {
            return false;
        }

        // Function table filter
        if (type == ETableSource.function && !options.isIncludeFunctionTables()) {
            return false;
        }

        // Physical tables only filter
        if (options.isPhysicalTablesOnly()) {
            if (type != ETableSource.objectname || table.isCTEName()) {
                return false;
            }
        }

        return true;
    }

    @Override
    public List<TObjectName> getColumns(TCustomSqlStatement stmt) {
        List<TObjectName> result = new ArrayList<>();

        for (TObjectName col : allColumnReferences) {
            if (belongsToStatement(col, stmt)) {
                result.add(col);
            }
        }

        return result;
    }

    @Override
    public List<TObjectName> getColumnsForTable(TCustomSqlStatement stmt, TTable table) {
        List<TObjectName> result = new ArrayList<>();

        for (TObjectName col : allColumnReferences) {
            if (belongsToStatement(col, stmt) && col.getSourceTable() == table) {
                result.add(col);
            }
        }

        return result;
    }

    @Override
    public List<TObjectName> getOrphanColumns(TCustomSqlStatement stmt) {
        List<TObjectName> result = new ArrayList<>();

        for (TObjectName col : allColumnReferences) {
            if (belongsToStatement(col, stmt) && col.getSourceTable() == null) {
                result.add(col);
            }
        }

        return result;
    }

    @Override
    public List<TCTE> getCTEs(TCustomSqlStatement stmt) {
        List<TCTE> result = new ArrayList<>();

        if (stmt instanceof TSelectSqlStatement) {
            TSelectSqlStatement select = (TSelectSqlStatement) stmt;
            if (select.getCteList() != null) {
                for (int i = 0; i < select.getCteList().size(); i++) {
                    TCTE cte = select.getCteList().getCTE(i);
                    if (cte != null) {
                        result.add(cte);
                    }
                }
            }
        }

        return result;
    }

    /**
     * Determine if a column belongs to the specified statement.
     */
    private boolean belongsToStatement(TObjectName col, TCustomSqlStatement stmt) {
        // First try scope mapping
        IScope scope = columnToScopeMap.get(col);
        if (scope instanceof SelectScope) {
            SelectScope selectScope = (SelectScope) scope;
            return selectScope.getNode() == stmt;
        }

        // Fall back to AST parent traversal
        return isAncestor(stmt, col);
    }

    private boolean isAncestor(TCustomSqlStatement stmt, TObjectName col) {
        Object parent = col.getParentObjectName();
        while (parent != null) {
            if (parent == stmt) {
                return true;
            }
            if (parent instanceof TParseTreeNode) {
                parent = ((TParseTreeNode) parent).getParentObjectName();
            } else {
                break;
            }
        }
        return false;
    }

    // ==================== Global access methods ====================

    @Override
    public Set<String> getAllTableNames() {
        if (cachedTableNames == null) {
            cachedTableNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
            collectAllTables(cachedTableNames);
        }
        return Collections.unmodifiableSet(cachedTableNames);
    }

    private void collectAllTables(Set<String> tables) {
        for (int i = 0; i < statements.size(); i++) {
            collectTablesRecursive(statements.get(i), tables);
        }
    }

    private void collectTablesRecursive(TCustomSqlStatement stmt, Set<String> tables) {
        if (stmt == null) return;

        for (TTable table : getTables(stmt)) {
            if (ResolutionUtils.isPhysicalTable(table)) {
                tables.add(ResolutionUtils.getFullTableName(table));
            }
        }

        for (int i = 0; i < stmt.getStatements().size(); i++) {
            collectTablesRecursive(stmt.getStatements().get(i), tables);
        }
    }

    @Override
    public Set<String> getAllFieldNames() {
        if (cachedFieldNames == null) {
            cachedFieldNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
            for (TObjectName col : allColumnReferences) {
                if (col.getSourceTable() != null) {
                    cachedFieldNames.add(ResolutionUtils.getDisplayName(col));
                }
            }
        }
        return Collections.unmodifiableSet(cachedFieldNames);
    }

    @Override
    public Set<String> getAllCTENames() {
        if (cachedCTENames == null) {
            cachedCTENames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
            Map<String, CTENamespace> cteNamespaces = scopeBuildResult.getCTENamespaces();
            if (cteNamespaces != null) {
                cachedCTENames.addAll(cteNamespaces.keySet());
            }
        }
        return Collections.unmodifiableSet(cachedCTENames);
    }

    @Override
    public List<TObjectName> getAllResolvedColumns() {
        List<TObjectName> result = new ArrayList<>();
        for (TObjectName col : allColumnReferences) {
            if (col.getSourceTable() != null) {
                result.add(col);
            }
        }
        return result;
    }

    @Override
    public List<TObjectName> getAllUnresolvedColumns() {
        List<TObjectName> result = new ArrayList<>();
        for (TObjectName col : allColumnReferences) {
            if (col.getSourceTable() == null) {
                result.add(col);
            }
        }
        return result;
    }

    @Override
    public ResolutionStatistics getStatistics() {
        if (cachedStatistics == null) {
            cachedStatistics = buildStatistics();
        }
        return cachedStatistics;
    }

    private ResolutionStatistics buildStatistics() {
        int total = allColumnReferences.size();
        int resolved = 0;
        int ambiguous = 0;
        int unresolved = 0;
        int tables = 0;

        for (TObjectName col : allColumnReferences) {
            if (col.getSourceTable() != null) {
                resolved++;
            } else {
                unresolved++;
            }
        }

        for (int i = 0; i < statements.size(); i++) {
            tables += countTablesRecursive(statements.get(i));
        }

        // Use model.ResolutionStatistics constructor:
        // (total, exact, ambiguous, unresolved, tableCount)
        return new ResolutionStatistics(total, resolved, ambiguous, unresolved, tables);
    }

    private int countTablesRecursive(TCustomSqlStatement stmt) {
        if (stmt == null) return 0;
        int count = getTables(stmt, TableFilterOptions.PHYSICAL_ONLY).size();
        for (int i = 0; i < stmt.getStatements().size(); i++) {
            count += countTablesRecursive(stmt.getStatements().get(i));
        }
        return count;
    }
}