package gudusoft.gsqlparser.stmt;

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

/**
 * A LOOP statement executes a sequence of statements multiple times. PL/SQL provides
 * these loop statements:
 * <ul>
 * <li>Basic loop</li>
 * <li>WHILE loop</li>
 * <li>FOR loop
 * <p>FOR indexName IN lower_bound .. upper_bound LOOP statements END LOOP
 * </li>
 * <li>Cursor FOR loop</li>
 * </ul>
 *
 * @see TBlockSqlStatement#bodyStatements
 */

public class TLoopStmt extends TBlockSqlStatement {

    public final static int basic_loop = 1;
    public final static int while_loop = 2;
    public final static int for_loop = 3;
    public final static int cursor_for_loop = 4;

    private int kind = basic_loop;

    public void setKind(int kind) {
        this.kind = kind;
        if (this.kind == cursor_for_loop){
            this.recordName = this.indexName;
        }
    }

    /**
     *
     * @return What's kind of loop statement: simple, while or for.

     */
    public int getKind() {
        return kind;
    }

    public TLoopStmt(){
        this(EDbVendor.dbvoracle);
    }

     public TLoopStmt(EDbVendor dbvendor){
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sst_loopstmt;
        }

    private TObjectNameList scalarVariables;

    public TObjectNameList getScalarVariables() {
        return scalarVariables;
    }

    /**
     * An undeclared identifier that names the loop index.
     * Or, it should be a record-name when kind is cursor_for_loop.
     * @return Index name used in for-loop-statement.
     */
    public TObjectName getIndexName() {
        return indexName;
    }

    private TObjectName indexName = null;

    public TObjectName getRecordName() {
        return recordName;
    }

    private  TObjectName recordName = null;

    private TStatementListSqlNode stmts = null;

    private TExpression lower_bound = null;
    private TExpression upper_bound = null;

    private  boolean  isReverse = false;

    public void setReverse(boolean reverse) {
        isReverse = reverse;
    }

    public boolean isReverse() {

        return isReverse;
    }

    /**
     * Used in for-loop-statement.
     * @return
     */
    public TExpression getUpper_bound() {

        return upper_bound;
    }

    /**
     * Used in for-loop-statement.
     * @return
     */
    public TExpression getLower_bound() {

        return lower_bound;
    }



    public void setSubquery(TSelectSqlStatement subquery) {
        this.subquery = subquery;
    }

    /**
     *
     * @return Select statement when {@link #kind} is cursor_for_loop.
     */
    public TSelectSqlStatement getSubquery() {
        return subquery;
    }

    private TSelectSqlStatement subquery = null;
    private TSelectSqlNode selectSqlNode = null;

    public void setSelectSqlNode(TSelectSqlNode selectSqlNode) {
        this.selectSqlNode = selectSqlNode;
    }

    private TExpressionList cursorParameterNames = null;

    public void setCursorParameterNames(TExpressionList cursorParameterNames) {
        this.cursorParameterNames = cursorParameterNames;
    }

    /**
     *
     * @return  Cursor parameter names  when {@link #kind} is cursor_for_loop if any.
     */
    public TExpressionList getCursorParameterNames() {

        return cursorParameterNames;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    public void init(Object arg1)
    {
        stmts = (TStatementListSqlNode)arg1;
    }

    public void init(Object arg1,Object arg2)
    {
        stmts = (TStatementListSqlNode)arg1;
        if (arg2 instanceof TExpression){
            this.condition = (TExpression)arg2;
        }else if (arg2 instanceof TObjectNameList){
           this.scalarVariables = (TObjectNameList) arg2;
           this.indexName = this.scalarVariables.getObjectName(0);
        }else{
            this.indexName = (TObjectName)arg2;
        }
    }

    public void init(Object arg1,Object arg2,Object arg3)
    {
        init(arg1,arg2);
        cursorName = (TObjectName)arg3;
    }

    public void init(Object arg1,Object arg2,Object arg3,Object arg4)
    {
        init(arg1,arg2);

        lower_bound = (TExpression)arg3;
        upper_bound = (TExpression)arg4;
    }

    /**
     *
     * @return Cursor name when {@link #kind} is cursor_for_loop.
     */
    public TObjectName getCursorName() {
        return cursorName;
    }

    private TObjectName cursorName = null;
    

    /**
     * Used in while-loop-statement
     * @return If and only if the value of this expression is TRUE,
     * the statements in while will execute.
     */
    public TExpression getCondition() {
        return condition;
    }

    private TExpression condition = null;

    private TExpression executeExpr;
    private TExpressionList executeUsingVars;

    public void setExecuteExpr(TExpression executeExpr) {
        this.executeExpr = executeExpr;
    }

    public void setExecuteUsingVars(TExpressionList executeUsingVars) {
        this.executeUsingVars = executeUsingVars;
    }

    public TExpression getExecuteExpr() {

        return executeExpr;
    }

    public TExpressionList getExecuteUsingVars() {
        return executeUsingVars;
    }

    public int doParseStatement(TCustomSqlStatement psql) {
        super.doParseStatement(psql);
        this.stmtScope.setValidToDeclareVariable(true);

        TFrame currentFrame = new TFrame(this.stmtScope);
        currentFrame.pushMeToStack(getFrameStack());

        switch (dbvendor){
            case dbvmysql:
            case dbvteradata:
            case dbvbigquery:
                if (rootNode == null) return -1;
                TLoopSqlNode loopSqlNode = (TLoopSqlNode)rootNode;
                setLabelName(loopSqlNode.getLabelName());

                loopSqlNode.getStmts().doParse(this,ESqlClause.unknown);
                for(int i=0;i<loopSqlNode.getStmts().size();i++){
                    this.getBodyStatements().add(loopSqlNode.getStmts().getStatementSqlNode(i).getStmt());
                }
                break;
            default:
                //super.doParseStatement(psql);

                if (indexName != null){
                    this.getTopStatement().getSymbolTable().push( new TSymbolTableItem(TObjectName.ttobjParameter,this, indexName));
                    TVariable variable = new TVariable(indexName);
                    this.stmtScope.addSymbol(variable);
                }
                if (this.condition != null){
                    this.condition.doParse(this,ESqlClause.unknown);
                }
                if (subquery != null){
                    subquery.parsestatement(this,false);
                }else if (selectSqlNode != null){
                    //postgresql
                    subquery = new TSelectSqlStatement(this.dbvendor);
                    subquery.rootNode = selectSqlNode;
                    subquery.doParseStatement(this);
                }

                stmts.doParse(this,ESqlClause.unknown);
                for(int i=0;i<stmts.size();i++){
                    this.getBodyStatements().add(stmts.getStatementSqlNode(i).getStmt());
                }
                if (indexName != null) {
                    this.getTopStatement().getSymbolTable().pop();
                }

                break;
        }

        currentFrame.popMeFromStack(getFrameStack());

        return 0;
    }

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

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        if (this.condition != null) condition.acceptChildren(v);
        if (subquery != null) subquery.acceptChildren(v);
        getBodyStatements().acceptChildren(v);
        v.postVisit(this);
    }

    public void setIndexName(TObjectName indexName) {
        this.indexName = indexName;
    }

    public void setRecordName(TObjectName recordName) {
        this.recordName = recordName;
    }

    public void setLower_bound(TExpression lower_bound) {
        this.lower_bound = lower_bound;
    }

    public void setUpper_bound(TExpression upper_bound) {
        this.upper_bound = upper_bound;
    }

    public void setCursorName(TObjectName cursorName) {
        this.cursorName = cursorName;
    }

    public void setCondition(TExpression condition) {
        this.condition = condition;
    }
}