package gudusoft.gsqlparser.stmt.mssql;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.TBlockSqlNode;
import gudusoft.gsqlparser.nodes.TParseTreeVisitor;
import gudusoft.gsqlparser.nodes.TStatementSqlNode;
import gudusoft.gsqlparser.nodes.mssql.TTryCatchSqlNode;

/**
 * Represents SQL Server TRY...CATCH statement.
 * <p>
 * Syntax:
 * <pre>
 * BEGIN TRY
 *     { sql_statement | statement_block }
 * END TRY
 * BEGIN CATCH
 *     [ { sql_statement | statement_block } ]
 * END CATCH
 * </pre>
 * <p>
 * Example:
 * <pre>
 * BEGIN TRY
 *     SELECT 1/0;
 * END TRY
 * BEGIN CATCH
 *     SELECT ERROR_MESSAGE();
 * END CATCH
 * </pre>
 */
public class TMssqlTryCatch extends TCustomSqlStatement {

    private TStatementList tryStatements = null;
    private TStatementList catchStatements = null;

    public TMssqlTryCatch(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstmssqlTryCatch;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    /**
     * Get the statements inside the BEGIN TRY ... END TRY block.
     */
    public TStatementList getTryStatements() {
        if (tryStatements == null) {
            tryStatements = new TStatementList();
        }
        return tryStatements;
    }

    /**
     * Get the statements inside the BEGIN CATCH ... END CATCH block.
     * May be empty if the CATCH block has no statements.
     */
    public TStatementList getCatchStatements() {
        if (catchStatements == null) {
            catchStatements = new TStatementList();
        }
        return catchStatements;
    }

    public int doParseStatement(TCustomSqlStatement psql) {
        if (rootNode == null) return -1;
        super.doParseStatement(psql);

        // Handle TTryCatchSqlNode (from grammar with separate TRY/CATCH lists)
        if (rootNode instanceof TTryCatchSqlNode) {
            TTryCatchSqlNode tryCatchNode = (TTryCatchSqlNode) rootNode;

            // Parse TRY block statements
            if (tryCatchNode.getTryStmts() != null) {
                tryCatchNode.getTryStmts().doParse(this, ESqlClause.unknown);
                for (int i = 0; i < tryCatchNode.getTryStmts().size(); i++) {
                    this.getTryStatements().add(tryCatchNode.getTryStmts().getStatementSqlNode(i).getStmt());
                }
            }

            // Parse CATCH block statements
            if (tryCatchNode.getCatchStmts() != null) {
                tryCatchNode.getCatchStmts().doParse(this, ESqlClause.unknown);
                for (int i = 0; i < tryCatchNode.getCatchStmts().size(); i++) {
                    this.getCatchStatements().add(tryCatchNode.getCatchStmts().getStatementSqlNode(i).getStmt());
                }
            }
        }
        // Handle TBlockSqlNode (from token-based detection where grammar merges TRY+CATCH)
        else if (rootNode instanceof TBlockSqlNode) {
            TBlockSqlNode blockNode = (TBlockSqlNode) rootNode;

            if (blockNode.getStmts() != null) {
                blockNode.getStmts().doParse(this, ESqlClause.unknown);

                // Find the position where TRY block ends and CATCH block begins
                // by looking for END TRY tokens
                int endTryPosition = findEndTryPosition();
                int catchStartPosition = findCatchStartPosition();

                for (int i = 0; i < blockNode.getStmts().size(); i++) {
                    TStatementSqlNode stmtNode = blockNode.getStmts().getStatementSqlNode(i);
                    TCustomSqlStatement stmt = stmtNode.getStmt();

                    if (stmt != null) {
                        // Determine if statement is in TRY or CATCH block based on token position
                        int stmtStartPos = (stmt.getStartToken() != null) ? stmt.getStartToken().posinlist : -1;

                        if (catchStartPosition > 0 && stmtStartPos >= catchStartPosition) {
                            // Statement is after BEGIN CATCH, belongs to CATCH block
                            this.getCatchStatements().add(stmt);
                        } else if (endTryPosition > 0 && stmtStartPos < endTryPosition) {
                            // Statement is before END TRY, belongs to TRY block
                            this.getTryStatements().add(stmt);
                        } else if (catchStartPosition <= 0) {
                            // No CATCH block, all statements are in TRY
                            this.getTryStatements().add(stmt);
                        }
                    }
                }
            }
        }

        return 0;
    }

    /**
     * Find the token position of END TRY in the source.
     */
    private int findEndTryPosition() {
        if (getStartToken() == null) return -1;
        TSourceTokenList tokenList = getStartToken().container;
        if (tokenList == null) return -1;

        int startPos = getStartToken().posinlist;
        int endPos = (getEndToken() != null) ? getEndToken().posinlist : tokenList.size();

        for (int i = startPos; i < endPos; i++) {
            TSourceToken token = tokenList.get(i);
            if (token.astext != null && token.astext.equalsIgnoreCase("END")) {
                // Check if next solid token is TRY
                for (int j = i + 1; j < endPos; j++) {
                    TSourceToken nextToken = tokenList.get(j);
                    if (nextToken.tokentype != ETokenType.ttwhitespace &&
                        nextToken.tokentype != ETokenType.ttreturn) {
                        if (nextToken.astext != null && nextToken.astext.equalsIgnoreCase("TRY")) {
                            return j; // Return position after END TRY
                        }
                        break;
                    }
                }
            }
        }
        return -1;
    }

    /**
     * Find the token position where BEGIN CATCH starts.
     */
    private int findCatchStartPosition() {
        if (getStartToken() == null) return -1;
        TSourceTokenList tokenList = getStartToken().container;
        if (tokenList == null) return -1;

        int startPos = getStartToken().posinlist;
        int endPos = (getEndToken() != null) ? getEndToken().posinlist : tokenList.size();

        for (int i = startPos; i < endPos; i++) {
            TSourceToken token = tokenList.get(i);
            if (token.astext != null && token.astext.equalsIgnoreCase("BEGIN")) {
                // Check if next solid token is CATCH
                for (int j = i + 1; j < endPos; j++) {
                    TSourceToken nextToken = tokenList.get(j);
                    if (nextToken.tokentype != ETokenType.ttwhitespace &&
                        nextToken.tokentype != ETokenType.ttreturn) {
                        if (nextToken.astext != null && nextToken.astext.equalsIgnoreCase("CATCH")) {
                            return j; // Return position of BEGIN CATCH
                        }
                        break;
                    }
                }
            }
        }
        return -1;
    }

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

    public void acceptChildren(TParseTreeVisitor v) {
        v.preVisit(this);
        if (tryStatements != null && tryStatements.size() > 0) {
            tryStatements.acceptChildren(v);
        }
        if (catchStatements != null && catchStatements.size() > 0) {
            catchStatements.acceptChildren(v);
        }
        v.postVisit(this);
    }

    public void setTryStatements(TStatementList tryStatements) {
        this.tryStatements = tryStatements;
    }

    public void setCatchStatements(TStatementList catchStatements) {
        this.catchStatements = catchStatements;
    }
}