package gudusoft.gsqlparser.pp2.region;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.pp2.token.Pp2Token;
import gudusoft.gsqlparser.pp2.token.Pp2TokenStream;
import gudusoft.gsqlparser.pp2.token.TokenRole;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;

/**
 * Walks a {@link Pp2TokenStream} and produces a list of
 * {@link StatementRange}s — one per statement in the source.
 *
 * <p>Terminators recognized:
 * <ul>
 *   <li>{@code ;} — standard SQL statement separator. Every dialect.</li>
 *   <li>{@code GO} (keyword) — SQL Server / Sybase batch separator,
 *       recognized only when the vendor is in the T-SQL family. It is not
 *       part of the statement it ends: the range stops before it, and the
 *       separator, with the count of SQL Server's {@code GO n}, is left to
 *       the gap between ranges, which the assembler emits verbatim. Every
 *       renderer then works on a statement alone, and a region's parse is
 *       one statement.</li>
 * </ul>
 *
 * <h2>What this detector handles correctly</h2>
 *
 * <ul>
 *   <li><b>Strings containing {@code ;}</b> — string literals tokenize as
 *       a single {@code ttsqstring} token; the inner {@code ;} never
 *       appears as a {@code ttsemicolon} so no special case is needed.</li>
 *   <li><b>PL/SQL block-internal {@code ;}</b> — a {@code BEGIN ... END;}
 *       block has internal semicolons at depth ≥ 1; only depth-0
 *       semicolons split statements. The detector tracks BEGIN/END depth
 *       and treats {@code END IF / LOOP / WHILE / REPEAT / FOR} as
 *       inner-construct ends that do not pop the block-depth counter
 *       (those keywords don't push depth, so there's nothing to pop).</li>
 *   <li><b>CASE expressions inside a {@code BEGIN} block</b> —
 *       {@code CASE} pushes its own {@code caseDepth} counter so its
 *       unqualified {@code END} doesn't accidentally pop the surrounding
 *       block-depth. {@code END CASE} pops {@code caseDepth} (and the
 *       trailing {@code CASE} keyword is consumed as a qualifier, not as
 *       a new {@code CASE} push).</li>
 *   <li><b>NO_FORMAT zones</b> — tokens flagged with
 *       {@link TokenRole#NO_FORMAT_ZONE} (by S9's
 *       {@code ProtectedZoneDetector}) are treated as opaque: depth
 *       is not adjusted, terminators are not consumed.</li>
 *   <li><b>Truncated final statement</b> — a stream that ends without a
 *       terminator yields a final range with
 *       {@link StatementRange.Terminator#NONE}.</li>
 * </ul>
 *
 * <h2>What this detector deliberately does NOT handle</h2>
 *
 * <ul>
 *   <li>Standalone Oracle {@code DECLARE ... BEGIN ... END;} blocks where
 *       the {@code DECLARE} clause has its own {@code ;} at depth 0 — the
 *       detector will split there. S22's island recognizer can refine.
 *       PL/SQL in practice almost always wraps in {@code BEGIN}.</li>
 *   <li>Oracle SQL*Plus {@code /} on its own line as a block terminator —
 *       not in the plan §7.3/S11 scope. The {@code /} appears as a normal
 *       token; the next statement starts after it.</li>
 * </ul>
 *
 * <p>Plan reference: §7.3/S11, §7.4/S11.
 */
public final class StatementBoundaryDetector {

    /**
     * Inner-construct keywords that may follow {@code END}. Each takes a
     * different code path:
     *
     * <ul>
     *   <li>{@code IF / LOOP / WHILE / REPEAT / FOR} — these constructs
     *       don't push any depth counter (their internal scope is left to
     *       S22's island recognizer), so the matching {@code END FOO} is
     *       a no-op for the depth model.</li>
     *   <li>{@code CASE} — paired with a {@code CASE} keyword earlier that
     *       pushed {@code caseDepth}. {@code END CASE} pops
     *       {@code caseDepth}; the trailing {@code CASE} keyword is
     *       consumed as a qualifier (does NOT push again).</li>
     * </ul>
     */
    private static final Set<String> END_QUALIFIERS;
    static {
        Set<String> q = new HashSet<String>();
        q.add("IF");
        q.add("LOOP");
        q.add("CASE");
        q.add("WHILE");
        q.add("REPEAT");
        q.add("FOR");
        END_QUALIFIERS = q;
    }

    /**
     * Detect statement boundaries.
     *
     * @param stream non-null token stream (typically already annotated by
     *               S9's {@code ProtectedZoneDetector})
     * @param vendor non-null vendor identity; used to decide whether
     *               {@code GO} is a terminator
     * @return an immutable list of {@link StatementRange}s in source order
     * @throws NullPointerException if either argument is null
     */
    public List<StatementRange> detect(Pp2TokenStream stream, EDbVendor vendor) {
        if (stream == null) throw new NullPointerException("stream");
        if (vendor == null) throw new NullPointerException("vendor");
        final boolean goIsTerminator = isTsqlFamily(vendor);
        final int n = stream.size();
        List<StatementRange> out = new ArrayList<StatementRange>();
        int rangeStart = 0;
        int blockDepth = 0;
        int caseDepth = 0;
        // When an "END CASE" sequence pops caseDepth, the following CASE
        // keyword is the qualifier — not a new CASE statement. Skip its
        // push effect.
        boolean swallowNextCaseAsQualifier = false;

        for (int i = 0; i < n; i++) {
            Pp2Token wrapped = stream.get(i);
            // Skip tokens inside a NO_FORMAT zone — opaque, no depth or
            // terminator effects.
            if (wrapped.hasRole(TokenRole.NO_FORMAT_ZONE)) {
                continue;
            }
            TSourceToken t = wrapped.getSourceToken();
            ETokenType type = t.tokentype;
            String text = wrapped.getText();

            if (type == ETokenType.ttkeyword && text != null) {
                String upper = text.toUpperCase(Locale.ROOT);
                if ("BEGIN".equals(upper)) {
                    blockDepth++;
                } else if ("CASE".equals(upper)) {
                    if (swallowNextCaseAsQualifier) {
                        swallowNextCaseAsQualifier = false;
                    } else {
                        caseDepth++;
                    }
                } else if ("END".equals(upper)) {
                    String nextQual = nextSolidKeywordText(stream, i);
                    String nextUpper = nextQual == null
                        ? null
                        : nextQual.toUpperCase(Locale.ROOT);
                    if (nextUpper != null && END_QUALIFIERS.contains(nextUpper)) {
                        // Qualified END. END CASE pops caseDepth and
                        // marks the trailing CASE as a consumed qualifier;
                        // END IF/LOOP/WHILE/REPEAT/FOR are no-ops because
                        // those keywords don't push.
                        if ("CASE".equals(nextUpper)) {
                            if (caseDepth > 0) caseDepth--;
                            swallowNextCaseAsQualifier = true;
                        }
                    } else {
                        // Unqualified END. Pop caseDepth first (CASE
                        // expressions outrank block scope), then blockDepth.
                        if (caseDepth > 0) {
                            caseDepth--;
                        } else if (blockDepth > 0) {
                            blockDepth--;
                        }
                    }
                }
            }

            // Terminators only fire at top-level depth.
            if (blockDepth != 0 || caseDepth != 0) continue;

            if (type == ETokenType.ttsemicolon) {
                out.add(makeRange(stream, rangeStart, i + 1,
                    StatementRange.Terminator.SEMICOLON));
                rangeStart = i + 1;
            } else if (goIsTerminator
                && type == ETokenType.ttkeyword
                && "GO".equalsIgnoreCase(text)) {
                if (i > rangeStart) {
                    out.add(makeRange(stream, rangeStart, i,
                        StatementRange.Terminator.GO));
                }
                int next = i + 1;
                if (next < n && isBatchCount(stream.get(next))) next++;
                rangeStart = next;
                i = next - 1;
            }
        }

        // Truncated final statement (no terminator at end).
        if (rangeStart < n) {
            out.add(makeRange(stream, rangeStart, n,
                StatementRange.Terminator.NONE));
        }
        return java.util.Collections.unmodifiableList(out);
    }

    /**
     * Return the text of the next solid (non-comment, non-empty) token
     * after {@code fromIndex}, or {@code null} if there is none. Tokens
     * inside a {@link TokenRole#NO_FORMAT_ZONE} are skipped — they're
     * opaque to the depth model.
     */
    private static String nextSolidKeywordText(Pp2TokenStream stream, int fromIndex) {
        for (int j = fromIndex + 1; j < stream.size(); j++) {
            Pp2Token next = stream.get(j);
            if (next.hasRole(TokenRole.NO_FORMAT_ZONE)) continue;
            if (next.hasRole(TokenRole.COMMENT_LINE)
                || next.hasRole(TokenRole.COMMENT_BLOCK)) {
                continue;
            }
            String nextText = next.getText();
            if (nextText == null || nextText.isEmpty()) continue;
            return nextText;
        }
        return null;
    }

    private static StatementRange makeRange(Pp2TokenStream stream,
                                            int startIdx, int endIdxExclusive,
                                            StatementRange.Terminator terminator) {
        int startOffset = startIdx < stream.size()
            ? (int) stream.get(startIdx).getSourceToken().offset
            : 0;
        int endOffset = startOffset;
        if (endIdxExclusive > startIdx) {
            Pp2Token last = stream.get(endIdxExclusive - 1);
            String txt = last.getText();
            int textLen = txt == null ? 0 : txt.length();
            endOffset = (int) last.getSourceToken().offset + textLen;
        }
        return new StatementRange(startIdx, endIdxExclusive,
            startOffset, endOffset, terminator);
    }

    /** The count of SQL Server's {@code GO n}: a number on the line of its {@code GO}. */
    private static boolean isBatchCount(Pp2Token token) {
        return token.getSourceToken().tokentype == ETokenType.ttnumber
            && token.getPrecedingLinebreaks() == 0
            && !token.hasRole(TokenRole.NO_FORMAT_ZONE);
    }

    /**
     * True when {@code GO} is a batch separator for the vendor: SQL Server,
     * Azure SQL, Sybase ASE and IQ, and SQL Anywhere.
     */
    private static boolean isTsqlFamily(EDbVendor vendor) {
        if (vendor == null) return false;
        switch (vendor) {
            case dbvmssql:
            case dbvazuresql:
            case dbvsybase:
                return true;
            case dbvsybasease:
                return true;
            case dbvsqlanywhere:
                return true;
            case dbvsybaseiq:
                return true;
            default:
                return false;
        }
    }
}