package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.VendorNameMatcher;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.scope.GlobalScope;
import gudusoft.gsqlparser.resolver2.scope.IScope;
import gudusoft.gsqlparser.resolver2.scope.SelectScope;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Index structure for fast lookups in FromScope.
 *
 * <p>This class optimizes O(N) linear scans to O(1) hash lookups for common
 * operations like finding tables by alias/name and finding candidate namespaces
 * for star column inference.</p>
 *
 * <p>The index is built lazily on first access and cached for subsequent lookups.
 * This avoids the overhead of building the index when it's not needed.</p>
 *
 * <p><b>Performance improvement:</b> For queries with N tables and M column references,
 * reduces complexity from O(N*M) to O(N + M).</p>
 *
 * <p><b>Slice S2 — vendor-aware identifier compares.</b> Pre-S2 keys were
 * built via raw {@link String#toLowerCase()} which broke quoted-sensitive
 * dialects (Oracle / Postgres / Snowflake / Hive / Teradata quoted) and
 * BigQuery's case-sensitive table rule. S2 stores aliases / display names
 * <em>raw</em> (preserving quotes and original case) and routes lookups
 * through {@link IdentifierService} via the supplied {@link INameMatcher}
 * with {@link ESQLDataObjectType#dotTable}. The exact-text fast probe
 * still handles same-as-written queries in O(1); cross-case / quoted-vs-
 * unquoted lookups fall through to a vendor-aware linear scan. Storing
 * the raw form is critical: a normalized key would lose quote provenance
 * — codex round-1 review caught that comparing the stripped-and-folded
 * stored key against the raw input would false-positive an unquoted
 * probe against a quoted alias on strict-case dialects.</p>
 *
 * @since 3.1.0.9
 */
public class FromScopeIndex {

    /**
     * Map from <em>raw</em> alias text (with quotes preserved, original
     * case) to ScopeChild. Lookup uses an exact-text fast probe first;
     * mismatches fall through to a vendor-aware matcher scan. Storing
     * raw text preserves quote provenance so {@link IdentifierService}
     * can decide quoted-vs-unquoted compare authoritatively in the
     * matcher scan (codex round-1 review).
     */
    private final Map<String, ScopeChild> aliasMap;

    /**
     * Map from <em>raw</em> namespace display name to ScopeChild.
     * Used when lookup by alias fails but table name might match.
     */
    private final Map<String, ScopeChild> nameMap;

    /**
     * First namespace that supports star columns or dynamic inference.
     * Used for unqualified column resolution when no table prefix is specified.
     */
    private final INamespace preferredStarNamespace;

    /**
     * Total number of children in the FromScope.
     */
    private final int childCount;

    /**
     * Name matcher used to normalize keys and to fall back on a vendor-aware
     * linear scan when the stored key normalization disagrees with the
     * lookup-time normalization (rare).
     */
    private final INameMatcher nameMatcher;

    /**
     * Creates an index from the given list of scope children using a
     * vendor-agnostic {@link DefaultNameMatcher}. Prefer the matcher-aware
     * constructor; this overload exists for synthetic / unit-test scopes
     * that have no GlobalScope above them.
     *
     * @param children The list of ScopeChild from a FromScope
     */
    public FromScopeIndex(List<ScopeChild> children) {
        this(children, new DefaultNameMatcher());
    }

    /**
     * Creates an index from the given list of scope children, using the
     * supplied matcher to normalize alias / table-name keys per-vendor.
     *
     * @param children The list of ScopeChild from a FromScope
     * @param nameMatcher Vendor-aware matcher (typically the GlobalScope's)
     */
    public FromScopeIndex(List<ScopeChild> children, INameMatcher nameMatcher) {
        this.nameMatcher = nameMatcher != null ? nameMatcher : new DefaultNameMatcher();
        // Use LinkedHashMap so the matcher-driven fallback scan (when the
        // lookup-time normalization disagrees with stored keys, e.g. a
        // quoted identifier in scope alongside an unquoted one) walks
        // entries in insertion order, matching the deterministic behaviour
        // of FromScope.getChildren().
        this.aliasMap = new LinkedHashMap<>();
        this.nameMap = new LinkedHashMap<>();
        this.childCount = children != null ? children.size() : 0;

        INamespace firstStar = null;

        if (children != null) {
            for (ScopeChild child : children) {
                // S2: store raw alias / display-name text (quotes preserved).
                String alias = child.getAlias();
                if (alias != null && !alias.isEmpty()) {
                    aliasMap.put(alias, child);
                }

                // Also index by namespace display name
                INamespace ns = child.getNamespace();
                if (ns != null) {
                    String displayName = ns.getDisplayName();
                    if (displayName != null && !displayName.isEmpty()) {
                        nameMap.put(displayName, child);
                    }

                    // Track first star/dynamic namespace
                    if (firstStar == null &&
                        (ns.hasStarColumn() || ns.supportsDynamicInference())) {
                        firstStar = ns;
                    }
                }
            }
        }

        this.preferredStarNamespace = firstStar;
    }

    /**
     * Finds a ScopeChild by its alias (vendor-aware).
     *
     * @param alias The alias to search for
     * @return The matching ScopeChild, or null if not found
     */
    public ScopeChild findByAlias(String alias) {
        if (alias == null || alias.isEmpty()) {
            return null;
        }
        // O(1) exact-text fast probe (same case + same quote state as the
        // alias was originally written).
        ScopeChild byExact = aliasMap.get(alias);
        if (byExact != null) {
            return byExact;
        }
        // Slow-path: vendor-aware matcher scan against raw stored aliases
        // (with quotes preserved), so {@link IdentifierService} can decide
        // quoted-vs-unquoted compare authoritatively.
        return findByMatcher(aliasMap.values(), ScopeChild::getAlias, alias);
    }

    /**
     * Finds a ScopeChild by alias first, then by namespace name (vendor-aware).
     *
     * @param qualifier The qualifier (alias or table name) to search for
     * @return The matching ScopeChild, or null if not found
     */
    public ScopeChild findByQualifier(String qualifier) {
        if (qualifier == null || qualifier.isEmpty()) {
            return null;
        }

        ScopeChild result = findByAlias(qualifier);
        if (result != null) {
            return result;
        }

        ScopeChild byNameExact = nameMap.get(qualifier);
        if (byNameExact != null) {
            return byNameExact;
        }
        return findByMatcher(nameMap.values(),
                child -> child.getNamespace() != null ? child.getNamespace().getDisplayName() : null,
                qualifier);
    }

    /**
     * Walk the children comparing the raw, quote-preserving identifier
     * supplied by {@code rawAccessor} against the input via the matcher
     * with {@link ESQLDataObjectType#dotTable}.
     *
     * <p><strong>Invariant:</strong> compare raw alias / display name
     * (with quotes) — NOT a normalized stored key — so
     * {@link IdentifierService} can resolve quoted-vs-unquoted semantics
     * authoritatively.
     */
    private ScopeChild findByMatcher(java.util.Collection<ScopeChild> children,
                                     java.util.function.Function<ScopeChild, String> rawAccessor,
                                     String input) {
        if (children.isEmpty()) {
            return null;
        }
        for (ScopeChild child : children) {
            String storedRaw = rawAccessor.apply(child);
            if (storedRaw == null || storedRaw.isEmpty()) continue;
            if (nameMatcher instanceof VendorNameMatcher) {
                if (((VendorNameMatcher) nameMatcher).matches(storedRaw, input, ESQLDataObjectType.dotTable)) {
                    return child;
                }
            } else if (nameMatcher.matches(storedRaw, input)) {
                return child;
            }
        }
        return null;
    }

    /**
     * Gets the TTable from a ScopeChild by qualifier, if the namespace represents a table.
     *
     * @param qualifier The qualifier (alias or table name) to search for
     * @return The TTable if found and the namespace is a table, null otherwise
     */
    public TTable findTableByQualifier(String qualifier) {
        ScopeChild child = findByAlias(qualifier);
        if (child != null) {
            INamespace ns = child.getNamespace();
            if (ns != null && ns.getNode() instanceof TTable) {
                return (TTable) ns.getNode();
            }
        }
        return null;
    }

    /**
     * Gets the first namespace that supports star columns or dynamic inference.
     * Used for resolving unqualified column references.
     *
     * @return The preferred star namespace, or null if none exists
     */
    public INamespace getPreferredStarNamespace() {
        return preferredStarNamespace;
    }

    /**
     * Finds a candidate namespace for column resolution.
     *
     * <p>If a table prefix is provided, looks up by that prefix.
     * Otherwise, returns the first star/dynamic namespace for unqualified columns.</p>
     *
     * @param tablePrefix The table prefix (alias or name), or null for unqualified columns
     * @return The candidate namespace, or null if not found
     */
    public INamespace findCandidateNamespace(String tablePrefix) {
        if (tablePrefix != null && !tablePrefix.isEmpty()) {
            // Qualified reference - find by prefix
            ScopeChild child = findByQualifier(tablePrefix);
            if (child != null) {
                return child.getNamespace();
            }
            return null;
        } else {
            // Unqualified reference - use star namespace
            return preferredStarNamespace;
        }
    }

    /**
     * Gets the total number of children indexed.
     *
     * @return The child count
     */
    public int getChildCount() {
        return childCount;
    }

    /**
     * Checks if the index is empty.
     *
     * @return true if no children are indexed
     */
    public boolean isEmpty() {
        return childCount == 0;
    }

    /**
     * Creates an index from a scope, extracting the FromScope if needed.
     * Walks the scope chain to find the {@link GlobalScope}'s name matcher
     * so vendor-specific identifier rules apply (S2).
     *
     * @param scope The scope (SelectScope, UpdateScope, or FromScope)
     * @return A new FromScopeIndex, or null if no FromScope is found
     */
    public static FromScopeIndex fromScope(IScope scope) {
        if (scope == null) {
            return null;
        }

        IScope fromScope = null;

        if (scope instanceof SelectScope) {
            fromScope = ((SelectScope) scope).getFromScope();
        } else if (scope instanceof gudusoft.gsqlparser.resolver2.scope.UpdateScope) {
            fromScope = ((gudusoft.gsqlparser.resolver2.scope.UpdateScope) scope).getFromScope();
        } else if (scope instanceof gudusoft.gsqlparser.resolver2.scope.FromScope) {
            fromScope = scope;
        }

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

        return new FromScopeIndex(fromScope.getChildren(), findNameMatcher(fromScope));
    }

    /**
     * Walk the parent chain to find the {@link GlobalScope}'s name matcher.
     */
    private static INameMatcher findNameMatcher(IScope cursor) {
        while (cursor != null) {
            if (cursor instanceof GlobalScope) {
                INameMatcher m = ((GlobalScope) cursor).getNameMatcher();
                if (m != null) {
                    return m;
                }
                break;
            }
            IScope next = cursor.getParent();
            if (next == cursor) break;
            cursor = next;
        }
        return new DefaultNameMatcher();
    }

    @Override
    public String toString() {
        return String.format("FromScopeIndex(aliases=%d, names=%d, hasStar=%b)",
            aliasMap.size(), nameMap.size(), preferredStarNamespace != null);
    }
}