package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * Locates the statements to skip in a T-SQL routine ({@code CREATE}/{@code ALTER PROCEDURE}, {@code FUNCTION} or
 * {@code TRIGGER}) whose body holds statements the grammar rejects. Without recovery such a routine fails as a whole
 * and keeps no body statement, so one statement GSP cannot parse loses the lineage of every other statement in it.
 *
 * <p>For each syntax error the statement around it is found -- the innermost statement inside the innermost
 * {@code BEGIN ... END} (or {@code BEGIN TRY/CATCH}) block that holds the error, delimited by the vendor's own raw
 * statement splitter -- and its tokens are returned. {@link TGSqlParser} makes them ignorable
 * ({@link TBaseType#sqlpluscmd}, as CREATE TABLE recovery does for options it cannot parse) and parses the routine
 * again: the same statement over the same tokens, so every position stays the original one. Whenever something is
 * uncertain -- an error in the routine's header, a block structure that does not balance, an error no statement
 * holds -- no token is returned and the routine fails as it always did.
 */
public final class RoutineBodyRecovery {

    private RoutineBodyRecovery() {}

    /** The vendors and statement types the recovery applies to: T-SQL routines. */
    public static boolean appliesTo(EDbVendor vendor, ESqlStatementType type) {
        if (vendor != EDbVendor.dbvmssql && vendor != EDbVendor.dbvazuresql) return false;
        switch (type) {
            case sstmssqlcreateprocedure:
            case sstmssqlalterprocedure:
            case sstmssqlcreatefunction:
            case sstmssqlalterfunction:
            case sstcreatetrigger:              // CREATE [OR ALTER] TRIGGER
            case sstmssqlcreatetrigger:
            case sstmssqlaltertrigger:
                return true;
            default:
                return false;
        }
    }

    /**
     * The tokens of the statements that hold {@code errors}, to make ignorable so that the rest of {@code routine}
     * parses; empty when any error cannot be placed in a statement of the routine's body, or when the body's blocks do
     * not balance (no region is certain then, and the whole body is no statement to skip).
     */
    public static List<TSourceToken> tokensToIgnore(TCustomSqlStatement routine, List<TSyntaxError> errors,
                                                    EDbVendor vendor) {
        List<TSourceToken> none = new ArrayList<TSourceToken>();
        TSourceTokenList tokens = routine.sourcetokenlist;
        if (tokens == null || tokens.size() == 0 || errors == null || errors.isEmpty()) return none;
        int bodyStart = bodyStart(tokens);
        if (bodyStart < 0) return none;
        List<int[]> blocks = blocks(tokens, bodyStart);
        if (blocks == null) return none;
        Map<Long, Integer> solidTokens = solidTokensByPosition(tokens);
        // each region is split once, however many errors it holds: {first, last token index} per statement
        Map<Long, List<int[]>> regionStatements = new HashMap<Long, List<int[]>>();
        Set<TSourceToken> ignore = new LinkedHashSet<TSourceToken>();
        for (TSyntaxError error : errors) {
            Integer at = solidTokens.get(position(error.lineNo, error.columnNo));
            if (at == null || at <= bodyStart) return none;   // not in the body: the header cannot be skipped
            int regionStart = bodyStart + 1, regionEnd = tokens.size() - 1;
            // {BEGIN, first content token, END}, outer blocks first; blocks nest or are disjoint, so the last one
            // holding the error is the innermost
            for (int[] block : blocks) {
                if (block[1] <= at && at < block[2]) {
                    regionStart = block[1];
                    regionEnd = block[2] - 1;
                }
            }
            long region = ((long) regionStart << 32) | regionEnd;
            List<int[]> statements = regionStatements.get(region);
            if (statements == null) {
                statements = statements(tokens, regionStart, regionEnd, vendor);
                regionStatements.put(region, statements);
            }
            int[] statement = null;
            for (int[] candidate : statements) {
                if (candidate[0] <= at && at <= candidate[1]) {
                    statement = candidate;
                    break;
                }
            }
            if (statement == null || holdsBlock(statement, blocks) || runsOnPastItsEnd(tokens, statement)) return none;
            for (int i = statement[0]; i <= statement[1]; i++) {
                if (tokens.get(i).issolidtoken()) ignore.add(tokens.get(i));
            }
        }
        return new ArrayList<TSourceToken>(ignore);
    }

    /**
     * Index of the {@code AS} that ends the routine's header, or -1: the first {@code AS} outside parentheses that is
     * neither {@code EXECUTE AS} (a WITH option) nor {@code @parameter AS type}.
     */
    static int bodyStart(TSourceTokenList tokens) {
        int depth = 0;
        TSourceToken previous = null;
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (!t.issolidtoken()) continue;
            if (t.tokencode == '(' || t.tokencode == TBaseType.left_parenthesis_2) depth++;
            else if (t.tokencode == ')') depth--;
            else if (depth == 0 && t.tokencode == TBaseType.rrw_as && previous != null
                    && previous.tokencode != TBaseType.rrw_exec && previous.tokencode != TBaseType.rrw_execute
                    && !previous.toString().startsWith("@")) {
                return i;
            }
            previous = t;
        }
        return -1;
    }

    /**
     * The routine body's statement blocks as {BEGIN index, first content index, END index}, in the order they open;
     * null when BEGIN and END do not balance (an error may have eaten one, or left a CASE open). {@code CASE ... END}
     * is an expression, {@code BEGIN TRAN}/{@code TRANSACTION}/{@code DISTRIBUTED}/{@code DIALOG}/{@code CONVERSATION}
     * open no block, and {@code END CONVERSATION} ends none.
     */
    static List<int[]> blocks(TSourceTokenList tokens, int bodyStart) {
        List<int[]> blocks = new ArrayList<int[]>();
        Deque<int[]> open = new ArrayDeque<int[]>();      // {BEGIN index or -1 for CASE, first content index}
        for (int i = bodyStart + 1; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (!t.issolidtoken()) continue;
            if (t.tokencode == TBaseType.rrw_case) {
                open.push(new int[]{-1, i + 1});
            } else if (t.tokencode == TBaseType.rrw_begin) {
                int next = nextSolid(tokens, i + 1);
                TSourceToken n = next < 0 ? null : tokens.get(next);
                if (n != null && opensNoBlock(n)) continue;
                if (n != null && (n.tokencode == TBaseType.rrw_try || n.tokencode == TBaseType.rrw_catch)) {
                    open.push(new int[]{i, next + 1});
                    i = next;
                } else {
                    open.push(new int[]{i, i + 1});
                }
            } else if (t.tokencode == TBaseType.rrw_end) {
                int next = nextSolid(tokens, i + 1);
                if (next >= 0 && endsNoBlock(tokens.get(next))) continue;
                if (open.isEmpty()) return null;
                int[] top = open.pop();
                if (top[0] >= 0) blocks.add(new int[]{top[0], top[1], i});
                if (next >= 0 && top[0] >= 0 && (tokens.get(next).tokencode == TBaseType.rrw_try
                        || tokens.get(next).tokencode == TBaseType.rrw_catch)) {
                    i = next;                                      // END TRY / END CATCH
                }
            }
        }
        if (!open.isEmpty()) return null;
        blocks.sort((a, b) -> Integer.compare(a[1], b[1]));        // outer blocks first
        return blocks;
    }

    /** {@code BEGIN TRAN}, {@code BEGIN DISTRIBUTED ...}, {@code BEGIN DIALOG}, {@code BEGIN CONVERSATION TIMER}. */
    private static boolean opensNoBlock(TSourceToken next) {
        // non-identifier-compare: T-SQL keywords, not object names
        String word = next.toString().toUpperCase(Locale.ROOT);
        return word.equals("TRAN") || word.equals("TRANSACTION") || word.equals("DISTRIBUTED")
                || word.equals("DIALOG") || word.equals("CONVERSATION");
    }

    /** {@code END CONVERSATION}, a Service Broker statement: it ends no block. */
    private static boolean endsNoBlock(TSourceToken next) {
        // non-identifier-compare: a T-SQL keyword, not an object name
        return next.toString().toUpperCase(Locale.ROOT).equals("CONVERSATION");
    }

    private static int nextSolid(TSourceTokenList tokens, int from) {
        for (int i = from; i < tokens.size(); i++) if (tokens.get(i).issolidtoken()) return i;
        return -1;
    }

    /**
     * Whether a statement holds a whole {@code BEGIN ... END} block: an {@code IF} or {@code WHILE} whose condition is
     * broken, or a statement the raw splitter ran on past its end (an open parenthesis takes in what follows). Skipping
     * it would drop statements that parse, so such an error is not recovered.
     */
    private static boolean holdsBlock(int[] statement, List<int[]> blocks) {
        for (int[] block : blocks) {
            if (statement[0] <= block[0] && block[0] <= statement[1]) return true;
        }
        return false;
    }

    /**
     * Whether a statement goes on past a semicolon that ends a statement: the raw splitter took a broken statement and
     * the next for one ({@code INSERT INTO t (a); EXEC (...)} reads as INSERT ... EXEC). Skipping it would drop the
     * statement after the semicolon, which parses, so such an error is not recovered.
     */
    private static boolean runsOnPastItsEnd(TSourceTokenList tokens, int[] statement) {
        for (int i = statement[0]; i < statement[1]; i++) {
            if (tokens.get(i).tokentype != ETokenType.ttsemicolon) continue;
            for (int j = i + 1; j <= statement[1]; j++) {
                if (tokens.get(j).issolidtoken()) return true;
            }
        }
        return false;
    }

    private static long position(long line, long column) {
        return (line << 32) | (column & 0xffffffffL);
    }

    /** Index of every solid token by its line and column (a syntax error names the token it points at so). */
    private static Map<Long, Integer> solidTokensByPosition(TSourceTokenList tokens) {
        Map<Long, Integer> positions = new HashMap<Long, Integer>();
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (t.issolidtoken() && !positions.containsKey(position(t.lineNo, t.columnNo))) {
                positions.put(position(t.lineNo, t.columnNo), i);
            }
        }
        return positions;
    }

    /**
     * The statements of a region as {first, last token index}, found by the vendor's raw statement splitter over the
     * region's text; empty when the splitter fails. The region's tokens are contiguous, so a position in its text
     * maps back to the original token by offset.
     */
    static List<int[]> statements(TSourceTokenList tokens, int regionStart, int regionEnd, EDbVendor vendor) {
        List<int[]> found = new ArrayList<int[]>();
        if (regionStart > regionEnd) return found;
        StringBuilder text = new StringBuilder();
        for (int i = regionStart; i <= regionEnd; i++) text.append(tokens.get(i).getAstext());
        long base = tokens.get(regionStart).offset;
        TGSqlParser splitter = new TGSqlParser(vendor);
        splitter.sqltext = text.toString();
        if (splitter.getrawsqlstatements() != 0) return found;
        TStatementList statements = splitter.sqlstatements;
        int i = regionStart;
        for (int s = 0; s < statements.size(); s++) {
            TCustomSqlStatement statement = statements.get(s);
            if (statement.getStartToken() == null || statement.getEndToken() == null) continue;
            long from = statement.getStartToken().offset;
            long to = statement.getEndToken().offset + statement.getEndToken().getAstext().length();
            while (i <= regionEnd && tokens.get(i).offset - base < from) i++;
            int first = i;
            while (i <= regionEnd && tokens.get(i).offset - base < to) i++;
            if (i > first) found.add(new int[]{first, i - 1});
        }
        return found;
    }
}