package gudusoft.gsqlparser.stmt;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TSymbolTableManager;
import gudusoft.gsqlparser.compiler.TVariable;
import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TParseTreeVisitor;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TSelectSqlNode;
import gudusoft.gsqlparser.nodes.TTypeName;

/**
 * The assignment statement sets the current value of a variable, field, parameter,
 * or element that has been declared in the current scope.
 */

public class TAssignStmt extends TCustomSqlStatement {

    public enum AssignType  {normal, variableAssignment, cursorAssignment,resultsetAssignment};

    private AssignType assignType = AssignType.normal;

    private TParseTreeNode queryNode;
    private TSelectSqlStatement query;

    public TSelectSqlStatement getQuery() {
        return query;
    }

    public AssignType getAssignType() {
        return assignType;
    }

    private TObjectName resultsetName;

    public TObjectName getResultsetName() {
        return resultsetName;
    }

    private TObjectName variableName;

    public TObjectName getVariableName() {
        return variableName;
    }

    /**
     * The data type of the variable in a LET statement (Snowflake).
     * For example, in "let x INTEGER := 10;", this returns the INTEGER type.
     */
    private TTypeName dataType;

    public TTypeName getDataType() {
        return dataType;
    }

    public void setDataType(TTypeName dataType) {
        this.dataType = dataType;
    }

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

    public TAssignStmt(TExpression pLeft, TExpression pExpr){
        this(EDbVendor.dbvoracle);
        this.left = pLeft;
        this.expression = pExpr;
    }


     public TAssignStmt(EDbVendor dbvendor){
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sst_assignstmt;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }



    private TExpression left = null;

    /**
     * @return The expression whose value is to be assigned to the target (the item to the left of the
     * assignment operator) when the assignment statement executes.
     */
    public TExpression getExpression() {
        return expression;
    }

    /**
     * Lefe side of this assignment, can be
     * <ul>
     * <li>attribute_name</li>
     * <li>collection_name</li>
     * <li>cursor_variable_name</li>
     * <li>field_name</li>
     * <li>host_cursor_variable_name</li>
     * <li>host_variable_name</li>
     * <li>object_name</li>
     * <li>parameter_name</li>
     * <li>record_name</li>
     * <li>variable_name</li>
     * </ul>
     * @return  A TExpression object.
     */
    public TExpression getLeft() {
        return left;
    }

    private TExpression expression = null;

    public void setLeft(TExpression left) {
        this.left = left;
    }

    public void setExpression(TExpression expression) {
        this.expression = expression;
    }

    public void init(Object arg1,Object arg2)
    {
        if (arg1 instanceof TObjectName){
            variableName = (TObjectName)arg1;
        }else if (arg1 instanceof  TExpression){
            left = (TExpression)arg1;
        }

        if (arg2 instanceof TExpression){
            expression = (TExpression)arg2;
        }else if (arg2 instanceof TSelectSqlNode){
            // Vertica PLvSQL truncating assignment: var <- SELECT ...
            this.queryNode = (TParseTreeNode)arg2;
        }
    }

    public void init(Object arg1, Object arg2,Object arg3){
        this.assignType = (AssignType) arg1;
        switch (this.assignType){
            case variableAssignment:
                this.variableName = (TObjectName) arg2;
                this.expression = (TExpression) arg3;
                break;
            case cursorAssignment:
                this.variableName = (TObjectName) arg2;
                this.queryNode = (TParseTreeNode)arg3;
                break;
            case resultsetAssignment:
                this.variableName = (TObjectName) arg2;
                this.resultsetName = (TObjectName) arg3;
                break;
        }

    }

    /**
     * Init method for LET statement with datatype (Snowflake).
     * @param arg1 AssignType
     * @param arg2 variable name (TObjectName)
     * @param arg3 datatype (TTypeName), can be null
     * @param arg4 expression (TExpression)
     */
    public void init(Object arg1, Object arg2, Object arg3, Object arg4){
        this.assignType = (AssignType) arg1;
        if (this.assignType == AssignType.variableAssignment){
            this.variableName = (TObjectName) arg2;
            if (arg3 instanceof TTypeName){
                this.dataType = (TTypeName) arg3;
            }
            this.expression = (TExpression) arg4;
        }
    }

    public int doParseStatement(TCustomSqlStatement psql) {
        super.doParseStatement(psql);

        switch (getAssignType()){
            case normal:
                if (expression != null) {
                    if (left != null){
                        left.doParse(this,ESqlClause.spAssignValue);
                        if (left.getExpressionType() == EExpressionType.simple_object_name_t){
                            TVariable symbolVariable =  TSymbolTableManager.searchSymbolVariable(this.getFrameStack(), left.getObjectOperand().toString());
                            if (symbolVariable != null){
                                expression.evaluate(this.getFrameStack(),this);
                                // only record the value when the expression resolved to an
                                // actual string (literal, or concatenation seeded by one).
                                // A bare function call such as REPLACE(cur.rule_sql, ...) or an
                                // unresolved variable only yields a placeholder name; recording
                                // it would make EXECUTE IMMEDIATE parse that placeholder as SQL
                                // and report a bogus syntax error (MantisBT 4503)
                                if (this.expression.getVal() != null){
                                    symbolVariable.setVariableStr(this.expression.getPlainText());
                                    symbolVariable.setVariableStrPartial(this.expression.isValPartial());
                                    if (expression.getStartToken() != null){
                                        symbolVariable.setLineNo(expression.getStartToken().lineNo);
                                        symbolVariable.setColumnNo(expression.getStartToken().columnNo);
                                    }
                                }else{
                                    // the assignment replaced the variable's value with an
                                    // unknowable one - clear any previously recorded value so a
                                    // later EXECUTE IMMEDIATE does not parse stale SQL
                                    symbolVariable.setVariableStr(null);
                                    symbolVariable.setVariableStrPartial(false);
                                }
                            }
                        }
                    }
                    expression.doParse(this,ESqlClause.spAssignValue);
                } else if (queryNode instanceof TSelectSqlNode) {
                    // Vertica PLvSQL truncating assignment: var <- SELECT ...
                    query = new TSelectSqlStatement(this.dbvendor);
                    query.rootNode = (TSelectSqlNode) queryNode;
                    query.doParseStatement(this);
                }
                break;
            case variableAssignment:
                if (expression != null) {
                    expression.doParse(this,ESqlClause.spAssignValue);
                }
                break;
            case cursorAssignment:
                if (queryNode instanceof TSelectSqlNode) {
                    query = new TSelectSqlStatement(this.dbvendor);
                    query.rootNode = (TSelectSqlNode) queryNode;
                    query.doParseStatement(this);
                }
                break;
        }

        return 0;
    }

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

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        if (left != null){
            left.acceptChildren(v);
        }
        if (expression != null){
            expression.acceptChildren(v);
        }else{
            TBaseType.log("Value expression in assign statement is not specified",TLog.WARNING);
        }

        v.postVisit(this);
    }
}