package gudusoft.gsqlparser.pp2.island;

import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;
import gudusoft.gsqlparser.pp2.island.ClauseScopeAnnotator.ClauseScopeResult;
import gudusoft.gsqlparser.pp2.island.SqlScopeDetector.SqlScope;
import gudusoft.gsqlparser.pp2.island.SqlScopeDetector.SqlScopeResult;
import gudusoft.gsqlparser.pp2.token.Pp2Token;
import gudusoft.gsqlparser.pp2.token.Pp2TokenStream;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.List;
import java.util.Locale;

/**
 * Recognises typed {@link IslandScope}s over a {@link Pp2TokenStream}, using the
 * SQL scope (S20), clause membership (S21), and block scope (S19) results.
 *
 * <h2>What it emits</h2>
 *
 * <ul>
 *   <li><b>Clause islands</b> — maximal runs of identical {@link ClausePart} at
 *       the same SQL level become SELECT / FROM / JOIN / WHERE / GROUP_BY /
 *       HAVING / ORDER_BY / INTO / INSERT_VALUES / UPDATE_SET islands. A clause
 *       island whose only content is keyword(s) (no operand) is flagged
 *       {@link IncompleteReason#MISSING_OPERAND}, and an {@link IslandKind#ERROR_REGION}
 *       island is emitted over the dangling tokens (length-capped by
 *       {@link Pp2FormatOptions#maxErrorRegionSize}).</li>
 *   <li><b>Subquery / CTE islands</b> — each S20 query-paren scope becomes a
 *       {@link IslandKind#CTE} island (if its {@code (} is preceded by {@code AS})
 *       or a {@link IslandKind#SUBQUERY} island; an unclosed one is flagged
 *       {@link IncompleteReason#UNCLOSED_PAREN}.</li>
 *   <li><b>CASE islands</b> — {@code CASE ... END} spans (iterative, nesting-aware,
 *       {@code END CASE} qualifier handled); an unterminated CASE is flagged
 *       {@link IncompleteReason#MISSING_END}.</li>
 *   <li><b>MERGE islands</b> — a {@code MERGE} statement span (light: keyword to
 *       statement end).</li>
 * </ul>
 *
 * <p>Islands may nest/overlap; the result is sorted by start index. The
 * recogniser is iterative (explicit {@link ArrayDeque}) and read-only — it does
 * not mutate any {@link Pp2Token}.
 *
 * <p>Plan reference: §7.3/S22, §7.4/S22.
 */
public final class IslandRecognizer {

    /**
     * Keywords that, immediately after {@code END}, qualify an end of a
     * construct this recogniser does not track (so {@code END IF} etc. pop
     * nothing from the CASE/BEGIN stack).
     */
    private static final java.util.Set<String> END_INNER_QUALIFIERS;
    static {
        java.util.Set<String> q = new java.util.HashSet<String>(java.util.Arrays.asList(
            "IF", "LOOP", "WHILE", "REPEAT", "FOR"));
        END_INNER_QUALIFIERS = java.util.Collections.unmodifiableSet(q);
    }

    // Note on trivia: the Pp2TokenStream produced by Pp2TokenStreamBuilder (S7)
    // folds whitespace/newlines into precedingBlanks/precedingLinebreaks, so the
    // stream contains only solid tokens and comments. The "skip comments" helpers
    // here therefore reach the true next/previous solid token, and runHasOperand
    // never miscounts whitespace as an operand.

    /**
     * Recognise islands over {@code stream}.
     *
     * @param stream the token stream; must not be null
     * @param sql    S20 scope result for the same stream; must not be null
     * @param clause S21 clause result for the same stream; must not be null
     * @param opts   pp2 options (for {@code maxErrorRegionSize}); must not be null
     * @return an immutable, start-index-ordered list of islands; never null
     * @throws NullPointerException if any argument is null
     */
    public List<IslandScope> recognize(Pp2TokenStream stream,
                                       SqlScopeResult sql,
                                       ClauseScopeResult clause,
                                       Pp2FormatOptions opts) {
        if (stream == null) throw new NullPointerException("stream");
        if (sql == null) throw new NullPointerException("sql");
        if (clause == null) throw new NullPointerException("clause");
        if (opts == null) throw new NullPointerException("opts");

        List<IslandScope> islands = new ArrayList<IslandScope>();
        addClauseIslands(stream, sql, clause, opts, islands);
        addSubqueryAndCteIslands(stream, sql, islands);
        addCaseIslands(stream, sql, islands);
        addMergeIslands(stream, sql, islands);

        Collections.sort(islands, BY_START);
        return Collections.unmodifiableList(islands);
    }

    private static final Comparator<IslandScope> BY_START = new Comparator<IslandScope>() {
        @Override
        public int compare(IslandScope a, IslandScope b) {
            int c = Integer.compare(a.getStartIndex(), b.getStartIndex());
            return c != 0 ? c : Integer.compare(a.getEndIndex(), b.getEndIndex());
        }
    };

    // ---- clause islands -------------------------------------------------

    private void addClauseIslands(Pp2TokenStream stream, SqlScopeResult sql,
                                  ClauseScopeResult clause, Pp2FormatOptions opts,
                                  List<IslandScope> out) {
        int n = stream.size();
        int i = 0;
        while (i < n) {
            ClausePart part = clause.partAt(i);
            IslandKind kind = islandKindFor(part);
            int level = sql.levelAt(i);
            if (kind == null) { i++; continue; }

            // Extend the run while clause part and sql level stay the same.
            int j = i;
            while (j + 1 < n
                && clause.partAt(j + 1) == part
                && sql.levelAt(j + 1) == level) {
                j++;
            }

            boolean complete = runHasOperand(stream, i, j);
            IncompleteReason reason = complete
                ? IncompleteReason.NONE : IncompleteReason.MISSING_OPERAND;
            out.add(new IslandScope(kind, i, j, level, complete, reason));

            if (!complete) {
                int cappedEnd = charCappedEnd(stream, i, j, opts.maxErrorRegionSize);
                out.add(new IslandScope(IslandKind.ERROR_REGION, i, cappedEnd, level,
                    false, IncompleteReason.UNRECOVERABLE));
            }
            i = j + 1;
        }
    }

    /** A clause run is complete if it contains at least one non-comment, non-keyword token. */
    private static boolean runHasOperand(Pp2TokenStream stream, int start, int end) {
        for (int k = start; k <= end; k++) {
            ETokenType type = stream.get(k).getSourceToken().tokentype;
            if (isComment(type)) continue;
            if (type != ETokenType.ttkeyword) return true;
        }
        return false;
    }

    private static IslandKind islandKindFor(ClausePart part) {
        switch (part) {
            case SELECT_LIST:   return IslandKind.SELECT;
            case FROM:          return IslandKind.FROM;
            case JOIN:          return IslandKind.JOIN;
            case WHERE:         return IslandKind.WHERE;
            case GROUP_BY:      return IslandKind.GROUP_BY;
            case HAVING:        return IslandKind.HAVING;
            case ORDER_BY:      return IslandKind.ORDER_BY;
            case INTO:          return IslandKind.INTO;
            case INSERT_VALUES: return IslandKind.INSERT_VALUES;
            case UPDATE_SET:    return IslandKind.UPDATE_SET;
            default:            return null; // NONE, SET_OP -> not a clause island
        }
    }

    // ---- subquery / CTE islands -----------------------------------------

    private void addSubqueryAndCteIslands(Pp2TokenStream stream, SqlScopeResult sql,
                                          List<IslandScope> out) {
        int lastSolid = lastNonTriviaIndex(stream);
        for (SqlScope sc : sql.getScopes()) {
            int start = sc.getOpenIndex();
            int end = sc.isClosed() ? sc.getCloseIndex() : Math.max(start, lastSolid);
            IslandKind kind = isAsPreceded(stream, start) ? IslandKind.CTE : IslandKind.SUBQUERY;
            boolean complete = sc.isClosed();
            IncompleteReason reason = complete
                ? IncompleteReason.NONE : IncompleteReason.UNCLOSED_PAREN;
            out.add(new IslandScope(kind, start, end, sc.getEnclosingLevel(), complete, reason));
        }
    }

    /** True if the first solid token before {@code openIndex} is the keyword AS. */
    private static boolean isAsPreceded(Pp2TokenStream stream, int openIndex) {
        for (int j = openIndex - 1; j >= 0; j--) {
            ETokenType type = stream.get(j).getSourceToken().tokentype;
            if (isComment(type)) continue;
            if (type != ETokenType.ttkeyword) return false;
            String text = stream.get(j).getText();
            return text != null && "AS".equalsIgnoreCase(text);
        }
        return false;
    }

    // ---- CASE islands ---------------------------------------------------

    /** Frame kinds on the CASE/BEGIN balancing stack. */
    private static final int FRAME_CASE = 0;
    private static final int FRAME_BEGIN = 1;

    private void addCaseIslands(Pp2TokenStream stream, SqlScopeResult sql,
                                List<IslandScope> out) {
        int n = stream.size();
        // Unified stack of open CASE / BEGIN frames so an END pops the nearest
        // open construct (a BEGIN's END must not close an enclosing CASE).
        // Each entry is {frameKind, startIndex}.
        Deque<int[]> stack = new ArrayDeque<int[]>();
        int skipCaseAt = -1; // index of a CASE that is the qualifier of "END CASE"
        int lastSolid = lastNonTriviaIndex(stream);

        for (int i = 0; i < n; i++) {
            if (stream.get(i).getSourceToken().tokentype != ETokenType.ttkeyword) continue;
            String upper = upperKeyword(stream, i);

            if ("CASE".equals(upper)) {
                if (i == skipCaseAt) { skipCaseAt = -1; continue; }
                stack.push(new int[]{FRAME_CASE, i});
            } else if ("BEGIN".equals(upper)) {
                stack.push(new int[]{FRAME_BEGIN, i});
            } else if ("END".equals(upper)) {
                int next = nextSolidIndex(stream, i);
                String nextUpper = next < 0 ? null : upperKeyword(stream, next);
                // END IF / END LOOP / END WHILE / END REPEAT / END FOR close
                // inner constructs this recogniser does not track; they pop nothing.
                if (nextUpper != null && END_INNER_QUALIFIERS.contains(nextUpper)) {
                    continue;
                }
                if (stack.isEmpty()) continue;
                boolean endCase = "CASE".equals(nextUpper); // the "END CASE" terminator
                int[] frame = stack.pop();
                if (frame[0] == FRAME_CASE) {
                    // Include the trailing CASE token of an "END CASE" terminator.
                    int end = endCase ? next : i;
                    out.add(new IslandScope(IslandKind.CASE, frame[1], end,
                        sql.levelAt(frame[1]), true, IncompleteReason.NONE));
                }
                // For a BEGIN frame we emit nothing (S19 owns block scopes); we
                // only needed it to balance the END correctly.
                if (endCase) skipCaseAt = next; // don't treat the qualifier as a new CASE
            }
        }
        // Unterminated CASE blocks (any BEGIN frames left are S19's concern).
        while (!stack.isEmpty()) {
            int[] frame = stack.pop();
            if (frame[0] == FRAME_CASE) {
                int end = Math.max(frame[1], lastSolid);
                out.add(new IslandScope(IslandKind.CASE, frame[1], end,
                    sql.levelAt(frame[1]), false, IncompleteReason.MISSING_END));
            }
        }
    }

    /** Uppercased text of the keyword token at i (assumes it is a ttkeyword). */
    private static String upperKeyword(Pp2TokenStream stream, int i) {
        String text = stream.get(i).getText();
        return text == null ? "" : text.toUpperCase(Locale.ROOT);
    }

    // ---- MERGE islands --------------------------------------------------

    private void addMergeIslands(Pp2TokenStream stream, SqlScopeResult sql,
                                 List<IslandScope> out) {
        int n = stream.size();
        for (int i = 0; i < n; i++) {
            if (!isKeyword(stream, i, "MERGE")) continue;
            int end = i;
            for (int j = i + 1; j < n; j++) {
                if (stream.get(j).getSourceToken().tokentype == ETokenType.ttsemicolon) break;
                end = j;
            }
            out.add(new IslandScope(IslandKind.MERGE, i, end, sql.levelAt(i),
                true, IncompleteReason.NONE));
        }
    }

    // ---- helpers --------------------------------------------------------

    /**
     * The greatest index {@code e} in {@code [start, end]} such that the summed
     * source text length of tokens {@code [start, e]} does not exceed
     * {@code maxChars}. At least {@code start} is always included.
     */
    private static int charCappedEnd(Pp2TokenStream stream, int start, int end, int maxChars) {
        if (maxChars <= 0) return start;
        int chars = 0;
        for (int k = start; k <= end; k++) {
            String text = stream.get(k).getText();
            chars += (text == null ? 0 : text.length());
            if (chars > maxChars) return Math.max(start, k - 1);
        }
        return end;
    }

    private static int nextSolidIndex(Pp2TokenStream stream, int from) {
        for (int j = from + 1; j < stream.size(); j++) {
            if (!isComment(stream.get(j).getSourceToken().tokentype)) return j;
        }
        return -1;
    }

    private static int lastNonTriviaIndex(Pp2TokenStream stream) {
        for (int j = stream.size() - 1; j >= 0; j--) {
            if (!isComment(stream.get(j).getSourceToken().tokentype)) return j;
        }
        return Math.max(0, stream.size() - 1);
    }

    private static boolean isKeyword(Pp2TokenStream stream, int i, String upper) {
        if (i < 0 || i >= stream.size()) return false;
        Pp2Token t = stream.get(i);
        if (t.getSourceToken().tokentype != ETokenType.ttkeyword) return false;
        String text = t.getText();
        return text != null && text.toUpperCase(Locale.ROOT).equals(upper);
    }

    private static boolean isComment(ETokenType type) {
        return type == ETokenType.ttsimplecomment
            || type == ETokenType.ttbracketedcomment
            || type == ETokenType.ttCPPComment;
    }
}