package gudusoft.gsqlparser.ir.semantic.binding;

import gudusoft.gsqlparser.ir.semantic.RelationKind;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TResultColumn;
import gudusoft.gsqlparser.nodes.TResultColumnList;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ResolutionStatus;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.model.ResolutionResult;
import gudusoft.gsqlparser.sqlenv.TSQLColumn;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * {@link NameBindingProvider} backed by the data already attached to AST
 * nodes by {@code TSQLResolver2} during {@code TGSqlParser.parse()}.
 *
 * <p>Slice 1/2 only handled {@link RelationKind#TABLE}. Slice 3 adds
 * {@link RelationKind#CTE} via {@link #withCteContext(Set)}: when the
 * provider is given a non-empty CTE-name set, a FROM-clause reference
 * whose name (case-insensitive) is in the set binds as
 * {@code RelationKind.CTE} instead of {@code RelationKind.TABLE}.
 */
public final class Resolver2NameBindingProvider implements NameBindingProvider {

    /**
     * Slice 58 — optional catalog source for {@link
     * #getRelationColumnNames(TTable)}. May be {@code null} (no catalog
     * available); in that case {@code getRelationColumnNames} returns
     * {@code null} and the builder emits a structured "requires catalog"
     * diagnostic.
     */
    private final TSQLEnv sqlEnv;

    private final Set<String> cteNamesInScope;

    /**
     * Slice 60 — REPLACE-semantics map of in-scope CTE / FROM-subquery
     * names → published column names for star expansion. Always
     * non-null (empty map when no scope is set). Keys are lower-case
     * (defensive copy in the canonical constructor); the value lists
     * are wrapped with {@link Collections#unmodifiableList} so callers
     * cannot mutate the snapshot the provider observed.
     */
    private final Map<String, List<String>> inScopeRelationColumns;

    /**
     * Slice 65 — REPLACE-semantics using-key scope for the current
     * SELECT body. Always non-null (defaults to {@link UsingScope#EMPTY}).
     * Each {@code buildSelectStatementImpl} invocation resets this at
     * entry so an enclosing SELECT's USING cannot leak into recursive
     * nested builds.
     */
    private final UsingScope usingScope;

    /**
     * Slice 93 — when true, {@link #bindColumn} promotes a column
     * reference whose Phase-2 ({@code TSQLResolver2}) {@code resolution}
     * is null but whose Phase-1 ({@code linkColumnToTable})
     * {@code sourceTable} is set from {@code NOT_FOUND} to
     * {@code EXACT_MATCH}. Used for Hive multi-insert sub-SELECTs whose
     * secondary branches are not traversed by Resolver2 during
     * {@code TGSqlParser.parse()}. The promotion additionally requires
     * the column's SQL-written qualifier (if any) to be consistent with
     * the source table's name / alias (see {@link #bindColumn}).
     */
    private final boolean sourceTableFallback;

    /**
     * Slice 117 — set of inner local relation aliases (lowercased) used
     * by the tolerant-outer-binding fallback in {@link #bindColumn}. When
     * non-empty, any qualified ref whose Phase-2 binding is not
     * {@link ResolutionStatus#EXACT_MATCH} AND whose qualifier is NOT in
     * this set is promoted to a synthetic EXACT_MATCH binding with
     * {@code (qualifier, columnName)}. Qualifiers IN this set fall
     * through to strict binding (a real typo on a local alias still
     * rejects). Empty set disables the fallback.
     */
    private final Set<String> tolerantInnerLocalAliases;

    /**
     * Structural anchor for the {@code COLUMN_BINDING_NON_EXACT} degrade: true
     * when the current SELECT body's FROM clause resolved a fully-built join
     * graph (two or more endpoints from explicit ON / CROSS / comma
     * predicates). Set per-SELECT by the IR builder after relations are bound
     * and reset at every nested build entry so it cannot leak across scopes.
     * See {@link #withJoinStructureAnchor(boolean)}.
     */
    private final boolean joinStructureAnchor;

    public Resolver2NameBindingProvider() {
        this(null, Collections.<String>emptySet(),
                Collections.<String, List<String>>emptyMap(),
                UsingScope.EMPTY, false, Collections.<String>emptySet(), false);
    }

    /**
     * Slice 58 — construct a provider with catalog access. The {@code
     * sqlEnv} is used only by {@link #getRelationColumnNames(TTable)} for
     * star expansion; the resolver binding paths remain unchanged.
     */
    public Resolver2NameBindingProvider(TSQLEnv sqlEnv) {
        this(sqlEnv, Collections.<String>emptySet(),
                Collections.<String, List<String>>emptyMap(),
                UsingScope.EMPTY, false, Collections.<String>emptySet(), false);
    }

    /**
     * Slice 60 / 65 — canonical private constructor. All public and
     * narrower entry points delegate here so every Resolver2-backed
     * provider instance has all four fields populated explicitly.
     * Adding another facet later is a single signature change here +
     * mirror updates at the narrowers ({@link #withCteContext},
     * {@link #withInScopeRelationColumns}, {@link #withUsingScope}).
     */
    private Resolver2NameBindingProvider(TSQLEnv sqlEnv,
                                         Set<String> cteNamesInScope,
                                         Map<String, List<String>> inScopeRelationColumns,
                                         UsingScope usingScope,
                                         boolean sourceTableFallback,
                                         Set<String> tolerantInnerLocalAliases,
                                         boolean joinStructureAnchor) {
        this.sqlEnv = sqlEnv;
        this.sourceTableFallback = sourceTableFallback;
        this.joinStructureAnchor = joinStructureAnchor;
        // Slice 117: defensive copy + lowercased. Empty set disables
        // the tolerant-outer-binding fallback.
        Set<String> normalizedTolerant = new HashSet<>();
        if (tolerantInnerLocalAliases != null) {
            for (String a : tolerantInnerLocalAliases) {
                if (a != null && !a.isEmpty()) {
                    normalizedTolerant.add(a.toLowerCase(Locale.ROOT));
                }
            }
        }
        this.tolerantInnerLocalAliases =
                Collections.unmodifiableSet(normalizedTolerant);
        // Defensive copy + lowercased for case-insensitive lookup.
        // NOTE: this is a slice-3 simplification; quoted/case-sensitive
        // identifiers (e.g. Oracle's `"a"` vs `a`, PostgreSQL's lowercased
        // unquoted names) are not yet handled. A later slice should fold
        // identifiers through the parser/resolver's vendor-aware identifier
        // model rather than `String.toLowerCase()`.
        Set<String> normalized = new HashSet<>();
        if (cteNamesInScope != null) {
            for (String n : cteNamesInScope) {
                if (n != null && !n.isEmpty()) {
                    normalized.add(n.toLowerCase(Locale.ROOT));
                }
            }
        }
        this.cteNamesInScope = Collections.unmodifiableSet(normalized);
        // Slice 60: deep-copy the map. Lower-case keys; wrap value
        // lists in unmodifiableList. Empty entries are skipped — an
        // empty list never means "in scope but has no columns" (it
        // would surface as `NO_INSCOPE_RELATION_COLUMNS` at the
        // expander anyway, but explicit drop here keeps the provider
        // invariant clean).
        Map<String, List<String>> normalizedColumns = new HashMap<>();
        if (inScopeRelationColumns != null) {
            for (Map.Entry<String, List<String>> e : inScopeRelationColumns.entrySet()) {
                String k = e.getKey();
                List<String> v = e.getValue();
                if (k == null || k.isEmpty() || v == null || v.isEmpty()) continue;
                normalizedColumns.put(
                        k.toLowerCase(Locale.ROOT),
                        Collections.unmodifiableList(new ArrayList<>(v)));
            }
        }
        this.inScopeRelationColumns = Collections.unmodifiableMap(normalizedColumns);
        this.usingScope = usingScope == null ? UsingScope.EMPTY : usingScope;
    }

    @Override
    public NameBindingProvider withCteContext(Set<String> cteNamesInScope) {
        // Slice 58 preserves sqlEnv. Slice 60 also preserves
        // inScopeRelationColumns: the CTE-context narrowing is
        // orthogonal to star-expansion scope. Without this, the
        // CTE-body build path's bodyProvider would lose the outer
        // map and CTE-body star expansion of an EARLIER CTE would
        // hit NO_INSCOPE_RELATION_COLUMNS. Slice 65 also preserves
        // usingScope so a withCteContext call inside an already-narrowed
        // build doesn't lose the current SELECT's USING scope.
        // Slice 93: also preserves sourceTableFallback.
        // Slice 117: also preserves tolerantInnerLocalAliases.
        return new Resolver2NameBindingProvider(this.sqlEnv, cteNamesInScope,
                this.inScopeRelationColumns, this.usingScope,
                this.sourceTableFallback, this.tolerantInnerLocalAliases,
                this.joinStructureAnchor);
    }

    @Override
    public NameBindingProvider withInScopeRelationColumns(
            Map<String, List<String>> nameToColumns) {
        // Slice 60 replace-semantics: the supplied map fully describes
        // the new scope. Preserves sqlEnv (catalog access for
        // base-table star expansion stays available even when scoped
        // to a CTE body) AND cteNamesInScope (so a later
        // bindRelation() call still classifies CTE-bound relations
        // correctly). Slice 65: also preserves usingScope.
        // Slice 93: also preserves sourceTableFallback.
        // Slice 117: also preserves tolerantInnerLocalAliases.
        return new Resolver2NameBindingProvider(this.sqlEnv,
                this.cteNamesInScope, nameToColumns, this.usingScope,
                this.sourceTableFallback, this.tolerantInnerLocalAliases,
                this.joinStructureAnchor);
    }

    @Override
    public NameBindingProvider withUsingScope(UsingScope scope) {
        // Slice 65 replace-semantics: the supplied scope fully describes
        // the merged-key context for the current SELECT body. Preserves
        // sqlEnv, cteNamesInScope, and inScopeRelationColumns so the
        // other facets are unaffected.
        // Slice 93: also preserves sourceTableFallback.
        // Slice 117: also preserves tolerantInnerLocalAliases.
        return new Resolver2NameBindingProvider(this.sqlEnv,
                this.cteNamesInScope, this.inScopeRelationColumns,
                scope == null ? UsingScope.EMPTY : scope,
                this.sourceTableFallback, this.tolerantInnerLocalAliases,
                this.joinStructureAnchor);
    }

    @Override
    public NameBindingProvider withSourceTableFallback(boolean enabled) {
        // Slice 93 — preserves all other facets. Returns same instance
        // when state already matches the requested mode (cheap no-op).
        // Slice 117: also preserves tolerantInnerLocalAliases.
        if (this.sourceTableFallback == enabled) {
            return this;
        }
        return new Resolver2NameBindingProvider(this.sqlEnv,
                this.cteNamesInScope, this.inScopeRelationColumns,
                this.usingScope, enabled, this.tolerantInnerLocalAliases,
                this.joinStructureAnchor);
    }

    @Override
    public NameBindingProvider withTolerantOuterBinding(
            Set<String> innerLocalAliasesLower) {
        // Slice 117 — REPLACE semantics: the supplied set fully
        // describes the inner-local guard for tolerant-outer-binding.
        // Preserves all other facets (sqlEnv / cteNamesInScope /
        // inScopeRelationColumns / usingScope / sourceTableFallback).
        // Passing null / empty disables the fallback in the canonical
        // constructor (which normalises a null/empty set to an empty
        // unmodifiable set).
        return new Resolver2NameBindingProvider(this.sqlEnv,
                this.cteNamesInScope, this.inScopeRelationColumns,
                this.usingScope, this.sourceTableFallback,
                innerLocalAliasesLower, this.joinStructureAnchor);
    }

    @Override
    public UsingScope getUsingScope() {
        return usingScope;
    }

    @Override
    public NameBindingProvider withJoinStructureAnchor(boolean anchored) {
        // REPLACE semantics: the supplied flag fully describes whether THIS
        // SELECT body has a fully-built join graph. Preserves all other facets
        // (sqlEnv / cteNamesInScope / inScopeRelationColumns / usingScope /
        // sourceTableFallback / tolerantInnerLocalAliases). Returns the same
        // instance when state already matches (cheap no-op).
        if (this.joinStructureAnchor == anchored) {
            return this;
        }
        return new Resolver2NameBindingProvider(this.sqlEnv,
                this.cteNamesInScope, this.inScopeRelationColumns,
                this.usingScope, this.sourceTableFallback,
                this.tolerantInnerLocalAliases, anchored);
    }

    @Override
    public boolean hasJoinStructureAnchor() {
        return joinStructureAnchor;
    }

    @Override
    public Map<String, List<String>> getInScopeRelationColumns() {
        return inScopeRelationColumns;
    }

    @Override
    public List<String> getRelationColumnNames(TTable table) {
        if (sqlEnv == null || table == null) {
            return null;
        }
        // Only base-table relations are eligible for catalog lookup;
        // CTE / FROM-subquery / function tables resolve via separate
        // binding paths and are out of scope for slice 58 (S60).
        if (table.getTableType() != gudusoft.gsqlparser.ETableSource.objectname) {
            return null;
        }
        TObjectName tableName = table.getTableName();
        if (tableName == null) {
            return null;
        }
        // TSQLEnv.searchTable(TObjectName) handles bare names via the
        // "..<name>" fallback (TSQLEnv.java:1167-1171) for PG/Oracle/
        // Snowflake. Other dialects (e.g. MSSQL with ".dbo." expansion)
        // require the caller to register the table under the matching
        // qualified form.
        TSQLTable tbl = sqlEnv.searchTable(tableName);
        if (tbl == null) {
            return null;
        }
        List<TSQLColumn> cols = tbl.getColumnList();
        if (cols == null || cols.isEmpty()) {
            return null;
        }
        // Slice 58 dedup. TSQLTable.getColumnList iterates columnMap.keySet,
        // and addColumn stores each column under both the legacy
        // normalization key AND the IdentifierService key when the two
        // differ (TSQLTable.java:127-150). For unquoted identifiers on
        // most dialects those keys disagree, so the same TSQLColumn
        // surfaces twice (the SAME instance under two keys). Identity-
        // based dedup keeps distinct case-sensitive/quoted catalog
        // columns intact (codex round-1 diff review SHOULD) — case-fold
        // dedup would have collapsed e.g. catalog columns "Id" and "id"
        // declared as separate quoted identifiers.
        List<String> names = new ArrayList<>(cols.size());
        java.util.IdentityHashMap<TSQLColumn, Boolean> seen = new java.util.IdentityHashMap<>();
        for (TSQLColumn c : cols) {
            if (c == null) {
                continue;
            }
            if (seen.put(c, Boolean.TRUE) != null) {
                continue;
            }
            String n = c.getNameKeepCase();
            if (n == null || n.isEmpty()) {
                n = c.getName();
            }
            if (n == null || n.isEmpty()) {
                continue;
            }
            names.add(n);
        }
        if (names.isEmpty()) {
            return null;
        }
        return Collections.unmodifiableList(names);
    }

    @Override
    public RelationBinding bindRelation(TTable table) {
        if (table == null) {
            return null;
        }
        // Slice 5 added FROM-clause subqueries: a TTable of type
        // ETableSource.subquery binds as RelationKind.SUBQUERY using its
        // alias as the qualifiedName (no globally-visible name exists).
        // Slice 74 extended this to admit anonymous (unaliased) FROM
        // subqueries by synthesizing a position-keyed alias via
        // FromSubqueryNaming.synthAliasFor.
        // NOTE: aliases are matched case-insensitively elsewhere in the
        // builder (see e.g. cte alias lookup) — quoted/case-sensitive
        // aliases share the same slice-3 limitation.
        if (table.getTableType() == gudusoft.gsqlparser.ETableSource.subquery) {
            String alias = table.getAliasName();
            if (alias == null || alias.isEmpty()) {
                alias = FromSubqueryNaming.synthAliasFor(table);
            }
            if (alias == null || alias.isEmpty()) {
                return null;
            }
            return new RelationBinding(RelationKind.SUBQUERY, alias);
        }
        // Table-valued function source (SQL Server CROSS/OUTER APPLY's
        // right operand, or a plain FROM dbo.fn(...) t). Bind as an opaque
        // FUNCTION relation whose qualifiedName is the function name (the
        // stable lineage terminal, matching resolver2's resolution of the
        // function's output columns) — the source alias is carried by
        // RelationSource.alias via effectiveAliasOf. The column set is
        // opaque, so referenced columns (t.q) resolve to this relation but
        // are never expanded/validated.
        //
        // Boundary (uniform across APPLY and non-APPLY positions): the
        // function ARGUMENTS are not modelled as lineage/correlation here.
        // For a correlated APPLY arg (CROSS APPLY dbo.fn(o.id) t) the
        // o.id->orders correlation is therefore not surfaced as an edge;
        // for a non-APPLY CROSS JOIN the right side is genuinely
        // independent. A correlated argument in a non-APPLY join is invalid
        // T-SQL (correlation requires APPLY), so that shape is GIGO rather
        // than a supported case. Argument lineage is a documented follow-up.
        if (table.getTableType() == gudusoft.gsqlparser.ETableSource.function) {
            String fnName = (table.getTableName() != null)
                    ? table.getTableName().toString() : null;
            if (fnName == null || fnName.isEmpty()) {
                fnName = table.getName();
            }
            if (fnName == null || fnName.isEmpty()) {
                fnName = table.getAliasName();
            }
            if (fnName == null || fnName.isEmpty()) {
                return null;
            }
            return new RelationBinding(RelationKind.FUNCTION, fnName);
        }
        // Otherwise only base tables (ETableSource.objectname) are bound.
        // Other source kinds (rowList, etc.) return null so the builder
        // fails fast.
        if (table.getTableType() != gudusoft.gsqlparser.ETableSource.objectname) {
            return null;
        }
        String name = table.getName();
        if (name == null || name.isEmpty()) {
            return null;
        }
        if (cteNamesInScope.contains(name.toLowerCase(Locale.ROOT))) {
            return new RelationBinding(RelationKind.CTE, name);
        }
        return new RelationBinding(RelationKind.TABLE, name);
    }

    @Override
    public ColumnBinding bindColumn(TObjectName columnRef) {
        if (columnRef == null) {
            return null;
        }
        String columnName = columnRef.getColumnNameOnly();
        if (columnName == null || columnName.isEmpty() || "*".equals(columnName)) {
            return null;
        }
        // Effective in-statement alias: prefer the prefix actually written in
        // the SQL (e.g. `e` in `e.id`); fall back to the resolved source-table
        // name when the column was written unqualified.
        // Slice 74: when the source table is an unaliased FROM-subquery,
        // route through FromSubqueryNaming so the ColumnRef.relationAlias
        // matches the synth name used by buildRelation / processDirectSubqueryTable
        // (otherwise we'd emit `relationAlias = "subquery"`, which no
        // relation map knows about, and projection lookups would fail
        // with "references unknown relation 'subquery'").
        String relationAlias = columnRef.getTableString();
        if (relationAlias == null || relationAlias.isEmpty()) {
            if (columnRef.getSourceTable() != null) {
                gudusoft.gsqlparser.nodes.TTable st = columnRef.getSourceTable();
                String sourceAlias = st.getAliasName();
                if (sourceAlias != null && !sourceAlias.isEmpty()) {
                    relationAlias = sourceAlias;
                } else if (st.getTableType() == gudusoft.gsqlparser.ETableSource.subquery) {
                    relationAlias = FromSubqueryNaming.synthAliasFor(st);
                } else {
                    relationAlias = st.getName();
                }
            }
        }
        if (relationAlias == null || relationAlias.isEmpty()) {
            return null;
        }

        ResolutionResult resolution = columnRef.getResolution();
        ResolutionStatus status = resolution == null ? ResolutionStatus.NOT_FOUND : resolution.getStatus();
        String finalTable = null;
        if (resolution != null && resolution.getStatus() == ResolutionStatus.EXACT_MATCH) {
            ColumnSource source = resolution.getColumnSource();
            if (source != null && source.getFinalTable() != null) {
                finalTable = source.getFinalTable().getName();
            }
        }
        // Slice 93 — Phase-1 source-table fallback for Hive multi-insert
        // sub-SELECTs. Resolver2 does not traverse secondary multi-insert
        // branches, so their columns have resolution == null (Phase 2 did
        // not run). When Phase 1's linkColumnToTable has set sourceTable,
        // trust that and promote the status to EXACT_MATCH so
        // collectColumnRefs admits the binding.
        //
        // CRITICAL DISCRIMINATORS:
        //  1. Only fire when resolution == null (Phase 2 did not run).
        //     Do NOT fire on an explicit NOT_FOUND/AMBIGUOUS status from
        //     Resolver2 — that would overrule Resolver2's deliberate
        //     rejections (round-2 codex Q1 BLOCKING).
        //  2. If the column has a SQL-written qualifier (e.g. `s.id`),
        //     the qualifier MUST match Phase 1's chosen source table by
        //     name or alias (case-insensitive). Otherwise Phase 1 may have
        //     heuristically picked a source the user did not name, and
        //     promoting would silently mis-bind (round-3 codex P0 BLOCKING).
        //  3. The source table must have a non-empty resolvable name; an
        //     anonymous source table is not a trustworthy fallback target.
        if (sourceTableFallback && resolution == null
                && columnRef.getSourceTable() != null
                && qualifierMatchesSource(columnRef)) {
            status = ResolutionStatus.EXACT_MATCH;
            // finalTable stays null — Phase 1 only knows the source table,
            // not the catalog's final binding. Downstream consumers should
            // tolerate finalTable == null on fallback-promoted bindings.
        }
        // Slice 117 — tolerant-outer-binding fallback for the UPDATE
        // SET-RHS scalar-subquery extractor. When the binding is still
        // non-EXACT_MATCH at this point (Resolver2 marked the ref as
        // NOT_FOUND because the qualifier resolves to neither an inner
        // local relation nor a Phase-1 sourceTable), AND the ref carries
        // a non-empty SQL-written qualifier, AND that qualifier is NOT
        // in the inner local FROM aliases, promote to a synthetic
        // EXACT_MATCH binding with (qualifier, columnName). The slice-11
        // promoter then sees the resulting ColumnRef and synthesises an
        // OUTER_REFERENCE relation against the enclosing scope.
        //
        // Qualifiers IN the inner local FROM aliases fall through to
        // strict binding so real typos (e.g. `o.bad_col` where `o` is the
        // inner FROM alias) still reject as COLUMN_BINDING_NON_EXACT.
        // Unqualified refs also fall through (their binding is genuinely
        // ambiguous between inner and outer; the caller throws the same
        // diagnostic).
        if (status != ResolutionStatus.EXACT_MATCH
                && !tolerantInnerLocalAliases.isEmpty()) {
            String qual = columnRef.getTableString();
            if (qual != null && !qual.isEmpty()
                    && !tolerantInnerLocalAliases.contains(
                            qual.toLowerCase(Locale.ROOT))) {
                // Use the SQL-written qualifier as the relationAlias so
                // promoteCorrelatedRefsToOuterReference looks up the
                // enclosing scope by the user-written name (matches the
                // slice-14 alias-preserving convention).
                return new ColumnBinding(qual, columnName, /*finalTable=*/ null,
                        ResolutionStatus.EXACT_MATCH);
            }
        }
        return new ColumnBinding(relationAlias, columnName, finalTable, status);
    }

    /**
     * Slice 93 — safety predicate for the {@link #sourceTableFallback}
     * path. Returns true when it's safe to trust Phase 1's
     * {@code sourceTable} on a column reference whose Phase 2 resolution
     * is null.
     *
     * <p>Safe when:
     * <ul>
     *   <li>The source table has a non-empty name (anonymous tables are
     *       not trustworthy fallback targets), AND</li>
     *   <li>Either the column reference is unqualified (single-source
     *       FROMs in Hive multi-insert make Phase 1's choice unambiguous),
     *       or the qualifier matches the source's name or alias
     *       (case-insensitive) — a mismatched qualifier means Phase 1
     *       picked a different source than the user named.</li>
     * </ul>
     */
    private static boolean qualifierMatchesSource(TObjectName columnRef) {
        gudusoft.gsqlparser.nodes.TTable st = columnRef.getSourceTable();
        if (st == null) {
            return false;
        }
        String srcName = st.getName();
        String srcAlias = st.getAliasName();
        boolean hasIdentifiableSource = (srcName != null && !srcName.isEmpty())
                || (srcAlias != null && !srcAlias.isEmpty());
        if (!hasIdentifiableSource) {
            return false;
        }
        String qual = columnRef.getTableString();
        if (qual == null || qual.isEmpty()) {
            // Unqualified — Phase 1's choice stands. In single-source FROM
            // contexts (the only Hive multi-insert shape currently
            // admitted) this is unambiguous.
            return true;
        }
        // Qualified — qualifier must match source name or alias.
        return qual.equalsIgnoreCase(srcName) || qual.equalsIgnoreCase(srcAlias);
    }

    /**
     * Slice 19: detect alias-bound PARTITION BY / OVER ORDER BY refs.
     *
     * <p>The check fires only when ALL of:
     * <ol>
     *   <li>{@code columnRef} is unqualified ({@code getTableToken() == null});
     *       a qualified ref like {@code e.doubled} explicitly names a FROM
     *       relation, not a SELECT alias.</li>
     *   <li>The resolver's binding lacks definite FROM-scope evidence
     *       (i.e. {@code !hasDefiniteEvidence()}); the discriminator only
     *       fires for the heuristic {@code inferred_from_usage} fallback
     *       in {@code TableNamespace.resolveColumn}.</li>
     *   <li>Some result column in {@code enclosingSelect}'s result-column
     *       list exposes the same name (case-insensitive) AND its
     *       expression is a calculated expression (anything but a simple
     *       column reference / star).</li>
     * </ol>
     *
     * <p>If multiple result columns share the exposed name and at least
     * one is calculated, the method returns {@code true} — order-
     * independent rejection keeps the slice invariant deterministic.
     *
     * <p>Classification reuses {@code ColumnSource.isCalculatedColumn()}
     * by constructing a transient {@code ColumnSource} pinned to the
     * candidate {@code TResultColumn}; the helper inspects only the
     * definition-node expression and is independent of namespace state.
     */
    @Override
    public boolean isCalculatedProjectionAliasFallback(TObjectName columnRef,
                                                       TSelectSqlStatement enclosingSelect) {
        if (columnRef == null || enclosingSelect == null) {
            return false;
        }
        // Unqualified-only.
        if (columnRef.getTableToken() != null) {
            return false;
        }
        String columnName = columnRef.getColumnNameOnly();
        if (columnName == null || columnName.isEmpty()) {
            return false;
        }
        // Definite-evidence guard: skip when the resolver has positive
        // FROM-scope evidence (DDL / SQLEnv / explicit metadata).
        ResolutionResult resolution = columnRef.getResolution();
        if (resolution == null || resolution.getStatus() != ResolutionStatus.EXACT_MATCH) {
            return false;
        }
        ColumnSource source = resolution.getColumnSource();
        if (source == null) {
            return false;
        }
        if (source.hasDefiniteEvidence()) {
            return false;
        }
        // AST walk: any matching exposed name on a calculated expression?
        TResultColumnList rcl = enclosingSelect.getResultColumnList();
        if (rcl == null) {
            return false;
        }
        for (int i = 0; i < rcl.size(); i++) {
            TResultColumn rc = rcl.getResultColumn(i);
            if (rc == null) {
                continue;
            }
            String exposed;
            if (rc.getColumnAlias() != null && !rc.getColumnAlias().isEmpty()) {
                exposed = rc.getColumnAlias();
            } else {
                exposed = rc.getColumnNameOnly();
            }
            if (exposed == null || exposed.isEmpty()) {
                continue;
            }
            if (!exposed.equalsIgnoreCase(columnName)) {
                continue;
            }
            // Reuse ColumnSource's calculated-column classification by
            // pinning the definition node to this result column. The
            // transient source has no namespace; isCalculatedColumn()
            // looks only at the definition expression.
            ColumnSource transientSource = new ColumnSource(
                    null, exposed, rc, 0.0, "slice19_alias_classifier");
            if (transientSource.isCalculatedColumn()) {
                return true;
            }
        }
        return false;
    }
}