package gudusoft.gsqlparser.pp2.render;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.pp.logger.PPLogger;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;
import gudusoft.gsqlparser.pp2.token.SourceSpanLedger;
import gudusoft.gsqlparser.pp2.zone.CommentPolicy;

import java.util.List;

/**
 * Assembles per-region rendered texts into a single output string, bridging
 * gaps between regions with the original inter-region trivia extracted from
 * the {@link SourceSpanLedger}.
 *
 * <h2>Why the ledger owns inter-region trivia</h2>
 *
 * <p>Every {@link RegionRenderer} intentionally omits the leading whitespace
 * for the <em>first</em> token of its range (see {@link RenderedRegion}).
 * The bytes between adjacent regions — whitespace, comments, blank lines,
 * {@code --BEGIN_NO_FORMAT}/{@code --END_NO_FORMAT} blocks — live in the
 * original source at positions {@code [r_i.endOffset, r_{i+1}.startOffset)}.
 * The assembler is the counterparty that places those bytes into the output,
 * so they reach the caller byte-for-byte regardless of which renderer handled
 * the surrounding statements.
 *
 * <h2>Assembly model</h2>
 *
 * <p>Given an ordered, non-overlapping list of {@link RenderedRegion}s:
 * <ol>
 *   <li><b>Preamble</b> — {@code source[0, first.startOffset)}</li>
 *   <li>For each region {@code r_i}:
 *     <ol>
 *       <li>Emit {@code r_i.getText()} (the renderer's output)</li>
 *       <li>Emit {@code source[r_i.endOffset, r_{i+1}.startOffset)}
 *           (inter-region gap; the final region skips this step)</li>
 *     </ol>
 *   </li>
 *   <li><b>Trailer</b> — {@code source[last.endOffset, source.length())}</li>
 * </ol>
 *
 * <p>An empty regions list returns the entire source string unchanged — all
 * bytes come from the preamble/trailer path.
 *
 * <h2>Comment policy</h2>
 *
 * <p>Phase-2 MVP implements only {@link CommentPolicy#PRESERVE}: inter-region
 * bytes are always emitted verbatim. {@link CommentPolicy#REANCHOR} and
 * {@link CommentPolicy#REFLOW} log a notice and fall back to PRESERVE; the
 * Phase-3 island pipeline will provide real semantics.
 *
 * <h2>Defensive behaviour</h2>
 *
 * <p>Overlapping or out-of-order region offsets (which should never occur when
 * {@code StatementBoundaryDetector} S11 produces the list) are detected and
 * logged; overlap bytes are skipped rather than emitted twice. Out-of-bounds
 * source-slice requests are also guarded — no byte is lost due to an offset
 * arithmetic bug in the caller.
 *
 * <p>Plan reference: §7.3/S15, §7.4/S15, §10.4.
 */
public final class RegionAssembler {

    /**
     * Dialect whose comment syntax governs {@link #nextRegionStartsWithComment}.
     * May be {@code null} (vendor-agnostic): then only the universal {@code --}
     * and {@code /*} openers are recognised.
     */
    private final EDbVendor vendor;

    /** Vendor-agnostic assembler ({@code --} and {@code /*} comments only). */
    public RegionAssembler() {
        this(null);
    }

    /**
     * Assembler that recognises {@code vendor}'s line-comment syntax when
     * deciding whether a region begins with a (trailing) comment. In
     * particular {@code #} is treated as a line comment for every dialect
     * except the SQL Server family, where {@code #name} is a temp-table
     * identifier rather than a comment.
     */
    public RegionAssembler(EDbVendor vendor) {
        this.vendor = vendor;
    }

    /**
     * Assemble rendered regions into a final output string.
     *
     * @param regions ordered (source position), non-overlapping list of
     *                rendered regions; empty list is allowed
     * @param ledger  the source-span ledger for the original SQL;
     *                {@link SourceSpanLedger#getSource()} is the byte authority
     * @param opts    pp2 format options;
     *                {@link Pp2FormatOptions#commentPolicy} governs how
     *                inter-region trivia is emitted
     * @return the assembled output string; never null
     * @throws NullPointerException if any argument is null
     */
    public String assemble(List<RenderedRegion> regions,
                           SourceSpanLedger ledger,
                           Pp2FormatOptions opts) {
        if (opts == null) throw new NullPointerException("opts");
        return assemble(regions, ledger, opts, opts.breakStatementsOnNewLine);
    }

    /**
     * Assemble rendered regions, with explicit control over statement-break
     * normalization. Identical to {@link #assemble(List, SourceSpanLedger,
     * Pp2FormatOptions)} except {@code breakStatements} overrides
     * {@link Pp2FormatOptions#breakStatementsOnNewLine}. The engine uses this
     * overload to re-assemble verbatim ({@code breakStatements=false}) as a
     * content-preservation fallback when a break would alter the token stream.
     *
     * @param breakStatements when {@code true}, whitespace-only line-break-free
     *                        gaps between statements become a single newline;
     *                        when {@code false}, all inter-region trivia is
     *                        emitted verbatim
     */
    public String assemble(List<RenderedRegion> regions,
                           SourceSpanLedger ledger,
                           Pp2FormatOptions opts,
                           boolean breakStatements) {
        if (regions == null) throw new NullPointerException("regions");
        if (ledger == null) throw new NullPointerException("ledger");
        if (opts == null) throw new NullPointerException("opts");

        String source = ledger.getSource();

        if (regions.isEmpty()) {
            // All bytes are inter-region trivia; return source unchanged.
            return source;
        }

        if (opts.commentPolicy != CommentPolicy.PRESERVE) {
            PPLogger.info("RegionAssembler: commentPolicy="
                + opts.commentPolicy
                + " is not yet implemented in the Phase-2 MVP; "
                + "falling back to PRESERVE (verbatim inter-region trivia)");
        }

        StringBuilder out = new StringBuilder(source.length());

        // Preamble: source bytes before the first region's first token.
        int firstStart = regions.get(0).getRange().getStartOffset();
        appendSourceSlice(out, source, 0, firstStart, "preamble");

        for (int i = 0; i < regions.size(); i++) {
            RenderedRegion region = regions.get(i);
            int rStart = region.getRange().getStartOffset();
            int rEnd   = region.getRange().getEndOffset();

            // Emit the renderer's output for this region.
            out.append(region.getText());

            if (i + 1 < regions.size()) {
                int nextStart = regions.get(i + 1).getRange().getStartOffset();
                if (rEnd > nextStart) {
                    // Overlapping regions — the boundary detector should never
                    // produce this, but log and skip rather than double-emit.
                    PPLogger.info("RegionAssembler: region[" + i + "].endOffset="
                        + rEnd + " > region[" + (i + 1) + "].startOffset="
                        + nextStart + " — overlapping ranges; skipping gap");
                } else if (breakStatements
                        && isWhitespaceOnlyWithoutLineBreak(source, rEnd, nextStart)
                        && !nextRegionStartsWithComment(source, nextStart)) {
                    // Two statements share a physical line (separated only by
                    // horizontal whitespace, no line break). Emit a single
                    // newline so each statement gets its own line. The next
                    // region renders its first token at column 0, so the
                    // dropped horizontal spaces would otherwise become stray
                    // leading indentation.
                    //
                    // Skipped when the next region begins with a comment: such a
                    // comment is a trailing comment of the statement just emitted
                    // (e.g. "SELECT 1; -- c"), and breaking here would detach it
                    // onto its own line. Preserving the gap keeps it attached;
                    // the comment's own line break still separates the next
                    // statement.
                    out.append('\n');
                } else {
                    // Inter-region gap: whitespace, comments, blank lines, etc.
                    appendSourceSlice(out, source, rEnd, nextStart,
                        "gap[" + i + "->" + (i + 1) + "]");
                }
            }
        }

        // Trailer: source bytes after the last region's last token.
        int lastEnd = regions.get(regions.size() - 1).getRange().getEndOffset();
        appendSourceSlice(out, source, lastEnd, source.length(), "trailer");

        return out.toString();
    }

    /**
     * Append {@code source[from..to)} to {@code out}. Guards against
     * out-of-bounds indices: an invalid range logs a warning and emits
     * nothing rather than throwing, so a single bad region cannot corrupt the
     * rest of the assembly.
     */
    private static void appendSourceSlice(StringBuilder out,
                                          String source,
                                          int from, int to,
                                          String label) {
        if (from >= to) return;  // empty or zero-width slice
        if (from < 0 || to > source.length()) {
            PPLogger.info("RegionAssembler: " + label + " source slice ["
                + from + ".." + to + ") is out of bounds "
                + "(sourceLen=" + source.length() + "); skipping");
            return;
        }
        out.append(source, from, to);
    }

    /**
     * True when {@code source[from..to)} consists solely of horizontal
     * whitespace (or is empty) and contains no line break. Such a gap means
     * two statements sit on the same physical line; the assembler replaces it
     * with a newline when {@link Pp2FormatOptions#breakStatementsOnNewLine} is
     * on. A gap containing a {@code \n}/{@code \r} (statements already on
     * separate lines) or any comment / non-whitespace trivia returns
     * {@code false} so it is preserved verbatim.
     */
    private static boolean isWhitespaceOnlyWithoutLineBreak(String source,
                                                            int from, int to) {
        if (from < 0 || to > source.length()) return false;  // bounds-guard; verbatim path handles it
        if (from >= to) return true;  // adjacent statements (no gap) still want a break
        for (int i = from; i < to; i++) {
            char c = source.charAt(i);
            if (c == '\n' || c == '\r') return false;  // already line-separated
            if (!Character.isWhitespace(c)) return false;  // comment / other trivia
        }
        return true;
    }

    /**
     * True when the next region begins with a comment at {@code start}. Such a
     * comment is a trailing comment of the preceding statement; inserting a
     * statement break before it would detach it onto its own line, so we
     * preserve the gap verbatim instead.
     *
     * <p>The universal {@code --} and {@code /*} openers are always recognised.
     * {@code #} is recognised as a line comment for every dialect except the
     * SQL Server family ({@code dbvmssql}/{@code dbvazuresql}/{@code dbvsybase}),
     * where {@code #name} is a temp-table identifier, not a comment. Erring
     * toward "is a comment" only ever preserves trivia (skips a break), so a
     * rare misclassification degrades gracefully rather than corrupting output.
     */
    private boolean nextRegionStartsWithComment(String source, int start) {
        if (start < 0 || start >= source.length()) return false;
        if (source.startsWith("--", start) || source.startsWith("/*", start)) {
            return true;
        }
        return source.charAt(start) == '#' && hashIsLineComment();
    }

    /** True when {@code #} starts a line comment in {@link #vendor}. */
    private boolean hashIsLineComment() {
        if (vendor == null) return false;  // vendor-agnostic: don't guess
        switch (vendor) {
            case dbvmssql:
            case dbvazuresql:
            case dbvsybase:
                return false;  // #name is a temp-table identifier here
            default:
                return true;   // MySQL family and others: # is a line comment
        }
    }
}