package gudusoft.gsqlparser.pp2.token;

import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;

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

/**
 * Lossless adapter from {@link TSourceTokenList} to {@link Pp2TokenStream}.
 *
 * <p>Implements the Delphi {@code initTokenArray} semantics from
 * {@code gsp_vcl/pp/sqlion.pas}: walk the token list, fold every
 * {@code ttwhitespace} / {@code ttreturn} token into the
 * {@code precedingBlanks} and {@code precedingLinebreaks} counts of the
 * next non-whitespace token. Comments
 * ({@code ttsimplecomment}, {@code ttbracketedcomment}) are <b>not</b>
 * folded — they are first-class tokens in pp2 so downstream stages can
 * preserve, reanchor, or reflow them per {@code CommentPolicy}.
 *
 * <h2>Logical-line semantics</h2>
 *
 * <p>{@code precedingLinebreaks} is a count of <i>logical</i> new lines,
 * not raw characters. {@code "\r\n"} counts as <b>one</b> linebreak (not
 * two), as does a lone {@code "\n"} or a lone {@code "\r"}. Downstream
 * layout rules in S25/S28 treat each logical linebreak as a new visual
 * line; counting CRLF as two would surface as a spurious blank line on
 * Windows-encoded scripts.
 *
 * <p>Byte-exact recovery of mixed line endings is not the spine's job —
 * the {@code SourceSpanLedger} (S8) records every byte of the original
 * input, including the precise CR/LF/CRLF sequence, so the region
 * assembler (S15) can restore them when emitting output.
 *
 * <h2>Reconstruction property (CRLF-normalized)</h2>
 *
 * <p>After normalizing {@code "\r\n"} to {@code "\n"} in the original
 * input, summing across the produced stream:
 * <pre>
 *   Σ ( precedingLinebreaks + precedingBlanks + token.text.length() )
 *     + trailingBlanks + trailingLinebreaks
 *   == normalized input length
 * </pre>
 * The trailing trivia is returned alongside the stream so the source-span
 * ledger (S8) and the region assembler (S15) can place it back into the
 * output.
 *
 * <h2>Counting rules</h2>
 *
 * <ul>
 *   <li>{@code "\r\n"} consumed together → 1 linebreak.</li>
 *   <li>Lone {@code "\n"} → 1 linebreak.</li>
 *   <li>Lone {@code "\r"} → 1 linebreak.</li>
 *   <li>Any other character (space, tab, form-feed, vertical tab, NBSP)
 *       → 1 blank. {@code countWhitespace()} only sees lexer-classified
 *       whitespace tokens, so non-whitespace UTF-8 characters never reach
 *       it.</li>
 * </ul>
 */
public final class Pp2TokenStreamBuilder {

    /**
     * Result of a build: the stream of solid + comment tokens, plus any
     * trailing trivia characters that appeared after the last such token.
     */
    public static final class BuildResult {
        private final Pp2TokenStream stream;
        private final int trailingBlanks;
        private final int trailingLinebreaks;
        private final int totalSourceLength;

        BuildResult(Pp2TokenStream stream, int trailingBlanks,
                    int trailingLinebreaks, int totalSourceLength) {
            this.stream = stream;
            this.trailingBlanks = trailingBlanks;
            this.trailingLinebreaks = trailingLinebreaks;
            this.totalSourceLength = totalSourceLength;
        }

        public Pp2TokenStream getStream() { return stream; }
        public int getTrailingBlanks() { return trailingBlanks; }
        public int getTrailingLinebreaks() { return trailingLinebreaks; }

        /**
         * Total character count of the source token text the builder saw
         * (sum of every {@code TSourceToken.toString().length()} including
         * whitespace tokens). Reported for diagnostics; the reconstruction
         * property compares the per-token sum against the
         * <i>CRLF-normalized</i> input length, which differs from this raw
         * total whenever the input contains {@code "\r\n"}.
         */
        public int getTotalSourceLength() { return totalSourceLength; }
    }

    /**
     * Build a stream from the given source token list.
     *
     * @throws NullPointerException if {@code source} is null or contains a
     *     null element
     */
    public BuildResult build(TSourceTokenList source) {
        if (source == null) throw new NullPointerException("source");
        List<Pp2Token> tokens = new ArrayList<Pp2Token>(source.size());

        int pendingBlanks = 0;
        int pendingLinebreaks = 0;
        int totalSourceLength = 0;
        // GSP lexer quirk (probed for "${name}"): the lexer sometimes emits
        // an outer token covering a region AND phantom inner tokens for
        // the same bytes. Track the last emitted token's source-range end
        // so the shared TokenCoverage helper can skip phantom inner tokens.
        long lastEmittedEnd = -1L;

        for (int i = 0; i < source.size(); i++) {
            TSourceToken t = source.get(i);
            if (t == null) {
                throw new NullPointerException("source[" + i + "] — null entry in TSourceTokenList");
            }
            String text = t.toString();
            int len = text == null ? 0 : text.length();

            // Skip tokens FULLY shadowed by an earlier emitted token.
            // Partial overlap (start shadowed, end extending past) is
            // never silently dropped here — SourceSpanLedger (S8) is the
            // authority that detects partial overlap loudly.
            if (TokenCoverage.isFullyShadowed(t, lastEmittedEnd)) {
                continue;
            }
            totalSourceLength += len;

            if (isFoldable(t.tokentype)) {
                // Accumulate into pending counters; do not emit a Pp2Token.
                int[] counts = countWhitespace(text);
                pendingBlanks += counts[0];
                pendingLinebreaks += counts[1];
            } else {
                // Solid or comment token — emit, attaching pending trivia.
                tokens.add(new Pp2Token(t, pendingBlanks, pendingLinebreaks, null));
                pendingBlanks = 0;
                pendingLinebreaks = 0;
                lastEmittedEnd = TokenCoverage.endOffset(t);
            }
        }

        Pp2TokenStream stream = Pp2TokenStream.ofTokens(tokens);
        return new BuildResult(stream, pendingBlanks, pendingLinebreaks,
            totalSourceLength);
    }

    /**
     * Is this token type rolled into preceding-whitespace counters rather
     * than emitted as its own {@code Pp2Token}? Only true whitespace
     * tokens — comments are first-class in pp2.
     */
    public static boolean isFoldable(ETokenType type) {
        return type == ETokenType.ttwhitespace || type == ETokenType.ttreturn;
    }

    /**
     * Classify each character in a whitespace-token's text as blank vs
     * linebreak. {@code '\n'} and {@code '\r'} are linebreaks; everything
     * else (space, tab, form-feed, vertical tab, NBSP, ...) is a blank.
     *
     * @return {@code int[2]} with {@code [0]=blanks, [1]=linebreaks}
     */
    public static int[] countWhitespace(String text) {
        if (text == null || text.isEmpty()) return new int[] {0, 0};
        int blanks = 0;
        int breaks = 0;
        int i = 0;
        int n = text.length();
        while (i < n) {
            char c = text.charAt(i);
            if (c == '\r') {
                breaks++;
                // Consume "\r\n" as a single logical linebreak.
                if (i + 1 < n && text.charAt(i + 1) == '\n') {
                    i += 2;
                } else {
                    i++;
                }
            } else if (c == '\n') {
                breaks++;
                i++;
            } else {
                blanks++;
                i++;
            }
        }
        return new int[] {blanks, breaks};
    }

}