package gudusoft.gsqlparser.ir.semantic;

import gudusoft.gsqlparser.nodes.TParseTreeNode;

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

/**
 * Structured rejection from the SemanticIR builder. Carries a stable
 * {@link DiagnosticCode}, centrally-derived {@link DiagnosticCategory}, a
 * {@link Severity}, the rendered user-visible {@link #getMessage() message},
 * an optional primary {@link SourceSpan}, immutable secondary locations, and
 * optional exact vendor-error enrichment.
 *
 * <p><b>API status:</b> read-only diagnostic getters are part of Join Analysis
 * Consumption Profile v1. Consumers should treat code, category, severity,
 * locations, and exact vendor enrichment as structured data. Construction and
 * copy helpers are producer-oriented APIs.
 *
 * <p>Diagnostics are constructed via the {@link #error} factory
 * methods and wrapped in
 * {@code SemanticIRBuilder.SemanticIRBuildException} when the builder
 * cannot continue. External callers should pattern-match on
 * {@link #getCode()} rather than parsing {@link #getMessage()}
 * substrings — message text remains user-visible English and may
 * change without notice; the enum values are the public contract.
 */
public final class Diagnostic {

    private final DiagnosticCode code;
    private final DiagnosticCategory category;
    private final Severity severity;
    private final String message;
    private final SourceSpan span;
    private final List<RelatedLocation> relatedLocations;
    private final VendorError vendorError;

    private Diagnostic(DiagnosticCode code, Severity severity,
                       String message, SourceSpan span,
                       List<RelatedLocation> relatedLocations,
                       VendorError vendorError) {
        this.code = Objects.requireNonNull(code, "code");
        this.category = DiagnosticDescriptorCatalog.categoryOf(code);
        this.severity = Objects.requireNonNull(severity, "severity");
        this.message = Objects.requireNonNull(message, "message");
        this.span = span;
        List<RelatedLocation> locations = relatedLocations == null
                ? Collections.<RelatedLocation>emptyList()
                : new ArrayList<>(relatedLocations);
        for (RelatedLocation location : locations) {
            Objects.requireNonNull(location, "relatedLocations must not contain null");
        }
        this.relatedLocations = Collections.unmodifiableList(locations);
        validateVendorError(category, vendorError);
        this.vendorError = vendorError;
    }

    /**
     * Construct an {@link Severity#ERROR ERROR}-severity diagnostic
     * with no span anchor.
     */
    public static Diagnostic error(DiagnosticCode code, String message) {
        return builder(code, Severity.ERROR, message).build();
    }

    /**
     * Construct an {@link Severity#ERROR ERROR}-severity diagnostic
     * whose span is derived from {@code anchor} via
     * {@link SourceSpan#of(TParseTreeNode)}. Null-safe: when
     * {@code anchor} (or its boundary tokens) is {@code null}, the
     * resulting span is {@code null}.
     */
    public static Diagnostic error(DiagnosticCode code, String message,
                                   TParseTreeNode anchor) {
        return builder(code, Severity.ERROR, message).anchor(anchor).build();
    }

    /**
     * Construct an {@link Severity#ERROR ERROR}-severity diagnostic
     * with an explicit (already-computed) source span. Most callers
     * should prefer {@link #error(DiagnosticCode, String, TParseTreeNode)}
     * which derives the span from an AST node.
     */
    public static Diagnostic errorWithSpan(DiagnosticCode code, String message,
                                           SourceSpan span) {
        return builder(code, Severity.ERROR, message).span(span).build();
    }

    /**
     * Slice 77 — construct a {@link Severity#WARN WARN}-severity
     * diagnostic with no span anchor. Warnings are advisory: the
     * analyzer continues, the IR is built, and
     * {@code AnalysisResult.isSuccessful()} still returns {@code true}.
     */
    public static Diagnostic warn(DiagnosticCode code, String message) {
        return builder(code, Severity.WARN, message).build();
    }

    /**
     * Slice 77 — construct a {@link Severity#WARN WARN}-severity
     * diagnostic whose span is derived from {@code anchor}.
     */
    public static Diagnostic warn(DiagnosticCode code, String message,
                                  TParseTreeNode anchor) {
        return builder(code, Severity.WARN, message).anchor(anchor).build();
    }

    /**
     * Construct a {@link Severity#WARN WARN}-severity diagnostic with an
     * explicit (already-computed) source span — the WARN counterpart of
     * {@link #errorWithSpan}. Used by the builder's degrade paths, which
     * derive the span from a fallback anchor rather than a single node.
     */
    public static Diagnostic warnWithSpan(DiagnosticCode code, String message,
                                          SourceSpan span) {
        return builder(code, Severity.WARN, message).span(span).build();
    }

    /**
     * Begin constructing a diagnostic. Category is intentionally absent from
     * this API: it is derived centrally from {@link DiagnosticCode}.
     */
    public static Builder builder(DiagnosticCode code, Severity severity,
                                  String message) {
        return new Builder(code, severity, message);
    }

    public DiagnosticCode getCode() {
        return code;
    }

    public DiagnosticCategory getCategory() {
        return category;
    }

    public Severity getSeverity() {
        return severity;
    }

    public String getMessage() {
        return message;
    }

    /** @return the source span, or {@code null} when no AST anchor was available. */
    public SourceSpan getSpan() {
        return span;
    }

    /** @return immutable secondary source locations, never {@code null}. */
    public List<RelatedLocation> getRelatedLocations() {
        return relatedLocations;
    }

    /** @return exact vendor enrichment, or {@code null} when not available. */
    public VendorError getVendorError() {
        return vendorError;
    }

    /** Return an immutable copy with a new primary span. */
    public Diagnostic withSpan(SourceSpan newSpan) {
        return new Diagnostic(code, severity, message, newSpan,
                relatedLocations, vendorError);
    }

    /** Return an immutable copy with one additional secondary location. */
    public Diagnostic withRelatedLocation(RelatedLocation location) {
        Objects.requireNonNull(location, "location");
        List<RelatedLocation> locations = new ArrayList<>(relatedLocations);
        locations.add(location);
        return new Diagnostic(code, severity, message, span, locations, vendorError);
    }

    /**
     * Return an immutable copy enriched with an exact vendor error.
     * Unsupported/degraded/advisory categories reject this operation.
     */
    public Diagnostic withVendorError(VendorError error) {
        return new Diagnostic(code, severity, message, span,
                relatedLocations, Objects.requireNonNull(error, "error"));
    }

    private static void validateVendorError(DiagnosticCategory category,
                                            VendorError vendorError) {
        if (vendorError == null) return;
        if (category != DiagnosticCategory.SYNTAX_ERROR
                && category != DiagnosticCategory.DIALECT_SEMANTIC_ERROR) {
            throw new IllegalArgumentException("vendorError is not valid for " + category);
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Diagnostic)) return false;
        Diagnostic that = (Diagnostic) o;
        return code == that.code
                && category == that.category
                && severity == that.severity
                && message.equals(that.message)
                && Objects.equals(span, that.span)
                && relatedLocations.equals(that.relatedLocations)
                && Objects.equals(vendorError, that.vendorError);
    }

    @Override
    public int hashCode() {
        return Objects.hash(code, category, severity, message, span,
                relatedLocations, vendorError);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[').append(code.name()).append("] ").append(message);
        if (span != null) {
            sb.append(" at ").append(span);
        }
        return sb.toString();
    }

    /** Mutable construction helper; the built {@link Diagnostic} is immutable. */
    public static final class Builder {
        private final DiagnosticCode code;
        private final Severity severity;
        private final String message;
        private SourceSpan span;
        private final List<RelatedLocation> relatedLocations = new ArrayList<>();
        private VendorError vendorError;

        private Builder(DiagnosticCode code, Severity severity, String message) {
            this.code = Objects.requireNonNull(code, "code");
            this.severity = Objects.requireNonNull(severity, "severity");
            this.message = Objects.requireNonNull(message, "message");
        }

        public Builder span(SourceSpan value) {
            this.span = value;
            return this;
        }

        public Builder anchor(TParseTreeNode value) {
            this.span = SourceSpan.of(value);
            return this;
        }

        public Builder addRelatedLocation(RelatedLocation value) {
            relatedLocations.add(Objects.requireNonNull(value, "value"));
            return this;
        }

        public Builder vendorError(VendorError value) {
            this.vendorError = Objects.requireNonNull(value, "value");
            return this;
        }

        public Diagnostic build() {
            return new Diagnostic(code, severity, message, span,
                    relatedLocations, vendorError);
        }
    }
}