package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.model.ColumnReference;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.model.ColumnSourceWithReferences;

import java.util.*;

/**
 * Abstract base class for all namespaces.
 * Provides common functionality for column resolution and caching.
 *
 * <p>Enhanced with reference traceability support: multiple syntactically different
 * identifiers that refer to the same semantic column can be tracked and traced back.</p>
 */
public abstract class AbstractNamespace implements INamespace {

    /** Associated AST node */
    protected final Object node;

    /** Whether this namespace has been validated */
    protected boolean validated = false;

    /** Cached column sources (populated during validation) - keyed by normalized name */
    protected Map<String, ColumnSource> columnSources = null;

    /**
     * Enhanced column sources with reference traceability (keyed by normalized name).
     * When enabled, this map stores ColumnSourceWithReferences that track all original
     * references to each semantic column.
     */
    protected Map<String, ColumnSourceWithReferences> columnSourcesWithRefs = null;

    /** Whether reference traceability is enabled */
    protected boolean referenceTraceabilityEnabled = false;

    /** Name matcher for column name comparisons */
    protected final INameMatcher nameMatcher;

    /**
     * Strategy for handling ambiguous columns.
     * Defaults to -1, which means use global TBaseType.GUESS_COLUMN_STRATEGY.
     * Can be overridden per-namespace instance.
     */
    protected int guessColumnStrategy = -1;

    protected AbstractNamespace(Object node, INameMatcher nameMatcher) {
        this.node = node;
        this.nameMatcher = nameMatcher != null ? nameMatcher : new DefaultNameMatcher();
    }

    protected AbstractNamespace(Object node) {
        this(node, new DefaultNameMatcher());
    }

    /**
     * Set the strategy for handling ambiguous columns.
     * @param strategy One of TBaseType.GUESS_COLUMN_STRATEGY_* constants, or -1 to use global default
     */
    public void setGuessColumnStrategy(int strategy) {
        this.guessColumnStrategy = strategy;
    }

    /**
     * Get the strategy for handling ambiguous columns.
     * Returns the instance-level strategy if set, otherwise returns the global default.
     * @return The strategy constant
     */
    public int getGuessColumnStrategy() {
        if (guessColumnStrategy >= 0) {
            return guessColumnStrategy;
        }
        return gudusoft.gsqlparser.TBaseType.GUESS_COLUMN_STRATEGY;
    }

    @Override
    public Object getNode() {
        return node;
    }

    @Override
    public boolean isValidated() {
        return validated;
    }

    @Override
    public void validate() {
        if (!validated) {
            doValidate();
            validated = true;
        }
    }

    /**
     * Subclasses override this to perform actual validation logic.
     */
    protected abstract void doValidate();

    /**
     * Enable reference traceability for this namespace.
     * When enabled, all column additions will track original references.
     */
    public void enableReferenceTraceability() {
        this.referenceTraceabilityEnabled = true;
        if (columnSourcesWithRefs == null) {
            columnSourcesWithRefs = new LinkedHashMap<>();
        }
    }

    /**
     * Check if reference traceability is enabled.
     *
     * @return true if traceability is enabled
     */
    public boolean isReferenceTraceabilityEnabled() {
        return referenceTraceabilityEnabled;
    }

    /**
     * Add a column source with reference traceability support.
     *
     * <p>This method normalizes the column name and either:</p>
     * <ul>
     *   <li>Creates a new entry if this is the first reference</li>
     *   <li>Adds a reference to an existing entry if the column already exists</li>
     * </ul>
     *
     * @param columnName original column name (may include quotes)
     * @param source the column source
     * @param objectName the original AST node for traceability (may be null)
     */
    protected void addColumnSource(String columnName, ColumnSource source, TObjectName objectName) {
        if (columnSources == null) {
            columnSources = new LinkedHashMap<>();
        }

        String normalizedKey = nameMatcher.normalize(columnName);

        // Add to basic map if not exists
        if (!columnSources.containsKey(normalizedKey)) {
            columnSources.put(normalizedKey, source);
        }

        // Add to enhanced map with references if traceability is enabled
        if (referenceTraceabilityEnabled) {
            if (columnSourcesWithRefs == null) {
                columnSourcesWithRefs = new LinkedHashMap<>();
            }

            ColumnSourceWithReferences enhanced = columnSourcesWithRefs.computeIfAbsent(
                normalizedKey,
                k -> new ColumnSourceWithReferences(normalizedKey, source)
            );

            if (objectName != null) {
                enhanced.addReference(new ColumnReference(objectName));
            }
        }
    }

    /**
     * Add a column source (backward compatible - no traceability).
     *
     * @param columnName original column name
     * @param source the column source
     */
    protected void addColumnSource(String columnName, ColumnSource source) {
        addColumnSource(columnName, source, null);
    }

    /**
     * Slice S1: matcher-aware {@code containsKey} replacement for column maps
     * that need vendor-specific identifier rules to govern dedupe / lookup.
     *
     * <p>Per-vendor identifier rules differ on whether {@code MyCol} and {@code mycol}
     * are the same column (BigQuery / MySQL / SQL Server: yes for columns;
     * Oracle / Postgres unquoted: yes via folding; quoted Oracle / Postgres: no).
     * A raw {@code map.containsKey(name)} bypasses these rules and produces
     * duplicate-key drift; a fixed {@code equalsIgnoreCase} loop is wrong for
     * vendors where columns are case-sensitive (BigQuery tables, Oracle quoted).
     *
     * <p>This helper:
     * <ol>
     *   <li>tries an O(1) normalized-key probe (fast path for vendors that
     *       fold unquoted identifiers to a canonical form, where the stored
     *       raw key is itself the folded form — e.g. Postgres stored
     *       {@code "mycol"} probed by query {@code "MYCOL"} that normalizes
     *       to {@code "mycol"}),</li>
     *   <li>tries an O(1) raw-key probe for the exact-match common case,</li>
     *   <li>falls back to a matcher loop that compares against {@link
     *       ColumnSource#getExposedName()} (when values are {@code ColumnSource})
     *       so quote state is preserved on quoted-sensitive dialects.</li>
     * </ol>
     *
     * <p><strong>Quote-state preservation (codex round 1 + round 2).</strong>
     * The map values must hold the original-cased identifier (with quotes).
     * Storage keys are also raw (= {@code exposedName}) — round 2 caught
     * that storing under {@code nameMatcher.normalize(name)} can collide
     * two matcher-distinct identifiers (e.g. Postgres quoted {@code "mycol"}
     * vs unquoted {@code MYCOL} both normalize to {@code mycol}) into the
     * same key and lose information. With raw-keyed storage, the normalize
     * fast-probe only hits when the stored raw key already equals the
     * normalized form, and in that case {@link
     * gudusoft.gsqlparser.resolver2.matcher.INameMatcher#matches} agrees;
     * the matcher loop catches the case-only-different case.
     */
    protected boolean containsColumnByMatcher(Map<String, ?> map, String columnName) {
        if (map == null || map.isEmpty() || columnName == null) {
            return false;
        }
        String normalizedKey = nameMatcher.normalize(columnName);
        if (normalizedKey != null && map.containsKey(normalizedKey)) {
            return true;
        }
        if (map.containsKey(columnName)) {
            return true;
        }
        for (Map.Entry<String, ?> entry : map.entrySet()) {
            String compareName = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof ColumnSource) {
                String exposed = ((ColumnSource) value).getExposedName();
                if (exposed != null) {
                    compareName = exposed;
                }
            }
            if (compareName != null && nameMatcher.matches(compareName, columnName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Slice S1: matcher-aware {@code Set#contains} replacement. See
     * {@link #containsColumnByMatcher(Map, String)} for the rationale.
     */
    protected boolean containsColumnNameByMatcher(Set<String> set, String columnName) {
        if (set == null || set.isEmpty() || columnName == null) {
            return false;
        }
        if (set.contains(columnName)) {
            return true;
        }
        String normalizedKey = nameMatcher.normalize(columnName);
        if (normalizedKey != null && set.contains(normalizedKey)) {
            return true;
        }
        for (String existing : set) {
            if (nameMatcher.matches(existing, columnName)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        ensureValidated();

        if (columnSources == null) {
            return ColumnLevel.NOT_EXISTS;
        }

        // Use normalized key for O(1) lookup
        String normalizedKey = nameMatcher.normalize(columnName);
        if (columnSources.containsKey(normalizedKey)) {
            return ColumnLevel.EXISTS;
        }

        // Fallback to linear search for backward compatibility
        for (String existingCol : columnSources.keySet()) {
            if (nameMatcher.matches(existingCol, columnName)) {
                return ColumnLevel.EXISTS;
            }
        }

        return ColumnLevel.NOT_EXISTS;
    }

    @Override
    public ColumnSource resolveColumn(String columnName) {
        ensureValidated();

        if (columnSources == null) {
            return null;
        }

        // Use normalized key for O(1) lookup
        String normalizedKey = nameMatcher.normalize(columnName);
        ColumnSource source = columnSources.get(normalizedKey);
        if (source != null) {
            return source;
        }

        // Fallback to linear search for backward compatibility
        for (Map.Entry<String, ColumnSource> entry : columnSources.entrySet()) {
            if (nameMatcher.matches(entry.getKey(), columnName)) {
                return entry.getValue();
            }
        }

        return null;
    }

    @Override
    public Map<String, ColumnSource> getAllColumnSources() {
        ensureValidated();
        return columnSources != null
            ? Collections.unmodifiableMap(columnSources)
            : Collections.emptyMap();
    }

    /**
     * Get all column references for a specific column.
     *
     * <p>Requires reference traceability to be enabled.</p>
     *
     * @param columnName the column name (normalized or original)
     * @return list of all references, empty if not found or traceability not enabled
     */
    public List<ColumnReference> getColumnReferences(String columnName) {
        if (columnSourcesWithRefs == null) {
            return Collections.emptyList();
        }

        String normalizedKey = nameMatcher.normalize(columnName);
        ColumnSourceWithReferences enhanced = columnSourcesWithRefs.get(normalizedKey);

        return enhanced != null
            ? enhanced.getAllReferences()
            : Collections.emptyList();
    }

    /**
     * Get all unique columns with their references.
     *
     * <p>Requires reference traceability to be enabled.</p>
     *
     * @return collection of enhanced column sources, empty if traceability not enabled
     */
    public Collection<ColumnSourceWithReferences> getAllUniqueColumns() {
        if (columnSourcesWithRefs == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableCollection(columnSourcesWithRefs.values());
    }

    /**
     * Get enhanced column source with references for a specific column.
     *
     * @param columnName the column name
     * @return enhanced column source, or null if not found
     */
    public ColumnSourceWithReferences getColumnSourceWithReferences(String columnName) {
        if (columnSourcesWithRefs == null) {
            return null;
        }
        String normalizedKey = nameMatcher.normalize(columnName);
        return columnSourcesWithRefs.get(normalizedKey);
    }

    @Override
    public List<TTable> getAllFinalTables() {
        TTable finalTable = getFinalTable();
        if (finalTable != null) {
            return Collections.singletonList(finalTable);
        }
        return Collections.emptyList();
    }

    /**
     * Ensure this namespace is validated before accessing column info
     */
    protected void ensureValidated() {
        if (!validated) {
            validate();
        }
    }

    /**
     * Get the name matcher used by this namespace.
     *
     * @return the name matcher
     */
    public INameMatcher getNameMatcher() {
        return nameMatcher;
    }

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