package gudusoft.gsqlparser.ir.semantic;

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

/**
 * Semantic shape of one SQL statement. Currently covers SELECT.
 *
 * <p>{@link #name} is non-null when this statement is the body of a named
 * CTE or a FROM-clause subquery. For top-level outer SELECTs it is null.
 *
 * <p>{@link #filterColumnRefs}, {@link #joinColumnRefs},
 * {@link #groupByColumnRefs}, {@link #havingColumnRefs}, and
 * {@link #orderByColumnRefs} are flat lists of column references that
 * appear in the WHERE, JOIN predicate (ON / USING), GROUP BY, HAVING,
 * and ORDER BY clauses respectively. For {@code JOIN ... USING (k)}
 * (slice 64) {@code joinColumnRefs} contains one ref per
 * (relation, key) pair on both sides — left side first via
 * catalog-aware narrowing, then the right side. The IR deliberately
 * does <i>not</i> model structured
 * {@code Filter}, {@code Join}, or {@code GroupBy} nodes with predicate
 * trees yet; later slices will add them. Listing the affected columns
 * is enough to answer the roadmap's questions about
 * filter/join/grouping/having/ordering influence.
 *
 * <p>{@link #orderByColumnRefs} only ever contains references to physical
 * (base or in-statement) columns. Ordinal references ({@code ORDER BY 1})
 * and bare-constant sort keys are rejected by the builder — emitting
 * {@code []} for them would lose the dependency information silently.
 *
 * <p>Slice 9 (single-SELECT) rejects projection-alias references like
 * {@code SELECT id AS x ... ORDER BY x}. Slice 21 (set-op outer)
 * <i>accepts</i> alias references positionally against branch[0]'s
 * outputs — the alias IS the set-op output schema. The two paths
 * diverge intentionally; see
 * {@code SemanticIRBuilder.buildOrderByColumnRefs} (slice 9) versus
 * {@code SemanticIRBuilder.buildSetOpOuterOrderByColumnRefs} (slice 21).
 */
public final class StatementGraph {

    private final String name;
    private final String kind;
    private final List<RelationSource> relations;
    private final List<OutputColumn> outputColumns;
    private final List<OutputColumn> returningColumns;
    private final List<ColumnRef> filterColumnRefs;
    private final List<ColumnRef> joinColumnRefs;
    private final List<ColumnRef> groupByColumnRefs;
    private final List<ColumnRef> havingColumnRefs;
    private final List<ColumnRef> orderByColumnRefs;
    private final List<ColumnRef> distinctOnColumnRefs;
    private final boolean distinct;
    private final SetOperator setOperator;
    private final RowLimit rowLimit;
    private final TargetRelation target;

    /**
     * Slice 85 primary constructor — adds the optional
     * {@code returningColumns} slot for INSERT / UPDATE / DELETE RETURNING
     * (PG / Oracle) and OUTPUT (SQL Server) projections. The slot is
     * always non-null (use {@link Collections#emptyList()} when absent);
     * non-empty only on DML statements that supplied a RETURNING or
     * OUTPUT projection.
     */
    public StatementGraph(String name,
                          String kind,
                          List<RelationSource> relations,
                          List<OutputColumn> outputColumns,
                          List<OutputColumn> returningColumns,
                          List<ColumnRef> filterColumnRefs,
                          List<ColumnRef> joinColumnRefs,
                          List<ColumnRef> groupByColumnRefs,
                          List<ColumnRef> havingColumnRefs,
                          List<ColumnRef> orderByColumnRefs,
                          List<ColumnRef> distinctOnColumnRefs,
                          boolean distinct,
                          SetOperator setOperator,
                          RowLimit rowLimit,
                          TargetRelation target) {
        if (kind == null || kind.isEmpty()) {
            throw new IllegalArgumentException("kind must be non-empty");
        }
        if (relations == null || outputColumns == null
                || returningColumns == null
                || filterColumnRefs == null || joinColumnRefs == null
                || groupByColumnRefs == null || havingColumnRefs == null
                || orderByColumnRefs == null || distinctOnColumnRefs == null) {
            throw new IllegalArgumentException(
                    "relations/outputColumns/returningColumns/filterColumnRefs/joinColumnRefs/"
                            + "groupByColumnRefs/havingColumnRefs/orderByColumnRefs/"
                            + "distinctOnColumnRefs must not be null");
        }
        this.name = (name != null && name.isEmpty()) ? null : name;
        this.kind = kind;
        this.relations = Collections.unmodifiableList(new ArrayList<>(relations));
        this.outputColumns = Collections.unmodifiableList(new ArrayList<>(outputColumns));
        this.returningColumns = Collections.unmodifiableList(new ArrayList<>(returningColumns));
        this.filterColumnRefs = Collections.unmodifiableList(new ArrayList<>(filterColumnRefs));
        this.joinColumnRefs = Collections.unmodifiableList(new ArrayList<>(joinColumnRefs));
        this.groupByColumnRefs = Collections.unmodifiableList(new ArrayList<>(groupByColumnRefs));
        this.havingColumnRefs = Collections.unmodifiableList(new ArrayList<>(havingColumnRefs));
        this.orderByColumnRefs = Collections.unmodifiableList(new ArrayList<>(orderByColumnRefs));
        this.distinctOnColumnRefs = Collections.unmodifiableList(new ArrayList<>(distinctOnColumnRefs));
        this.distinct = distinct;
        this.setOperator = setOperator;
        this.rowLimit = rowLimit;
        this.target = target;
    }

    /**
     * Slice 78 constructor preserved so production code that predates
     * slice 85 keeps compiling unchanged. Delegates to the slice-85
     * primary constructor with empty {@code returningColumns}.
     */
    public StatementGraph(String name,
                          String kind,
                          List<RelationSource> relations,
                          List<OutputColumn> outputColumns,
                          List<ColumnRef> filterColumnRefs,
                          List<ColumnRef> joinColumnRefs,
                          List<ColumnRef> groupByColumnRefs,
                          List<ColumnRef> havingColumnRefs,
                          List<ColumnRef> orderByColumnRefs,
                          List<ColumnRef> distinctOnColumnRefs,
                          boolean distinct,
                          SetOperator setOperator,
                          RowLimit rowLimit,
                          TargetRelation target) {
        this(name, kind, relations, outputColumns,
                Collections.<OutputColumn>emptyList(),
                filterColumnRefs, joinColumnRefs, groupByColumnRefs,
                havingColumnRefs, orderByColumnRefs,
                distinctOnColumnRefs,
                distinct, setOperator, rowLimit, target);
    }

    /**
     * Slice 73 constructor preserved so SELECT-kind production code that
     * predates slice 78 keeps compiling unchanged. Delegates to the
     * slice-78 constructor with {@code target=null}.
     */
    public StatementGraph(String name,
                          String kind,
                          List<RelationSource> relations,
                          List<OutputColumn> outputColumns,
                          List<ColumnRef> filterColumnRefs,
                          List<ColumnRef> joinColumnRefs,
                          List<ColumnRef> groupByColumnRefs,
                          List<ColumnRef> havingColumnRefs,
                          List<ColumnRef> orderByColumnRefs,
                          List<ColumnRef> distinctOnColumnRefs,
                          boolean distinct,
                          SetOperator setOperator,
                          RowLimit rowLimit) {
        this(name, kind, relations, outputColumns,
                filterColumnRefs, joinColumnRefs, groupByColumnRefs,
                havingColumnRefs, orderByColumnRefs,
                distinctOnColumnRefs,
                distinct, setOperator, rowLimit, /*target=*/ null);
    }

    /**
     * Pre-slice-73 constructor preserved so hand-built test fixtures
     * (e.g. {@code SemanticIRProjectorBodyIndexesTest}) continue to
     * compile without touching every call site. Delegates to the
     * slice-73 constructor with an empty {@code distinctOnColumnRefs}
     * list. New production code should call the slice-78 primary
     * constructor directly.
     */
    public StatementGraph(String name,
                          String kind,
                          List<RelationSource> relations,
                          List<OutputColumn> outputColumns,
                          List<ColumnRef> filterColumnRefs,
                          List<ColumnRef> joinColumnRefs,
                          List<ColumnRef> groupByColumnRefs,
                          List<ColumnRef> havingColumnRefs,
                          List<ColumnRef> orderByColumnRefs,
                          boolean distinct,
                          SetOperator setOperator,
                          RowLimit rowLimit) {
        this(name, kind, relations, outputColumns,
                filterColumnRefs, joinColumnRefs, groupByColumnRefs,
                havingColumnRefs, orderByColumnRefs,
                Collections.<ColumnRef>emptyList(),
                distinct, setOperator, rowLimit);
    }

    /** Nullable: name for a CTE body or FROM-subquery alias, else null. */
    public String getName() {
        return name;
    }

    public String getKind() {
        return kind;
    }

    public List<RelationSource> getRelations() {
        return relations;
    }

    public List<OutputColumn> getOutputColumns() {
        return outputColumns;
    }

    /**
     * Slice 85 — RETURNING / OUTPUT projection columns for INSERT / UPDATE /
     * DELETE statements. Empty list on every SELECT-kind statement (CTE
     * body / FROM-subquery / scalar / set-op branch / outer), on every
     * DML statement that did not supply a RETURNING (PG / Oracle) or
     * OUTPUT (SQL Server) clause, and on CTAS / CREATE VIEW statements.
     *
     * <p>For PG / Oracle RETURNING, each entry's
     * {@link OutputColumn#getName()} is the explicit alias when present,
     * else the verbatim bare column spelling.
     * {@link OutputColumn#getSources()} lists the underlying column refs;
     * the {@code relationAlias} resolves through the same provider used
     * for SET RHS / WHERE / JOIN ON, so a joined-UPDATE with
     * {@code RETURNING t.a, s.x} produces refs against both target and
     * FROM-side relations.
     *
     * <p>For SQL Server OUTPUT pseudo-table refs (INSERTED.col,
     * DELETED.col), the {@code relationAlias} is preserved as the
     * uppercase pseudo-table name ({@code "INSERTED"} or
     * {@code "DELETED"}) so consumers can distinguish post-write from
     * pre-write row state. Lineage edges still flow to
     * {@link LineageRef#tableColumn(String, String)} pointing at the
     * physical target table column — both INSERTED and DELETED ultimately
     * reference the same physical column; only the temporal phase differs.
     */
    public List<OutputColumn> getReturningColumns() {
        return returningColumns;
    }

    public List<ColumnRef> getFilterColumnRefs() {
        return filterColumnRefs;
    }

    public List<ColumnRef> getJoinColumnRefs() {
        return joinColumnRefs;
    }

    public List<ColumnRef> getGroupByColumnRefs() {
        return groupByColumnRefs;
    }

    /**
     * Column references that appear in the {@code HAVING} clause's
     * predicate. The list is per-statement and per-clause: a HAVING
     * predicate that names {@code d.id} contributes one entry; a HAVING
     * predicate inside an aggregate ({@code HAVING SUM(salary) > 1000})
     * contributes the underlying column ({@code salary}) — the same
     * convention used for projection-side aggregate arguments
     * (slice 6 OutputColumn.sources).
     *
     * <p>Subqueries in HAVING (scalar, EXISTS, IN-SELECT, ANY/ALL/SOME)
     * and window functions in HAVING are rejected by the builder rather
     * than silently captured, because the visitor would descend into
     * inner scopes and leak refs (mirrors the slice-9 ORDER BY guards).
     *
     * <p>HAVING is row-influence semantically (it filters out groups),
     * but it deliberately does <i>not</i> contribute to the canonical
     * lineage model (slice 7 / {@code CanonicalLineageEdge}). The
     * canonical model is a parity contract between IR and dlineage, and
     * dlineage exposes no per-clause HAVING field — it folds HAVING refs
     * into aggregate-function fdr/fdd edges. Including HAVING-derived
     * canonical edges only on the IR side would manufacture
     * divergence-by-design. The {@code havingColumnRefs} field remains
     * useful for downstream consumers (SQL Guard, lineage explainers)
     * that don't depend on the dlineage parity contract.
     */
    public List<ColumnRef> getHavingColumnRefs() {
        return havingColumnRefs;
    }

    /**
     * Column references that appear in the {@code ORDER BY} clause's sort
     * keys. Only physical column references are recorded — ordinal
     * ({@code ORDER BY 1}) and projection-alias ({@code ORDER BY x})
     * forms are rejected by the builder, not silently emitted as
     * {@code []}. Sort direction ({@code ASC}/{@code DESC}) and null
     * placement ({@code NULLS FIRST}/{@code NULLS LAST}) are presentation
     * metadata and are not modelled.
     *
     * <p>The flag is per-statement: in
     * {@code WITH x AS (... ORDER BY id) SELECT id FROM x} the inner
     * statement's {@code orderByColumnRefs} contains {@code id} while the
     * outer's is empty.
     */
    public List<ColumnRef> getOrderByColumnRefs() {
        return orderByColumnRefs;
    }

    /**
     * Whether the statement applies row-deduplication. True for
     * {@code SELECT DISTINCT}, Oracle's deprecated synonym
     * {@code SELECT UNIQUE}, AND PostgreSQL / Greenplum
     * {@code SELECT DISTINCT ON (cols)}; false for {@code SELECT},
     * {@code SELECT ALL}, and the absence of any row-filter clause.
     * The flag is per-statement, never per-output.
     *
     * <p>For {@code DISTINCT ON (cols)} the partition keys live on
     * {@link #getDistinctOnColumnRefs()}; the boolean here pins the
     * semantic invariant that the statement deduplicates rows
     * regardless of which key shape is used.
     */
    public boolean isDistinct() {
        return distinct;
    }

    /**
     * Column references in the {@code DISTINCT ON (cols)} partition list
     * (PostgreSQL / Greenplum). Empty for plain {@code SELECT DISTINCT},
     * {@code SELECT UNIQUE}, {@code SELECT ALL}, and the absence of any
     * row-filter clause.
     *
     * <p>Invariant: {@code !distinctOnColumnRefs.isEmpty()} implies
     * {@link #isDistinct()} == {@code true}. The reverse does not hold
     * (plain {@code DISTINCT} also returns {@code true}).
     *
     * <p>The list collects physical column refs the same way
     * {@code groupByColumnRefs} does: column refs inside compound
     * expressions ({@code a + b}, {@code CASE WHEN ...}) and aggregate
     * arguments ({@code COUNT(x)}) are descended into; subqueries and
     * window functions in {@code DISTINCT ON} are rejected by the
     * builder so they cannot leak inner-scope refs.
     *
     * <p>Oracle, MySQL, Redshift and other non-PG vendors silently
     * accept {@code DISTINCT ON (...)} as plain {@code DISTINCT} —
     * their parser drops the ON expression list, so this slot stays
     * empty for those vendors regardless of the surface SQL.
     */
    public List<ColumnRef> getDistinctOnColumnRefs() {
        return distinctOnColumnRefs;
    }

    /**
     * Set-operation kind for the outer statement of a set-op program
     * (slice 12). Returns null on every regular SELECT statement and on
     * every CTE / FROM-subquery / scalar / set-op-branch body. The
     * {@code _ALL} variants encode {@code TSelectSqlStatement#isAll()};
     * {@code MINUS} (Oracle / Spark / Hive) and {@code EXCEPT}
     * (PostgreSQL / SQL Server / standard) are kept distinct because the
     * parser exposes them as separate
     * {@link gudusoft.gsqlparser.ESetOperatorType} values, even though
     * they are semantically equivalent.
     */
    public SetOperator getSetOperator() {
        return setOperator;
    }

    /**
     * Per-statement row-limit metadata (slice 70). Returns null when no
     * row-limit clause was present, or when the row-limit clause is in
     * slice-71 / 72 territory (TOP, standalone OFFSET, PG inline
     * {@code LIMIT N OFFSET M}, MySQL inline {@code LIMIT M, N},
     * set-op outer row-limit) — those surfaces continue to be rejected
     * by the builder with their existing diagnostic codes.
     *
     * <p>When non-null, the {@link RowLimit#getKind()} captures which
     * surface SQL form was used ({@code LIMIT} vs {@code FETCH FIRST})
     * and {@link RowLimit#getCount()} captures the verbatim count text.
     *
     * <p>Row-limit metadata does <i>not</i> change column lineage. The
     * canonical lineage model (slice 7 / {@code CanonicalLineageEdge})
     * deliberately ignores it: row-limit is presentation-time pruning,
     * not a column-flow influence. ORDER BY refs, output sources,
     * filter / join / group-by / having refs are all unaffected.
     */
    public RowLimit getRowLimit() {
        return rowLimit;
    }

    /**
     * Slice 78 — write-side target for INSERT statements. Non-null only on
     * {@code "INSERT"}-kind statements; null on every {@code "SELECT"}-kind
     * statement (whether the SELECT is an outer, CTE body, FROM-subquery
     * body, scalar-subquery body, or set-op branch).
     *
     * <p>When non-null, {@link TargetRelation#getBinding()} is the target
     * table (kind = {@link RelationKind#TABLE}) and
     * {@link TargetRelation#getColumns()} holds the verbatim SQL column-list
     * spellings (empty list when the SQL author omitted the column list).
     *
     * <p>Cross-statement {@link LineageEdge}s for INSERT use
     * {@link LineageRef#tableColumn(String, String)} as the {@code from}
     * endpoint (target_table, target_col) and
     * {@link LineageRef#statementOutput(int, String)} as the {@code to}
     * endpoint (source SELECT body statement index + output name).
     */
    public TargetRelation getTarget() {
        return target;
    }
}