package wow.doge.mygame.game.subsystems.input

import com.jme3.input.InputManager
import wow.doge.mygame.implicits._
import akka.actor.typed.ActorRef
import wow.doge.mygame.events.EventBus
import com.jme3.input.KeyInput
import com.jme3.input.controls.KeyTrigger
import monix.bio.UIO
import wow.doge.mygame.utils.IOUtils._
import wow.doge.mygame.subsystems.events.MovementEvent.PlayerMovementEvent
import scala.concurrent.duration._
import com.jme3.input.controls.MouseAxisTrigger
import com.jme3.input.MouseInput

// class GameInputHandler(
//     inputManager: InputManager
//     // inputEventBus: InputEventBus
// ) {}

object GameInputHandler {

  final case class Props(
      inputManager: InputManager,
      playerMovementEventBus: ActorRef[
        EventBus.Command[PlayerMovementEvent]
      ]
  ) {
    def begin =
      for {
        _ <- UIO(setupKeys(inputManager))
        _ <- toIO(
          generateMovementInputEvents(
            inputManager,
            playerMovementEventBus
          ).completedL.startAndForget
        )
        _ <- toIO(
          generateRotateEvents(
            inputManager,
            playerMovementEventBus
          ).completedL.startAndForget
        )
        _ <- toIO(
          generateCameraEvents(
            inputManager,
            playerMovementEventBus
          ).completedL.startAndForget
        )
      } yield ()
  }

  def setupKeys(inputManager: InputManager) =
    inputManager
      .withMapping(
        "Left",
        new KeyTrigger(KeyInput.KEY_A)
        // new KeyTrigger(KeyInput.KEY_LEFT)
      )
      .withMapping(
        "Right",
        new KeyTrigger(KeyInput.KEY_D)
        // new KeyTrigger(KeyInput.KEY_RIGHT)
      )
      .withMapping(
        "Up",
        new KeyTrigger(KeyInput.KEY_W)
        // new KeyTrigger(KeyInput.KEY_UP)
      )
      .withMapping(
        "Down",
        new KeyTrigger(KeyInput.KEY_S)
        // new KeyTrigger(KeyInput.KEY_DOWN)
      )
      .withMapping(
        "Jump",
        new KeyTrigger(KeyInput.KEY_SPACE)
      )
      .withMapping(
        "ROTATE_RIGHT",
        new KeyTrigger(KeyInput.KEY_RIGHT),
        new MouseAxisTrigger(MouseInput.AXIS_X, true)
      )
      .withMapping(
        "ROTATE_LEFT",
        new KeyTrigger(KeyInput.KEY_LEFT),
        new MouseAxisTrigger(MouseInput.AXIS_X, false)
      )
      .withMapping(
        "CAMERA_UP",
        // new KeyTrigger(KeyInput.KEY_LEFT),
        new MouseAxisTrigger(MouseInput.AXIS_Y, false)
      )
      .withMapping(
        "CAMERA_DOWN",
        // new KeyTrigger(KeyInput.KEY_LEFT),
        new MouseAxisTrigger(MouseInput.AXIS_Y, true)
      )
      .setCursorVisible(false)

  def generateMovementInputEvents(
      inputManager: InputManager,
      playerMovementEventBus: ActorRef[
        EventBus.Command[PlayerMovementEvent]
      ]
  ) = {
    val name = "movementInputEventsGenerator"
    inputManager
      .observableAction(
        "Left",
        "Right",
        "Up",
        "Down",
        "Jump",
        "ROTATE_RIGHT",
        "ROTATE_LEFT"
      )
      // .dump("O")
      .doOnNext { action =>
        action.binding.name match {
          case "Left" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerMovedLeft(pressed = action.value),
                name
              )
            )
          case "Right" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerMovedRight(pressed = action.value),
                name
              )
            )
          case "Up" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerMovedForward(pressed = action.value),
                name
              )
            )
          case "Down" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerMovedBackward(pressed = action.value),
                name
              )
            )

          case "Jump" if action.value =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerJumped,
                name
              )
            )

          case _ => monix.eval.Task.unit
        }
      }
  }

  def generateRotateEvents(
      inputManager: InputManager,
      playerMovementEventBus: ActorRef[
        EventBus.Command[PlayerMovementEvent]
      ]
  ) = {
    val name = "rotateMovementEventsGenerator"
    inputManager
      .analogObservable("ROTATE_RIGHT", "ROTATE_LEFT")
      .sample(1.millis)
      .mapEval(analogEvent =>
        analogEvent.binding.name match {
          case "ROTATE_RIGHT" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerRotatedRight,
                name
              )
            )
          case "ROTATE_LEFT" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerRotatedLeft,
                name
              )
            )
          case _ => monix.eval.Task.unit
        }
      )
  }

  def generateCameraEvents(
      inputManager: InputManager,
      playerMovementEventBus: ActorRef[
        EventBus.Command[PlayerMovementEvent]
      ]
  ) = {
    val name = "cameraMovementEventsGenerator"
    inputManager
      .analogObservable("CAMERA_UP", "CAMERA_DOWN")
      .sample(1.millis)
      .mapEval(analogEvent =>
        analogEvent.binding.name match {
          case "CAMERA_UP" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerCameraUp,
                name
              )
            )
          case "CAMERA_DOWN" =>
            toTask(
              playerMovementEventBus !! EventBus.Publish(
                PlayerMovementEvent.PlayerCameraDown,
                name
              )
            )
          case _ => monix.eval.Task.unit
        }
      )
  }

  // def bindMappings(inputManager: InputManager, mappings: ActionMapping*) = {
  //   inputManager
  //     .observableAction(mappings.map(_.name): _*)
  //     .doOnNext(action =>
  //       mappings.map(m =>
  //         if (action.binding.name == m.name) toTask(m.cb(action))
  //         else monix.eval.Task.unit
  //       )
  //     )
  // }
}

// case class ActionMapping(name: String, cb: ActionEvent => Task[Unit])