package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.ETableEffectType;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
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.TUpdateSqlStatement;

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

/**
 * Scope for UPDATE statement.
 *
 * Contains:
 * - Target table (the UPDATE table)
 * - FROM clause scope (optional - for UPDATE...FROM syntax)
 * - SET clause columns
 * - WHERE clause scope
 *
 * Example:
 * UPDATE titles
 * SET total_sales = total_sales + qty
 * FROM titles, salesdetail, sales
 * WHERE titles.title_id = salesdetail.title_id
 *
 * Resolution strategy:
 * - SET clause columns resolve from target table or FROM clause tables
 * - WHERE clause columns resolve from all visible tables
 */
public class UpdateScope extends AbstractScope {

    /** FROM clause scope (includes target table and FROM clause tables) */
    private FromScope fromScope;

    /** WHERE clause scope */
    private IScope whereScope;

    /** The UPDATE statement */
    private final TUpdateSqlStatement updateStatement;

    public UpdateScope(IScope parent, TUpdateSqlStatement stmt) {
        super(parent, stmt, ScopeType.UPDATE);
        this.updateStatement = stmt;
    }

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

    public FromScope getFromScope() {
        return fromScope;
    }

    public void setWhereScope(IScope whereScope) {
        this.whereScope = whereScope;
    }

    public IScope getWhereScope() {
        return whereScope;
    }

    public TUpdateSqlStatement getUpdateStatement() {
        return updateStatement;
    }

    @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 UPDATE scope.
     *
     * Resolution strategy:
     * 1. For unqualified names (col): first check parent scope for PL/SQL variables,
     *    then search all visible namespaces in FROM scope
     * 2. For qualified names (t.col): find table t in FROM scope, then resolve col
     * 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;

        // For single-part names (unqualified), first check if any parent scope has this
        // as a PL/SQL variable. PL/SQL variables should take precedence over table columns.
        // We need to check the entire parent chain because variables can be in outer scopes.
        if (names.size() == 1) {
            String varName = names.get(0);
            IScope current = parent;
            while (current != null && !(current instanceof GlobalScope)) {
                if (current instanceof PlsqlBlockScope) {
                    PlsqlBlockScope plsqlScope = (PlsqlBlockScope) current;
                    ColumnLevel level = plsqlScope.getVariableNamespace().hasColumn(varName);
                    if (level == ColumnLevel.EXISTS) {
                        // This is a PL/SQL variable - resolve it through the scope that has it.
                        // This prevents the variable from being incorrectly linked to a table column.
                        plsqlScope.resolve(names, matcher, deep, resolved);
                        return;
                    }
                }
                current = current.getParent();
            }
        }

        // 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
                // Track matched aliases to avoid duplicate matches for same table name
                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)) {
                        // Found matching table/subquery - only add once per 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;
                    }
                    // If multiple tables without metadata, report all for ambiguity detection
                    // This allows NameResolver to detect that the column is ambiguous
                    // and populate candidateTables with all potential sources
                    else if (inferredCandidates.size() > 1) {
                        for (INamespace ns : inferredCandidates) {
                            resolved.found(ns, 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 maybe candidates means ambiguous with star columns - don't resolve
                }
            }
        }

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

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