jmonkey-test/src/main/scala/wow/doge/mygame/MainApp.scala

package wow.doge.mygame

import akka.actor.typed.ActorRef
import akka.actor.typed.ActorSystem
import akka.actor.typed.Scheduler
import akka.actor.typed.SpawnProtocol
import akka.util.Timeout
import cats.effect.concurrent.Ref
import com.jme3.app.state.AppStateManager
import com.jme3.asset.AssetManager
import com.jme3.asset.plugins.ZipLocator
import com.jme3.bullet.BulletAppState
import com.jme3.input.InputManager
import com.jme3.renderer.Camera
import com.jme3.scene.Node
import com.softwaremill.macwire._
import com.softwaremill.tagging._
import io.odin.Logger
import monix.bio.IO
import monix.bio.Task
import wow.doge.mygame.events.EventBus
import wow.doge.mygame.game.GameApp2
import wow.doge.mygame.game.nodes.PlayerTag
import wow.doge.mygame.game.nodes.PlayerController
import wow.doge.mygame.game.subsystems.input.GameInputHandler
import wow.doge.mygame.implicits._
import wow.doge.mygame.math.ImVector3f
import wow.doge.mygame.subsystems.events.EntityMovementEvent
import wow.doge.mygame.subsystems.events.EventsModule2
import wow.doge.mygame.subsystems.events.PlayerCameraEvent
import wow.doge.mygame.game.subsystems.level.DefaultGameLevel
import com.jme3.renderer.ViewPort
import wow.doge.mygame.subsystems.scriptsystem.ScriptSystemResource
import wow.doge.mygame.subsystems.scriptsystem.ScriptInitMode
import wow.doge.mygame.launcher.Launcher
import wow.doge.mygame.executors.Schedulers
import scalafx.application.JFXApp.PrimaryStage
import scalafx.geometry.Insets
import scalafx.scene.Scene
import scalafx.scene.control.Button
import scalafx.scene.layout.StackPane
import scalafx.scene.paint.Color
import scalafx.scene.shape.Rectangle
import scalafx.Includes._
import scala.concurrent.duration._
import cats.effect.concurrent.Deferred
import monix.bio.Fiber
import wow.doge.mygame.launcher.Launcher.LauncherResult
import scalafx.scene.control.TextArea
import com.jayfella.jme.jfx.JavaFxUI
import wow.doge.mygame.utils.GenericConsoleStream
import java.io.PrintStream

class MainApp(
    logger: Logger[Task],
    gameApp: GameApp2,
    spawnProtocol: ActorSystem[SpawnProtocol.Command],
    jmeThread: monix.execution.Scheduler,
    schedulers: Schedulers,
    consoleStream: GenericConsoleStream[TextArea]
)(implicit
    @annotation.unused timeout: Timeout,
    @annotation.unused scheduler: Scheduler
) {

  lazy val scriptSystemInit =
    new ScriptSystemResource(os.pwd, spawnProtocol, ScriptInitMode.Eager).init

  def gameInit: Task[Fiber[Throwable, Unit]] =
    for {
      eventsModule <- Task(new EventsModule2(spawnProtocol))
      playerMovementEventBus <- eventsModule.playerMovementEventBusTask
      playerCameraEventBus <- eventsModule.playerCameraEventBusTask
      gameAppFib <- gameApp.start.executeOn(jmeThread).start
      /**
        * schedule a task to run on the JME thread and wait for it's completion
        * before proceeding forward, as a signal that JME thread has been
        * initialized, otherwise we'll get NPEs trying to access the fields
        * of the game app
        */
      res <- gameApp.enqueueL(() => Task("done")).flatten

      _ <- logger.info(s"Result = $res")
      inputManager <- gameApp.inputManager
      assetManager <- gameApp.assetManager
      stateManager <- gameApp.stateManager
      camera <- gameApp.camera
      rootNode <- gameApp.rootNode
      enqueueR <- Task(gameApp.enqueue _)
      viewPort <- gameApp.viewPort
      _ <- logger.info("before")
      // jfxUI <- Task(JavaFxUI.initialize(gameApp.app))
      //   .executeOn(gameApp.scheduler) >> Task.sleep(500.millis) >> Task(
      //   JavaFxUI.getInstance()
      // )
      // .start
      jfxUI <- gameApp.jfxUI
      consoleTextArea <- Task(new TextArea {
        text = "hello"
        editable = false
        wrapText = true
        // maxHeight = 150
        // maxWidth = 300
      })
      _ <- Task(consoleStream := consoleTextArea)
      _ <- Task(jfxUI += consoleTextArea)
      // consoleStream <- Task(
      //   GenericConsoleStream.textAreaStream(consoleTextArea)
      // )
      _ <- logger.info("after")
      bulletAppState <- Task(new BulletAppState())
      _ <- Task(stateManager.attach(bulletAppState))
      _ <- logger.info("Initializing console stream")
      // _ <- Task(GenericConsoleStream.textAreaStream(consoleTextArea)).bracket(
      //   consoleStream =>
      //     Task { System.setOut(consoleStream) } >> wire[MainAppDelegate]
      //       .init(gameApp.scheduler, consoleStream)
      //   // consoleLogger
      //   // Console.withOut(consoleStream)(
      //   // wire[MainAppDelegate].init(gameApp.scheduler, consoleStream)
      //   // )
      // )(stream => Task(stream.close()).onErrorHandle(_.printStackTrace()))
      // _ <- Task { System.setOut(new PrintStream(consoleStream, true)) }
      // _ <- Task {
      //   Console.withOut(consoleStream)(println("hello"))
      // }
      _ <- wire[MainAppDelegate].init(gameApp.scheduler)
    } yield (gameAppFib)

  lazy val program = for {
    scriptSystem <- scriptSystemInit
    /**
      * Signal for synchronization between the JavaFX launcher and the in-game JavaFX GUI
      * Without this, we get a "Toolkit already initialized" excResult. The launch button
      * in the launcher completes the signal. The game init process which listens for this
      * signal can then continue
      */
    launchSignal <- Deferred[Task, Launcher.LauncherResult]
    launcher <- new Launcher.Props(schedulers, launchSignal).create
    cancelToken <- launcher.init()
    launchResult <- launchSignal.get
    _ <- cancelToken.cancel
    _ <-
      if (launchResult == LauncherResult.Exit)
        logger.info("Exiting")
      else gameInit.flatMap(_.join)
    // _ <- Task.sleep(2000.millis)
    // gameAppFib <- gameInit
    /**
      * Wait for game window to close
      */
    // _ <- gameAppFib.join
  } yield ()
}

/**
  * Class with all dependencies in one place for easy wiring
  */
class MainAppDelegate(
    gameApp: GameApp2,
    spawnProtocol: ActorSystem[SpawnProtocol.Command],
    loggerL: Logger[Task],
    // eventBuses: EventsModule2
    playerMovementEventBus: ActorRef[
      EventBus.Command[EntityMovementEvent.PlayerMovementEvent]
    ],
    playerCameraEventBus: ActorRef[EventBus.Command[PlayerCameraEvent]],
    inputManager: InputManager,
    assetManager: AssetManager,
    stateManager: AppStateManager,
    camera: Camera,
    viewPort: ViewPort,
    enqueueR: Function1[() => Unit, Unit],
    rootNode: Ref[Task, Node],
    bulletAppState: BulletAppState
)(implicit
    @annotation.unused timeout: Timeout,
    @annotation.unused scheduler: Scheduler
) {

  def init(
      appScheduler: monix.execution.Scheduler
      // consoleStream: GenericConsoleStream[TextArea]
  ) =
    for {
      _ <- loggerL.info("Initializing Systems")
      _ <- Task(
        assetManager.registerLocator(
          (os.rel / "assets" / "town.zip"),
          classOf[ZipLocator]
        )
      )
      _ <- loggerL.info("test hmm")
      // _ <- Task(consoleStream.println("text"))
      _ <- DefaultGameLevel(assetManager, viewPort)
        .addToGame(
          rootNode,
          bulletAppState.physicsSpace
        )
        .executeOn(appScheduler)
      _ <- createPlayerController(appScheduler).startAndForget.onErrorRestart(3)
      _ <- wire[GameInputHandler.Props].begin.onErrorRestart(3)
    } yield ()

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