package gudusoft.gsqlparser.stmt;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TVariable;
import gudusoft.gsqlparser.nodes.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Stack;

/**
 * The EXECUTE IMMEDIATE statement builds and executes a dynamic SQL statement in
 * a single operation.
 */
public class TExecImmeStmt extends TBlockSqlStatement {

    private TExpression dynamicStringExpr = null;
    private TBindArgumentList bindArguments = null;
    private TExpressionList intoVariables = null;
    private TObjectNameList returnNames = null;
    private String dynamicSQL = null;
    private TStatementList dynamicStatements = null;

    public ArrayList<String> getEvaluatedDynamicSQLs() {
        return evaluatedDynamicSQLs;
    }

    private ArrayList <String> evaluatedDynamicSQLs = new ArrayList<String>();

    // Static parser instance for performance - reused across all dynamic SQL parsing
    private static TGSqlParser sqlparser = null;
    static {
        sqlparser = new TGSqlParser(EDbVendor.dbvoracle);
    }

    /**
     *
     * @return sql statement instance that generated dynamically based on {@link #dynamicSQL}
     */
    public synchronized TStatementList getDynamicStatements() {
        if (this.dynamicStatements != null) return this.dynamicStatements;
        if (this.getDynamicSQL() == null) return null;

        // Prepare parser for reuse by clearing cached state
        // This resets vendorParser, sqlEnv, sqlfilename, and parsing options
        sqlparser.prepareForReuse();
        // Parse the dynamic SQL fragment as-is (no leading blank-line padding).
        // The fragment's tokens are produced with coordinates relative to the
        // fragment itself (first character at line 1). After parsing we shift
        // every coordinate back to the position the fragment occupies in the
        // original source file (see shiftDynamicCoordinates).
        //
        // Historically this method prepended (lineNo - 1) blank lines via
        // TBaseType.stringBlock() so that the re-parsed tokens lined up with the
        // file. That padding was capped at 1000 blank lines to avoid OOM, which
        // produced wrong line numbers for any dynamic SQL located beyond line
        // 1000 in the file (a fragment at file line 1709 was reported at 1005).
        // Shifting coordinates after the fact is exact and allocates no padding.
        sqlparser.sqltext = this.getDynamicSQL();
        // Propagate the enclosing routine's PL/SQL scope (parameters and local
        // variables) into the dynamic-SQL parse, mirroring how the function /
        // procedure body re-parse does it (TCreateFunctionStmt /
        // TCreateProcedureStmt call newParser.setFrameStack(getFrameStack())).
        // Without this, an identifier inside the dynamic SQL that is actually a
        // routine parameter/variable (e.g. WHERE col = P_MANAGER_CODE) cannot be
        // located by linkColumnToTable -> locateVariableOrParameter and is wrongly
        // reported as an orphan column. With the scope available it resolves to
        // the variable instead.
        //
        // This statement's own frame stack is usually empty here (a routine
        // declared inside a package body does not push its parameter scope onto
        // the frame stack), so when it is empty we rebuild one from the
        // parameters / local variables of every enclosing routine.
        // Always install a definite frame stack: sqlparser is a reused static
        // parser and prepareForReuse() does not clear the frame stack, so a
        // previous routine's scope must not leak into a later no-scope parse.
        Stack<TFrame> dynFrameStack = getFrameStack();
        if (dynFrameStack == null || dynFrameStack.isEmpty()) {
            Stack<TFrame> built = buildEnclosingRoutineFrameStack();
            dynFrameStack = (built != null) ? built : new Stack<TFrame>();
        }
        sqlparser.setFrameStack(dynFrameStack);
        int ret = sqlparser.parse();

        if(this.getDynamicStringExpr().getPlainTextLineNo() != -1){
            int deltaLine = (int) this.getDynamicStringExpr().getPlainTextLineNo() - 1;
            int deltaColumn = (int) this.getDynamicStringExpr().getPlainTextColumnNo();
            TReparseCoordinateShifter.shift(sqlparser, deltaLine, deltaColumn);
        }

        if ( ret != 0){
            // a partially resolved value contains placeholder identifiers for
            // unknowable parts (e.g. v_prefix || ' FROM t'); a parse failure
            // on such text says nothing about the real SQL, so don't report it
            if (!this.dynamicSQLPartial){
                for(int j=0;j<sqlparser.getErrorCount();j++){
                    this.parseerrormessagehandle(sqlparser.getSyntaxErrors().get(j));
                }
            }

            return null;
        }

        this.dynamicStatements = new TStatementList();
        for(int i=0;i<sqlparser.sqlstatements.size();i++){
            if (this.getParentStmt() == null){
                sqlparser.sqlstatements.get(i).setParentStmt(this);
            }else{
                sqlparser.sqlstatements.get(i).setParentStmt(this.getParentStmt());
            }

            this.dynamicStatements.add(sqlparser.sqlstatements.get(i));
        }
        return dynamicStatements;
    }

    /**
     * Build a PL/SQL variable scope (frame stack) from the parameters and local
     * variable declarations of every routine enclosing this EXECUTE IMMEDIATE,
     * found by walking the parent-statement chain.
     * <p>
     * When a function / procedure is declared inside a package body its
     * parameter scope is not pushed onto the frame stack, so this statement's
     * own {@link #getFrameStack()} is empty and the dynamic-SQL parse would
     * report routine parameters/variables referenced in the dynamic SQL (e.g.
     * {@code WHERE col = P_MANAGER_CODE}) as orphan columns. Re-creating the
     * scope here lets {@code locateVariableOrParameter} resolve those names to
     * variables instead. Returns {@code null} when no enclosing routine
     * contributes any name (e.g. a top-level EXECUTE IMMEDIATE).
     */
    private Stack<TFrame> buildEnclosingRoutineFrameStack() {
        TGlobalScope scope = null;
        TCustomSqlStatement cur = this;
        while (cur != null) {
            if (cur instanceof TStoredProcedureSqlStatement) {
                TStoredProcedureSqlStatement routine = (TStoredProcedureSqlStatement) cur;

                TParameterDeclarationList params = routine.getParameterDeclarations();
                if (params != null) {
                    for (int i = 0; i < params.size(); i++) {
                        TParameterDeclaration pd = params.getParameterDeclarationItem(i);
                        if (pd != null && pd.getParameterName() != null) {
                            if (scope == null) scope = new TGlobalScope();
                            scope.addSymbol(new TVariable(pd.getParameterName(), pd));
                        }
                    }
                }

                TStatementList decls = routine.getDeclareStatements();
                if (decls != null) {
                    for (int i = 0; i < decls.size(); i++) {
                        TCustomSqlStatement d = decls.get(i);
                        if (d instanceof TVarDeclStmt && ((TVarDeclStmt) d).getElementName() != null) {
                            if (scope == null) scope = new TGlobalScope();
                            scope.addSymbol(new TVariable(((TVarDeclStmt) d).getElementName(), d));
                        }
                    }
                }
            }
            cur = cur.getParentStmt();
        }

        if (scope == null) return null;
        Stack<TFrame> frameStack = new Stack<TFrame>();
        new TFrame(scope).pushMeToStack(frameStack);
        return frameStack;
    }

    /**
     *
     * @return String representation of dynamic sql statement. if there is a variable in
     * {@link #dynamicStringExpr},  value of this variable will be returned.
     */

   public String getDynamicSQL() {
       if (!this.getEvaluatedDynamicSQLs().isEmpty()){
           // 使用 TASTEvaluator 计算动态 SQL 后，将结果保存在 evaluatedDynamicSQLs 中，如果有值，采用这个更精确的 SQL 值
           StringBuilder concatenatedSQL = new StringBuilder();

           for (int i = 0; i < this.getEvaluatedDynamicSQLs().size(); i++) {
               String sql = this.getEvaluatedDynamicSQLs().get(i);
               concatenatedSQL.append(sql);
               if (i < this.getEvaluatedDynamicSQLs().size() - 1) {
                   concatenatedSQL.append(";");
                   concatenatedSQL.append(TBaseType.newline);
               }
           }

           this.dynamicSQL = concatenatedSQL.toString();
       }
           return this.dynamicSQL;

//        if (this.dynamicSQL != null) return this.dynamicSQL;
//
//        if (dynamicStringExpr.getExpressionType() == EExpressionType.simple_constant_t)
//        {
//            this.dynamicSQL = TBaseType.getStringInsideLiteral(this.dynamicStringExpr.toString());
//        }else if (dynamicStringExpr.getExpressionType() == EExpressionType.simple_object_name_t){
//           // this is a variable, we have to search
//            String lcvar = this.getDynamicStringExpr().toString();
//            TCustomSqlStatement topsql = this.getTopStatement();
//            if (topsql instanceof TBlockSqlStatement){
//                TCustomSqlStatement stmt = null;
//                for(int i=0;i< ((TBlockSqlStatement)topsql).getBodyStatements().size();i++){
//                   stmt = ((TBlockSqlStatement)topsql).getBodyStatements().get(i);
//                   if (stmt instanceof TAssignStmt){
//                       if ( ((TAssignStmt)stmt).getLeft().toString().compareToIgnoreCase(lcvar) == 0 )
//                       {
//                           if (((TAssignStmt)stmt).getExpression().getExpressionType() == EExpressionType.simple_constant_t){
//                             this.dynamicSQL  = ((TAssignStmt)stmt).getExpression().toString().substring(1,((TAssignStmt)stmt).getExpression().toString().length() - 1);
//                           }else{
//                               this.dynamicSQL  = null;
//                           }
//                           break;
//                       }
//                   }
//                }
//            }
//           if ((this.getParentStmt() instanceof TBlockSqlStatement)&&(this.dynamicSQL  == null)){
//               TBlockSqlStatement blockSqlStatement = (TBlockSqlStatement)this.getParentStmt();
//               for(int i=0;i< blockSqlStatement.getBodyStatements().size();i++){
//                   TCustomSqlStatement stmt = blockSqlStatement.getBodyStatements().get(i);
//                   if (stmt instanceof TAssignStmt){
//                       if ( ((TAssignStmt)stmt).getLeft().toString().compareToIgnoreCase(lcvar) == 0 )
//                       {
//                           if (((TAssignStmt)stmt).getExpression().getExpressionType() == EExpressionType.simple_constant_t){
//                               this.dynamicSQL  = ((TAssignStmt)stmt).getExpression().toString().substring(1,((TAssignStmt)stmt).getExpression().toString().length() - 1);
//                           }else{
//                               this.dynamicSQL  = null;
//                           }
//                           break;
//                       }
//                   }
//               }
//           }
//
//        }else{
//            calculateExprVisitor cv = new calculateExprVisitor();
//            this.dynamicStringExpr.postOrderTraverse(cv);
//            //this.dynamicStringExpr.evaluate();
//
//            this.dynamicSQL  = this.dynamicStringExpr.getPlainText();
////            if (this.dynamicSQL.charAt(0) == '\''){
////                this.dynamicSQL  = this.dynamicSQL.substring(1,this.dynamicSQL.toString().length() - 2);
////            }
//        }
//        return this.dynamicSQL ;
    }

    /**
     * bind arguments
     * @return bind arguments in using clause.
     */    
    public TBindArgumentList getBindArguments() {
        return bindArguments;
    }

    /**
     * String expr
     *
     * @return   A string literal, string variable, or string expression that represents any SQL statement.
     * this is the original string of dynamic sql statement.
     */

    public TExpression getDynamicStringExpr() {
        return dynamicStringExpr;
    }

    /**
     * Into variable
     *
     * @return variable names in the into clause.
     */    
    public TExpressionList getIntoVariables() {
        return intoVariables;
    }

    /**
     *
     * Used if and only if dynamic_sql_stmt has a RETURNING INTO clause, this clause
     * returns the column values of the rows affected by dynamic_sql_stmt, in either
     * individual variables or records
     *
     * @return
     */
    
    public TObjectNameList getReturnNames() {
        return returnNames;
    }

    public TExecImmeStmt(EDbVendor dbvendor){
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstplsql_execimmestmt ;
        }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

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

        TExecImmeNode execImmeNode = (TExecImmeNode)rootNode;
        this.bindArguments = execImmeNode.getBindArguments();
        this.intoVariables = execImmeNode.getIntoVariables();
        this.dynamicStringExpr = execImmeNode.getDynamicStringExpr();
        this.returnNames = execImmeNode.getReturnNames();

        this.dynamicStringExpr.evaluate(this.getFrameStack(),this);
        // only treat the evaluated text as dynamic SQL when the expression
        // resolved to an actual string value. When the value is unknowable
        // (unassigned variable, value from a table column, bare function call)
        // the plain text is just a placeholder identifier; parsing it as SQL
        // produces a bogus "Error when tokenize" report (MantisBT 4503)
        if (this.dynamicStringExpr.getVal() != null){
            this.dynamicSQL = this.dynamicStringExpr.getPlainText();
            this.dynamicSQLPartial = this.dynamicStringExpr.isValPartial();
        }

        //TODO parse the dynamicSQL, 先不在这里解析动态 SQL， 考虑和 TASTEvaluator 结合
        // getDynamicStatements();

        return 0;
    }

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

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

    public void setDynamicStringExpr(TExpression dynamicStringExpr) {
        this.dynamicStringExpr = dynamicStringExpr;
    }

    public void setBindArguments(TBindArgumentList bindArguments) {
        this.bindArguments = bindArguments;
    }

    public void setIntoVariables(TExpressionList intoVariables) {
        this.intoVariables = intoVariables;
    }

    public void setReturnNames(TObjectNameList returnNames) {
        this.returnNames = returnNames;
    }

    public void setDynamicSQL(String dynamicSQL) {
        this.dynamicSQL = dynamicSQL;
    }

    private boolean dynamicSQLPartial = false;

    /**
     * True when {@link #getDynamicSQL()} was only partially resolved: it
     * contains placeholder identifiers for unknowable parts (unresolved
     * variables, function calls) alongside resolved literal text. Such text
     * is still worth analyzing for approximate lineage, but a parse failure
     * on it must not be reported as a syntax error.
     */
    public boolean isDynamicSQLPartial() {
        return dynamicSQLPartial;
    }

    public void setDynamicStatements(TStatementList dynamicStatements) {
        this.dynamicStatements = dynamicStatements;
    }

//    private String EvaluateExpr(){
//        if (this.dynamicStringExpr == null) return "";
//        return this.dynamicStringExpr.getPlainText();
//    }
}

//class calculateExprVisitor implements IExpressionVisitor {
//    Stack<TExpression> expressionStack = new Stack<>();
//
//    public boolean exprVisit(TParseTreeNode pNode,boolean isLeafNode){
//        if (isLeafNode){
//            expressionStack.push((TExpression)pNode);
//        }
//
//        TExpression expr = (TExpression)pNode;
//        switch (expr.getExpressionType()){
//            case concatenate_t:
//                TExpression expr1 = expressionStack.pop();
//                TExpression expr2 = expressionStack.pop();
//
//                String expr1Str = expr1.getPlainText();
//                String expr2Str = expr2.getPlainText();
//                switch (expr1.getExpressionType()){
//                    case simple_constant_t:
//                        expr1Str = TBaseType.getStringInsideLiteral(expr1Str);
//                        break;
//                    case function_t:
//                        expr1Str = expr1.getFunctionCall().getFunctionName().toString();
//                        break;
//                    case simple_object_name_t:
//                        expr1Str = expr1Str.replace(".","_");
//                        break;
//                    default:
//                        break;
//                }
//
//                switch (expr2.getExpressionType()){
//                    case simple_constant_t:
//                        expr2Str = TBaseType.getStringInsideLiteral(expr2Str);
//                        break;
//                    case function_t:
//                        expr2Str = expr2.getFunctionCall().getFunctionName().toString();
//                        break;
//                    case simple_object_name_t:
//                        expr2Str = expr2Str.replace(".","_");
//                        break;
//                    default:
//                        break;
//                }
//
//
//                //TExpression expr3 = expressionStack.peek();
//                ((TExpression)pNode).setPlainText(expr2Str+expr1Str);
//
//                expressionStack.push((TExpression)pNode);
//
//                break;
//        }
//        return true;
//    };
//
//}