package gudusoft.gsqlparser.pp2.zone;

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;

/**
 * Detects protected zones in a {@link Pp2TokenStream} and annotates the
 * affected tokens with the relevant {@link TokenRole} flags.
 *
 * <p>"Protected" here means: pp2 must emit the token's text verbatim. The
 * layout rules in S24–S29 may re-space <i>around</i> a protected token
 * but never alter its contents.
 *
 * <h2>What this detector recognizes</h2>
 *
 * <ul>
 *   <li><b>Line comments</b> ({@code ttsimplecomment}, {@code ttCPPComment})
 *       → {@link TokenRole#COMMENT_LINE}.</li>
 *   <li><b>Block comments</b> ({@code ttbracketedcomment})
 *       → {@link TokenRole#COMMENT_BLOCK}.</li>
 *   <li><b>Hint comments</b> (block comment whose text begins with
 *       {@code "/*+"}) → {@link TokenRole#HINT} in addition to
 *       {@code COMMENT_BLOCK}.</li>
 *   <li><b>String literals</b> ({@code ttsqstring})
 *       → {@link TokenRole#LITERAL}.</li>
 *   <li><b>Quoted identifiers</b> ({@code ttdqstring},
 *       {@code ttdbstring}, {@code ttbrstring})
 *       → {@link TokenRole#QUOTED_IDENTIFIER}.</li>
 *   <li><b>No-format blocks</b>: every token whose source position lies
 *       between a {@code --BEGIN_NO_FORMAT} line comment and a matching
 *       {@code --END_NO_FORMAT} line comment is flagged with
 *       {@link TokenRole#NO_FORMAT_ZONE}. The markers themselves carry
 *       the flag too.</li>
 *   <li><b>Template placeholders</b>: tokens whose text matches the
 *       shapes {@code ${name}}, {@code {{name}}}, or {@code #{name}}
 *       are flagged {@link TokenRole#TEMPLATE_PLACEHOLDER} and
 *       {@link TokenRole#NO_FORMAT_ZONE} so layout never reflows
 *       inside them. {@code ${name}} arrives from the lexer as a
 *       single identifier-style token and is matched in the per-token
 *       pass; {@code {{name}}} and {@code #{name}} are tokenized as
 *       multiple tokens (e.g., {@code "{" "{" name "}" "}"}) and a
 *       second pass walks the stream looking for those sequences. The
 *       second-pass body check rejects shapes whose interior does not
 *       look like a placeholder body, so SQL fragments that happen to
 *       contain isolated braces (e.g., JSON path literals) are not
 *       misflagged.</li>
 * </ul>
 *
 * <p>The detector does not consume or produce tokens; it only adds roles
 * to existing {@link Pp2Token}s. Repeated invocations are idempotent (the
 * underlying {@link java.util.EnumSet} is set-typed).
 *
 * <p>Plan reference: §7.3/S9, §7.4/S9.
 */
public final class ProtectedZoneDetector {

    /** Marker comment text that opens a no-format block. */
    public static final String NO_FORMAT_BEGIN = "--BEGIN_NO_FORMAT";
    /** Marker comment text that closes a no-format block. */
    public static final String NO_FORMAT_END = "--END_NO_FORMAT";

    /**
     * Annotate the supplied stream in place. The stream's structural
     * immutability is not violated — only the per-token role sets are
     * touched.
     *
     * <p>Performed in two passes:
     * <ol>
     *   <li>Per-token classification (comments, literals, quoted ids,
     *       single-token placeholders) and the no-format block state
     *       machine.</li>
     *   <li>Multi-token template placeholders {@code {{name}}} and
     *       {@code #{name}}, detected by scanning consecutive token text.</li>
     * </ol>
     *
     * <p>Idempotent: repeated invocations don't double-flag because the
     * underlying role set is set-typed.
     *
     * @throws NullPointerException if {@code stream} is null
     */
    public void annotate(Pp2TokenStream stream) {
        if (stream == null) throw new NullPointerException("stream");
        annotatePerToken(stream);
        annotateMultiTokenPlaceholders(stream);
    }

    private void annotatePerToken(Pp2TokenStream stream) {
        boolean inNoFormat = false;
        for (int i = 0; i < stream.size(); i++) {
            Pp2Token wrapped = stream.get(i);
            TSourceToken t = wrapped.getSourceToken();
            ETokenType type = t.tokentype;
            String text = wrapped.getText();

            // Per-token basic classification.
            switch (type) {
                case ttsimplecomment:
                case ttCPPComment:
                    wrapped.addRole(TokenRole.COMMENT_LINE);
                    break;
                case ttbracketedcomment:
                    wrapped.addRole(TokenRole.COMMENT_BLOCK);
                    if (isHintText(text)) {
                        wrapped.addRole(TokenRole.HINT);
                    }
                    break;
                case ttsqstring:
                    wrapped.addRole(TokenRole.LITERAL);
                    break;
                case ttdqstring:
                case ttdbstring:
                case ttbrstring:
                    wrapped.addRole(TokenRole.QUOTED_IDENTIFIER);
                    break;
                default:
                    // not a protected token type
                    break;
            }

            // Single-token template placeholders (e.g., "${name}").
            if (isTemplatePlaceholder(text)) {
                wrapped.addRole(TokenRole.TEMPLATE_PLACEHOLDER);
                wrapped.addRole(TokenRole.NO_FORMAT_ZONE);
            }

            // No-format block state machine. A BEGIN marker turns the
            // zone on; the BEGIN comment itself is part of the zone (so
            // pp2 emits it verbatim and downstream tools can rely on it
            // being preserved). An END marker turns the zone off after
            // being marked itself.
            //
            // The state machine is non-nesting: a second BEGIN inside an
            // open block re-opens (no-op). Documented limitation for v2.
            if (inNoFormat) {
                wrapped.addRole(TokenRole.NO_FORMAT_ZONE);
            }
            if (isNoFormatBeginMarker(type, text)) {
                wrapped.addRole(TokenRole.NO_FORMAT_ZONE);
                inNoFormat = true;
            } else if (isNoFormatEndMarker(type, text)) {
                wrapped.addRole(TokenRole.NO_FORMAT_ZONE);
                inNoFormat = false;
            }
        }
    }

    /**
     * Second pass: detect template placeholder shapes that span multiple
     * tokens because the lexer split them into pieces. Recognized shapes:
     * <ul>
     *   <li>{@code "{" "{" body... "}" "}"}: Mustache-style.</li>
     *   <li>{@code "#" "{" body... "}"}: MyBatis-style.</li>
     * </ul>
     * Only flags when the open and close markers are present and the
     * intervening body looks like a placeholder body (idents, digits,
     * underscores, dots) so SQL fragments that happen to use {@code {{}
     * (e.g., array-literal syntax in JSON path expressions) are not
     * misflagged. If no matching close marker is found within a small
     * search window, the open tokens are left untouched.
     */
    private void annotateMultiTokenPlaceholders(Pp2TokenStream stream) {
        int n = stream.size();
        for (int i = 0; i < n; i++) {
            String ti = stream.get(i).getText();
            // {{ ... }}
            if ("{".equals(ti) && i + 1 < n && "{".equals(stream.get(i + 1).getText())) {
                int end = findMustacheClose(stream, i + 2);
                if (end >= 0) {
                    flagPlaceholderRange(stream, i, end);
                    i = end;
                    continue;
                }
            }
            // # { ... }
            if ("#".equals(ti) && i + 1 < n && "{".equals(stream.get(i + 1).getText())) {
                int end = findBraceClose(stream, i + 2);
                if (end >= 0) {
                    flagPlaceholderRange(stream, i, end);
                    i = end;
                }
            }
        }
    }

    /**
     * Find a matching {@code "}" "}"} pair after the {@code {{} opener.
     * The body must look like a placeholder body. Returns the index of
     * the second {@code }} or {@code -1} if not found.
     */
    private static int findMustacheClose(Pp2TokenStream stream, int from) {
        int n = stream.size();
        for (int j = from; j + 1 < n; j++) {
            if ("}".equals(stream.get(j).getText())
                && "}".equals(stream.get(j + 1).getText())) {
                // Verify the body in between looks like a placeholder body.
                if (looksLikePlaceholderBodyTokens(stream, from, j)) {
                    return j + 1;
                }
                return -1;
            }
        }
        return -1;
    }

    /** Find the matching {@code "}"} after the {@code #{} opener. */
    private static int findBraceClose(Pp2TokenStream stream, int from) {
        int n = stream.size();
        for (int j = from; j < n; j++) {
            if ("}".equals(stream.get(j).getText())) {
                if (looksLikePlaceholderBodyTokens(stream, from, j)) {
                    return j;
                }
                return -1;
            }
        }
        return -1;
    }

    /**
     * Check the [from, to) token range: each token's text must look like
     * placeholder-body content (idents, digits, dots, underscores, dashes).
     * An empty range is rejected — placeholders must have a body.
     */
    private static boolean looksLikePlaceholderBodyTokens(Pp2TokenStream stream,
                                                          int from, int to) {
        if (to <= from) return false;
        for (int j = from; j < to; j++) {
            String text = stream.get(j).getText();
            if (text == null || text.isEmpty()) return false;
            for (int k = 0; k < text.length(); k++) {
                char c = text.charAt(k);
                if (Character.isLetterOrDigit(c) || c == '_' || c == '.' || c == '-') {
                    continue;
                }
                return false;
            }
        }
        return true;
    }

    private static void flagPlaceholderRange(Pp2TokenStream stream, int start, int end) {
        for (int j = start; j <= end; j++) {
            stream.get(j).addRole(TokenRole.TEMPLATE_PLACEHOLDER);
            stream.get(j).addRole(TokenRole.NO_FORMAT_ZONE);
        }
    }

    // --- single-token detectors (public static for testability) ---------

    /**
     * True if the given text is a hint-style block comment, i.e., starts
     * with {@code "/*+"}.
     */
    public static boolean isHintText(String text) {
        return text != null && text.length() >= 3
            && text.charAt(0) == '/' && text.charAt(1) == '*'
            && text.charAt(2) == '+';
    }

    /**
     * True if the given text matches a single-token template-placeholder
     * shape: {@code ${name}}, {@code {{name}}}, or {@code #{name}}.
     */
    public static boolean isTemplatePlaceholder(String text) {
        if (text == null || text.length() < 4) return false;
        if (text.charAt(0) == '$' && text.charAt(1) == '{'
            && text.charAt(text.length() - 1) == '}') {
            return looksLikePlaceholderBody(text, 2, text.length() - 1);
        }
        if (text.charAt(0) == '#' && text.charAt(1) == '{'
            && text.charAt(text.length() - 1) == '}') {
            return looksLikePlaceholderBody(text, 2, text.length() - 1);
        }
        if (text.length() >= 6
            && text.charAt(0) == '{' && text.charAt(1) == '{'
            && text.charAt(text.length() - 2) == '}'
            && text.charAt(text.length() - 1) == '}') {
            return looksLikePlaceholderBody(text, 2, text.length() - 2);
        }
        return false;
    }

    private static boolean looksLikePlaceholderBody(String text, int from, int to) {
        if (to <= from) return false;
        for (int i = from; i < to; i++) {
            char c = text.charAt(i);
            if (Character.isLetterOrDigit(c) || c == '_' || c == '.' || c == '-') {
                continue;
            }
            return false;
        }
        return true;
    }

    /**
     * True if the given line-comment text opens a no-format block. The
     * match is case-sensitive and ignores trailing whitespace; the comment
     * may include trailing characters as long as the prefix matches the
     * documented marker.
     */
    public static boolean isNoFormatBeginMarker(ETokenType type, String text) {
        if (text == null) return false;
        if (type != ETokenType.ttsimplecomment && type != ETokenType.ttCPPComment) {
            return false;
        }
        return text.startsWith(NO_FORMAT_BEGIN);
    }

    /** True if the given line-comment text closes a no-format block. */
    public static boolean isNoFormatEndMarker(ETokenType type, String text) {
        if (text == null) return false;
        if (type != ETokenType.ttsimplecomment && type != ETokenType.ttCPPComment) {
            return false;
        }
        return text.startsWith(NO_FORMAT_END);
    }
}