package gudusoft.gsqlparser.pp2.island;

import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
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.Deque;
import java.util.List;
import java.util.Locale;

/**
 * Computes, for every token in a {@link Pp2TokenStream}, its SQL query-scope
 * level: how many enclosing subqueries / CTE bodies contain it.
 *
 * <h2>Scope model</h2>
 *
 * <p>A token's SQL scope level is the number of enclosing <i>query parens</i>.
 * A query paren is a {@code (} whose next solid (non-comment) token is
 * {@code SELECT} or {@code WITH} — i.e. a parenthesised subquery or CTE body.
 * Top-level query tokens are level 0; tokens inside one subquery are level 1;
 * doubly-nested are level 2; and so on.
 *
 * <p>This makes the model robust and well-defined lexically:
 * <ul>
 *   <li>{@code SELECT * FROM (SELECT * FROM (SELECT 1))} → levels 0, 1, 2.</li>
 *   <li>{@code SELECT 1 UNION SELECT 2} → all level 0 (set-operation siblings
 *       share a scope; no extra query paren is introduced).</li>
 *   <li>{@code WITH x AS (SELECT 1) SELECT * FROM x} → the CTE body is level 1,
 *       the outer query level 0.</li>
 *   <li>{@code SELECT (1 + 2) FROM t} → all level 0 (a grouping paren is not a
 *       query paren — its next solid token is not SELECT/WITH).</li>
 * </ul>
 *
 * <h2>Iterative, read-only</h2>
 *
 * <p>Traversal uses an explicit {@link ArrayDeque} of paren frames — never
 * recursion — so a 2000-deep nested-subquery input cannot
 * {@code StackOverflowError} (CLAUDE.md iterative-traversal mandate; plan
 * §10.1, §13/R3). The detector does not mutate any {@link Pp2Token}, its roles,
 * or the wrapped {@link TSourceToken}; it returns a {@link SqlScopeResult} side
 * structure (consistent with S18/S19).
 *
 * <p>Plan reference: §7.3/S20, §7.4/S20, §10.1, §13/R3.
 */
public final class SqlScopeDetector {

    /**
     * Annotate the SQL scope level of every token in {@code stream}.
     *
     * @param stream the token stream; must not be null
     * @return a {@link SqlScopeResult} indexed by token position; never null
     * @throws NullPointerException if {@code stream} is null
     */
    public SqlScopeResult detect(Pp2TokenStream stream) {
        if (stream == null) throw new NullPointerException("stream");

        int n = stream.size();
        int[] level = new int[n];

        Deque<ParenFrame> stack = new ArrayDeque<ParenFrame>();
        List<SqlScope> scopes = new ArrayList<SqlScope>();
        int queryDepth = 0;
        int maxLevel = 0;

        for (int i = 0; i < n; i++) {
            Pp2Token t = stream.get(i);
            ETokenType type = t.getSourceToken().tokentype;

            if (type == ETokenType.ttleftparenthesis) {
                // Opener belongs to the enclosing scope; descend afterwards.
                level[i] = queryDepth;
                boolean isQuery = nextSolidIsQueryIntroducer(stream, i);
                stack.push(new ParenFrame(isQuery, i, queryDepth));
                if (isQuery) queryDepth++;
            } else if (type == ETokenType.ttrightparenthesis) {
                // Closer belongs to the enclosing scope: pop first (if matching).
                if (!stack.isEmpty()) {
                    ParenFrame f = stack.pop();
                    if (f.isQuery) {
                        queryDepth--;
                        scopes.add(new SqlScope(f.openIndex, i, f.enclosingLevel));
                    }
                }
                level[i] = queryDepth;
            } else {
                level[i] = queryDepth;
            }

            if (level[i] > maxLevel) maxLevel = level[i];
        }

        // Unclosed query parens are still recorded (closeIndex -1).
        while (!stack.isEmpty()) {
            ParenFrame f = stack.pop();
            if (f.isQuery) {
                scopes.add(new SqlScope(f.openIndex, -1, f.enclosingLevel));
            }
        }

        return new SqlScopeResult(level, maxLevel, Collections.unmodifiableList(scopes));
    }

    /** True if the next solid (non-comment) token after index i is SELECT or WITH. */
    private static boolean nextSolidIsQueryIntroducer(Pp2TokenStream stream, int i) {
        for (int j = i + 1; j < stream.size(); j++) {
            ETokenType type = stream.get(j).getSourceToken().tokentype;
            if (isComment(type)) continue;
            if (type != ETokenType.ttkeyword) return false;
            String text = stream.get(j).getText();
            if (text == null) return false;
            String upper = text.toUpperCase(Locale.ROOT);
            return "SELECT".equals(upper) || "WITH".equals(upper);
        }
        return false;
    }

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

    /** A single open paren frame on the explicit traversal stack. */
    private static final class ParenFrame {
        final boolean isQuery;
        final int openIndex;
        final int enclosingLevel;
        ParenFrame(boolean isQuery, int openIndex, int enclosingLevel) {
            this.isQuery = isQuery;
            this.openIndex = openIndex;
            this.enclosingLevel = enclosingLevel;
        }
    }

    /** Per-token SQL scope level plus the list of detected subquery/CTE scopes. */
    public static final class SqlScopeResult {
        private final int[] level;
        private final int maxLevel;
        private final List<SqlScope> scopes;

        SqlScopeResult(int[] level, int maxLevel, List<SqlScope> scopes) {
            this.level = level;
            this.maxLevel = maxLevel;
            this.scopes = scopes;
        }

        /** Number of tokens covered. */
        public int size() { return level.length; }

        /** SQL scope level of the token at {@code index} (0 = top-level query). */
        public int levelAt(int index) { return level[index]; }

        /** Maximum scope level observed (0 if no subqueries). */
        public int getMaxLevel() { return maxLevel; }

        /**
         * All detected subquery / CTE-body scopes, each carrying the opening
         * paren index, the closing paren index ({@code -1} if unclosed), and
         * the enclosing level at which the subquery sits.
         */
        public List<SqlScope> getScopes() { return scopes; }
    }

    /** An immutable subquery/CTE scope (a query paren and its contents). */
    public static final class SqlScope {
        private final int openIndex;
        private final int closeIndex;   // -1 if unclosed
        private final int enclosingLevel;

        SqlScope(int openIndex, int closeIndex, int enclosingLevel) {
            this.openIndex = openIndex;
            this.closeIndex = closeIndex;
            this.enclosingLevel = enclosingLevel;
        }

        public int getOpenIndex() { return openIndex; }
        public int getCloseIndex() { return closeIndex; }
        public boolean isClosed() { return closeIndex >= 0; }
        public int getEnclosingLevel() { return enclosingLevel; }

        @Override
        public String toString() {
            return "SqlScope[open=" + openIndex + " close=" + closeIndex
                + " enclosingLevel=" + enclosingLevel + "]";
        }
    }
}