package com.ts.rules

case class Point () {
  val values:Map[String,Any] = Map[String,Any]("f1"->1.0,"f2"->"f2","f3"->3.0, "f4"->true,"f5"->"str","f6"->"str")
  def getByName[T](name:String) = values(name).asInstanceOf[T]
}


trait Expression[+T] {
  def eval():T
  def boolEval():Boolean = false
}

trait BoolExpression extends Expression[Boolean] {
  override def boolEval(): Boolean = eval()
}

case class ExtractExpression[T](p:Point, fieldStr:String) extends Expression[T] {
  override def eval(): T = p.getByName(fieldStr)
}

case class ConstExpression[T](value:T) extends Expression[T] {
  override def eval(): T = value

  override def boolEval(): Boolean = value match {
    case v:Boolean => v
    case d:Double => d > 0
    case i:Int => i > 0
    case _ => false
  }
}

case class EqExpression[T](left:Expression[T],right:Expression[T]) extends BoolExpression {
  override def eval(): Boolean = left.eval() == right.eval()

}

case class GtExpression[T](left:Expression[T],right:Expression[T]) extends BoolExpression {
  override def eval(): Boolean = left.eval() match {
    case c1:Double => right.eval() match {
      case  c2:Double=> c1 > c2
      case _ => false
    }
    case _ => false
  }
}

case class OrExpression[T](expressions:Seq[Expression[T]]) extends BoolExpression {
  override def eval(): Boolean =
    expressions.exists(ex => ex.boolEval())

}

case class AndExpression[T](expressions:Seq[Expression[T]]) extends BoolExpression {
  override def eval(): Boolean =
    expressions.map(ex => ex.boolEval()).forall(v=>v)
}


object RulesApp extends  App {

  val p: Point = Point()

  val ev1 = ExtractExpression(p, "f1")
  val ev2 = ConstExpression(1.0)
  val eq1 = EqExpression(ev1, ev2)

  val ev3 = ExtractExpression(p, "f5")
  val ev4 = ExtractExpression(p, "f6")
  val eq2 = EqExpression(ev1, ev2)

  val ev5 = ExtractExpression(p, "f3")
  val ev6 = ExtractExpression(p, "f1")
  val eq3 = GtExpression(ev5, ev6)

  val eqFalse = GtExpression(ev6,ev5) // false

  val and1 = AndExpression(Seq(eq2, eq1, eq3, ConstExpression(true)))

  val or1 = OrExpression(Seq(eq2, eq1, eqFalse, ConstExpression(false)))

  //and1 :
  // "AND" : {
  //          EQ : {
  //                "attr:f3, , attr:f1
  //               }, //true
  //          EQ : {
  //                "attr:f1, , 1.0
  //               }, //true
  //          GT : {
  //                "attr:f3, , attr:f1
  //               }, //true
  //          true
  //          }
  // ALL True !

  println(and1.eval() + "  should be true")


  //or1 :
  // "OR" : {
  //          EQ : {
  //                "attr:f6, , attr:f5
  //               }, //true
  //          EQ : {
  //                "attr:f1, , 1.0
  //               },  //true
  //          GT : {
  //                "attr:f1, , attr:f3 // false
  //               },
  //          false
  //
  // Some True !
  println(or1.eval() + "  should be true")


  //falseList :
  // "AND" : {
  //          GT : {
  //                "attr:f1, , attr:f3
  //               }, //false
  //          EQ : {
  //                "attr:f5, , attr:f6
  //               }, //true
  //          EQ : {
  //                "attr:f1, , 1.0
  //               }, //true
  //          GT : {
  //                "attr:f3, , attr:f1
  //               }, //true
  //          true
  //          }
  // One False -> False

  val falseList = eqFalse :: and1.expressions.toList
  println(AndExpression(falseList).eval()+ " should be false")


}