package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.scope.IScope;
import gudusoft.gsqlparser.resolver2.scope.SelectScope;

import java.util.HashMap;
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>
 *
 * @since 3.1.0.9
 */
public class FromScopeIndex {

    /**
     * Map from lowercase alias/name to ScopeChild for O(1) lookup.
     * Key is always lowercase for case-insensitive matching.
     */
    private final Map<String, ScopeChild> aliasMap;

    /**
     * Map from lowercase 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;

    /**
     * Creates an index from the given list of scope children.
     *
     * @param children The list of ScopeChild from a FromScope
     */
    public FromScopeIndex(List<ScopeChild> children) {
        this.aliasMap = new HashMap<>();
        this.nameMap = new HashMap<>();
        this.childCount = children != null ? children.size() : 0;

        INamespace firstStar = null;

        if (children != null) {
            for (ScopeChild child : children) {
                // Index by alias (lowercase for case-insensitive matching)
                String alias = child.getAlias();
                if (alias != null && !alias.isEmpty()) {
                    aliasMap.put(alias.toLowerCase(), 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.toLowerCase(), child);
                    }

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

        this.preferredStarNamespace = firstStar;
    }

    /**
     * Finds a ScopeChild by its alias (case-insensitive).
     *
     * @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;
        }
        return aliasMap.get(alias.toLowerCase());
    }

    /**
     * Finds a ScopeChild by alias first, then by namespace name (case-insensitive).
     *
     * @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;
        }

        String lowerQualifier = qualifier.toLowerCase();

        // First try alias
        ScopeChild result = aliasMap.get(lowerQualifier);
        if (result != null) {
            return result;
        }

        // Then try namespace name
        return nameMap.get(lowerQualifier);
    }

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

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