case class Field[A](name: String) {
  def ===(value: A): Tree = Equals(this, value)
  def !==(value: A): Tree = NotEquals(this, value)
  def <(value: A): Tree = LessThan(this, value)
  def >(value: A): Tree = GreaterThan(this, value)
  def >=(value: A): Tree = GreaterOrEqual(this, value)
  def <=(value: A): Tree = LessOrEqual(this, value)
}

sealed trait Tree { self =>
  def &&(t: Tree): Tree = and(t)
  def and(t: Tree): Tree = And(self, t)
  def ||(t: Tree): Tree = or(t)
  def or(t: Tree): Tree = Or(self, t)
}
sealed trait Operator extends Tree { def left: Tree; def right: Tree}
case class Or(left: Tree, right: Tree) extends Operator
case class And(left: Tree, right: Tree) extends Operator
sealed trait Operand[+A] extends Tree { def field: Field[_]; def value: A }
case class GreaterOrEqual[A](field: Field[A], value: A) extends Operand[A]
case class GreaterThan[A](field: Field[A], value: A) extends Operand[A]
case class LessOrEqual[A](field: Field[A], value: A) extends Operand[A]
case class LessThan[A](field: Field[A], value: A) extends Operand[A]
case class Equals[A](field: Field[A], value: A) extends Operand[A]
case class NotEquals[A](field: Field[A], value: A) extends Operand[A]

object QueryObjects {
  object Test {
    object name extends Field[String]("name")
    object age extends Field[Int]("age")
    object shoesize extends Field[Int]("shoesize")
    object showsize extends Field[Int]("showsize")
  }
}

object QueryApp extends App {
  import QueryObjects._

  def query = (Test.name === "Zandre") and (Test.age > 21) or ((Test.shoesize < 12) and (Test.showsize >= 22))

  println(query)

  def interpreter(q: Tree): MongoDBObject = {
    def loop(q: Tree, acc: MongoDBObject): Imports.DBObject = q match {
      case Or(left, right) => acc ++ $or(loop(left, MongoDBObject()), loop(right, MongoDBObject()))
      case And(left, right) => acc ++ $and(loop(left, MongoDBObject()), loop(right, MongoDBObject()))
      case Equals(f, v: Int) => f.name $eq v
      case Equals(f, v: String) => f.name $eq v
      case GreaterOrEqual(f, v: Int) => f.name $gte v
      case GreaterThan(f, v: Int) => f.name $gt v
      case LessOrEqual(f, v: Int) => f.name $lte v
      case LessThan(f, v: Int) => f.name $lt v
      case NotEquals(f, v: Int) => f.name $ne v
      case NotEquals(f, v: String) => f.name $ne v
      case _ => throw new UnsupportedOperationException()
    }
    loop(q,MongoDBObject())
  }

  println(interpreter(query))

  val q1 = Test.name === "tester"
  println(q1)
  println(interpreter(q1))

}


// output -----
---------------
Or(And(Equals(Field(name),Zandre),GreaterThan(Field(age),21)),And(LessThan(Field(shoesize),12),GreaterOrEqual(Field(showsize),22)))

{ "$or" : [ { "$and" : [ { "name" : "Zandre"} , { "age" : { "$gt" : 21}}]} , { "$and" : [ { "shoesize" : { "$lt" : 12}} , { "showsize" : { "$gte" : 22}}]}]}

Equals(Field(name),tester)

{ "name" : "tester"}