package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;

import java.util.*;

/**
 * Global context for resolution results.
 * Provides efficient querying and statistics about resolved columns.
 *
 * Design principles:
 * 1. Reverse indexing for O(1) queries
 * 2. Categorized storage for quick access to different resolution states
 * 3. Statistics for monitoring resolution quality
 */
public class ResolutionContext {

    // === Core storage: forward mapping ===

    /** All processed column references -> resolution results */
    private final Map<TObjectName, ResolutionResult> resolutions = new LinkedHashMap<>();

    // === Reverse indexes for efficient queries ===

    /** Table -> all columns referencing that table */
    private final Map<TTable, List<TObjectName>> tableReferences = new HashMap<>();

    /** Column name -> all column references with that name (for conflict detection) */
    private final Map<String, List<TObjectName>> columnNameIndex = new HashMap<>();

    // === Categorized lists for quick access ===

    /** Exactly matched columns (EXACT_MATCH) */
    private final List<TObjectName> exactMatches = new ArrayList<>();

    /** Ambiguous columns (AMBIGUOUS) */
    private final List<TObjectName> ambiguousColumns = new ArrayList<>();

    /** Unresolved columns (NOT_FOUND) */
    private final List<TObjectName> unresolvedColumns = new ArrayList<>();

    // === Statistics ===

    /** Table reference counts */
    private final Map<TTable, Integer> tableReferenceCounts = new HashMap<>();

    /** Total column references processed */
    private int totalColumnReferences = 0;


    // ===== Internal methods: called by NameResolver =====

    /**
     * Register a resolution result.
     * Called by NameResolver when a column is resolved.
     */
    public void registerResolution(TObjectName objName, ResolutionResult result) {
        // 1. Forward storage
        resolutions.put(objName, result);
        totalColumnReferences++;

        // 2. Update reverse index by column name
        String columnName = objName.getColumnNameOnly();
        if (columnName != null) {
            columnNameIndex.computeIfAbsent(columnName, k -> new ArrayList<>())
                          .add(objName);
        }

        // 3. Categorize by status
        switch (result.getStatus()) {
            case EXACT_MATCH:
                exactMatches.add(objName);
                ColumnSource source = result.getColumnSource();
                if (source != null) {
                    updateTableReference(source.getFinalTable(), objName);
                }
                break;

            case AMBIGUOUS:
                ambiguousColumns.add(objName);
                // For ambiguous: all candidates count as references
                AmbiguousColumnSource ambiguous = result.getAmbiguousSource();
                if (ambiguous != null) {
                    for (ColumnSource candidate : ambiguous.getCandidates()) {
                        updateTableReference(candidate.getFinalTable(), objName);
                    }
                }
                break;

            case NOT_FOUND:
                unresolvedColumns.add(objName);
                break;
        }
    }

    /**
     * Update table reference index
     */
    private void updateTableReference(TTable table, TObjectName objName) {
        if (table == null) return;

        // Reverse index
        tableReferences.computeIfAbsent(table, k -> new ArrayList<>())
                      .add(objName);

        // Reference count
        tableReferenceCounts.merge(table, 1, Integer::sum);
    }


    // ===== Public query API (Level 2 API) =====

    /**
     * Get all column references to a specific table.
     * Complexity: O(1)
     *
     * @param table Target table
     * @return List of TObjectName referencing that table
     */
    public List<TObjectName> getReferencesTo(TTable table) {
        return tableReferences.getOrDefault(table, Collections.emptyList());
    }

    /**
     * Get all column references to a specific table.column.
     * Complexity: O(m) where m = number of references to the table
     *
     * @param table Target table
     * @param columnName Target column name
     * @return List of matching TObjectName
     */
    public List<TObjectName> getReferencesTo(TTable table, String columnName) {
        INameMatcher matcher = new DefaultNameMatcher();

        return getReferencesTo(table).stream()
            .filter(obj -> {
                String colName = obj.getColumnNameOnly();
                return colName != null && matcher.matches(colName, columnName);
            })
            .collect(java.util.stream.Collectors.toList());
    }

    /**
     * Find all column references with a given name (for conflict detection).
     * Complexity: O(1)
     */
    public List<TObjectName> getColumnsByName(String columnName) {
        return columnNameIndex.getOrDefault(columnName, Collections.emptyList());
    }

    /**
     * Get all exactly matched columns
     */
    public List<TObjectName> getExactMatches() {
        return Collections.unmodifiableList(exactMatches);
    }

    /**
     * Get all ambiguous columns
     */
    public List<TObjectName> getAmbiguousColumns() {
        return Collections.unmodifiableList(ambiguousColumns);
    }

    /**
     * Get all unresolved columns
     */
    public List<TObjectName> getUnresolvedColumns() {
        return Collections.unmodifiableList(unresolvedColumns);
    }

    /**
     * Get reference count for a specific table
     */
    public int getTableReferenceCount(TTable table) {
        return tableReferenceCounts.getOrDefault(table, 0);
    }

    /**
     * Get all tables that have been referenced
     */
    public Set<TTable> getAllReferencedTables() {
        return tableReferences.keySet();
    }

    /**
     * Get resolution statistics
     */
    public ResolutionStatistics getStatistics() {
        return new ResolutionStatistics(
            totalColumnReferences,
            exactMatches.size(),
            ambiguousColumns.size(),
            unresolvedColumns.size(),
            tableReferences.size()
        );
    }

    /**
     * Get resolution result for a specific TObjectName
     */
    public ResolutionResult getResolution(TObjectName objName) {
        return resolutions.get(objName);
    }

    /**
     * Clear all data (for reuse or testing)
     */
    public void clear() {
        resolutions.clear();
        tableReferences.clear();
        columnNameIndex.clear();
        exactMatches.clear();
        ambiguousColumns.clear();
        unresolvedColumns.clear();
        tableReferenceCounts.clear();
        totalColumnReferences = 0;
    }
}