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.TLexerHive;
import gudusoft.gsqlparser.TParserHive;
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.Arrays;
import java.util.List;
import java.util.Stack;

/**
 * Apache Hive SQL parser implementation.
 *
 * <p>This parser handles Hive-specific SQL syntax including:
 * <ul>
 *   <li>Hive DDL statements (CREATE TABLE/DATABASE with Hive-specific options)</li>
 *   <li>Hive DML statements (INSERT OVERWRITE, LOAD DATA, etc.)</li>
 *   <li>HiveQL functions and extensions</li>
 *   <li>Backtick-quoted identifiers including qualified names (`schema.table`)</li>
 *   <li>Hive-specific keywords and data types</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerHive} for tokenization</li>
 *   <li>Uses {@link TParserHive} for parsing</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 *   <li>Splits backtick-quoted qualified names (`schema.table`) into individual tokens</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get Hive parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvhive);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvhive)
 *     .sqlText("SELECT * FROM `default.employee` WHERE dept = 'IT'")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerHive
 * @see TParserHive
 * @since 3.2.0.0
 */
public class HiveSqlParser extends AbstractSqlParser {

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

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

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

    /** The Hive lexer used for tokenization */
    public TLexerHive flexer;

    /** SQL parser (for Hive statements) */
    private TParserHive fparser;

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

    /** Parser context for current operation */
    private ParserContext parserContext;

    // Note: Global context and frame stack fields inherited from AbstractSqlParser:
    // - protected TContext globalContext
    // - protected TSQLEnv sqlEnv
    // - protected Stack<TFrame> frameStack
    // - protected TFrame globalFrame
    // - protected TSourceTokenList sourcetokenlist
    // - protected TStatementList sqlstatements
    // - protected ISqlCmds sqlcmds
    // - protected TCustomLexer lexer

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

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

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

    /**
     * Hive does not use a secondary parser (unlike Oracle with PL/SQL).
     */
    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    /**
     * Call Hive-specific tokenization logic.
     * <p>
     * Delegates to dohivetexttotokenlist which handles Hive's
     * specific keyword recognition, backtick-quoted identifiers, and
     * qualified name splitting.
     */
    @Override
    protected void tokenizeVendorSql() {
        dohivetexttotokenlist();
    }

    /**
     * Setup Hive parser for raw statement extraction.
     * <p>
     * Hive 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 Hive-specific raw statement extraction logic.
     * <p>
     * Delegates to dohivegetrawsqlstatements which handles Hive's
     * statement delimiters (semicolons).
     * <p>
     * Note: parserContext is already set by AbstractSqlParser before this is called
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        int errorCount = dohivegetrawsqlstatements(builder);
        // Error count is tracked internally; errors are already added to syntaxErrors list

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

    // ========== Tokenization Methods ==========

    /**
     * Tokenize Hive SQL text into a list of tokens.
     * <p>
     * This method handles Hive-specific token processing:
     * <ul>
     *   <li>Splits backtick-quoted qualified names (`schema.table`) into separate tokens</li>
     *   <li>Handles MAP keyword disambiguation</li>
     *   <li>Handles all standard SQL tokens (keywords, identifiers, operators, etc.)</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dohivetexttotokenlist()
     */
    private void dohivetexttotokenlist() {

        TSourceToken asourcetoken, lcprevst;
        int yychar;

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

        while (yychar > 0) {
            if (asourcetoken != null) {
                sourcetokenlist.add(asourcetoken);
            }
            asourcetoken = getanewsourcetoken();
            if (asourcetoken == null) break;
            if (asourcetoken.tokencode == TBaseType.rrw_map) {
                TSourceToken token = asourcetoken.searchToken(')', -1);
                if (token != null) {
                    asourcetoken.tokencode = TBaseType.ident;
                }
            } else if (asourcetoken.tokencode == '(') {
//            TSourceToken token = asourcetoken.searchToken(TBaseType.ident,-1);
//            if (token != null){
//                token.tokencode = TBaseType.HIVE_FUNC_IDENT;
//            }
            }
            yychar = asourcetoken.tokencode;

            // `schema.table_name`
            if ((asourcetoken.tokencode == TBaseType.ident)
                    && (asourcetoken.toString().startsWith("`")) && (asourcetoken.toString().endsWith("`"))
                    && (asourcetoken.toString().indexOf(".") > 0)
            ) {
                yychar = splitQualifiedNameInBacktick(asourcetoken);
                asourcetoken = null;
            }

        }

    }

    /**
     * Turn one token: `schema.table_name` into 3 tokens: `schema` . `table_name`
     * <p>
     * This helper method splits backtick-quoted qualified names into individual
     * identifier and period tokens, preserving line/column information for each part.
     * <p>
     * Migrated from TGSqlParser.splitQualifiedNameInBacktick()
     *
     * @param asourcetoken the token to split
     * @return the token code of the last token created
     */
    private int splitQualifiedNameInBacktick(TSourceToken asourcetoken) {
        int yychar = 0;

        List<String> elephantList = Arrays.asList(TBaseType.getTextWithoutQuoted(asourcetoken.toString()).split("\\."));
        int p = 0, offset = 0;
        for (String s : elephantList) {
            TSourceToken pst = new TSourceToken("`" + s + "`");
            pst.tokencode = asourcetoken.tokencode;
            pst.tokentype = asourcetoken.tokentype;
            pst.tokenstatus = asourcetoken.tokenstatus;
            pst.lineNo = asourcetoken.lineNo;
            pst.columnNo = asourcetoken.columnNo + offset;
            if (p == 0) offset++; // this count the first ` token
            offset = offset + s.length();
            pst.container = sourcetokenlist;
            if (p > 0) { // 第一个token使用被拆分前那个token的位置，从第二个开始的token，需要先把列表的位置指针加 1
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
            }
            pst.posinlist = sourcetokenlist.curpos;

            sourcetokenlist.add(pst);
            yychar = pst.tokencode;

            if (p != elephantList.size() - 1) {
                //`schema.table_name`, add period token in the middle of the backtick included identifier.
                TSourceToken periodst = new TSourceToken(".");
                periodst.tokencode = '.';
                periodst.tokentype = ETokenType.ttperiod;
                periodst.tokenstatus = asourcetoken.tokenstatus;
                periodst.lineNo = asourcetoken.lineNo;
                periodst.columnNo = asourcetoken.columnNo + offset;
                offset++;
                periodst.container = sourcetokenlist;
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
                periodst.posinlist = sourcetokenlist.curpos;
                sourcetokenlist.add(periodst);
                yychar = periodst.tokencode;
            }

            p++;
        }

        return yychar;

    }

    // ========== Raw Statement Extraction ==========

    /**
     * Extract raw SQL statements from the token list.
     * <p>
     * This method separates individual SQL statements without full syntax checking.
     * It handles Hive-specific syntax including:
     * <ul>
     *   <li>Token code adjustments (CharSetName, DATE function, SORT keyword)</li>
     *   <li>Semicolon-terminated statements</li>
     *   <li>Continuous semicolon handling (treated as comments)</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dohivegetrawsqlstatements()
     *
     * @param builder the result builder to populate
     * @return number of errors encountered
     */
    private int dohivegetrawsqlstatements(SqlParseResult.Builder builder) {

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

        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;

            if (ast.tokencode == TBaseType.hive_CharSetName) {
                TSourceToken st1 = ast.searchToken(TBaseType.hive_CharSetLiteral, 1);
                if (st1 == null) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == TBaseType.rrw_date) {
                TSourceToken st1 = ast.nextSolidToken(); //ast.searchToken('(',1);
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        ast.tokencode = TBaseType.rrw_hive_DATE_FUNCTION;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sort) {
                TSourceToken st1 = ast.searchToken(TBaseType.rrw_by, 1);
                if (st1 == null) {
                    ast.tokencode = TBaseType.ident;
                }
            }

            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;
                    }


                    gcurrentsqlstatement = sqlcmds.issql(ast, gst, gcurrentsqlstatement);

                    if (gcurrentsqlstatement != null) {
                        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(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

            } //switch
        }//for

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

        return syntaxErrors.size();
    }

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

    /**
     * Parse all raw SQL statements.
     * <p>
     * This method performs full syntax analysis of each statement:
     * <ul>
     *   <li>Initializes global context and SQL environment</li>
     *   <li>Parses each statement using TParserHive</li>
     *   <li>Handles errors with optional error recovery</li>
     *   <li>Collects syntax errors for reporting</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.performParsing()
     *
     * @param context the parser context
     * @param parser the main parser (TParserHive)
     * @param secondaryParser the secondary parser (null for Hive)
     * @param tokens the source token list
     * @param rawStatements raw statements already extracted (never null)
     * @return the parsed statement list
     */
    @Override
    protected TStatementList performParsing(ParserContext context, TCustomParser parser, TCustomParser secondaryParser, TSourceTokenList tokens, TStatementList rawStatements) {
        this.parserContext = context;
        this.fparser = (TParserHive) parser;
        this.sourcetokenlist = tokens;
        this.sqlstatements = rawStatements;

        // Initialize sqlcmds for this parsing operation
        if (this.sqlcmds == null) {
            this.sqlcmds = SqlCmdsFactory.get(vendor);
        }

        // CRITICAL: Inject sqlcmds into parser (required for make_stmt to work)
        this.fparser.sqlcmds = this.sqlcmds;

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

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

            try {
                // Set frame stack for nested scope resolution
                stmt.setFrameStack(frameStack);

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

                // Attempt error recovery using inherited method
                parseResult = attemptErrorRecovery(stmt, parseResult, context.isOnlyNeedRawParseTree());

                // Collect errors from statement
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }

            } catch (Exception ex) {
                // Use inherited exception handler from AbstractSqlParser
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

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

        return sqlstatements;
    }

    // ========== Semantic Analysis ==========

    /**
     * Perform semantic analysis on parsed statements.
     * <p>
     * Runs TSQLResolver to build relationships between tables and columns,
     * resolve references, and perform type checking.
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (TBaseType.isEnableResolver() && getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(globalContext, statements);
            resolver.resolve();
        }
    }

    // ========== Interpretation ==========

    /**
     * Perform interpretation/evaluation on statements.
     * <p>
     * Runs TASTEvaluator for compile-time constant expression evaluation.
     * Hive does not require interpretation currently.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        // Hive does not require interpretation currently
    }

    @Override
    public String toString() {
        return "HiveSqlParser{vendor=" + vendor + "}";
    }
}