package gudusoft.gsqlparser.ir.semantic.joinanalysis;

import gudusoft.gsqlparser.ir.semantic.SourceSpan;

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

/**
 * A structured per-join entity (GAP 1): the type, the two input
 * endpoints, the written order, optional USING / NATURAL metadata, how
 * it was written, an optional span, the decomposed ON predicate list
 * (GAP 2, attached in slice 168), and an optional verbatim
 * {@code conditionText} (the SQL substring derived from {@code span},
 * never reformatted).
 *
 * <p>Endpoints are {@link JoinEndpoint}s, never bare aliases, so a
 * left-deep chain is modelled correctly: {@code rightEndpoint} is the
 * newly added relation; {@code leftEndpoint} is the accumulated
 * {@link JoinEndpointKind#JOIN_RESULT} of prior joins (or the first
 * {@link JoinEndpointKind#RELATION}).
 *
 * <p>Immutable. Introduced by join-analysis slice 162 (S1); built in
 * slice 167 (S6); predicates attached in slice 168 (S7).
 */
public final class JoinEntity {

    private final SemanticJoinType joinType;
    private final JoinEndpoint leftEndpoint;
    private final JoinEndpoint rightEndpoint;
    private final int order;
    private final JoinSourceSyntax sourceSyntax;
    private final boolean naturalFlag;
    private final boolean lateralFlag;
    private final List<String> usingColumns;
    private final List<Predicate> conditions;
    private final SourceSpan sourceSpan;
    private final String conditionText;

    /**
     * Original 10-arg constructor (non-lateral). Retained so existing
     * callers and tests compile unchanged; delegates with
     * {@code lateralFlag = false}.
     */
    public JoinEntity(SemanticJoinType joinType,
                      JoinEndpoint leftEndpoint, JoinEndpoint rightEndpoint,
                      int order, JoinSourceSyntax sourceSyntax,
                      boolean naturalFlag, List<String> usingColumns,
                      List<Predicate> conditions, SourceSpan sourceSpan,
                      String conditionText) {
        this(joinType, leftEndpoint, rightEndpoint, order, sourceSyntax,
                naturalFlag, usingColumns, conditions, sourceSpan, conditionText, false);
    }

    /**
     * Full constructor. {@code lateralFlag} marks a lateral join
     * (SQL Server {@code CROSS APPLY} / {@code OUTER APPLY}); such a join
     * carries no ON/USING and empty {@code conditions} — the correlation
     * lives inside the right operand's own statement graph. The flag lets
     * consumers distinguish a lateral join from a buggy cartesian INNER.
     */
    public JoinEntity(SemanticJoinType joinType,
                      JoinEndpoint leftEndpoint, JoinEndpoint rightEndpoint,
                      int order, JoinSourceSyntax sourceSyntax,
                      boolean naturalFlag, List<String> usingColumns,
                      List<Predicate> conditions, SourceSpan sourceSpan,
                      String conditionText, boolean lateralFlag) {
        if (joinType == null) {
            throw new IllegalArgumentException("joinType must be non-null");
        }
        if (leftEndpoint == null || rightEndpoint == null) {
            throw new IllegalArgumentException("both endpoints must be non-null");
        }
        if (sourceSyntax == null) {
            throw new IllegalArgumentException("sourceSyntax must be non-null");
        }
        if (order < 0) {
            throw new IllegalArgumentException("order must be >= 0");
        }
        this.joinType = joinType;
        this.leftEndpoint = leftEndpoint;
        this.rightEndpoint = rightEndpoint;
        this.order = order;
        this.sourceSyntax = sourceSyntax;
        this.naturalFlag = naturalFlag;
        this.lateralFlag = lateralFlag;
        this.usingColumns = usingColumns == null
                ? Collections.<String>emptyList()
                : Collections.unmodifiableList(new ArrayList<String>(usingColumns));
        this.conditions = conditions == null
                ? Collections.<Predicate>emptyList()
                : Collections.unmodifiableList(new ArrayList<Predicate>(conditions));
        this.sourceSpan = sourceSpan;
        this.conditionText = conditionText;
    }

    /**
     * Return a copy of this entity with its ON-condition predicate list
     * replaced (used by slice 168 to attach predicates without mutating
     * the immutable entity built in slice 167). Preserves the lateral flag.
     */
    public JoinEntity withConditions(List<Predicate> newConditions) {
        return new JoinEntity(joinType, leftEndpoint, rightEndpoint, order, sourceSyntax,
                naturalFlag, usingColumns, newConditions, sourceSpan, conditionText, lateralFlag);
    }

    public SemanticJoinType getJoinType() {
        return joinType;
    }

    public JoinEndpoint getLeftEndpoint() {
        return leftEndpoint;
    }

    public JoinEndpoint getRightEndpoint() {
        return rightEndpoint;
    }

    public int getOrder() {
        return order;
    }

    public JoinSourceSyntax getSourceSyntax() {
        return sourceSyntax;
    }

    public boolean isNatural() {
        return naturalFlag;
    }

    /**
     * True for a lateral join (SQL Server {@code CROSS APPLY} /
     * {@code OUTER APPLY}). Such a join has empty {@link #getConditions()}
     * and {@link #getUsingColumns()}; the correlation lives inside the
     * right operand. Distinguishes a lateral join from a cartesian INNER.
     */
    public boolean isLateral() {
        return lateralFlag;
    }

    /** Never null; empty unless a USING clause was written. */
    public List<String> getUsingColumns() {
        return usingColumns;
    }

    /** Never null; empty until ON predicates are attached (slice 168). */
    public List<Predicate> getConditions() {
        return conditions;
    }

    /** Optional; null when the parser cannot anchor the join clause. */
    public SourceSpan getSourceSpan() {
        return sourceSpan;
    }

    /** Optional verbatim SQL substring of the ON condition; may be null. */
    public String getConditionText() {
        return conditionText;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof JoinEntity)) return false;
        JoinEntity that = (JoinEntity) o;
        return order == that.order
                && naturalFlag == that.naturalFlag
                && lateralFlag == that.lateralFlag
                && joinType == that.joinType
                && sourceSyntax == that.sourceSyntax
                && leftEndpoint.equals(that.leftEndpoint)
                && rightEndpoint.equals(that.rightEndpoint)
                && usingColumns.equals(that.usingColumns)
                && conditions.equals(that.conditions)
                && Objects.equals(sourceSpan, that.sourceSpan)
                && Objects.equals(conditionText, that.conditionText);
    }

    @Override
    public int hashCode() {
        return Objects.hash(joinType, leftEndpoint, rightEndpoint, order, sourceSyntax,
                naturalFlag, lateralFlag, usingColumns, conditions, sourceSpan, conditionText);
    }

    @Override
    public String toString() {
        return "JoinEntity{order=" + order + ", " + joinType
                + (lateralFlag ? " LATERAL" : "") + ", "
                + leftEndpoint + " <-> " + rightEndpoint
                + (conditions.isEmpty() ? "" : ", conds=" + conditions.size()) + "}";
    }
}