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.TLexerMdx;
import gudusoft.gsqlparser.TParserMdx;
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.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;

/**
 * MDX (Multidimensional Expressions) SQL parser implementation.
 *
 * <p>This parser handles MDX-specific syntax including:
 * <ul>
 *   <li>MDX SELECT statements with axes specifications</li>
 *   <li>SCOPE statements for calculated members</li>
 *   <li>IF/CASE/END block structures</li>
 *   <li>MDX-specific functions and operators</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerMdx} for tokenization</li>
 *   <li>Uses {@link TParserMdx} for parsing</li>
 *   <li>Delimiter character: ';' for MDX statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get MDX parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvmdx);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvmdx)
 *     .sqlText("SELECT [Measures].[Sales] ON COLUMNS FROM [Cube]")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerMdx
 * @see TParserMdx
 * @since 3.2.0.0
 */
public class MdxSqlParser extends AbstractSqlParser {

    /**
     * Construct MDX SQL parser.
     * <p>
     * Configures the parser for MDX 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 MdxSqlParser() {
        super(EDbVendor.dbvmdx);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerMdx();
        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 TParserMdx(null);
        this.fparser.lexer = this.flexer;
    }

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

    /** The MDX lexer used for tokenization */
    public TLexerMdx flexer;

    /** MDX parser (for MDX statements) */
    private TParserMdx 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 MDX lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

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

    /**
     * MDX doesn't have a secondary parser.
     * @return null
     */
    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    /**
     * Call MDX-specific tokenization logic.
     * <p>
     * Delegates to domdxtexttotokenlist which handles MDX's
     * specific keyword recognition and token generation.
     */
    @Override
    protected void tokenizeVendorSql() {
        domdxtexttotokenlist();
    }

    /**
     * Setup MDX parser for raw statement extraction.
     * <p>
     * MDX uses a single parser, so we inject sqlcmds and update
     * the token list for the main parser only.
     */
    @Override
    protected void setupVendorParsersForExtraction() {
        // Inject sqlcmds into parser (required for make_stmt)
        this.fparser.sqlcmds = this.sqlcmds;

        // Update token list for parser
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    /**
     * Call MDX-specific raw statement extraction logic.
     * <p>
     * Delegates to domdxgetrawsqlstatements which handles MDX's
     * statement delimiters and SCOPE/END blocks.
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        domdxgetrawsqlstatements(builder);

        // Set the extracted statements in the builder
        builder.sqlStatements(this.sqlstatements);
    }

    /**
     * Perform full parsing of statements with syntax checking.
     * <p>
     * This method orchestrates the parsing of all statements.
     */
    @Override
    protected TStatementList performParsing(ParserContext context,
                                           TCustomParser parser,
                                           TCustomParser secondaryParser,
                                           TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references
        this.fparser = (TParserMdx) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

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

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

        // Initialize global context (from AbstractSqlParser)
        initializeGlobalContext();

        // Parse each statement
        for (int i = 0; i < sqlstatements.size(); i++) {
            TCustomSqlStatement stmt = sqlstatements.getRawSql(i);

            try {
                // Set frame stack
                stmt.setFrameStack(frameStack);

                // Parse the statement
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());

                // Error recovery for CREATE TABLE statements
                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;
    }

    /**
     * Perform MDX-specific semantic analysis using TSQLResolver.
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (TBaseType.isEnableResolver() && getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(globalContext, statements);
            resolver.resolve();
        }
    }

    /**
     * Perform interpretation/evaluation on parsed statements.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        if (TBaseType.ENABLE_INTERPRETER && getSyntaxErrors().isEmpty()) {
            TLog.clearLogs();
            TGlobalScope interpreterScope = new TGlobalScope(sqlEnv);
            TLog.enableInterpreterLogOnly();
            TASTEvaluator astEvaluator = new TASTEvaluator(statements, interpreterScope);
            astEvaluator.eval();
        }
    }

    // ========== MDX-Specific Tokenization ==========

    /**
     * Tokenize MDX input into source tokens.
     * <p>
     * Migrated from TGSqlParser.doMdxtexttotokenlist() (lines 4824-4841)
     * <p>
     * MDX uses simple token-by-token processing without special handling.
     */
    private void domdxtexttotokenlist() {
        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;
        }
    }

    // ========== MDX-Specific Raw Statement Extraction ==========

    /**
     * Extract raw MDX statements from token list.
     * <p>
     * Migrated from TGSqlParser.domdxgetrawsqlstatements() (lines 10861-11011)
     * <p>
     * Handles:
     * <ul>
     *   <li>Semicolon statement terminators</li>
     *   <li>SCOPE...END blocks with nested IF/CASE/END support</li>
     *   <li>Continuous semicolons treated as comments</li>
     * </ul>
     */
    private void domdxgetrawsqlstatements(SqlParseResult.Builder builder) {
        int waitingEnd = 0;
        boolean foundEnd = false;

        if (TBaseType.assigned(sqlstatements)) sqlstatements.clear();
        if (!TBaseType.assigned(sourcetokenlist)) return;

        gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        TSourceToken lcprevsolidtoken = null, ast = null;

        for (int i = 0; i < sourcetokenlist.size(); i++) {

            if ((ast != null) && (ast.issolidtoken()))
                lcprevsolidtoken = ast;

            ast = sourcetokenlist.get(i);
            sourcetokenlist.curpos = i;

            switch (gst) {
                case sterror: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                } //sterror

                case stnormal: {
                    if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                            || (ast.tokencode == TBaseType.cmtslashstar)
                            || (ast.tokencode == TBaseType.lexspace)
                            || (ast.tokencode == TBaseType.lexnewline)
                            || (ast.tokentype == ETokenType.ttsemicolon)) {
                        if (gcurrentsqlstatement != null) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                        if ((lcprevsolidtoken != null) && (ast.tokentype == ETokenType.ttsemicolon)) {
                            if (lcprevsolidtoken.tokentype == ETokenType.ttsemicolon) {
                                // ;;;; continuous semicolon, treat it as comment
                                ast.tokentype = ETokenType.ttsimplecomment;
                                ast.tokencode = TBaseType.cmtdoublehyphen;
                            }
                        }

                        continue;
                    }

                    // find a tokentext to start sql or plsql mode
                    gcurrentsqlstatement = sqlcmds.issql(ast, gst, gcurrentsqlstatement);

                    if (gcurrentsqlstatement != null) {
                        if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmdxscope) {
                            gst = EFindSqlStateType.ststoredprocedure;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            foundEnd = false;
                            waitingEnd = 1;
                        } else {
                            gst = EFindSqlStateType.stsql;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                    } else {
                        //error tokentext found

                        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(this.vendor);
                        gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstinvalid;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);

                    }

                    break;
                } // stnormal

                case stsql: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    break;
                }//case stsql

                case ststoredprocedure: {
                    if (ast.tokencode == TBaseType.rrw_if) {
                        waitingEnd++;
                    } else if (ast.tokencode == TBaseType.rrw_case) {
                        waitingEnd++;
                    } else if (ast.tokencode == TBaseType.rrw_scope) {
                        // ignore scope after end keyword like this:
                        // end scope
                        if (lcprevsolidtoken.tokencode != TBaseType.rrw_end) {
                            waitingEnd++;
                        }
                    } else if (ast.tokencode == TBaseType.rrw_end) {
                        foundEnd = true;
                        waitingEnd--;
                        if (waitingEnd < 0) {
                            waitingEnd = 0;
                        }
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    if ((ast.tokentype == ETokenType.ttsemicolon) && (waitingEnd == 0) && (foundEnd)) {
                        gst = EFindSqlStateType.stnormal;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    }

                    break;
                } //ststoredprocedure
            } //switch
        }//for

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

    /**
     * Handle CREATE TABLE error recovery.
     * <p>
     * Attempts to recover from parsing errors in CREATE TABLE statements
     * by marking unparseable tokens as ignoreable.
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        // MDX doesn't typically have CREATE TABLE statements
        // but we keep this method for consistency with the pattern
        // No specific recovery logic needed for MDX
    }
}