package controllers

import scala.concurrent.duration._
import scala.concurrent._
import akka.actor.{Actor, Props, ActorRef}
import play.api.libs.concurrent.Akka
import play.api.libs.concurrent.Execution.Implicits._
import play.api.libs.iteratee._
import play.api.libs.concurrent._
import akka.util.Timeout
import akka.pattern.ask

case class Join()
case class SendMsg()
case class Connected(
  enumerator: Enumerator[String]
	)
case class Ready()

object TestActor {
	implicit val timeout = Timeout(1 second)
import play.api.Play.current
	def join(actorName:String):Future[Enumerator[String]] = {
		val joiningActor = Akka.system.actorFor("*/actor"+actorName)
		(joiningActor ? Join()) map {
			case Connected(enumerator) =>
				println("connectede")
				enumerator
		}
	}

}

class TestActorGenerator(actorName:String) extends Actor {
	val (actorEnumerator, actorChannel) = Concurrent.broadcast[String]
	import play.api.Play.current

	def receive = {
		case Join() => {
			sender ! Connected(actorEnumerator)
		}
		case SendMsg() => {
			actorChannel.push(actorName + " sent message ")
		}
	}

}

class TestActorConsumer(name:String, actorRef:ActorRef) extends Actor {
	import play.api.Play.current
	implicit val timeout = Timeout(1 seconds)

	val enum = (actorRef ? Join()) map {
		case Connected(enumerator) =>
			println("Consumer hooked up")
			enumerator |>> Iteratee.foreach[String] { str => println(name + " caught " + str)}
	}


	def apply() {
	}

	def receive = {
		case Join() => {}
	}
}
case class Add(actor:ActorRef)
class TestActorPanelConsumer(name:String, actorRefA:ActorRef, actorRefB:ActorRef) extends Actor {
	import play.api.Play.current
	import scala.collection.mutable.Seq
	implicit val timeout = Timeout(1 seconds)
	var p:Concurrent.PatchPanel[String]=null
	val outEnum = Concurrent.patchPanel[String]{patcher => 
		p = patcher
	}
	var enums:Seq[Enumerator[String]] = Seq()

	def apply() {
		println (outEnum)
	}

	def receive = {
		case Join() => {
			sender ! Connected(outEnum)
		}
		case Add(actor) => {
			println("Adding " + actor toString)
			
			(actor ? Join()) map {
				case Connected(enumerator) => {
					enums = enums :+ enumerator
					p.patchIn(Enumerator.interleave[String](enums))
				}
			}
		}
		case Connected(enumerator) => {
					enums = enums :+ enumerator
          //Combines the enumerators together, then swaps it in to the patch panel
					p.patchIn(Enumerator.interleave[String](enums))
		}
	}
}