import akka.actor._
import akka.pattern.{ask, pipe}
import akka.util.Timeout

import scala.concurrent.duration._
import scala.concurrent.{Await, Future, Promise}

def main(): Unit = {
  implicit val system = ActorSystem("system")

  import system.dispatcher

  object Counter {
    sealed trait Message
    case class Inc(i: Int = 1) extends Message
    case object Get extends Message
    case class SetToken(token: String)

    case class Result(token: String, cnt: Int)

    case class Data(token: String, cnt: Int)
  }

  import Counter._

  object TokenService {

    def getToken(): Future[String] = {
      val res = Promise[String]
      system.scheduler.scheduleOnce(1.second)(res.success("myToken"))
      res.future
    }
  }

  class Counter extends Actor with Stash {
    override def preStart(): Unit = {
      super.preStart()
      TokenService.getToken().map(SetToken).pipeTo(self)
    }

    def running(state: Data): Receive = {
      case Inc(i) =>
        context.become(running(state.copy(cnt = state.cnt + 1)))
      case Get =>
        sender() ! Result(state.token, state.cnt)
    }

    def initializing: Receive = {
      case SetToken(token) =>
        unstashAll()
        context.become(running(Data(token, 0)))
      case _ => stash()
    }
    override def receive: Receive = initializing
  }
  implicit val timeout = Timeout(5.seconds)

  class Worker(counter: ActorRef) extends Actor {
    def receive: Receive = {
      case "send" =>
        counter ! Inc()
        context.system.scheduler.scheduleOnce(100.millis)(self ! "send")
      case "get" =>
        val cnt = counter ? Get
        cnt.mapTo[Int].pipeTo(sender())
    }
  }

  val counter: ActorRef = system.actorOf(Props(new Counter))
//  val worker: ActorRef = system.actorOf(Props(new Worker(counter)))


//  worker ! "send"

  counter ! Inc()
  counter ! Inc()
  counter ! Inc()
  counter ! Inc()
  val cnt = counter ? Get

//  Thread.sleep(1000)

//  val cnt: Future[Any] = worker ? "get"
  cnt.mapTo[Result].foreach(i => println(s"count: $i"))

  Await.result(cnt, 5.seconds)

  Await.ready(system.terminate(), 5.seconds)
}

main()