package gudusoft.gsqlparser.ir.semantic.joinanalysis;

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

/**
 * One input side of a {@link JoinEntity}. A join never references a bare
 * alias directly; it references a {@code JoinEndpoint} so that the left
 * side of a left-deep chain ({@code t1 JOIN t2 JOIN t3}) can be modelled
 * as the accumulated {@link JoinEndpointKind#JOIN_RESULT} of the prior
 * joins rather than a single relation.
 *
 * <ul>
 *   <li>A {@link JoinEndpointKind#RELATION} endpoint carries the
 *       FROM-clause {@code alias} and the relation's
 *       {@code qualifiedName} (e.g. {@code t1}).</li>
 *   <li>A {@link JoinEndpointKind#JOIN_RESULT} endpoint carries the
 *       {@code producingJoinOrder} (the {@link JoinEntity#getOrder()} of
 *       the join that produced this result) and the immutable list of
 *       {@code contributingAliases} flowing through it.</li>
 * </ul>
 *
 * <p>Immutable. Introduced by join-analysis slice 162 (S1).
 */
public final class JoinEndpoint {

    /** Sentinel for "no stable relation instance id" (slice 179). */
    public static final int NO_INSTANCE_ID = -1;

    /** Sentinel for "no subquery statement index" (R8). */
    public static final int NO_STATEMENT_INDEX = -1;

    private final JoinEndpointKind kind;
    // RELATION fields
    private final String alias;
    private final String qualifiedName;
    private final int instanceId;
    // JOIN_RESULT fields
    private final int producingJoinOrder;
    private final List<String> contributingAliases;
    // SUBQUERY field (R8): index of the lifted subquery's StatementGraph.
    private final int statementIndex;

    private JoinEndpoint(JoinEndpointKind kind, String alias, String qualifiedName,
                         int instanceId, int producingJoinOrder,
                         List<String> contributingAliases, int statementIndex) {
        this.kind = kind;
        this.alias = alias;
        this.qualifiedName = qualifiedName;
        this.instanceId = instanceId;
        this.producingJoinOrder = producingJoinOrder;
        this.contributingAliases = contributingAliases == null
                ? Collections.<String>emptyList()
                : Collections.unmodifiableList(new ArrayList<String>(contributingAliases));
        this.statementIndex = statementIndex;
    }

    /**
     * A single FROM-clause relation with no stable instance id. {@code alias}
     * must be non-empty; {@code qualifiedName} may be {@code null} when the
     * relation has no resolvable name (e.g. an unaliased derived table).
     */
    public static JoinEndpoint relation(String alias, String qualifiedName) {
        return relation(alias, qualifiedName, NO_INSTANCE_ID);
    }

    /**
     * A single FROM-clause relation carrying its stable
     * {@code instanceId} (slice 179, R4) — the same per-block FROM-order
     * ordinal as the matching {@code RelationSource.getInstanceId()}, so an
     * endpoint links to its exact relation instance without alias-keying.
     */
    public static JoinEndpoint relation(String alias, String qualifiedName, int instanceId) {
        if (alias == null || alias.isEmpty()) {
            throw new IllegalArgumentException("alias must be non-empty");
        }
        return new JoinEndpoint(JoinEndpointKind.RELATION, alias, qualifiedName,
                instanceId, -1, null, NO_STATEMENT_INDEX);
    }

    /**
     * The right side of a predicate-derived semi-join (R8): a lifted
     * {@code EXISTS} / {@code IN} subquery. {@code statementIndex} is the
     * index of the subquery's own {@link gudusoft.gsqlparser.ir.semantic.StatementGraph}
     * block in the program; {@code label} is an optional human-facing name
     * (the synthetic {@code <predicate_subquery_N>} name or the subquery's
     * alias), may be {@code null}.
     */
    public static JoinEndpoint subquery(int statementIndex, String label) {
        if (statementIndex < 0) {
            throw new IllegalArgumentException("statementIndex must be >= 0");
        }
        return new JoinEndpoint(JoinEndpointKind.SUBQUERY, label, null,
                NO_INSTANCE_ID, -1, null, statementIndex);
    }

    /**
     * The accumulated result of prior joins in a left-deep chain.
     *
     * @param producingJoinOrder the {@link JoinEntity#getOrder()} of the
     *                           join producing this result
     * @param contributingAliases aliases flowing through this result (may
     *                            be empty, never null)
     */
    public static JoinEndpoint joinResult(int producingJoinOrder, List<String> contributingAliases) {
        if (producingJoinOrder < 0) {
            throw new IllegalArgumentException("producingJoinOrder must be >= 0");
        }
        return new JoinEndpoint(JoinEndpointKind.JOIN_RESULT, null, null,
                NO_INSTANCE_ID, producingJoinOrder, contributingAliases, NO_STATEMENT_INDEX);
    }

    public JoinEndpointKind getKind() {
        return kind;
    }

    /** Non-null only for {@link JoinEndpointKind#RELATION}. */
    public String getAlias() {
        return alias;
    }

    /** May be null even for {@link JoinEndpointKind#RELATION}. */
    public String getQualifiedName() {
        return qualifiedName;
    }

    /**
     * Stable relation instance id (slice 179, R4) for a RELATION endpoint —
     * matches {@code RelationSource.getInstanceId()}. {@link #NO_INSTANCE_ID}
     * for JOIN_RESULT endpoints or when not assigned.
     */
    public int getInstanceId() {
        return instanceId;
    }

    /** Meaningful only for {@link JoinEndpointKind#JOIN_RESULT}; else -1. */
    public int getProducingJoinOrder() {
        return producingJoinOrder;
    }

    /** Never null; empty for {@link JoinEndpointKind#RELATION}. */
    public List<String> getContributingAliases() {
        return contributingAliases;
    }

    /**
     * Index of the lifted subquery's {@code StatementGraph} for a
     * {@link JoinEndpointKind#SUBQUERY} endpoint (R8); {@link #NO_STATEMENT_INDEX}
     * for other endpoint kinds. For a SUBQUERY endpoint {@link #getAlias()}
     * returns the optional label (synthetic name or alias, may be null).
     */
    public int getStatementIndex() {
        return statementIndex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof JoinEndpoint)) return false;
        JoinEndpoint that = (JoinEndpoint) o;
        return kind == that.kind
                && instanceId == that.instanceId
                && producingJoinOrder == that.producingJoinOrder
                && statementIndex == that.statementIndex
                && Objects.equals(alias, that.alias)
                && Objects.equals(qualifiedName, that.qualifiedName)
                && contributingAliases.equals(that.contributingAliases);
    }

    @Override
    public int hashCode() {
        return Objects.hash(kind, alias, qualifiedName, instanceId,
                producingJoinOrder, contributingAliases, statementIndex);
    }

    @Override
    public String toString() {
        if (kind == JoinEndpointKind.RELATION) {
            return "RELATION{" + alias + (qualifiedName != null ? "/" + qualifiedName : "")
                    + (instanceId != NO_INSTANCE_ID ? "#" + instanceId : "") + "}";
        }
        if (kind == JoinEndpointKind.SUBQUERY) {
            return "SUBQUERY{stmt=" + statementIndex
                    + (alias != null ? ", label=" + alias : "") + "}";
        }
        return "JOIN_RESULT{order=" + producingJoinOrder + ", aliases=" + contributingAliases + "}";
    }
}