import scala.collection.mutable.{Queue, ArrayBuffer, Map}

object DSL {

  abstract class Condition[A,C] {
    def holds(a: A, ctx: C): Boolean
  }
  
  class Operator(val id: Long){

    var lastCall = -1L
    
    var commands = Queue[String]()
    
    def run(f: String => Unit) {
      lastCall = System.currentTimeMillis()
      commands.foreach(f(_))
      commands.clear()
    }
    
    def logOut() {
      println("logging out");
    }
  
    override def toString = new StringBuilder()
      .append("Operator(id=")
      .append(id)
      .append(")")
      .toString()
  
  }

  class OperatorConfig(val timeOut: Long)
  
  class ProcessorConfig(val latencyThreshold: Long)
  
  class ProcessorState(var latency: Long)


  class WhenClause[A,C](val body: A => Unit, val condition: Condition[A,C]) {
    private var _otherwise = (a: A) => {}
    
    def otherwise(f: A => Unit) {
      _otherwise = f
    }

    def otherwise(a: A) {
      _otherwise(a)
    }
  }

  abstract class Processor(val operatorConfig: OperatorConfig, val processorConfig: ProcessorConfig) {

    private val operators = Map[Long, Operator]()
    
    private val processorConditions = ArrayBuffer[WhenClause[ProcessorState,ProcessorConfig]]()

    private val operatorConditions = ArrayBuffer[WhenClause[Operator, OperatorConfig]]()


    var state = new ProcessorState(100)
    
    def addOperator(o: Operator)  {
      o.lastCall = System.currentTimeMillis()
      operators += ((o.id, o))
    }
    
    def publishCommand(id: Long, cmd: String) {

      operators.get(id).map{_.commands += cmd}

    }
    
    def when(c: Condition[ProcessorState, ProcessorConfig])(f: => Unit) = {
      val body: ProcessorState => Unit = s => { f }
      val clause = new WhenClause(body, c)
      processorConditions += clause
      clause
    }

    def when(c: Condition[Operator,OperatorConfig])(f: Operator => Unit) = {
      val clause = new WhenClause(f, c)
      operatorConditions += clause
      clause
    }

    def update() {

      for (c <- processorConditions) {
        if (c.condition.holds(state, processorConfig)) {
          c.body(state)
        }
      }
      
      for ((id, o) <- operators) {
        for (oc <- operatorConditions) {
          if (oc.condition.holds(o, operatorConfig)) {
            oc.body(o)
          } else {
            oc.otherwise(o)
          }
        }
      }
      
    }
  }


  object OperatorTimedOut extends Condition[Operator, OperatorConfig] {

    def holds(a: Operator, ctx: OperatorConfig) = {
      System.currentTimeMillis() - a.lastCall > ctx.timeOut
    }
  }

  object OperatorReceivedCommand extends Condition[Operator, OperatorConfig] {
    def holds(a: Operator, cfg: OperatorConfig) = {
      !a.commands.isEmpty
    }
  }

  object HighLatency extends Condition[ProcessorState, ProcessorConfig] {
    
    def holds(a: ProcessorState, ctx: ProcessorConfig) = {
      a.latency > ctx.latencyThreshold
    }
  }

}