using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Data;

namespace System.Data.Linq.SqlClient {
    using System.Data.Linq;
    using System.Diagnostics.CodeAnalysis;

    /// <summary>
    /// This visitor searches for places where 'Predicate' is found but a 'Bit'
    /// was expected or vice versa. In response, it will call VisitBitExpectedPredicate
    /// and VisitPredicateExpectedBit.
    /// </summary>
    internal abstract class SqlBooleanMismatchVisitor : SqlVisitor {

        internal SqlBooleanMismatchVisitor() {
        }

        internal abstract SqlExpression ConvertValueToPredicate(SqlExpression valueExpression);
        internal abstract SqlExpression ConvertPredicateToValue(SqlExpression predicateExpression);

        internal override SqlSelect VisitSelect(SqlSelect select) {
            select.From = this.VisitSource(select.From);
            select.Where = this.VisitPredicate(select.Where);
            for (int i = 0, n = select.GroupBy.Count; i < n; i++) {
                select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
            }
            select.Having = this.VisitPredicate(select.Having);
            for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
                select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
            }
            select.Top = this.VisitExpression(select.Top);
            select.Row = (SqlRow)this.Visit(select.Row);

            // don't visit selection
            //select.Selection = this.VisitExpression(select.Selection);

            return select;
        }

        internal override SqlSource VisitJoin(SqlJoin join) {
            join.Left = this.VisitSource(join.Left);
            join.Right = this.VisitSource(join.Right);
            join.Condition = this.VisitPredicate(join.Condition);
            return join;
        }

        internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
            if (uo.NodeType.IsUnaryOperatorExpectingPredicateOperand()) {
                uo.Operand = this.VisitPredicate(uo.Operand);
            } else {
                uo.Operand = this.VisitExpression(uo.Operand);
            }
            return uo;
        }

        internal override SqlExpression VisitBinaryOperator(SqlBinary bo) {
            if (bo.NodeType.IsBinaryOperatorExpectingPredicateOperands()) {
                bo.Left = this.VisitPredicate(bo.Left);
                bo.Right = this.VisitPredicate(bo.Right);
            } else {
                bo.Left = this.VisitExpression(bo.Left);
                bo.Right = this.VisitExpression(bo.Right);
            }

            return bo;
        }

        internal override SqlStatement VisitAssign(SqlAssign sa) {
            // L-Value of assign is never a 'Bit' nor a 'Predicate'.
            sa.LValue = this.VisitExpression(sa.LValue);
            sa.RValue = this.VisitExpression(sa.RValue);
            return sa;
        }

        internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) {
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlWhen when = c.Whens[i];
                when.Match = this.VisitPredicate(when.Match);
                when.Value = this.VisitExpression(when.Value);
            }
            c.Else = this.VisitExpression(c.Else);
            return c;
        }

        internal override SqlExpression VisitLift(SqlLift lift) {
            lift.Expression = base.VisitExpression(lift.Expression);
            return lift;
        }

        /// <summary>
        /// If an expression is type 'Bit' but a 'Predicate' is expected then 
        /// call 'VisitBitExpectedPredicate'.
        /// </summary>
        internal SqlExpression VisitPredicate(SqlExpression exp) {
            exp = (SqlExpression)base.Visit(exp);
            if (exp != null) {
                if (!IsPredicateExpression(exp)) {
                    exp = ConvertValueToPredicate(exp);
                }
            }
            return exp;
        }

        /// <summary>
        /// Any remaining calls to VisitExpression expect a 'Bit' when there's
        /// a boolean expression.
        /// </summary>
        internal override SqlExpression VisitExpression(SqlExpression exp) {
            exp = (SqlExpression)base.Visit(exp);
            if (exp != null) {
                if (IsPredicateExpression(exp)) {
                    exp = ConvertPredicateToValue(exp);
                }
            }
            return exp;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
        private static bool IsPredicateExpression(SqlExpression exp) {
            switch (exp.NodeType) {
                case SqlNodeType.And:
                case SqlNodeType.Or:
                case SqlNodeType.Not:
                case SqlNodeType.Not2V:
                case SqlNodeType.EQ:
                case SqlNodeType.EQ2V:
                case SqlNodeType.NE:
                case SqlNodeType.NE2V:
                case SqlNodeType.GE:
                case SqlNodeType.GT:
                case SqlNodeType.LE:
                case SqlNodeType.LT:
                case SqlNodeType.Exists:
                case SqlNodeType.Between:
                case SqlNodeType.In:
                case SqlNodeType.Like:
                case SqlNodeType.IsNotNull:
                case SqlNodeType.IsNull:
                    return true;
                case SqlNodeType.Lift:
                    return IsPredicateExpression(((SqlLift)exp).Expression);
                default:
                    return false;
            }
        }
    }
}