using System;

public class Program

{

    public static void Main()

    {

        var cond = new OrCondition(

            new EqCondition(new Literal("test"),

                            new Literal("anothertest")),

            new AndCondition(

         new EqCondition(new Literal("1"),

                         new Literal("1")),

         new EqCondition(new Literal("2"),

                        new Literal("3"))));

        Console.WriteLine(cond.Output());

    }

    interface IExpressionBuilder

    {

       IExpression Build();

       IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder);

        IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression);

        IExpressionBuilder And(

           IExpression left,

           IExpression right);

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder);

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression);

        IExpressionBuilder Or(

           IExpression left,

           IExpression right);

    }

    class ExpressionBuilder: IExpressionBuilder

    {

       private IExpression _expression;

       public IExpression Build()

       {

           return _expression;

       }

       public IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder)

       {

           var lBuilder = new ExpressionBuilder();

           var rBuilder = new ExpressionBuilder();

           leftBuilder?.Invoke(lbuilder);

           rightBuilder?.Invoke(rBuilder);

          _expression= new AndCondition(lBuilder.Build(),

                                        rBuilder.Build());

           return this;

       }

       public IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder)

       {

           return this;

       }

       public IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression)

       {

           return this;

       }

        public IExpressionBuilder And(

           IExpression left,

           IExpression right)

        {

           return this;

        }

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder);

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression);

        IExpressionBuilder Or(

           IExpression left,

           IExpression right);

       }

​

        IExpressionBuilder And(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression);

        IExpressionBuilder And(

           IExpression left,

           IExpression right);

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           Action<IExpressionBuilder> rightBuilder);

        IExpressionBuilder Or(

           Action<IExpressionBuilder> leftBuilder,

           IExpression expression);

        IExpressionBuilder Or(

           IExpression left,

           IExpression right);

    }

    interface IExpression

    {

       string Output();

    }

    interface ICondition : IExpression

    {

       string Operator{get;}

       IExpression Left{get;}

       IExpression Right{get;}

    }

    abstract class Condition: ICondition

    {

      public virtual string Operator =>this.GetType()

          .Name

          .Replace(nameof(Condition), string.Empty)

          .ToUpper();

      public IExpression Left{get;}

      public IExpression Right{get;}

      public virtual string Output()

      {

         return $"({this.Left.Output()} {this.Operator} {this.Right.Output()})";

      }

       public Condition(IExpression left,

                        IExpression right)

       {

           this.Left=left;

           this.Right=right;

       }

    }

    sealed class AndCondition: Condition

    {

       public AndCondition(

           IExpression left,

           IExpression right)

            :base(left,right)

        {

        }

    }

    sealed class OrCondition: Condition

    {

       public OrCondition(

           IExpression left,

           IExpression right)

            :base(left,right)

        {

        }

    }

    class Literal: IExpression

    {

        private readonly object _literal;   

        public Literal(object literal)

        {

            _literal = literal ?? 

                new ArgumentNullException(nameof(literal));

        }

        public virtual string Output()

        {

           return _literal.ToString();

        }

    }

    sealed class EqCondition: Condition

    {

       public override string Operator=>"=";

​

       public EqCondition(

           IExpression left,

           IExpression right)

            :base(left,right)

        {

        }

    }

    sealed class BetweenCondition: IExpression

    {

        private readonly IExpression _expression;

        private readonly int _min;

        private readonly int _max;

        public BetweenCondition(

           IExpression expression,

           int min, int max)

        {

            _expression=expression;

            _min=min;

            _max=max;

        }

        public string Output()

        {

            return $"{_expression.Output()} BETWEEN {_min} AND {_max}";

        }

    }

}