package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.VendorNameMatcher;
import gudusoft.gsqlparser.resolver2.model.ResolvePath;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Base class for scopes that manage a list of child namespaces.
 * Used for FROM clauses, which contain multiple tables/subqueries.
 *
 * Key features:
 * 1. Maintains ordered list of children
 * 2. Resolves names by searching through children
 * 3. Supports aliases
 */
public abstract class ListBasedScope extends AbstractScope {

    /** Child namespaces in this scope */
    protected final List<ScopeChild> children = new ArrayList<>();

    protected ListBasedScope(IScope parent, TParseTreeNode node, ScopeType scopeType) {
        super(parent, node, scopeType);
    }

    @Override
    public void addChild(INamespace namespace, String alias, boolean nullable) {
        if (alias == null) {
            throw new IllegalArgumentException("Alias cannot be null in ListBasedScope");
        }
        children.add(new ScopeChild(children.size(), alias, namespace, nullable));
    }

    @Override
    public List<ScopeChild> getChildren() {
        return Collections.unmodifiableList(children);
    }

    @Override
    public INamespace resolveTable(String tableName) {
        // Search in children only - do NOT delegate to parent
        // The parent (SelectScope) already handles fallback to outer scopes
        // Delegating to parent causes infinite recursion:
        // SelectScope.resolveTable -> fromScope.resolveTable -> parent.resolveTable -> SelectScope.resolveTable -> ...
        // Slice S15: route alias compare through INameMatcher so per-dialect
        // quoted-vs-unquoted rules apply (e.g. Oracle quoted alias is
        // case-sensitive, unquoted folds to upper). The matcher is sourced
        // from the GlobalScope at the root of the scope chain. When the
        // matcher is a {@link VendorNameMatcher}, route through {@link
        // ESQLDataObjectType#dotTable} explicitly because BigQuery and
        // MySQL have different rules between table and column object types
        // (BigQuery: tables SENSITIVE, columns INSENSITIVE; MySQL: tables
        // depend on lower_case_table_names, columns always INSENSITIVE).
        INameMatcher matcher = findNameMatcher();
        for (ScopeChild child : children) {
            if (aliasMatches(matcher, child.getAlias(), tableName)) {
                return child.getNamespace();
            }
        }

        // Not found - return null, let caller handle fallback
        return null;
    }

    private static boolean aliasMatches(INameMatcher matcher, String childAlias, String tableName) {
        if (matcher instanceof VendorNameMatcher) {
            return ((VendorNameMatcher) matcher).matches(childAlias, tableName, ESQLDataObjectType.dotTable);
        }
        return matcher.matches(childAlias, tableName);
    }

    /**
     * Walk the parent chain to find the {@link GlobalScope}'s name matcher.
     * Falls back to a {@link DefaultNameMatcher} if the chain does not
     * include a {@code GlobalScope} (e.g. unit tests with synthetic scopes).
     */
    private INameMatcher findNameMatcher() {
        IScope cursor = this;
        while (cursor != null && !(cursor instanceof EmptyScope)) {
            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 void resolve(List<String> names,
                       INameMatcher matcher,
                       boolean deep,
                       IResolved resolved) {
        if (names.isEmpty()) {
            return;
        }

        String firstName = names.get(0);

        // Search through children
        for (ScopeChild child : children) {
            if (matcher.matches(child.getAlias(), firstName)) {
                // Found matching child
                INamespace namespace = child.getNamespace();
                ResolvePath path = new ResolvePath();

                if (names.size() == 1) {
                    // Just the table alias
                    resolved.found(namespace, child.isNullable(), this, path, Collections.emptyList());
                } else {
                    // Resolve remaining parts in the namespace
                    List<String> remaining = names.subList(1, names.size());
                    resolveInNamespace(namespace, child.isNullable(), remaining, matcher, path, resolved);
                }
            }
        }

        // Also try parent scope
        parent.resolve(names, matcher, deep, resolved);
    }

    /**
     * Resolve remaining name parts within a namespace.
     * For example, if we found table "t" and need to resolve "t.col1",
     * this method handles resolving "col1" within table t.
     */
    protected void resolveInNamespace(INamespace namespace,
                                     boolean nullable,
                                     List<String> remainingNames,
                                     INameMatcher matcher,
                                     ResolvePath path,
                                     IResolved resolved) {
        if (remainingNames.isEmpty()) {
            resolved.found(namespace, nullable, this, path, Collections.emptyList());
            return;
        }

        // For now, simple implementation - just mark as found with remaining names
        // Full implementation would traverse into structured types
        resolved.found(namespace, nullable, this, path, remainingNames);
    }

    @Override
    public List<INamespace> getVisibleNamespaces() {
        List<INamespace> visible = new ArrayList<>();
        for (ScopeChild child : children) {
            visible.add(child.getNamespace());
        }
        // Add parent's visible namespaces
        visible.addAll(parent.getVisibleNamespaces());
        return visible;
    }

    @Override
    public String toString() {
        return String.format("%s(children=%d)", scopeType, children.size());
    }
}