package wow.doge.mygame.actor

import akka.actor.typed.ActorRef
import akka.actor.typed.SpawnProtocol
import akka.actor.typed.scaladsl.ActorContext
import akka.actor.typed.scaladsl.Behaviors
import wow.doge.mygame.implicits._
// import wow.doge.mygame.subsystems.events.EventsModule.GameEventBus
// import wow.doge.mygame.subsystems.events.Event
// import scala.reflect.ClassTag
// import akka.actor.typed.LogOptions
// import wow.doge.mygame.subsystems.events.EventBus
// import scala.concurrent.duration._
// import akka.util.Timeout
// import akka.actor.typed.SupervisorStrategy

object GameActorSystem {
  sealed trait Command
  case class GetSpawnProtocol(
      replyTo: ActorRef[ActorRef[SpawnProtocol.Command]]
  ) extends Command

  class Props() {
    def create =
      Behaviors.setup[Command] { ctx =>
        val systemSpawnProtocol = ctx.spawnN(SpawnProtocol())
        new GameActorSystem(ctx, this, systemSpawnProtocol).receive
      }
  }
}
class GameActorSystem(
    ctx: ActorContext[GameActorSystem.Command],
    props: GameActorSystem.Props,
    sp: ActorRef[SpawnProtocol.Command]
) {
  import GameActorSystem._
  def receive =
    Behaviors.receiveMessage[Command] {
      case GetSpawnProtocol(replyTo) =>
        replyTo ! sp
        Behaviors.same
    }
}

// object EventBusSupervisor {
//   sealed trait Command
//   case class GetMainEventBus(replyTo: ActorRef[GameEventBus[Event]])
//       extends Command
//   case class GetEventBus[T](replyTo: ActorRef[GameEventBus[T]])(implicit
//       classTag: ClassTag[T]
//   ) extends Command {
//     def ct = classTag
//   }

//   class Props(val spawnProtocol: ActorRef[SpawnProtocol.Command]) {
//     def create =
//       Behaviors.setup[Command] { ctx =>
//         new EventBusSupervisor(ctx, this).receive
//       }
//   }
// }
// class EventBusSupervisor(
//     ctx: ActorContext[EventBusSupervisor.Command],
//     props: EventBusSupervisor.Props
// ) {
//   import EventBusSupervisor._
//   implicit val timeout = Timeout(1.second)
//   implicit val sp = props.spawnProtocol
//   def receive =
//     Behaviors.receiveMessage[Command] {
//       case g @ GetEventBus(replyTo) =>
//         implicit val ct = g.ct
//         Behaviors
//           .supervise(EventBus())
//           .onFailure[Exception](
//             SupervisorStrategy.restart.withLimit(2, 100.millis)
//           )
//         Behaviors.same
//       case _ => Behaviors.same
//     }
// }