/* ****************************************************************************
 *
 * Copyright (c) Microsoft Corporation. 
 *
 * This source code is subject to terms and conditions of the Microsoft Public License. A 
 * copy of the license can be found in the License.html file at the root of this distribution. If 
 * you cannot locate the  Microsoft Public License, please send an email to 
 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Microsoft Public License.
 *
 * You must not remove this notice, or any other, from this software.
 *
 *
 * ***************************************************************************/

using System.Diagnostics;
using System.Linq.Expressions;
using Microsoft.Scripting.Utils;

namespace Microsoft.Scripting.Generation {

    public static class ConstantCheck {

        /// <summary>
        /// Tests to see if the expression is a constant with the given value.
        /// </summary>
        /// <param name="expression">The expression to examine</param>
        /// <param name="value">The constant value to check for.</param>
        /// <returns>true/false</returns>
        public static bool Check(Expression expression, object value) {
            ContractUtils.RequiresNotNull(expression, "expression");
            return IsConstant(expression, value);
        }


        /// <summary>
        /// Tests to see if the expression is a constant with the given value.
        /// </summary>
        /// <param name="e">The expression to examine</param>
        /// <param name="value">The constant value to check for.</param>
        /// <returns>true/false</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
        internal static bool IsConstant(Expression e, object value) {
            switch (e.NodeType) {
                case ExpressionType.AndAlso:
                    return CheckAndAlso((BinaryExpression)e, value);

                case ExpressionType.OrElse:
                    return CheckOrElse((BinaryExpression)e, value);

                case ExpressionType.Constant:
                    return CheckConstant((ConstantExpression)e, value);

                case ExpressionType.TypeIs:
                    return Check((TypeBinaryExpression)e, value);

                default:
                    return false;
            }
        }

        //CONFORMING
        internal static bool IsNull(Expression e) {
            return IsConstant(e, null);
        }


        private static bool CheckAndAlso(BinaryExpression node, object value) {
            Debug.Assert(node.NodeType == ExpressionType.AndAlso);

            if (node.Method != null) {
                return false;
            }
            //TODO: we can propagate through conversion, but it may not worth it.
            if (node.Conversion != null) {
                return false;
            }
    
            if (value is bool) {
                if ((bool)value) {
                    return IsConstant(node.Left, true) && IsConstant(node.Right, true);
                } else {
                    // if left isn't a constant it has to be evaluated
                    return IsConstant(node.Left, false);
                }
            }
            return false;
        }

        private static bool CheckOrElse(BinaryExpression node, object value) {
            Debug.Assert(node.NodeType == ExpressionType.OrElse);

            if (node.Method != null) {
                return false;
            }

            if (value is bool) {
                if ((bool)value) {
                    return IsConstant(node.Left, true);
                } else {
                    return IsConstant(node.Left, false) && IsConstant(node.Right, false);
                }
            }
            return false;
        }

        private static bool CheckConstant(ConstantExpression node, object value) {
            if (value == null) {
                return node.Value == null;
            } else {
                return value.Equals(node.Value);
            }
        }

        private static bool Check(TypeBinaryExpression node, object value) {
            // allow constant TypeIs expressions to be optimized away
            if (value is bool && ((bool)value) == true) {
                return node.TypeOperand.IsAssignableFrom(node.Expression.Type);
            }
            return false;
        }
    }
}
