package wow.doge.mygame.game

import akka.actor.typed.scaladsl.Behaviors
import wow.doge.mygame.state.PlayerMovementState
import com.jme3.scene.Geometry

import wow.doge.mygame.events.EventBus
import wow.doge.mygame.events.Events
import wow.doge.mygame.state.ImMovementActor
import com.jme3.scene.CameraNode
import com.jme3.scene.Node
import com.jme3.renderer.Camera
import wow.doge.mygame.executors.Schedulers
import wow.doge.mygame.game.nodes.PlayerNode
import com.softwaremill.macwire._

import wow.doge.mygame.implicits._

object GameAppActor {
  import Methods._

  sealed trait Command
  case object XD extends Command
  case object Stop extends Command
  def apply(app: GameApp, schedulers: Schedulers) =
    Behaviors.setup[Command] { ctx =>
      ctx.log.info("Hello from GameAppActor")
      // lazy val b = new Box(1, 1, 1)
      // lazy val geom = new Geometry("Box", b)
      // lazy val playerNode = new Node("PlayerNode")
      // lazy val camNode = new CameraNode("CameraNode", app.getCamera())
      // lazy val players = createPlayer(geom, app.getCamera())

      // ctx.pipeToSelf(
      //   app.enqueueF(() => ())(monix.execution.Scheduler.io("aege"))
      // ) {
      //   case x =>
      //     println("SENDEDEEEEEd")
      //     XD
      // }
      // ctx.pipeToSelf(
      //   createPlayer(
      //     geom,
      //     app.getCamera(),
      //     schedulers.jme
      //   )
      // ) {
      //   case x =>
      //     println(x)
      //     XD
      // }
      val subscribingActor = ctx.spawn(SubscribingActor(), "subscriber-1")

      val tickEventBus =
        ctx.spawn(Behaviors.logMessages(EventBus[Events.Tick]()), "eventBus1")

      tickEventBus ! EventBus.Subscribe(subscribingActor)

      tickEventBus ! EventBus.Publish(Events.PhysicsTick, ctx.self)

      // {
      //   app
      //     .getInputManager()
      //     .observableAction("Left")
      //     .map { action =>
      //       action.binding.name match {
      //         case "Left" => Task(println("Pressed left"))
      //       }
      //     }
      // }
      // binding match {
      // case "Left"  =>

      def playerNodeFactory =
        PlayerNode(
          modelPath = os.rel / "Models" / "Jaime" / "Jaime.j3o",
          cam = app.camera
        ) _
      // (assetManager = app.assetManager)
      {
        lazy val playerNode = playerNodeFactory(app.assetManager)

        lazy val actor = ctx.spawn(
          ImMovementActor(ImMovementActor.Props(app, playerNode)),
          "imMovementActor"
        )
        lazy val state = wire[PlayerMovementState]
        app.stateManager.attach(state)
      }

      Thread.sleep(2000)

      app
        .getRootNode()
        .depthFirst(s =>
          // s match {
          //   case node: Node =>
          //     println("node" + s.getName() + " children " + node.getChildren())
          //   case g: Geometry => println(s.getName())
          // }
          println(s.getName())
        )

      println("----------------")

      {
        app
          .getRootNode()
          .observableDepthFirst()
          .map(s => s.getName())
          // .takeWhileInclusive(_.getName() != "level")
          .onErrorHandle(e => e.getMessage())
          .foreach(println)(schedulers.async)

      }

      println("----------------")

      {
        app
          .getRootNode()
          .observableBreadthFirst()
          .map(s => s.getName())
          // .takeWhileInclusive(_.getName() != "level")
          .onErrorHandle(e => e.getMessage())
          .foreach(println)(schedulers.async)

      }

      // app.start()
      // Behaviors.same
      Behaviors.receiveMessage { msg =>
        msg match {
          case XD =>
            ctx.log.info("RECEEEEEIVED")
            ctx.log.info(app.camera.toString())
            Behaviors.same
          case Stop =>
            ctx.log.info("Received stop")
            Behaviors.stopped

        }
      }
    }
}

object Methods {
  def createPlayer(
      geom: Geometry,
      cam: Camera
  ): Node = {
    val playerNode = new Node("PlayerNode")
    lazy val camNode = new CameraNode("CameraNode", cam)
    playerNode
      .child(camNode)
      .child(geom)
    playerNode
  }

  def old() = {
    // val movementActor =
    //   ctx.spawn(
    //     MovementActor(MovementActor.Props(app, geom)),
    //     "movementActor"
    //     // DispatcherSelector.fromConfig("jme-dispatcher")
    //   )

    // val movementActorTimer = ctx.spawn(
    //   MovementActorTimer(movementActor),
    //   "movementActorTimer"
    // )
  }
}

object SubscribingActor {
  def apply() =
    Behaviors.receive[Events.PhysicsTick.type] { (ctx, msg) =>
      ctx.log.debug(s"received event $msg")
      Behaviors.same
    }
}
// new PlayerMovementState(
//   // movementActor,
//   // movementActorTimer,
//   imMovementActor,
//   // geom,
//   // camNode,
//   playerNode
//   // ctx.self
// )