package gudusoft.gsqlparser.dlineage.dynamicsql;

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

/**
 * Result for a single dynamic-SQL EXEC site inside a procedure.
 *
 * <p>Either it resolved (status {@link Status#RESOLVED}/{@link Status#PARTIAL}/
 * {@link Status#CONDITIONAL}) and carries a materialized {@link #getResolvedSql()}
 * plus the lineage {@link #getEdges()} extracted from analyzing it, or it could not
 * be reduced (status {@link Status#UNRESOLVED}/{@link Status#PARSE_ERROR}) and carries
 * an honest {@link #getUnresolvedReason()} so the caller keeps it as a diagnostic
 * rather than guessing.
 */
public final class DynamicSiteResult {

    public enum Kind { EXEC_STRING, SP_EXECUTESQL }

    public enum Status {
        /** Materialized to a fully concrete string; lineage edges produced. */
        RESOLVED,
        /**
         * Materialized, but the string still contains unresolved fragment(s).
         * LEGACY/SHADOW retain historical candidate edges; SHADOW also labels
         * their incomplete provenance.
         */
        PARTIAL,
        /**
         * The EXEC site materialized to a usable string but is gated by an undecidable conditional
         * (e.g. {@code IF @Debug = 0 EXEC(@sql)} with {@code @Debug} unbound), so any edge it
         * produces is reached only <em>if the guarded statement executes</em>. The materialized
         * string may be fully concrete (all edges emitted) or still PARTIAL (placeholder edges
         * suppressed, only the resolvable subset emitted). The subset can legitimately be empty when
         * every relationship touched a placeholder; like {@link #RESOLVED}, this status reflects that
         * the SQL resolved, not that edges are guaranteed. {@link #getUnresolvedReason()} records the
         * gate, any placeholder suppression, and whether resolvable edges were produced. Edges, if
         * any, are correct if the branch runs.
         */
        CONDITIONAL,
        /** Could not be reduced to a usable string (NULL, opaque value, bound exceeded, undecidable control flow). */
        UNRESOLVED,
        /** Materialized string failed to re-parse. */
        PARSE_ERROR
    }

    private final Kind kind;
    private final Status status;
    private final String resolvedSql;
    private final String concreteSqlHash;
    private final String sourceProc;
    private final String dynamicSite;
    private final String bindingHash;
    private final String unresolvedReason;
    private final String diagnostic;
    private final long startLine;
    private final long startColumn;
    private final List<DynamicLineageEdge> edges;
    private final DynamicSqlTrustMode trustMode;
    private final int unprovenRelationshipCount;
    private final int unresolvedHoleCount;
    private final boolean holeCountExact;

    DynamicSiteResult(Kind kind, Status status, String resolvedSql, String concreteSqlHash, String sourceProc,
            String dynamicSite, String bindingHash, String unresolvedReason, long startLine, long startColumn,
            List<DynamicLineageEdge> edges) {
        this(kind, status, resolvedSql, concreteSqlHash, sourceProc, dynamicSite, bindingHash,
                unresolvedReason, startLine, startColumn, edges, DynamicSqlTrustMode.LEGACY,
                0, -1, false, null);
    }

    DynamicSiteResult(Kind kind, Status status, String resolvedSql, String concreteSqlHash, String sourceProc,
            String dynamicSite, String bindingHash, String unresolvedReason, long startLine, long startColumn,
            List<DynamicLineageEdge> edges, DynamicSqlTrustMode trustMode,
            int unprovenRelationshipCount,
            int unresolvedHoleCount, boolean holeCountExact) {
        this(kind, status, resolvedSql, concreteSqlHash, sourceProc, dynamicSite, bindingHash,
                unresolvedReason, startLine, startColumn, edges, trustMode,
                unprovenRelationshipCount, unresolvedHoleCount, holeCountExact, null);
    }

    DynamicSiteResult(Kind kind, Status status, String resolvedSql, String concreteSqlHash, String sourceProc,
            String dynamicSite, String bindingHash, String unresolvedReason, long startLine, long startColumn,
            List<DynamicLineageEdge> edges, DynamicSqlTrustMode trustMode,
            int unprovenRelationshipCount,
            int unresolvedHoleCount, boolean holeCountExact, String diagnostic) {
        this.kind = kind;
        this.status = status;
        this.resolvedSql = resolvedSql;
        this.concreteSqlHash = concreteSqlHash;
        this.sourceProc = sourceProc;
        this.dynamicSite = dynamicSite;
        this.bindingHash = bindingHash;
        this.unresolvedReason = unresolvedReason;
        this.diagnostic = diagnostic;
        this.startLine = startLine;
        this.startColumn = startColumn;
        this.edges = edges == null ? new ArrayList<DynamicLineageEdge>()
                : new ArrayList<DynamicLineageEdge>(edges);
        this.trustMode = trustMode == null ? DynamicSqlTrustMode.LEGACY : trustMode;
        this.unprovenRelationshipCount = unprovenRelationshipCount;
        this.unresolvedHoleCount = unresolvedHoleCount;
        this.holeCountExact = holeCountExact;
    }

    public Kind getKind() {
        return kind;
    }

    public Status getStatus() {
        return status;
    }

    public boolean isResolved() {
        return status == Status.RESOLVED || status == Status.PARTIAL || status == Status.CONDITIONAL;
    }

    /** True when unresolved string fragments remain or their count is unavailable. */
    public boolean hasUnresolvedFragments() {
        return !holeCountExact || unresolvedHoleCount != 0;
    }

    /** The materialized SQL string (null when unresolved with no usable text). */
    public String getResolvedSql() {
        return resolvedSql;
    }

    public String getConcreteSqlHash() {
        return concreteSqlHash;
    }

    public String getSourceProc() {
        return sourceProc;
    }

    /** Stable id of this EXEC site (proc + ordinal path + source span), robust to reformatting. */
    public String getDynamicSite() {
        return dynamicSite;
    }

    public String getBindingHash() {
        return bindingHash;
    }

    public String getUnresolvedReason() {
        return unresolvedReason;
    }

    /** Additive analysis note, kept separate from an unresolved reason. */
    public String getDiagnostic() {
        return diagnostic;
    }

    public long getStartLine() {
        return startLine;
    }

    public long getStartColumn() {
        return startColumn;
    }

    public List<DynamicLineageEdge> getEdges() {
        return Collections.unmodifiableList(edges);
    }

    public int getPublishedRelationshipCount() {
        return edges.size();
    }

    /** Historical candidate relationships SHADOW observed without a per-edge proof. */
    public int getUnprovenRelationshipCount() {
        return unprovenRelationshipCount;
    }

    /** Exact unresolved fragment count, or {@code -1} if the producing channel cannot enumerate holes. */
    public int getUnresolvedHoleCount() {
        return unresolvedHoleCount;
    }

    public boolean isHoleCountExact() {
        return holeCountExact;
    }

    public DynamicSqlTrustMode getTrustMode() {
        return trustMode;
    }

    @Override
    public String toString() {
        return "DynamicSiteResult{" + kind + ", " + status + ", site=" + dynamicSite
                + ", edges=" + edges.size()
                + (unresolvedReason != null ? ", reason=" + unresolvedReason : "") + "}";
    }
}