package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.ETableEffectType;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.ResolvePath;
import gudusoft.gsqlparser.resolver2.model.ScopeChild;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.stmt.TMergeSqlStatement;

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

/**
 * Scope for MERGE statement.
 *
 * Contains:
 * - Target table (MERGE INTO table)
 * - Source table/subquery (USING clause)
 * - ON clause condition
 * - WHEN MATCHED/NOT MATCHED clauses
 *
 * Example:
 * MERGE INTO archive ar
 * USING (SELECT activity, description FROM activities) ac
 * ON (ar.activity = ac.activity)
 * WHEN MATCHED THEN UPDATE SET description = ac.description
 * WHEN NOT MATCHED THEN INSERT (activity, description) VALUES (ac.activity, ac.description)
 *
 * Resolution strategy:
 * - All column references resolve from target table or source table/subquery
 * - Qualified names (ar.col, ac.col) resolve to specific table
 * - Unqualified names search all visible tables
 */
public class MergeScope extends AbstractScope {

    /** FROM clause scope (contains target table and using table) */
    private FromScope fromScope;

    /** The MERGE statement */
    private final TMergeSqlStatement mergeStatement;

    public MergeScope(IScope parent, TMergeSqlStatement stmt) {
        super(parent, stmt, ScopeType.MERGE);
        this.mergeStatement = stmt;
    }

    public void setFromScope(FromScope fromScope) {
        this.fromScope = fromScope;
    }

    public FromScope getFromScope() {
        return fromScope;
    }

    public TMergeSqlStatement getMergeStatement() {
        return mergeStatement;
    }

    @Override
    public INamespace resolveTable(String tableName) {
        // First try FROM scope
        if (fromScope != null) {
            INamespace ns = fromScope.resolveTable(tableName);
            if (ns != null) {
                return ns;
            }
        }

        // Then delegate to parent
        return super.resolveTable(tableName);
    }

    @Override
    public List<INamespace> getVisibleNamespaces() {
        List<INamespace> visible = new ArrayList<>();

        // The FROM scope's own relations. The FROM scope's parent is this scope, so asking it for ITS visible
        // namespaces would come straight back here and never terminate (Mantis 4820).
        addOwnNamespaces(visible, fromScope);

        // Add parent's namespaces
        addAllDistinct(visible, getLookupParent().getVisibleNamespaces());

        return visible;
    }

    /**
     * Resolve a name within this MERGE scope.
     *
     * Resolution strategy:
     * 1. For qualified names (t.col): find table t in FROM scope, then resolve col
     * 2. For unqualified names (col): search all visible namespaces in FROM scope
     * 3. Delegate to parent for names not found locally
     */
    @Override
    public void resolve(List<String> names,
                       INameMatcher matcher,
                       boolean deep,
                       IResolved resolved) {
        if (names.isEmpty()) {
            return;
        }

        boolean foundLocally = false;

        // First, try to resolve via FROM scope
        if (fromScope != null) {
            if (names.size() >= 2) {
                // Qualified name like "t.col" - let FROM scope handle it
                String firstName = names.get(0);

                // Check if first name matches any child in FROM scope
                java.util.Set<String> matchedAliases = new java.util.HashSet<>();
                for (ScopeChild child : fromScope.getChildren()) {
                    String alias = child.getAlias();
                    if (matcher.matches(alias, firstName) && !matchedAliases.contains(alias)) {
                        matchedAliases.add(alias);
                        INamespace namespace = child.getNamespace();
                        List<String> remaining = names.subList(1, names.size());
                        resolved.found(namespace, child.isNullable(), this, new ResolvePath(), remaining);
                        foundLocally = true;
                    }
                }
            } else {
                // Single name - could be a table alias or unqualified column
                String name = names.get(0);

                // First check if it's a table alias
                for (ScopeChild child : fromScope.getChildren()) {
                    if (matcher.matches(child.getAlias(), name)) {
                        // It's a table alias - resolve as table
                        resolved.found(child.getNamespace(), child.isNullable(),
                                      this, new ResolvePath(), Collections.emptyList());
                        foundLocally = true;
                    }
                }

                // If not a table alias, try to resolve as unqualified column
                if (!foundLocally) {
                    // First, determine if we have a "sole implicit derived table" scenario
                    // According to teradata_implicit_derived_tables_zh.md:
                    // "当前作用域只可见 1 张表：未限定列默认归属该表"
                    // If there are NO explicit tables AND exactly 1 implicit derived table,
                    // unqualified columns should be linked to that implicit derived table
                    List<INamespace> explicitTables = new ArrayList<>();
                    List<INamespace> implicitDerivedTables = new ArrayList<>();

                    for (ScopeChild child : fromScope.getChildren()) {
                        INamespace ns = child.getNamespace();
                        TTable table = ns.getFinalTable();
                        if (table != null && table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable) {
                            implicitDerivedTables.add(ns);
                        } else {
                            explicitTables.add(ns);
                        }
                    }

                    // If no explicit tables and exactly 1 implicit derived table,
                    // include it for unqualified column resolution
                    boolean useSoleImplicitDerivedTable = explicitTables.isEmpty() &&
                                                           implicitDerivedTables.size() == 1;

                    // Search through all visible namespaces
                    List<INamespace> candidates = new ArrayList<>();
                    List<INamespace> maybeCandidates = new ArrayList<>();
                    List<INamespace> inferredCandidates = new ArrayList<>();

                    for (ScopeChild child : fromScope.getChildren()) {
                        INamespace ns = child.getNamespace();

                        // Skip implicit lateral derived tables (Teradata-specific)
                        // They should only match qualified references like "employee.employee_id"
                        // UNLESS this is a "sole implicit derived table" scenario where there
                        // are no explicit tables and exactly 1 implicit derived table
                        TTable table = ns.getFinalTable();
                        if (table != null && table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable) {
                            if (!useSoleImplicitDerivedTable) {
                                continue;
                            }
                        }

                        ColumnLevel level = ns.hasColumn(name);

                        if (level == ColumnLevel.EXISTS) {
                            candidates.add(ns);
                        } else if (level == ColumnLevel.MAYBE) {
                            // MAYBE means the column might exist (no metadata to confirm)
                            // For subqueries/CTEs with star columns, add to maybeCandidates
                            // For physical tables without metadata, add to inferredCandidates
                            // so we can detect ambiguity when multiple tables could have the column
                            if (ns.supportsDynamicInference()) {
                                maybeCandidates.add(ns);
                            } else {
                                // Physical tables without metadata - potential candidates for ambiguity
                                inferredCandidates.add(ns);
                            }
                        }
                    }

                    // If we found exact matches, use them
                    if (!candidates.isEmpty()) {
                        for (INamespace ns : candidates) {
                            resolved.found(ns, false, this, new ResolvePath(), names);
                        }
                        foundLocally = true;
                    }
                    // If we found MAYBE matches (star columns), only use if exactly one
                    // Multiple MAYBE candidates means ambiguous - don't resolve
                    else if (maybeCandidates.size() == 1) {
                        resolved.found(maybeCandidates.get(0), false, this, new ResolvePath(), names);
                        foundLocally = true;
                    }
                    // Single inferred candidate with no maybeCandidates - resolve to it
                    // This handles the case where other tables definitively don't have the column
                    // (e.g., subqueries with explicit SELECT lists that don't expose this column)
                    // and only one table might have it (physical table without schema metadata)
                    else if (inferredCandidates.size() == 1 && maybeCandidates.isEmpty()) {
                        resolved.found(inferredCandidates.get(0), false, this, new ResolvePath(), names);
                        foundLocally = true;
                    }
                    // Multiple inferred candidates or multiple maybe candidates - leave unresolved
                    // The column will be handled by the old resolver or formatter's linkOrphanColumnToFirstTable
                }
            }
        }

        // If not found locally, delegate to parent
        if (!foundLocally) {
            parent.resolve(names, matcher, deep, resolved);
        }
    }

    @Override
    public String toString() {
        return String.format("MergeScope(from=%s)", fromScope != null ? "present" : "null");
    }
}