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.TDeleteSqlStatement;

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

/**
 * Scope for DELETE statement.
 *
 * Contains:
 * - Target table (the DELETE table)
 * - FROM clause scope (optional - for DELETE...FROM syntax in SQL Server)
 * - WHERE clause scope
 *
 * Example (SQL Server):
 * DELETE FROM Sales.SalesPersonQuotaHistory
 * FROM Sales.SalesPersonQuotaHistory AS spqh
 * INNER JOIN Sales.SalesPerson AS sp
 * ON spqh.SalesPersonID = sp.SalesPersonID
 * WHERE sp.SalesYTD > 2500000.00;
 *
 * Resolution strategy:
 * - WHERE clause columns resolve from all visible tables (target table + FROM clause tables)
 * - JOIN ON clause columns resolve from the joined tables
 */
public class DeleteScope extends AbstractScope {

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

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

    /** The DELETE statement */
    private final TDeleteSqlStatement deleteStatement;

    public DeleteScope(IScope parent, TDeleteSqlStatement stmt) {
        super(parent, stmt, ScopeType.DELETE);
        this.deleteStatement = 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 TDeleteSqlStatement getDeleteStatement() {
        return deleteStatement;
    }

    @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<>();

        // Add FROM scope's namespaces
        if (fromScope != null) {
            visible.addAll(fromScope.getVisibleNamespaces());
        }

        // Add parent's namespaces
        visible.addAll(parent.getVisibleNamespaces());

        return visible;
    }

    /**
     * Resolve a name within this DELETE scope.
     *
     * Resolution strategy (same as UpdateScope):
     * 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
                // 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.
                    //
                    // Mirrors UpdateScope.resolve: physical tables without
                    // metadata (no catalog supplied) report ColumnLevel.MAYBE
                    // but do NOT support dynamic inference. They land in
                    // {@code inferredCandidates} so a single-target DELETE
                    // without a catalog still resolves its WHERE columns to
                    // the lone visible base table (EXACT_MATCH downstream).
                    // Without this branch, the slice-77 / slice-81 path that
                    // collects column refs via NameBindingProvider.bindColumn
                    // fails with NOT_FOUND for every DELETE WHERE column
                    // when no catalog is supplied.
                    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 AND resolve unambiguously when only one could.
                            if (ns.supportsDynamicInference()) {
                                maybeCandidates.add(ns);
                            } else {
                                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.
                    // For single-target DELETE without a catalog this is the typical
                    // case — the lone employees table becomes the EXACT_MATCH source.
                    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("DeleteScope(from=%s)", fromScope != null ? "present" : "null");
    }
}