package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.binding.BindingSkipReason;
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;

    // === Binding-trace state (S3) ===
    //
    // Identity-keyed per-TObjectName trace, used by BindingDiagnosticPostPass
    // (S5+) as deterministic input. Both maps stay null until enableBindingTrace()
    // is called by TSQLResolver2 — keeping the default-off path allocation-free
    // (plan §10.1 perf gate). IdentityHashMap on purpose: two TObjectName
    // instances with equal toString must NOT collide.

    private boolean bindingTraceEnabled = false;
    private IdentityHashMap<TObjectName, ResolutionResult> columnResolutionResults;
    private IdentityHashMap<TObjectName, BindingSkipReason> columnSkipReasons;


    // ===== 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;
        }

        // Binding-trace tap (S3). All resolver call sites flow through
        // registerResolution — both NameResolver.resolve() and the four
        // bypass paths in TSQLResolver2 (USING-left, USING-right, Teradata
        // NAMED alias, QUALIFY clause alias) — so a single put here covers
        // every reference that produces a ResolutionResult.
        if (bindingTraceEnabled && columnResolutionResults != null && objName != null) {
            columnResolutionResults.put(objName, result);
        }
    }

    /**
     * Register a resolution that CORRECTS one already registered for the same
     * reference, retracting the superseded bookkeeping first.
     *
     * <p>{@link #registerResolution} is purely additive: it overwrites the forward
     * map but appends to {@code columnNameIndex}, the status lists,
     * {@code tableReferences} and the counters. Calling it twice for one reference
     * therefore leaves the OLD binding visible — after a WHERE reference is
     * corrected from a table column to a SELECT-list alias,
     * {@code getReferencesTo(oldTable)} would still list it, it would appear twice
     * in {@code getExactMatches()}, and {@code totalColumnReferences} would
     * over-count. That makes the context disagree with {@code TObjectName}, and
     * resolver2's own data structures are supposed to be the single source of truth
     * (MantisBT 4659).</p>
     *
     * <p>Safe to call when nothing was registered before — it degrades to a plain
     * {@link #registerResolution}.</p>
     */
    public void replaceResolution(TObjectName objName, ResolutionResult result) {
        ResolutionResult previous = resolutions.get(objName);
        if (previous != null) {
            totalColumnReferences--;

            String columnName = objName.getColumnNameOnly();
            if (columnName != null) {
                List<TObjectName> byName = columnNameIndex.get(columnName);
                if (byName != null) {
                    byName.remove(objName);
                    if (byName.isEmpty()) columnNameIndex.remove(columnName);
                }
            }

            switch (previous.getStatus()) {
                case EXACT_MATCH:
                    exactMatches.remove(objName);
                    if (previous.getColumnSource() != null) {
                        removeTableReference(previous.getColumnSource().getFinalTable(), objName);
                    }
                    break;
                case AMBIGUOUS:
                    ambiguousColumns.remove(objName);
                    AmbiguousColumnSource ambiguous = previous.getAmbiguousSource();
                    if (ambiguous != null && ambiguous.getCandidates() != null) {
                        for (ColumnSource candidate : ambiguous.getCandidates()) {
                            removeTableReference(candidate.getFinalTable(), objName);
                        }
                    }
                    break;
                case NOT_FOUND:
                    unresolvedColumns.remove(objName);
                    break;
            }
        }

        registerResolution(objName, result);
    }

    /**
     * Undo one {@link #updateTableReference} contribution.
     */
    private void removeTableReference(TTable table, TObjectName objName) {
        if (table == null) return;

        List<TObjectName> refs = tableReferences.get(table);
        if (refs != null) {
            refs.remove(objName);
            if (refs.isEmpty()) tableReferences.remove(table);
        }

        Integer count = tableReferenceCounts.get(table);
        if (count != null) {
            if (count <= 1) {
                tableReferenceCounts.remove(table);
            } else {
                tableReferenceCounts.put(table, count - 1);
            }
        }
    }

    /**
     * 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;
        if (columnResolutionResults != null) {
            columnResolutionResults.clear();
        }
        if (columnSkipReasons != null) {
            columnSkipReasons.clear();
        }
    }

    // ===== Binding-trace API (S3, plan §7.3) =====

    /**
     * Enable per-{@link TObjectName} binding-trace recording.
     *
     * <p>Allocates the identity-keyed trace and skip-reason maps on first call;
     * subsequent calls are no-ops. {@code TSQLResolver2.resolve()} flips this
     * on at the start of resolution when either {@code emitBindingDiagnostics}
     * or {@code bindingIncludeSuccessfulReferences} is set.</p>
     */
    public void enableBindingTrace() {
        if (!bindingTraceEnabled) {
            bindingTraceEnabled = true;
            columnResolutionResults = new IdentityHashMap<>();
            columnSkipReasons = new IdentityHashMap<>();
        }
    }

    /**
     * @return {@code true} once {@link #enableBindingTrace()} has been called
     *         for this context.
     */
    public boolean isBindingTraceEnabled() {
        return bindingTraceEnabled;
    }

    /**
     * Get the recorded resolution for a specific {@link TObjectName} reference.
     *
     * <p>Identity-keyed (two references with equal {@code toString} are kept
     * separate). Returns {@code null} when no resolution has been recorded for
     * this reference, including when the trace is disabled.</p>
     */
    public ResolutionResult getColumnResolutionResult(TObjectName objName) {
        if (columnResolutionResults == null || objName == null) {
            return null;
        }
        return columnResolutionResults.get(objName);
    }

    /**
     * Get the skip-reason recorded for a specific {@link TObjectName} reference.
     */
    public BindingSkipReason getColumnSkipReason(TObjectName objName) {
        if (columnSkipReasons == null || objName == null) {
            return null;
        }
        return columnSkipReasons.get(objName);
    }

    /**
     * Record an explicit binding-skip reason for a reference. Silently ignored
     * when the trace is disabled.
     */
    public void recordColumnSkipReason(TObjectName objName, BindingSkipReason reason) {
        if (!bindingTraceEnabled || objName == null || reason == null) {
            return;
        }
        columnSkipReasons.put(objName, reason);
    }
}