package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;

/**
 * Error recovery for a Doris or StarRocks {@code CREATE TABLE ... AS SELECT} whose table clauses
 * the grammar cannot read.
 *
 * <p>When a CREATE TABLE fails to parse, the general recovery ignores everything after the first
 * closing parenthesis at depth zero and parses the statement again, so a table whose column list
 * is followed by an unsupported option still yields its columns. For a CREATE TABLE AS SELECT that
 * ignores the query too, and with it every lineage edge of the statement, while the statement
 * reports success. When the first closing parenthesis belongs to an option, as in
 * {@code DUPLICATE KEY(k1)}, or to the query itself, the result is a query cut short.</p>
 *
 * <p>This recovery keeps the header and the query and ignores only the table clauses between
 * them: {@code CREATE TABLE t DUPLICATE KEY(k1) DISTRIBUTED BY HASH(k1) AS SELECT ...} is parsed as
 * {@code CREATE TABLE t AS SELECT ...}. When nothing stands between the header and the query, the
 * error lies in one of them and is kept.</p>
 *
 * <p>Used by both parse paths, {@code TGSqlParser} and the vendor {@code SqlParser}, so that they
 * recover in the same way. Not intended for use outside the parser.</p>
 */
public final class CreateTableAsSelectRecovery {

    private CreateTableAsSelectRecovery() {
    }

    /**
     * Position of the AS that starts the query of a CREATE TABLE AS SELECT: the first AS at
     * parenthesis depth zero that is followed by SELECT, WITH or an opening parenthesis, or -1 when
     * the statement has no query. A generated column ({@code k2 INT AS k1 + 1}) sits inside the
     * column list, one level deep, so it is never taken for the query.
     *
     * @param tokens the tokens of one CREATE TABLE statement
     * @return the position of the AS in {@code tokens}, or -1
     */
    public static int queryStart(TSourceTokenList tokens) {
        int depth = 0;
        for (int k = 0; k < tokens.size(); k++) {
            TSourceToken st = tokens.get(k);
            if (st.tokencode == '(') {
                depth++;
            } else if (st.tokencode == ')') {
                depth--;
            } else if ((depth == 0) && (st.tokencode == TBaseType.rrw_as)) {
                int next = nextSolidTokenPos(tokens, k);
                if (next >= 0) {
                    int code = tokens.get(next).tokencode;
                    if ((code == TBaseType.rrw_select) || (code == TBaseType.rrw_with) || (code == '(')) {
                        return k;
                    }
                }
            }
        }
        return -1;
    }

    /**
     * Ignores the table clauses between the header and the query, so that the grammar reads both
     * even when it cannot read a clause in between (an OLAP key, a partition or distribution
     * clause, properties, ...).
     *
     * @param tokens the tokens of one CREATE TABLE statement
     * @param queryStart the position returned by {@link #queryStart}
     * @return true when a clause was ignored and the statement must be parsed again; false when
     * nothing stands between the header and the query, or the header was not found, so the
     * tokens are unchanged and the error is kept
     */
    public static boolean ignoreClausesBeforeQuery(TSourceTokenList tokens, int queryStart) {
        int headerEnd = headerEnd(tokens, queryStart);
        if (headerEnd < 0) {
            return false;
        }
        boolean hasClause = false;
        for (int k = headerEnd + 1; k < queryStart; k++) {
            if (tokens.get(k).issolidtoken()) {
                hasClause = true;
                break;
            }
        }
        if (!hasClause) {
            return false;
        }
        for (int k = headerEnd + 1; k < queryStart; k++) {
            tokens.get(k).tokencode = TBaseType.sqlpluscmd;
        }
        return true;
    }

    /**
     * Position of the last token of the header {@code CREATE ... TABLE [IF NOT EXISTS] name}, or of
     * the closing parenthesis of the column list that follows the name, or -1 when the header is not
     * found before the query.
     */
    private static int headerEnd(TSourceTokenList tokens, int queryStart) {
        int table = -1;
        for (int k = 0; k < queryStart; k++) {
            if (tokens.get(k).tokencode == TBaseType.rrw_table) {
                table = k;
                break;
            }
        }
        if (table < 0) {
            return -1;
        }
        int beforeName = table;
        int next = nextSolidTokenPos(tokens, table);
        if ((next >= 0) && (tokens.get(next).tokencode == TBaseType.rrw_if)) {
            // IF NOT EXISTS: the name follows EXISTS, the second solid token after IF
            beforeName = nextSolidTokenPos(tokens, nextSolidTokenPos(tokens, next));
            if (beforeName < 0) {
                return -1;
            }
        }
        int nameEnd = tokens.nextObjectNameToken(beforeName, 1, false);
        if ((nameEnd < 0) || (nameEnd >= queryStart)) {
            return -1;
        }
        int after = nextSolidTokenPos(tokens, nameEnd);
        if ((after < 0) || (after >= queryStart) || (tokens.get(after).tokencode != '(')) {
            return nameEnd;
        }
        int depth = 0;
        for (int k = after; k < queryStart; k++) {
            int code = tokens.get(k).tokencode;
            if (code == '(') {
                depth++;
            } else if ((code == ')') && (--depth == 0)) {
                return k;
            }
        }
        return -1;
    }

    private static int nextSolidTokenPos(TSourceTokenList tokens, int pos) {
        if (pos < 0) {
            return -1;
        }
        for (int k = pos + 1; k < tokens.size(); k++) {
            if (tokens.get(k).issolidtoken()) {
                return k;
            }
        }
        return -1;
    }
}