/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.royale.compiler.internal.tree.as;

import static org.apache.royale.compiler.internal.parsing.as.ASTokenTypes.*;

import antlr.Token;

import org.apache.royale.compiler.constants.IASLanguageConstants.BuiltinType;
import org.apache.royale.compiler.definitions.ITypeDefinition;
import org.apache.royale.compiler.internal.semantics.SemanticUtils;
import org.apache.royale.compiler.parsing.IASToken;
import org.apache.royale.compiler.projects.ICompilerProject;
import org.apache.royale.compiler.tree.as.IASNode;
import org.apache.royale.compiler.tree.as.IDynamicAccessNode;
import org.apache.royale.compiler.tree.as.IBinaryOperatorNode;
import org.apache.royale.compiler.tree.as.IExpressionNode;

/**
 * Abstract base class for all binary operator nodes.
 */
public abstract class BinaryOperatorNodeBase extends OperatorNodeBase implements IBinaryOperatorNode
{
    /**
     * Factory method for various kinds of binary operator nodes.
     */
    public static BinaryOperatorNodeBase create(IASToken operatorToken, ExpressionNodeBase leftOperand, ExpressionNodeBase rightOperand)
    {
        switch (operatorToken.getType())
        {
            // simple assignment
            
            case TOKEN_OPERATOR_ASSIGNMENT:
                return new BinaryOperatorAssignmentNode(operatorToken, leftOperand, rightOperand);
            
            // arithmetic
            
            case TOKEN_OPERATOR_PLUS:
                return new BinaryOperatorPlusNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_PLUS_ASSIGNMENT:
                return new BinaryOperatorPlusAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_MINUS:
                return new BinaryOperatorMinusNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_MINUS_ASSIGNMENT:
                return new BinaryOperatorMinusAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_STAR:
                return new BinaryOperatorMultiplicationNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_MULTIPLICATION_ASSIGNMENT:
                return new BinaryOperatorMultiplicationAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_DIVISION:
                return new BinaryOperatorDivisionNode(operatorToken, leftOperand, rightOperand);
            
            case TOKEN_OPERATOR_DIVISION_ASSIGNMENT:
                return new BinaryOperatorDivisionAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_MODULO:
                return new BinaryOperatorModuloNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_MODULO_ASSIGNMENT:
                return new BinaryOperatorModuloAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            // equality
                
            case TOKEN_OPERATOR_EQUAL:
                return new BinaryOperatorEqualNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_NOT_EQUAL:
                return new BinaryOperatorNotEqualNode(operatorToken, leftOperand, rightOperand);
                    
            case TOKEN_OPERATOR_STRICT_EQUAL:
                return new BinaryOperatorStrictEqualNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_STRICT_NOT_EQUAL:
                return new BinaryOperatorStrictNotEqualNode(operatorToken, leftOperand, rightOperand);
                
            // comparison
            
            case TOKEN_OPERATOR_LESS_THAN:
                return new BinaryOperatorLessThanNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_LESS_THAN_EQUALS:
                return new BinaryOperatorLessThanEqualsNode(operatorToken, leftOperand, rightOperand);
                    
            case TOKEN_OPERATOR_GREATER_THAN:
                return new BinaryOperatorGreaterThanNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_GREATER_THAN_EQUALS:
                return new BinaryOperatorGreaterThanEqualsNode(operatorToken, leftOperand, rightOperand);
                
            // logical
                
            case TOKEN_OPERATOR_LOGICAL_AND:
                return new BinaryOperatorLogicalAndNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_LOGICAL_AND_ASSIGNMENT:
                return new BinaryOperatorLogicalAndAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_LOGICAL_OR:
                return new BinaryOperatorLogicalOrNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_LOGICAL_OR_ASSIGNMENT:
                return new BinaryOperatorLogicalOrAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            // bitwise logical
                
            case TOKEN_OPERATOR_BITWISE_AND:
                return new BinaryOperatorBitwiseAndNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_AND_ASSIGNMENT:
                return new BinaryOperatorBitwiseAndAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_OR:
                return new BinaryOperatorBitwiseOrNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_OR_ASSIGNMENT:
                return new BinaryOperatorBitwiseOrAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_XOR:
                return new BinaryOperatorBitwiseXorNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_XOR_ASSIGNMENT:
                return new BinaryOperatorBitwiseXorAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            // shift
                
            case TOKEN_OPERATOR_BITWISE_LEFT_SHIFT:
                return new BinaryOperatorBitwiseLeftShiftNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_LEFT_SHIFT_ASSIGNMENT:
                return new BinaryOperatorBitwiseLeftShiftAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_RIGHT_SHIFT:
                return new BinaryOperatorBitwiseRightShiftNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_RIGHT_SHIFT_ASSIGNMENT:
                return new BinaryOperatorBitwiseRightShiftAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_UNSIGNED_RIGHT_SHIFT:
                return new BinaryOperatorBitwiseUnsignedRightShiftNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_OPERATOR_BITWISE_UNSIGNED_RIGHT_SHIFT_ASSIGNMENT:
                return new BinaryOperatorBitwiseUnsignedRightShiftAssignmentNode(operatorToken, leftOperand, rightOperand);
                
            // other
            
            case TOKEN_KEYWORD_AS:
                return new BinaryOperatorAsNode(operatorToken, leftOperand, rightOperand);
                
            case TOKEN_COMMA:
                return new BinaryOperatorCommaNode(operatorToken, leftOperand, rightOperand);
            
            case TOKEN_KEYWORD_IN:
                return new BinaryOperatorInNode(operatorToken, leftOperand, rightOperand);
            
            case TOKEN_KEYWORD_INSTANCEOF:
                return new BinaryOperatorInstanceOfNode(operatorToken, leftOperand, rightOperand);
            
            case TOKEN_KEYWORD_IS:
                return new BinaryOperatorIsNode(operatorToken, leftOperand, rightOperand);
        }
        
        assert false : "Token '" + operatorToken.getText() + "' unexpected in BinaryOperatorNodeBase.create()";
        return null;
    }
    
    /**
     * Constructor.
     * <p>
     * Creates a {@code BinaryOperatorNode} from an operator and both operands.
     * If either operand is {@code null}, we will synthesize
     * empty {@link IdentifierNode} to repair the tree.
     * 
     * @param op operator token
     * @param left first operand
     * @param right second operand
     */
    public BinaryOperatorNodeBase(IASToken op, ExpressionNodeBase left, ExpressionNodeBase right)
    {
        super(op);

        // Synthesize an empty ID node if either operand is null. (Fix for CMP-883)

        if (left == null)
            leftOperandNode = IdentifierNode.createEmptyIdentifierNodeAfterToken((Token)op);
        else
            leftOperandNode = left;

        if (right == null)
            rightOperandNode = IdentifierNode.createEmptyIdentifierNodeAfterToken((Token)op);
        else
            rightOperandNode = right;
        
        span(leftOperandNode, rightOperandNode);
    }
    
    /**
     * Copy constructor.
     * 
     * @param other The node to copy.
     */
    protected BinaryOperatorNodeBase(BinaryOperatorNodeBase other)
    {
        super(other);
        
        this.leftOperandNode = other.leftOperandNode != null ? other.leftOperandNode.copy() : null;
        this.rightOperandNode = other.rightOperandNode != null ? other.rightOperandNode.copy() : null;
    }

    /**
     * The expression to the left of the operator
     */
    protected ExpressionNodeBase leftOperandNode;

    /**
     * The expression to the right of the operator
     */
    protected ExpressionNodeBase rightOperandNode;
    
    //
    // NodeBase overrides
    //
    
    @Override
    public int getChildCount()
    {
        int count = 0;
        
        if (leftOperandNode != null)
            count++;
        
        if (rightOperandNode != null)
            count++;
        
        return count;
    }

    @Override
    public IASNode getChild(int i)
    {
        if (i == 0)
            return leftOperandNode != null ? leftOperandNode : rightOperandNode;
        
        else if (i == 1)
            return rightOperandNode;
        
        return null;
    }
    
    @Override
    protected void setChildren(boolean fillInOffsets)
    {
        if (leftOperandNode != null)
            leftOperandNode.setParent(this);

        if (rightOperandNode != null)
            rightOperandNode.setParent(this);
    }

    @Override
    protected void fillInOffsets()
    {
        if (rightOperandNode == null && leftOperandNode == null && operatorStart != -1)
            span(operatorStart, operatorStart + 1, -1, -1, -1, -1);
        else
            super.fillInOffsets();
    }
    
    //
    // ExpressionNodeBase overrides
    //
    
    @Override
    public ITypeDefinition resolveType(ICompilerProject project)
    {
        // Various subclasses override this default behavior.
        return project.getBuiltinType(BuiltinType.ANY_TYPE);
    }
    
    //
    // OperatorNodeBase overrides
    //
    
    @Override
    public ExpressionType getExpressionType()
    {
        return ExpressionType.BINARY;
    }
    
    //
    // IBinaryOperatorNode implementations
    //
    
    @Override
    public IExpressionNode getLeftOperandNode()
    {
        return leftOperandNode;
    }

    @Override
    public IExpressionNode getRightOperandNode()
    {
        return rightOperandNode;
    }

    //
    // Other methods
    //

    /**
     * Sets the left-hand side of the expression.
     * 
     * @param leftOperandNode Left-hand side expression.
     */
    public void setLeftOperandNode(ExpressionNodeBase leftOperandNode)
    {
        this.leftOperandNode = leftOperandNode;
    }

    /**
     * Sets the right side of the expression
     * 
     * @param rightOperandNode ExpressionNodeBase to the right of the operator
     */
    public void setRightOperandNode(ExpressionNodeBase rightOperandNode)
    {
        this.rightOperandNode = rightOperandNode;
    }
    
    public boolean isOperatingOnArray()
    {
        if (leftOperandNode instanceof IDynamicAccessNode || rightOperandNode instanceof IDynamicAccessNode)
            return true;
        
        if (leftOperandNode instanceof IBinaryOperatorNode)
        {
            boolean onArray = ((BinaryOperatorNodeBase)leftOperandNode).isOperatingOnArray();
            if (onArray)
                return true;
        }
        
        if (rightOperandNode instanceof IBinaryOperatorNode)
            return ((BinaryOperatorNodeBase)rightOperandNode).isOperatingOnArray();

        return false;
    }

    /**
     * Utility method called by {@link #resolveType(ICompilerProject)}
     * in subclasses for assignment operators.
     */
    protected ITypeDefinition resolveAssignmentType(ICompilerProject project)
    {
        // The type of any assignment expression is the type
        // of what we are assigning to.
        return getLeftOperandNode().resolveType(project);
    }

    /**
     * Utility method called by {@link #resolveType(ICompilerProject)}
     * in subclasses for the <code>&&</code> and <code>||</code> operators.
     */
    protected ITypeDefinition resolveLogicalType(ICompilerProject project)
    {
        // The old compiler says the type of && or || is one of the operand types,
        // but only checks if the types are identical.
        // this compiler is smarter and tries to find a common base type, if
        // the types are not identical.
        ITypeDefinition leftType = getLeftOperandNode().resolveType(project);
        ITypeDefinition rightType = getRightOperandNode().resolveType(project);
        if (leftType != null && leftType.equals(rightType))
            return leftType;
        ITypeDefinition commonType = SemanticUtils.resolveCommonType(leftType, rightType, project);
        if (commonType != null)
        {
            return commonType;
        }
        
        return project.getBuiltinType(BuiltinType.ANY_TYPE);
    }
}
