package gudusoft.gsqlparser.pp2;

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

/**
 * Immutable result of a {@code Pp2Formatter.format(...)} call.
 *
 * <p>Carries the formatted SQL text, the overall outcome
 * ({@link FormatStatus}), the per-region rendering record
 * ({@link Region}), and the diagnostic events the engine emitted along the
 * way ({@link FormatDiagnostic}).
 *
 * <p>Built only by pp2 internals. Callers consume the immutable accessors:
 * {@link #getText()}, {@link #getStatus()}, {@link #getRegions()},
 * {@link #getDiagnostics()}. The two list accessors return unmodifiable
 * views.
 *
 * <p>{@link #getRegions()} is how you tell what actually formatted your SQL.
 * A region tagged {@link RendererId#GUARDED_AST} holds
 * {@code FormatterFactory.pp}'s own output, unchanged — on input that parses
 * as a whole, every region is that and {@link #getText()} is byte-identical to
 * {@code pp()}. Any other {@link RendererId} marks a byte range pp could not
 * format, which pp2 rendered from the token stream instead.
 */
public final class Pp2FormatResult {

    /**
     * Per-region rendering record. Spans are byte offsets into the
     * <b>original</b> input string (not the formatted output), so multiple
     * regions can be reconstructed against the source.
     *
     * <p>Carries the {@link RendererId} that the engine actually used and a
     * region-local {@link FormatStatus} that may be {@link FormatStatus#OK}
     * even when the result's overall status is
     * {@link FormatStatus#OK_WITH_RECOVERY} (i.e., some other region needed
     * recovery, but this one did not).
     */
    public static final class Region {
        private final int startOffset;
        private final int endOffset;
        private final RendererId rendererId;
        private final FormatStatus status;

        public Region(int startOffset, int endOffset, RendererId rendererId,
                      FormatStatus status) {
            if (rendererId == null) throw new NullPointerException("rendererId");
            if (status == null) throw new NullPointerException("status");
            if (startOffset < 0) {
                throw new IllegalArgumentException("startOffset < 0: " + startOffset);
            }
            if (endOffset < startOffset) {
                throw new IllegalArgumentException(
                    "endOffset < startOffset: " + endOffset + " < " + startOffset);
            }
            this.startOffset = startOffset;
            this.endOffset = endOffset;
            this.rendererId = rendererId;
            this.status = status;
        }

        public int getStartOffset() { return startOffset; }
        public int getEndOffset() { return endOffset; }
        public RendererId getRendererId() { return rendererId; }
        public FormatStatus getStatus() { return status; }

        @Override
        public String toString() {
            return "Region{[" + startOffset + ".." + endOffset + "] "
                + rendererId + " " + status + "}";
        }
    }

    private final String text;
    private final FormatStatus status;
    private final List<Region> regions;
    private final List<FormatDiagnostic> diagnostics;
    private final boolean wholeDocument;
    private final boolean nameCaseApplied;

    public Pp2FormatResult(String text, FormatStatus status,
                           List<Region> regions,
                           List<FormatDiagnostic> diagnostics) {
        this(text, status, regions, diagnostics, false, false);
    }

    /**
     * @param wholeDocument true when {@code text} is {@code FormatterFactory.pp}'s
     *        output for the whole input; see {@link #isWholeDocument()}
     * @param nameCaseApplied see {@link #isNameCaseApplied()}
     */
    public Pp2FormatResult(String text, FormatStatus status,
                           List<Region> regions,
                           List<FormatDiagnostic> diagnostics,
                           boolean wholeDocument, boolean nameCaseApplied) {
        if (text == null) throw new NullPointerException("text");
        if (status == null) throw new NullPointerException("status");
        this.text = text;
        this.status = status;
        this.regions = regions == null || regions.isEmpty()
            ? Collections.<Region>emptyList()
            : Collections.unmodifiableList(new ArrayList<Region>(regions));
        this.diagnostics = diagnostics == null || diagnostics.isEmpty()
            ? Collections.<FormatDiagnostic>emptyList()
            : Collections.unmodifiableList(new ArrayList<FormatDiagnostic>(diagnostics));
        this.wholeDocument = wholeDocument;
        this.nameCaseApplied = nameCaseApplied;
    }

    public String getText() { return text; }
    public FormatStatus getStatus() { return status; }

    /** Unmodifiable view; never {@code null}, may be empty. */
    public List<Region> getRegions() { return regions; }

    /** Unmodifiable view; never {@code null}, may be empty. */
    public List<FormatDiagnostic> getDiagnostics() { return diagnostics; }

    /**
     * True when the whole input parsed and {@link #getText()} is
     * {@code FormatterFactory.pp}'s output for it. An all-{@link RendererId#GUARDED_AST}
     * regional run looks the same in {@link #getRegions()}, so this is the
     * way to tell.
     */
    public boolean isWholeDocument() { return wholeDocument; }

    /**
     * True when the per-kind name cases ({@code GFmtOpt.caseTableName},
     * {@code caseColumnName}, {@code caseTableAlias}, {@code caseColumnAlias})
     * applied: the whole document was formatted by pp, its names were
     * resolved, and they could be cased consistently. The regional pipeline
     * parses without name resolution, so a regional result never applies them.
     */
    public boolean isNameCaseApplied() { return nameCaseApplied; }

    @Override
    public String toString() {
        return "Pp2FormatResult{status=" + status
            + ", regions=" + regions.size()
            + ", diagnostics=" + diagnostics.size()
            + ", textLen=" + text.length() + "}";
    }
}