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.matcher.VendorNameMatcher;
import gudusoft.gsqlparser.resolver2.model.ColumnReference;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.model.ColumnSourceWithReferences;
import gudusoft.gsqlparser.sqlenv.CanonKey;

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;

    /**
     * Canonical-key index over {@link #columnSources} (Mantis 4684).
     *
     * <p>The matcher fallback loops in {@link #hasColumn}/{@link #resolveColumn}
     * are O(map size) with a full identifier comparison per entry — on SQL Server
     * each comparison is a {@link java.text.RuleBasedCollator} run. Inferred
     * columns ({@code TableNamespace.resolveColumn}) grow the map by one per
     * unresolved reference, so a wide select list makes resolution O(N²) in
     * collator comparisons (a 2000-column select took ~24s).</p>
     *
     * <p>This index maps {@link CanonKey} → first map key carrying that key.
     * Since P0d.1, {@code IdentifierService.areEqual} IS canonical-key equality
     * (collation-based dialects use {@link java.text.CollationKey} bytes from the
     * SAME cached collator), so an index probe is exactly equivalent to the
     * matcher loop; {@code putIfAbsent} in insertion order preserves the loop's
     * first-match-wins choice. The index is synced lazily: {@code columnSources}
     * is append-only in every namespace (no removals exist), so a sync only
     * indexes the entries added since the last one. Any name outside the
     * canonical-key domain (multi-segment, malformed quoting) permanently
     * disables the index for this namespace and the loop takes over.</p>
     */
    private Map<CanonKey, String> canonKeyIndex = null;
    /** Identity of the map instance the index was built over (subclasses reassign {@link #columnSources}). */
    private Map<String, ColumnSource> canonIndexedMap = null;
    /** How many insertion-order entries of {@link #canonIndexedMap} are indexed. */
    private int canonIndexedCount = 0;
    /** Set when a name refuses canonical-key construction; falls back to the matcher loop. */
    private boolean canonIndexUnusable = false;

    /**
     * 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);
            noteColumnSourceAdded(normalizedKey);
        }

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

        // Matcher-equality fallback (canonical-key indexed — see canonKeyIndex)
        if (findColumnKeyByMatcher(columnName) != null) {
            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;
        }

        // Matcher-equality fallback (canonical-key indexed — see canonKeyIndex)
        String matchedKey = findColumnKeyByMatcher(columnName);
        return matchedKey != null ? columnSources.get(matchedKey) : null;
    }

    /**
     * Find the first insertion-order key of {@link #columnSources} that the
     * {@link #nameMatcher} considers equal to {@code columnName}, or null when
     * no key matches.
     *
     * <p>Equivalent to the historical
     * {@code for (key : columnSources.keySet()) if (nameMatcher.matches(key, columnName))}
     * loop, but near-O(1) via the canonical-key index when the matcher is a
     * {@link VendorNameMatcher} (Mantis 4684 — the loop made wide select lists
     * quadratic with a collator comparison per entry on SQL Server).</p>
     */
    protected String findColumnKeyByMatcher(String columnName) {
        if (columnSources == null || columnSources.isEmpty() || columnName == null) {
            return null;
        }
        // Exact class only: a VendorNameMatcher SUBCLASS may override matches(),
        // and the index would bypass the override (Codex round-1 P2).
        if (!canonIndexUnusable && nameMatcher.getClass() == VendorNameMatcher.class) {
            try {
                syncCanonKeyIndex();
                return canonKeyIndex.get(canonKeyOf(columnName));
            } catch (RuntimeException e) {
                // Name outside the canonical-key domain (multi-segment or
                // malformed quoting): give up on the index for this namespace.
                canonIndexUnusable = true;
                canonKeyIndex = null;
                canonIndexedMap = null;
            }
        }
        for (String existingCol : columnSources.keySet()) {
            if (nameMatcher.matches(existingCol, columnName)) {
                return existingCol;
            }
        }
        return null;
    }

    /**
     * Canonical key of one name under the matcher's OWN identifier service and object type: the
     * same service {@link VendorNameMatcher#matches} compares with, so the index finds exactly the
     * columns the matcher equates. Keying by the vendor's default service instead dropped a
     * configured profile: under {@code Latin1_General_CI_AI}, {@code d.cafe} missed the column
     * {@code [café]} that the matcher equates with it, and under {@code Latin1_General_CS_AI}
     * {@code d.CAFÉ} resolved to {@code [café]} that the matcher keeps apart.
     */
    private CanonKey canonKeyOf(String name) {
        VendorNameMatcher vm = (VendorNameMatcher) nameMatcher;
        return vm.getIdentifierService().canonKey(name, vm.getDefaultObjectType());
    }

    /**
     * Incremental index maintenance for the append-one case (Codex round-1 P1):
     * without this, every {@link #syncCanonKeyIndex} after a single-key insert
     * re-walks the already-indexed prefix just to skip it — O(N²) iterator
     * steps on the wide-select workload even with O(N) canonical keys. Call
     * after putting {@code key} into {@link #columnSources}. A batch of puts
     * without notes is still safe: the size check fails and the next sync
     * catches up with the (now rare) prefix walk.
     */
    protected void noteColumnSourceAdded(String key) {
        if (canonIndexUnusable || canonKeyIndex == null || canonIndexedMap != columnSources) {
            return; // index not built yet or map replaced; next sync handles it
        }
        if (columnSources.size() != canonIndexedCount + 1) {
            return; // overwrite (size unchanged) or un-noted batch; sync catches up
        }
        try {
            canonKeyIndex.putIfAbsent(canonKeyOf(key), key);
            canonIndexedCount++;
        } catch (RuntimeException e) {
            canonIndexUnusable = true;
            canonKeyIndex = null;
            canonIndexedMap = null;
        }
    }

    /**
     * Bring {@link #canonKeyIndex} up to date with {@link #columnSources}.
     * The map is append-only between syncs, so only the entries beyond
     * {@link #canonIndexedCount} need indexing; a reassigned map instance or a
     * shrunken size (defensive — no remover exists today) rebuilds from scratch.
     */
    private void syncCanonKeyIndex() {
        if (canonKeyIndex == null || canonIndexedMap != columnSources
                || columnSources.size() < canonIndexedCount) {
            canonKeyIndex = new HashMap<>();
            canonIndexedMap = columnSources;
            canonIndexedCount = 0;
        }
        int size = columnSources.size();
        if (canonIndexedCount == size) {
            return;
        }
        int i = 0;
        for (String key : columnSources.keySet()) {
            if (i++ < canonIndexedCount) {
                continue;
            }
            // First entry with a given canonical key wins, matching the scan.
            canonKeyIndex.putIfAbsent(canonKeyOf(key), key);
        }
        canonIndexedCount = size;
    }

    @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();
    }
}