package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.QualifiedName;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;

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

/**
 * Abstract base class for all scopes.
 * Implements delegation pattern - most methods delegate to parent.
 *
 * Subclasses only need to override methods where they have special behavior.
 */
public abstract class AbstractScope implements IScope {

    /** Parent scope (never null - root has EmptyScope parent) */
    protected final IScope parent;

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

    /** Scope type */
    protected final ScopeType scopeType;

    protected AbstractScope(IScope parent, TParseTreeNode node, ScopeType scopeType) {
        if (parent == null) {
            throw new IllegalArgumentException("Parent scope cannot be null. Use EmptyScope for root.");
        }
        this.parent = parent;
        this.node = node;
        this.scopeType = scopeType;
    }

    /**
     * Where a name this scope cannot resolve continues its search, when that is not
     * {@link #parent}. See {@link #setLookupParent(IScope)}.
     */
    private IScope lookupParent;

    @Override
    public IScope getParent() {
        return parent;
    }

    /**
     * The scope an unresolved name climbs to: the parent, unless the search must skip it.
     */
    public IScope getLookupParent() {
        return lookupParent != null ? lookupParent : parent;
    }

    /**
     * Make an unresolved name skip the parent and continue at {@code lookupParent}.
     *
     * <p>A derived-table body and a CTE body cannot see the FROM clause that contains
     * them: in {@code SELECT ... FROM (SELECT x FROM a) d JOIN t9 ...} the {@code x} can
     * never be a column of {@code t9} or of {@code d} itself, only of {@code a} or of a
     * query enclosing the whole statement. Only name lookup skips; {@link #getParent()}
     * still returns the structural parent.</p>
     */
    public void setLookupParent(IScope lookupParent) {
        this.lookupParent = lookupParent;
    }

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

    @Override
    public ScopeType getScopeType() {
        return scopeType;
    }

    /**
     * Default implementation: delegate to parent
     */
    @Override
    public void resolve(List<String> names,
                       INameMatcher matcher,
                       boolean deep,
                       IResolved resolved) {
        getLookupParent().resolve(names, matcher, deep, resolved);
    }

    /**
     * Default implementation: delegate to parent
     */
    @Override
    public INamespace resolveTable(String tableName) {
        return parent.resolveTable(tableName);
    }

    /**
     * Default implementation: not supported (most scopes don't have children)
     */
    @Override
    public void addChild(INamespace namespace, String alias, boolean nullable) {
        throw new UnsupportedOperationException(
            "Scope type " + scopeType + " does not support adding children");
    }

    /**
     * Default implementation: empty list
     */
    @Override
    public List<ScopeChild> getChildren() {
        return Collections.emptyList();
    }

    /**
     * Default implementation: delegate to parent
     */
    /**
     * The namespaces a name in this scope can see: the scope's own, then those of its lookup parent, as
     * {@link #resolve} walks them. A non-lateral derived table or CTE body hides its owner's FROM scope by a
     * lookup parent (ScopeBuilder.setLookupParent), so the structural parent is not followed here either
     * (Mantis 4820, Codex review).
     */
    @Override
    public List<INamespace> getVisibleNamespaces() {
        return getLookupParent().getVisibleNamespaces();
    }

    /**
     * Adds the namespaces {@code scope} itself declares (its {@link IScope#getChildren()}), each once. Used by the
     * scopes that own a FROM scope: the FROM scope's parent is the owner, so the owner must read the FROM scope's own
     * children instead of calling {@code fromScope.getVisibleNamespaces()}, which would re-enter the owner and recurse
     * until the stack overflows (Mantis 4820).
     */
    protected static void addOwnNamespaces(List<INamespace> out, IScope scope) {
        if (scope == null) {
            return;
        }
        for (ScopeChild child : scope.getChildren()) {
            if (child != null) {
                addDistinct(out, child.getNamespace());
            }
        }
    }

    /** Appends every namespace of {@code more} that {@code out} does not already hold (by identity). */
    protected static void addAllDistinct(List<INamespace> out, List<INamespace> more) {
        if (more == null) {
            return;
        }
        for (INamespace ns : more) {
            addDistinct(out, ns);
        }
    }

    private static void addDistinct(List<INamespace> out, INamespace ns) {
        if (ns == null) {
            return;
        }
        for (INamespace present : out) {
            if (present == ns) {
                return;
            }
        }
        out.add(ns);
    }

    /**
     * Default implementation: delegate to parent
     */
    @Override
    public QualifiedName fullyQualify(String name) {
        return parent.fullyQualify(name);
    }

    /**
     * Default implementation: check ancestry
     */
    @Override
    public boolean isWithin(IScope ancestorScope) {
        if (this == ancestorScope) {
            return true;
        }
        if (parent == null) {
            return false;
        }
        return parent.isWithin(ancestorScope);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(scopeType);
        if (node != null) {
            sb.append("(").append(node.getClass().getSimpleName()).append(")");
        }
        return sb.toString();
    }
}