package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerDax;
import gudusoft.gsqlparser.TParserDax;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.dax.TDaxExprStmt;
import gudusoft.gsqlparser.stmt.dax.TDaxEvaluateStmt;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.TLog;
import gudusoft.gsqlparser.compiler.TASTEvaluator;

import java.io.BufferedReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * DAX (Data Analysis Expressions) database SQL parser implementation.
 *
 * <p>This parser handles DAX-specific SQL syntax including:
 * <ul>
 *   <li>DAX expressions starting with '=' at beginning of line</li>
 *   <li>DEFINE...EVALUATE statements</li>
 *   <li>EVALUATE statements</li>
 *   <li>DAX function calls and expressions</li>
 *   <li>Special handling of DAX keywords (PRODUCT, TRUE, FALSE, CALENDAR, SECOND)</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerDax} for tokenization</li>
 *   <li>Uses {@link TParserDax} for parsing</li>
 *   <li>Delimiter character: ';' for DAX statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get DAX parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvdax);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvdax)
 *     .sqlText("= CALCULATE(SUM(Sales[Amount]), ALL(Sales))")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerDax
 * @see TParserDax
 * @since 3.3.1
 */
public class DaxSqlParser extends AbstractSqlParser {

    /**
     * Construct DAX SQL parser.
     * <p>
     * Configures the parser for DAX database with default delimiter (;).
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     */
    public DaxSqlParser() {
        super(EDbVendor.dbvdax);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerDax();
        this.flexer.delimiterchar = this.delimiterChar;
        this.flexer.defaultDelimiterStr = this.defaultDelimiterStr;

        // Set parent's lexer reference for shared tokenization logic
        this.lexer = this.flexer;

        // Create parser once - will be reused for all parsing operations
        this.fparser = new TParserDax(null);
        this.fparser.lexer = this.flexer;
    }

    // ========== Parser Components ==========

    /** The DAX lexer used for tokenization */
    public TLexerDax flexer;

    /** DAX parser (for DAX statements) */
    private TParserDax fparser;

    /** Current statement being built during extraction */
    private TCustomSqlStatement gcurrentsqlstatement;

    // Note: Global context and frame stack fields inherited from AbstractSqlParser:
    // - protected TContext globalContext
    // - protected TSQLEnv sqlEnv
    // - protected Stack<TFrame> frameStack
    // - protected TFrame globalFrame

    // ========== AbstractSqlParser Abstract Methods Implementation ==========

    /**
     * Return the DAX lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

    /**
     * Return the DAX SQL parser instance with updated token list.
     */
    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

    /**
     * DAX does not use a secondary parser.
     * @return null (no secondary parser)
     */
    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    /**
     * Call DAX-specific tokenization logic.
     * <p>
     * Delegates to dodaxsqltexttotokenlist which handles DAX's
     * simple token iteration.
     */
    @Override
    protected void tokenizeVendorSql() {
        dodaxsqltexttotokenlist();
    }

    /**
     * Setup DAX parser for raw statement extraction.
     * <p>
     * Injects shared state (sqlcmds, sourcetokenlist) into the DAX parser
     * so it can access tokens and SQL command definitions during parsing.
     */
    @Override
    protected void setupVendorParsersForExtraction() {
        this.fparser.sqlcmds = this.sqlcmds;
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    /**
     * Call DAX-specific raw statement extraction logic.
     * <p>
     * Delegates to dodaxgetrawsqlstatements which handles DAX's
     * statement boundary detection (based on nested parentheses and
     * special DAX keywords).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        dodaxgetrawsqlstatements(builder);
    }

    // ========== DAX-Specific Tokenization ==========

    /**
     * Tokenize DAX SQL text to token list.
     * <p>
     * This is a simple tokenization process - just iterate through all tokens
     * from the lexer and add them to the source token list.
     * <p>
     * Migrated from TGSqlParser.dodaxsqltexttotokenlist()
     */
    private void dodaxsqltexttotokenlist() {
        TSourceToken asourcetoken;
        int yychar;

        asourcetoken = getanewsourcetoken();
        if (asourcetoken == null) return;
        yychar = asourcetoken.tokencode;

        while (yychar > 0) {
            sourcetokenlist.add(asourcetoken);
            asourcetoken = getanewsourcetoken();
            if (asourcetoken == null) break;
            yychar = asourcetoken.tokencode;
        }
    }

    // ========== DAX-Specific Raw Statement Extraction ==========

    /**
     * Extract raw DAX statements from token list.
     * <p>
     * DAX statement boundaries are determined by:
     * <ul>
     *   <li>Parentheses nesting level (statements are only complete at nesting level 0)</li>
     *   <li>Special DAX keywords that start new statements (=, DEFINE, EVALUATE)</li>
     *   <li>DAX keywords that might be identifiers (PRODUCT, TRUE, FALSE, CALENDAR, SECOND)</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dodaxgetrawsqlstatements()
     *
     * @param builder Result builder to collect parse errors and timing
     */
    private void dodaxgetrawsqlstatements(SqlParseResult.Builder builder) {
        gcurrentsqlstatement = null;
        TCustomSqlStatement tmpStmt = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        int i;
        TSourceToken ast;
        int errorcount = 0;
        int nestedParens = 0;

        for (i = 0; i < sourcetokenlist.size(); i++) {
            ast = sourcetokenlist.get(i);
            sourcetokenlist.curpos = i;

            // Handle DAX keywords that might be identifiers depending on context
            if ((ast.tokencode == TBaseType.rrw_dax_product)
                    || (ast.tokencode == TBaseType.rrw_dax_true)
                    || (ast.tokencode == TBaseType.rrw_dax_false)
                    || (ast.tokencode == TBaseType.rrw_dax_calendar)
                    || (ast.tokencode == TBaseType.rrw_dax_second)
                    ) {
                TSourceToken st1 = ast.searchToken("(", 1);
                if (st1 == null) {
                    // Not followed by '(' - treat as identifier, not keyword
                    ast.tokencode = TBaseType.ident;
                }
            }

            // Track parentheses nesting
            if (ast.tokencode == '(') nestedParens++;
            if (ast.tokencode == ')') nestedParens--;

            // If we're inside parentheses, just add token to current statement
            if (nestedParens > 0) {
                if (gcurrentsqlstatement != null) {
                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                }
                continue;
            }

            switch (gst) {
                case sterror: {
                    tmpStmt = startDaxStmt(ast, gcurrentsqlstatement);
                    if (tmpStmt != null) {
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                        gcurrentsqlstatement = tmpStmt;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gst = EFindSqlStateType.stsql;
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case stnormal: {
                    if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                            || (ast.tokencode == TBaseType.cmtslashstar)
                            || (ast.tokencode == TBaseType.lexspace)
                            || (ast.tokencode == TBaseType.lexnewline)
                            || (ast.tokentype == ETokenType.ttsemicolon)) {
                        if (TBaseType.assigned(gcurrentsqlstatement)) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                        continue;
                    }

                    gcurrentsqlstatement = startDaxStmt(ast, gcurrentsqlstatement);

                    if (TBaseType.assigned(gcurrentsqlstatement)) {
                        gst = EFindSqlStateType.stsql;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else {
                        this.syntaxErrors.add(new TSyntaxError(ast.getAstext(), ast.lineNo, (ast.columnNo < 0 ? 0 : ast.columnNo)
                                , "Error when tokenlize", EErrorType.spwarning, TBaseType.MSG_WARNING_ERROR_WHEN_TOKENIZE, null, ast.posinlist));

                        ast.tokentype = ETokenType.tttokenlizererrortoken;
                        gst = EFindSqlStateType.sterror;

                        gcurrentsqlstatement = new TUnknownSqlStatement(vendor);
                        gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstinvalid;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case stsql: {
                    tmpStmt = startDaxStmt(ast, gcurrentsqlstatement);
                    if (tmpStmt != null) {
                        gst = EFindSqlStateType.stsql;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                        gcurrentsqlstatement = tmpStmt;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        continue;
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                    break;
                }

            } //switch
        } //for

        // Last statement
        if (TBaseType.assigned(gcurrentsqlstatement) && ((gst == EFindSqlStateType.stsql) || (gst == EFindSqlStateType.sterror))) {
            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, true, builder);
        }

        // Add the sqlstatements to the builder so they can be returned
        builder.sqlStatements(this.sqlstatements);
    }

    /**
     * Determine if a token starts a new DAX statement.
     * <p>
     * DAX statements can start with:
     * <ul>
     *   <li>'=' at the beginning of a line - creates TDaxExprStmt</li>
     *   <li>DEFINE at the beginning of a line - creates TDaxEvaluateStmt with DEFINE flag</li>
     *   <li>EVALUATE at the beginning of a line - creates TDaxEvaluateStmt (but not if we're already in a DEFINE...EVALUATE block)</li>
     *   <li>Any token at the very beginning of the query (first token) - creates TDaxExprStmt</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.startDaxStmt()
     *
     * @param currToken Current token to check
     * @param currStmt Current statement being built
     * @return New statement if this token starts one, null otherwise
     */
    private TCustomSqlStatement startDaxStmt(TSourceToken currToken, TCustomSqlStatement currStmt) {
        TCustomSqlStatement newStmt = null;
        if (currToken == null) return null;

        if ((currToken.tokencode == '=') && (currToken.isFirstTokenOfLine())) {
            // '=' at beginning of line starts a DAX expression
            currToken.tokencode = TBaseType.equal_start_expr;
            newStmt = new TDaxExprStmt(EDbVendor.dbvdax);
        } else if ((currToken.tokencode == TBaseType.rrw_dax_define) && (currToken.isFirstTokenOfLine())) {
            // DEFINE at beginning of line starts a DEFINE...EVALUATE block
            newStmt = new TDaxEvaluateStmt(EDbVendor.dbvdax);
            ((TDaxEvaluateStmt) newStmt).setStartWithDefine(true);
        } else if ((currToken.tokencode == TBaseType.rrw_dax_evaluate) && (currToken.isFirstTokenOfLine())) {
            // EVALUATE at beginning of line - but not if we're inside a DEFINE block
            if ((currStmt != null) && (currStmt instanceof TDaxEvaluateStmt)) {
                TDaxEvaluateStmt tmp = (TDaxEvaluateStmt) currStmt;
                if (tmp.isStartWithDefine()) {
                    // We're inside a DEFINE...EVALUATE block, so EVALUATE is part of the current statement
                    return null;
                }
            }
            newStmt = new TDaxEvaluateStmt(EDbVendor.dbvdax);
        }

        if (newStmt == null) {
            // Check if this is the first token of the query
            boolean isFirst = currToken.isFirstTokenOfLine();
            TSourceToken prevToken = currToken.prevSolidToken();
            if ((isFirst) && (prevToken == null)) {
                // First token of query - start a DAX expression
                newStmt = new TDaxExprStmt(EDbVendor.dbvdax);
            }
        }
        return newStmt;
    }

    // ========== Statement Parsing ==========

    /**
     * Parse all raw DAX statements.
     * <p>
     * Iterates through all raw statements extracted by dodaxgetrawsqlstatements()
     * and parses each one using the DAX parser.
     * <p>
     * Follows the pattern from MssqlSqlParser.performParsing()
     */
    @Override
    protected TStatementList performParsing(ParserContext context, TCustomParser parser,
                                           TCustomParser secondaryParser, TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references to key objects
        this.fparser = (TParserDax) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // Use the raw statements passed from AbstractSqlParser.parse()
        this.sqlstatements = rawStatements;

        // Initialize sqlcmds for this vendor
        this.sqlcmds = SqlCmdsFactory.get(vendor);

        // CRITICAL: Inject sqlcmds into parser
        this.fparser.sqlcmds = this.sqlcmds;

        // Initialize global context for semantic analysis
        initializeGlobalContext();

        // Parse each statement
        for (int i = 0; i < sqlstatements.size(); i++) {
            TCustomSqlStatement stmt = sqlstatements.getRawSql(i);
            try {
                stmt.setFrameStack(frameStack);
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());

                // Error recovery
                boolean doRecover = TBaseType.ENABLE_ERROR_RECOVER_IN_CREATE_TABLE;
                if (doRecover && ((parseResult != 0) || (stmt.getErrorCount() > 0))) {
                    handleCreateTableErrorRecovery(stmt);
                }

                // Collect errors
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }
            } catch (Exception ex) {
                // Use inherited exception handler
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

        // Clean up frame stack
        if (globalFrame != null) globalFrame.popMeFromStack(frameStack);

        return sqlstatements;
    }

    /**
     * Handle CREATE TABLE error recovery.
     * <p>
     * DAX doesn't have CREATE TABLE statements, so this is a no-op.
     * However, we implement it to satisfy the AbstractSqlParser contract.
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        // No CREATE TABLE in DAX, so no error recovery needed
    }
}