/// <summary>
 /// Constructor with an <see cref="ConditionalExpression"/> and an <see cref="ExpressionConverter"/>.
 /// </summary>
 /// <param name="expression">The original, not serializable <see cref="Expression"/>.</param>
 /// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param>
 public SerializableConditionalExpression(ConditionalExpression expression, ExpressionConverter expConverter)
     : base(expression, expConverter)
 {
     IfTrue = expression.IfTrue.MakeSerializable(expConverter);
     IfFalse = expression.IfFalse.MakeSerializable(expConverter);
     Test = expression.Test.MakeSerializable(expConverter);
 }

        private bool TryRemoveNullPropagation(ConditionalExpression node, out Expression condition)
        {
            condition = null;
            if (!typeof(IEnumerable).IsAssignableFrom(node.Type)) {
                return false;
            }

            if (node.Test.NodeType != ExpressionType.Equal) {
                return false;
            }

            if (node.IfTrue.NodeType != ExpressionType.Call) {
                return false;
            }

            if (node.IfFalse.NodeType != ExpressionType.MemberAccess) {
                return false;
            }

            if (!node.Type.IsAssignableFrom(node.IfFalse.Type)) {
                return false;
            }

            _yankingNull = true;
            condition = node.IfFalse;
            _yankingNull = false;
            return true;
        }

 protected ConditionalExpression UpdateConditional(ConditionalExpression c, Expression test, Expression ifTrue, Expression ifFalse)
 {
     if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse) {
         return Expression.Condition(test, ifTrue, ifFalse);
     }
     return c;
 }

        private bool TryRemoveNullPropagation(ConditionalExpression node, out Expression condition)
        {
            condition = null;
            if (node.IfTrue.NodeType != ExpressionType.Constant) {
                return false;
            }

            if (node.Test.NodeType != ExpressionType.Equal) {
                return false;
            }

            var test = (BinaryExpression)node.Test;
            var constantExpr = (ConstantExpression)node.IfTrue;

            if (node.IfFalse.NodeType != ExpressionType.Call) {
                return false;
            }

            var memberExpr = (MethodCallExpression)node.IfFalse;

            _yankingNull = true;
            condition = Visit(memberExpr);
            _yankingNull = false;
            return true;
        }

 protected override Expression VisitConditional(ConditionalExpression node)
 {
     return Expression.Condition(
         Visit(node.Test),
         Visit(node.IfTrue),
         Visit(node.IfFalse));
 }

        private Expression TryToCoalesceAsNullable(ConditionalExpression c)
        {
            var hasValueTarget = (Expression)null;
            var getValueTarget = (Expression)null;

            var matched = Matcher
                .For(c.Test).AsPropertyOrField()
                    .Property(property => property.Name == "HasValue" && property.DeclaringType.IsGenericTypeDefinedAs(typeof(Nullable<>)))
                    .Do(p => hasValueTarget = p.Expression)

                .For(c.IfTrue).AsConvert()
                    .Type(typeof(Nullable<>))
                    .Operand().AsMethodCall()
                        .Method(method => method.Name == "GetValueOrDefault"
                                       && method.DeclaringType.IsGenericTypeDefinedAs(typeof(Nullable<>)))
                        .Do(call => getValueTarget = call.Object)

                .Matched;

            if (!matched)
                return null;

            if (hasValueTarget != getValueTarget)
                return null;

            return Expression.Coalesce(getValueTarget, c.IfFalse);
        }

 public override Expression VisitConditional(ConditionalExpression c)
 {
     _Builder.Append("(");
     var conditional = base.VisitConditional(c);
     _Builder.Append(")");
     return conditional;
 }

        protected override Expression VisitConditional(ConditionalExpression expression)
        {
            var test = this.Visit(expression.Test);
            var ifFalse = this.Visit(expression.IfFalse);
            var ifTrue = this.Visit(expression.IfTrue);

            if (test is BitBooleanExpression)
            {
                test = Expression.Equal(test, Expression.Constant(true));
            }

            if (ifFalse.Type.GetUnwrappedNullableType() == typeof(bool) && !(ifFalse is BitBooleanExpression))
            {
                ifFalse = BitBooleanExpression.Coerce(ifFalse);
            }

            if (ifTrue.Type.GetUnwrappedNullableType() == typeof(bool) && !(ifTrue is BitBooleanExpression))
            {
                ifTrue = BitBooleanExpression.Coerce(ifTrue);
            }

            if (test != expression.Test || ifFalse != expression.IfFalse || ifTrue != expression.IfTrue)
            {
                return new BitBooleanExpression(Expression.Condition(test, ifTrue, ifFalse));
            }
            else
            {
                return base.VisitConditional(expression);
            }
        }

        protected override Expression VisitConditional(ConditionalExpression c)
        {
            c = (ConditionalExpression)base.VisitConditional(c);

            return TryToCoalesceAsObjects(c)
                ?? TryToCoalesceAsNullable(c)
                ?? c;
        }

 protected static ConditionalExpression UpdateConditional(ConditionalExpression node, Expression test,
                                                          Expression ifTrue, Expression ifFalse)
 {
     if (node.Test != test || node.IfTrue != ifTrue || node.IfFalse != ifFalse)
     {
         return Expression.Condition(test, ifTrue, ifFalse);
     }
     return node;
 }

        /*********
        ** Protected methods
        *********/
        /// <summary>Handles the conditional expression (equivalent to <c>.If {} .Else {}</c> in the sample expression tree in the <see cref="FixStringMethodsVisitor"/> remarks).</summary>
        /// <param name="original">The original expression.</param>
        /// <param name="ifElse">The conditional expression.</param>
        /// <returns>A reduced if/else statement if it contains any of the matched methods. Otherwise, the original expression.</returns>
        private Expression HandleConditionalExpression(Expression original, ConditionalExpression ifElse)
        {
            var elseExpression = ifElse.IfFalse as UnaryExpression;
            if (elseExpression != null)
            {
                var methodCallExpression = elseExpression.Operand as MethodCallExpression;
                if (methodCallExpression != null)
                {
                    if (this.BooleanReturnStringMethods.Contains(methodCallExpression.Method))
                    {
                        var methodCallReplacement = Expression.Call(
                            methodCallExpression.Object,
                            methodCallExpression.Method,
                            methodCallExpression.Arguments);

                        // Convert the result to a nullable boolean so the Expression.Equal works.
                        var result = Expression.Convert(methodCallReplacement, typeof(bool?));
                        return result;
                    }

                    if (this.IntegerStringMethods.Contains(methodCallExpression.Method))
                    {
                        var methodCallReplacement = Expression.Call(
                            methodCallExpression.Object,
                            methodCallExpression.Method,
                            methodCallExpression.Arguments);

                        var result = Expression.Convert(methodCallReplacement, typeof(int?));
                        return result;
                    }
                }
            }

            var firstLevelMethodCallExpression = ifElse.IfFalse as MethodCallExpression;
            if (firstLevelMethodCallExpression != null)
            {
                // Using the method name and declaring type as strings because I don't want to add a dependency to the project for a simple check like that.
                if (firstLevelMethodCallExpression.Method.DeclaringType != null &&
                    firstLevelMethodCallExpression.Method.DeclaringType.FullName == "System.Web.Http.OData.Query.Expressions.ClrSafeFunctions" &&
                    (firstLevelMethodCallExpression.Method.Name == "SubstringStartAndLength"  || firstLevelMethodCallExpression.Method.Name == "SubstringStart"))
                {
                    var arguments = firstLevelMethodCallExpression.Arguments.Skip(1).ToArray();
                    return Expression.Call(
                        firstLevelMethodCallExpression.Arguments[0],
                        typeof(string).GetMethod("Substring", arguments.Select(x => typeof(int)).ToArray()),
                        arguments);
                }

                if (this.ConcatStringMethods.Contains(firstLevelMethodCallExpression.Method))
                {
                    return Expression.Add(firstLevelMethodCallExpression.Arguments.First(), firstLevelMethodCallExpression.Arguments.Last(), firstLevelMethodCallExpression.Method);
                }
            }

            return original;
        }

        protected override Expression VisitConditional(ConditionalExpression node)
        {
            DefaultExpression defaultExpression = node.IfFalse as DefaultExpression;

            if (defaultExpression == null || defaultExpression.Type != typeof (void) || !_canReplace)
                return base.VisitConditional(node);

            _canReplace = false;    
            return Visit(Expression.IfThenElse(node.Test, node.IfTrue, Replacement));
        }

 void Conditional(ConditionalExpression expression)
 {
     Write("Conditional:");
     Write("Test:");
     Expression(expression.Test);
     Write("IfTrue:");
     Expression(expression.IfTrue);
     Write("IfFalse:");
     Expression(expression.IfFalse);
 }

 protected override Expression VisitConditional(ConditionalExpression node)
 {
     var cond = Visit(node.Test);
     AddParameter(cond);
     var lhs = Visit(node.IfTrue);
     AddParameter(lhs);
     var rhs = Visit(node.IfFalse);
     AddParameter(rhs);
     return null;
 }

        protected override Expression VisitConditional(ConditionalExpression expression)
        {
            var constantExpression = expression.Test as ConstantExpression;

            if (constantExpression != null)
            {
                return Convert.ToBoolean(constantExpression.Value) ? expression.IfTrue : expression.IfFalse;
            }

            return base.VisitConditional(expression);
        }

 internal static Condition Condition(ConditionalExpression expression)
 {
     return new Condition()
     {
         Type = expression.Type != expression.IfTrue.Type
             ? TypeRef.Serialize(expression.Type)
             : null,
         Test = Serialize(expression.Test),
         IfTrue = Serialize(expression.IfTrue),
         IfFalse = Serialize(expression.IfFalse),
     }.If(n => n.Type == null, n => n.TypeHint = TypeRef.Serialize(expression.Type));
 }

		protected override Expression VisitConditionalExpression(ConditionalExpression expression)
		{
			var oldRequiresJoinForNonIdentifier = _requiresJoinForNonIdentifier;
			_requiresJoinForNonIdentifier = !_preventJoinsInConditionalTest && _requiresJoinForNonIdentifier;
			var newTest = VisitExpression(expression.Test);
			_requiresJoinForNonIdentifier = oldRequiresJoinForNonIdentifier;
			var newFalse = VisitExpression(expression.IfFalse);
			var newTrue = VisitExpression(expression.IfTrue);
			if ((newTest != expression.Test) || (newFalse != expression.IfFalse) || (newTrue != expression.IfTrue))
				return Expression.Condition(newTest, newTrue, newFalse);
			return expression;
		}

        protected override Expression VisitConditional(ConditionalExpression node)
        {
            if (node.IfFalse.NodeType != ExpressionType.Throw)
            {
                return base.VisitConditional(node);
            }

            Console.WriteLine(node.ToString());

            Expression<Func<Object>> dummyFalseResult = () => DUMMY_RESULT;
            var invokeDummyFalseResult = Expression.Invoke(dummyFalseResult, null);
            return Expression.Condition(node.Test, node.IfTrue, invokeDummyFalseResult);
        }

        protected override Expression VisitConditional(ConditionalExpression node)
        {
            Expression expression;
            if (TryRemoveNullPropagation(node, out expression)) {
                return expression;
            }

            if (_yankingNull && IsNullCheck(node.Test)) {
                return Visit(node.IfFalse);
            }

            return base.VisitConditional(node);
        }

		protected override Expression VisitConditional(ConditionalExpression node)
		{
			var newExpr = base.VisitConditional(node);
			if (newExpr.NodeType == ExpressionType.Conditional)
			{
				var cond = (ConditionalExpression) newExpr;
				if (cond.Test.NodeType == ExpressionType.Constant)
				{
					var testResult = (bool) ((ConstantExpression) cond.Test).Value;
					return testResult ? cond.IfTrue : cond.IfFalse;
				}
			}
			return newExpr;
		}