package wow.doge.mygame.game

import akka.actor.typed.ActorRef
import akka.actor.typed.SpawnProtocol
import cats.effect.Resource
import com.jme3.app.StatsAppState
import com.jme3.system.AppSettings
import io.odin.Logger
import monix.bio.Fiber
import monix.bio.IO
import monix.bio.Task
import monix.execution.Scheduler
import wow.doge.mygame.executors.Schedulers
import wow.doge.mygame.game.subsystems.input.GameInputHandler
class GameAppResource(
    logger: Logger[Task],
    jmeScheduler: Scheduler,
    schedulers: Schedulers
) {
  def get2: Resource[Task, (GameApp2, Fiber[Throwable, Unit])] =
    Resource.make(
      for {
        _ <- logger.info("Creating game app")
        app <- Task(new GameApp(schedulers, new StatsAppState()))
        app2 <- Task {
          val settings = new AppSettings(true)
          settings.setVSync(true)
          settings.setUseInput(true)
          // new FlyCamAppState
          // settings.setFrameRate(250)
          app.setSettings(settings)
          // JMERunner.runner = app
          // app
          new GameApp2(app)
        }
        fib <- app2.start.executeOn(jmeScheduler).start
      } yield (app2 -> fib)
    )(logger.info("Closing game app") >> _._2.cancel)

  def get: Resource[Task, GameApp2] =
    Resource.make(
      for {
        _ <- logger.info("Creating game app")
        app <- Task(new GameApp(schedulers, new StatsAppState()))
        app2 <- Task {
          val settings = new AppSettings(true)
          settings.setVSync(true)

          /**
            * disables the launcher
            * We'll be making our own launcher anyway
            */
          app.setShowSettings(false)
          app.setSettings(settings)
          // JMERunner.runner = app
          new GameApp2(app)
        }
        // fib <- app2.start.executeOn(jmeScheduler).start
      } yield (app2)
    )(_ => logger.info("Closing game app"))
}

trait GameModule {

  def gameAppResource(
      logger: Logger[Task],
      jmeScheduler: Scheduler,
      schedulers: Schedulers
  ): Resource[Task, (GameApp, Fiber[Throwable, Unit])] =
    Resource.make(
      (for {
        _ <- logger.info("Creating game app")
        app <- Task(new GameApp(schedulers))
        _ <- Task {
          val settings = new AppSettings(true)
          settings.setVSync(true)
          // settings.setFrameRate(250)
          app.setSettings(settings)
          // JMERunner.runner = app
          app
        }
        fib <- Task(app.start()).executeOn(jmeScheduler).start
      } yield (app -> fib))
    )(_._2.cancel)

  def inputHandlerSystemResource(
      props: GameInputHandler.Props
  ): Resource[Task, Task[Unit]] =
    Resource.liftF {
      Task.evalAsync(props.begin)
    }
  def gameSystemsResource(
      spawnProtocol: ActorRef[SpawnProtocol.Command],
      gameSystems: Task[Unit]*
  ): Resource[Task, List[Unit]] =
    Resource.liftF(IO.defer(Task.parSequence(gameSystems)))
}