jmonkey-test/src/main/scala/wow/doge/mygame/utils/wrappers/jme/InputManager.scala

package wow.doge.mygame.utils.wrappers.jme
import com.jme3.input.controls.InputListener
import com.jme3.input.controls.Trigger
import com.jme3.{input => jmei}
import enumeratum._
import monix.bio.UIO
import monix.reactive.Observable
import wow.doge.mygame.ActionEvent
import wow.doge.mygame.AnalogEvent
import wow.doge.mygame.EnumActionEvent
import wow.doge.mygame.EnumAnalogEvent
import wow.doge.mygame.implicits._

final class InputManager(val delegate: jmei.InputManager) {

  /**
    * Create a new mapping to the given triggers.
    *
    * <p>
    * The given mapping will be assigned to the given triggers, when
    * any of the triggers given raise an event, the listeners
    * registered to the mappings will receive appropriate events.
    *
    * @param mappingName The mapping name to assign.
    * @param triggers The triggers to which the mapping is to be registered.
    */
  def withMapping(mapping: String, triggers: Trigger*): UIO[Unit] =
    UIO(delegate.withMapping(mapping, triggers: _*)).void

  def withMapping[T <: EnumEntry](
      mapping: T,
      triggers: Trigger*
  ): UIO[Unit] = UIO(delegate.withMapping(mapping, triggers: _*)).void

  def withListener(listener: InputListener, mappings: String*) =
    UIO(delegate.withListener(listener, mappings: _*))

  /**
    * Creates new mappings from the values of the given Enum
    *
    * <p>
    * The given mapping will be assigned to the given triggers, when
    * any of the triggers given raise an event, the listeners
    * registered to the mappings will receive appropriate events.
    *
    * @param mappingName The mapping name to assign.
    * @param mappingFn Function from enum values to the sequence of trigers.
    *
    * @example
    *
    * {{{
    *
    * sealed trait PlayerAnalogMovementInput extends EnumEntry with UpperSnakecase
    * object PlayerAnalogMovementInput extends Enum[PlayerAnalogMovementInput] {
    *  val values = findValues
    *  case object TurnRight extends PlayerAnalogMovementInput
    *  case object TurnLeft extends PlayerAnalogMovementInput
    * }
    *
    * {
    *   inputManager.withEnumMappings(PlayerAnalogMovementInput) {
    *        case PlayerAnalogMovementInput.TurnRight =>
    *          Seq(new KeyTrigger(KeyInput.KEY_RIGHT))
    *        case PlayerAnalogMovementInput.TurnLeft =>
    *          Seq(new KeyTrigger(KeyInput.KEY_LEFT))
    *      }
    * }
    * }}}
    */
  def withEnumMappings[T <: EnumEntry](
      mappingEnum: Enum[T]
  )(mappingFn: T => Seq[Trigger]) =
    UIO(delegate.withEnumMappings(mappingEnum)(mappingFn))

  /**
    *  Create an observable which emits the given mappings as elements of an observable
    *
    * @param mappingNames
    * @return Observable of action events
    *
    * @see [[ActionEvent]]
    * @see [[enumObservableAction]]
    */
  def observableAction(mappingNames: String*): Observable[ActionEvent] =
    delegate.observableAction(mappingNames: _*)

  /**
    *  <p>
    *  Create an observable which emits the values of the given
    *  enum as elements of an observable
    *
    * @param mappingNames
    * @return Observable of enum values
    *
    * @example {{{
    *   inputManager
    *      .enumObservableAction(PlayerMovementInput)
    *      .doOnNext { action =>
    *        action.binding match {
    *          case PlayerMovementInput.WalkLeft => Task {/* your actions */}
    *     }
    *   }
    * }}}
    *
    * @see [[EnumActionEvent]]
    * @see [[enumAnalogObservable]]
    */
  def enumObservableAction[T <: EnumEntry](
      mappingEnum: Enum[T]
  ): Observable[EnumActionEvent[T]] =
    delegate.enumObservableAction(mappingEnum)

  def enumEntryObservableAction[T <: EnumEntry](
      mappingEnumEntry: T
  ) = delegate.enumEntryObservableAction(mappingEnumEntry)

  def analogObservable(mappingNames: String*): Observable[AnalogEvent] =
    delegate.analogObservable(mappingNames: _*)

  def enumAnalogObservable[T <: EnumEntry](
      mappingEnum: Enum[T]
  ): Observable[EnumAnalogEvent[T]] = delegate.enumAnalogObservable(mappingEnum)

  def cursorVisible_=(value: Boolean) = UIO(delegate.setCursorVisible(value))
  def cursorVisible = delegate.isCursorVisible
}