package gudusoft.gsqlparser.stmt.snowflake;

import gudusoft.gsqlparser.EDbObjectType;
import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TParseTreeVisitor;
import gudusoft.gsqlparser.nodes.TDummy;


public class TDropTaskStmt extends TCustomSqlStatement {

    private TObjectName taskName;
    private boolean ifExists = false;
    private boolean cascade = false;
    private boolean restrict = false;

    public TDropTaskStmt(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstDropTask;
    }

    public int doParseStatement(TCustomSqlStatement psql) {
        // When grammar parser provides rootNode, use it
        if (rootNode != null) {
            super.doParseStatement(psql);
            TDummy node = (TDummy)rootNode;
            taskName = (TObjectName) node.node1;
            taskName.setDbObjectType(EDbObjectType.task);
        }
        // Otherwise taskName was set in dochecksyntax
        return 0;
    }

    /**
     * Override dochecksyntax to parse DROP TASK statement directly from tokens.
     * This bypasses the grammar parser which may not have the DROP TASK rule.
     * Syntax: DROP TASK [IF EXISTS] <qualified_name> [CASCADE | RESTRICT]
     */
    @Override
    protected int dochecksyntax(TCustomSqlStatement psql) {
        isparsed = true;

        // Parse tokens: DROP TASK [IF EXISTS] name [CASCADE|RESTRICT]
        int index = 0;

        // Helper to skip non-solid tokens (whitespace, comments)
        while (index < sourcetokenlist.size() && !sourcetokenlist.get(index).issolidtoken()) {
            index++;
        }

        // Skip DROP token
        if (index < sourcetokenlist.size() && sourcetokenlist.get(index).tokencode == TBaseType.rrw_drop) {
            index++;
        }

        // Skip non-solid tokens
        while (index < sourcetokenlist.size() && !sourcetokenlist.get(index).issolidtoken()) {
            index++;
        }

        // Skip TASK token (it's an identifier, not a reserved word)
        if (index < sourcetokenlist.size()) {
            TSourceToken taskToken = sourcetokenlist.get(index);
            if (taskToken.toString().equalsIgnoreCase("TASK")) {
                index++;
            }
        }

        // Skip non-solid tokens
        while (index < sourcetokenlist.size() && !sourcetokenlist.get(index).issolidtoken()) {
            index++;
        }

        // Check for IF EXISTS
        if (index < sourcetokenlist.size()) {
            TSourceToken token = sourcetokenlist.get(index);
            if (token.tokencode == TBaseType.rrw_if) {
                index++;
                // Skip non-solid tokens
                while (index < sourcetokenlist.size() && !sourcetokenlist.get(index).issolidtoken()) {
                    index++;
                }
                // Check for EXISTS
                if (index < sourcetokenlist.size() && sourcetokenlist.get(index).toString().equalsIgnoreCase("EXISTS")) {
                    ifExists = true;
                    index++;
                }
                // Skip non-solid tokens
                while (index < sourcetokenlist.size() && !sourcetokenlist.get(index).issolidtoken()) {
                    index++;
                }
            }
        }

        // Now parse the qualified name (task name)
        // Collect tokens until we hit semicolon, CASCADE, RESTRICT, or end
        TSourceToken startToken = null;
        TSourceToken endToken = null;

        while (index < sourcetokenlist.size()) {
            TSourceToken token = sourcetokenlist.get(index);

            // Skip non-solid tokens
            if (!token.issolidtoken()) {
                index++;
                continue;
            }

            // Stop at semicolon
            if (token.tokencode == ';' || token.toString().equals(";")) {
                break;
            }

            // Check for CASCADE or RESTRICT
            String tokenStr = token.toString().toUpperCase();
            if (tokenStr.equals("CASCADE")) {
                cascade = true;
                index++;
                continue;
            }
            if (tokenStr.equals("RESTRICT")) {
                restrict = true;
                index++;
                continue;
            }

            // Part of the qualified name
            if (startToken == null) {
                startToken = token;
            }
            endToken = token;
            index++;
        }

        // Create TObjectName from the tokens
        if (startToken != null) {
            taskName = new TObjectName();
            taskName.setStartToken(startToken);
            taskName.setEndToken(endToken != null ? endToken : startToken);
            taskName.setDbObjectType(EDbObjectType.task);
        }

        return 0;
    }

    public TObjectName getTaskName() {
        return taskName;
    }


    public boolean isIfExists() {
        return ifExists;
    }

    public void setIfExists(boolean ifExists) {
        this.ifExists = ifExists;
    }

    public boolean isCascade() {
        return cascade;
    }

    public void setCascade(boolean cascade) {
        this.cascade = cascade;
    }

    public boolean isRestrict() {
        return restrict;
    }

    public void setRestrict(boolean restrict) {
        this.restrict = restrict;
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }
}