package wow.doge.mygame.game

import scala.concurrent.duration._

import akka.actor.typed.ActorRef
import akka.actor.typed.Scheduler
import akka.actor.typed.SpawnProtocol
import akka.util.Timeout
import com.jme3.asset.plugins.ZipLocator
import com.jme3.bullet.BulletAppState
import com.softwaremill.macwire._
import com.softwaremill.tagging._
import io.odin.Logger
import monix.bio.Task
import monix.reactive.Consumer
import wow.doge.mygame.events.EventBus
import wow.doge.mygame.game.nodes.Player
import wow.doge.mygame.game.nodes.PlayerController
import wow.doge.mygame.game.subsystems.input.GameInputHandler
import wow.doge.mygame.game.subsystems.level.DefaultGameLevel
import wow.doge.mygame.implicits._
import wow.doge.mygame.subsystems.events.EntityMovementEvent.PlayerMovementEvent
import wow.doge.mygame.subsystems.movement.ImMovementActor
import wow.doge.mygame.utils.IOUtils
import wow.doge.mygame.math.ImVector3f
import monix.bio.IO
import wow.doge.mygame.subsystems.events.EntityMovementEvent
import akka.actor.typed.ActorSystem
import wow.doge.mygame.subsystems.events.PlayerCameraEvent

class GameSystemsInitializer(
    spawnProtocol: ActorSystem[SpawnProtocol.Command],
    loggerL: Logger[Task],
    // eventBuses: EventsModule2
    playerMovementEventBus: ActorRef[
      EventBus.Command[EntityMovementEvent.PlayerMovementEvent]
    ],
    playerCameraEventBus: ActorRef[EventBus.Command[PlayerCameraEvent]]
)(app: GameApp) {
  implicit val timeout: Timeout = Timeout(1.second)

  import GameSystemsInitializer._

  implicit val akkaScheduler: Scheduler = spawnProtocol.scheduler
  lazy val inputManager = app.inputManager
  lazy val assetManager = app.assetManager
  lazy val bulletAppState = new BulletAppState()
  // lazy val playerMovementEventBus = eventBuses.playerMovementEventBusTask

  val init =
    for {
      _ <- loggerL.info("Initializing Systems")
      // playerMovementEventBus <- playerMovementEventBusTask
      _ <- Task(app.stateManager.attach(bulletAppState))
      _ <- Task(
        app.assetManager.registerLocator(
          // "src/main/resources/assets/town.zip",
          (os.rel / "src" / "main" / "resources" / "assets" / "town.zip"),
          classOf[ZipLocator]
        )
      )
      _ <- app.enqueueL(() => DefaultGameLevel(app, bulletAppState))
      _ <- wireWith(createPlayerController _).startAndForget
      _ <- wire[GameInputHandler.Props].begin

    } yield ()

  def createPlayerController(
      // playerMovementEventBus: ActorRef[
      //   EventBus.Command[PlayerMovementEvent]
      // ],
      // playerCameraEventBus: ActorRef[EventBus.Command[PlayerCameraEvent]]
  ): IO[PlayerController.Error, Unit] = {
    val playerPos = ImVector3f.ZERO
    val playerNode = None.taggedWith[Player]
    val modelPath = os.rel / "Models" / "Jaime" / "Jaime.j3o"
    wire[PlayerController.Props].create
  }
}

object GameSystemsInitializer {

  def playerMovementActorTickConsumer(
      playerMovementActor: ActorRef[ImMovementActor.Command]
  ) =
    Consumer
      .foreachTask[Float](tpf =>
        IOUtils.toTask(playerMovementActor !! ImMovementActor.Tick)
      )
  // .mapTask()
}