using System;

using UnityEngine;

using Framework.Input.Profiles;
using Framework.State;
using Framework.Services;

namespace Framework.Actors.Shooter {

  /// <summary>Lets the player to control a character's head via an HMD</summary>
  [RequireComponent(typeof(HeadPoser))]
  public class VirtualRealityHeadController : ScriptComponent, IHeadController {

    #region enum RecenterState

    /// <summary>State of the recenter functionality</summary>
    private enum RecenterState {

      /// <summary>The neutral position is not yet known</summary>
      NeutralPositionUnknown,
      /// <summary>A recenter has already been scheduled</summary>
      RecenterScheduled,
      /// <summary>Neutral position is known, a recenter is possible at any time</summary>
      RecenterPossible

    }

    #endregion // enum RecenterState

    /// <summary>Fired to pass on head rotation that was clamped</summary>
    public event Action<Quaternion> ExcessHeadRotation;

    /// <summary>Input profiles in which the virtual reality head controller is enabled</summary>
    public InputSources EnabledInputProfiles = InputSources.VirtualReality;

    /// <summary>Camera through which the player is looking</summary>
    /// <remarks>>
    ///   Enabling VR in Unity will cause the camera to move around according to where
    ///   the player's head is. So we need to take the position from this camera
    ///   and pose the character accordingly.
    /// </remarks>
    public Camera EyeCamera;

    /// <summary>
    ///   Calibrates the current HMD position so it matches the animation clip's head position
    /// </summary>
    /// <remarks>
    ///   This method only works if an animator is active on the actor, posing
    ///   the its head to its intended position before LateUpdate() is called on
    ///   this component. If you call it on an actor without an active animator
    ///   (or having posed the actor's head back into a neutral stance prior to
    ///   LateUpdate()), the results will not be pretty.
    /// </remarks>
    public void Recenter() {
      if(this.recenterState == RecenterState.RecenterPossible) {
        Recenter(
          this.neutralHeadPosition + this.headPoser.EyeOffset,
          this.neutralHeadOrientation
        );
      } else {
        this.recenterState = RecenterState.RecenterScheduled;
      }
    }

    /// <summary>
    ///   Calibrates the current HMD position so it matches the specified transform
    /// </summary>
    /// <param name="position">
    ///   Position at which the current HMD position should place the camera
    /// </param>
    /// <param name="orientation">
    ///   Orientation in which the current HMD orientation shoudl leave the camera
    /// </param>
    /// <remarks>
    ///   <para>
    ///     This is similar to what <see cref="UnityEngine.VR.InputTracking.Recenter" />
    ///     is supposed to do, but works with "room-scale experience," too (why should
    ///     players who <em>can</em> do room-scale VR not be able to just sit on their
    ///     chair and control a simple head?)
    ///   </para>
    /// </remarks>
    public void Recenter(Vector3 position, Quaternion orientation) {
      Transform eyeCameraTransform = this.EyeCamera.transform;
      Transform cameraRootTransform = eyeCameraTransform.parent;

      // The camera's parent transform needs to be an empty, intermediate transform
      // to do this. Log a warning if it isn't.
      warnIfCameraRootNotEmpty(cameraRootTransform);

      // Unity's InputTracker writes the world transform of the HMD into the local
      // transform of the camera game object. We need the current orientation to become
      // the orientation specified by the caller.
      Quaternion hmdRotation = eyeCameraTransform.localRotation;
      Quaternion compensationOrientation = Quaternion.Inverse(hmdRotation);
      cameraRootTransform.rotation = orientation * compensationOrientation;

      // Figure out the translation at which the HMDs current position would place
      // its camera at the requested world coordinates
      Vector3 hmdPosition = eyeCameraTransform.localPosition;
      Vector3 compensationPosition = orientation * compensationOrientation * -hmdPosition;
      cameraRootTransform.position = compensationPosition + position;
    }

    /// <summary>Injects the instance's dependencies</summary>
    /// <param name="inputSelector">
    ///   Input selector the instance uses to determine the active input source
    /// </param>
    /// <remarks>
    ///   This method is called automatically by the services framework. Any parameters
    ///   it requires will be filled out by looking up the respective services and creating
    ///   them as needed.
    /// </remarks>
    protected void Inject(IInputSelector inputSelector) {
      this.inputSelector = inputSelector;
    }

    /// <summary>Called when the component has been added to a game object</summary>
    protected override void Awake() {
      base.Awake();

      // This implementation exclusively uses the head poser to change
      // the orientation of the actor's head
      this.headPoser = GetComponent<HeadPoser>();
      if (this.headPoser == null) {
        Debug.LogError(
          "Virtual reality head controller assigned to '" + gameObject.name + "' found " +
          "no head poser component and will not work."
        );
      }

      // The HeadMovementRange component is shared between all head controllers
      // to define the limits within which the actor can move its head
      this.headMovementRange = GetComponent<HeadMovementRange>();
      if(this.headMovementRange == null) {
        this.headMovementRange = gameObject.AddComponent<HeadMovementRange>();
      }

      if (this.EyeCamera == null) {
        this.EyeCamera = GetComponentInChildren<Camera>();
        if (this.EyeCamera == null) {
          Debug.LogError(
            "Virtual reality head controller assigned to '" + gameObject.name + "' has " +
            "no camera assigned and could not find a camera on its own, thus will not work."
          );
        }
      }

      this.controllable = GetComponentInParent<IControllable>();
    }

    /// <summary>Called once per physics frame to advance the simulate</summary>
    protected virtual void FixedUpdate() {

      // If the player doesn't control this actor, don't do head movement.
      if(this.controllable != null) {
        if(this.controllable.ControllingPlayerIndex == -1) {
          return;
        }
      }

      // If the active input profile doesn't use mouse look, don't do anything.
      if((this.inputSelector.ActiveSource & this.EnabledInputProfiles) == 0) {
        return;
      }

      // Record the target position and orientation for the head
      Transform eyeCameraTransform = this.EyeCamera.transform;
      this.posedHeadPosition = eyeCameraTransform.position;
      this.posedHeadOrientation = eyeCameraTransform.rotation;

      // If the head has moved too far, clamp it into its movement range
      clampHeadRotation();

    }

    /// <summary>Reports head rotation beyond the allowed range </summary>
    private void clampHeadRotation() {

      float headPitch, headYaw;
      {
        Quaternion localHeadOrientation = (
          Quaternion.Inverse(this.headPoser.GetBaseOrientation()) * this.posedHeadOrientation
        );
        Vector3 headEulers = localHeadOrientation.eulerAngles;

        if(headEulers.x >= 180.0f) {
          headPitch = headEulers.x - 360.0f;
        } else {
          headPitch = headEulers.x;
        }
        if(headEulers.y >= 180.0f) {
          headYaw = headEulers.y - 360.0f;
        } else {
          headYaw = headEulers.y;
        }
      }

      float excessHeadPitch = headPitch;
      float excessHeadYaw = headYaw;

      this.headMovementRange.ClampPitchAndYaw(ref headPitch, ref headYaw);

      excessHeadPitch -= headPitch;
      excessHeadYaw -= headYaw;
      
      // Report the excess rotation
      bool excessRotationPresent = (
        (Math.Abs(excessHeadPitch) >= float.Epsilon) ||
        (Math.Abs(excessHeadYaw) >= float.Epsilon)
      );
      if(excessRotationPresent) {
        OnExcessHeadRotation(
          Quaternion.AngleAxis(excessHeadYaw, Vector3.up) *
          Quaternion.AngleAxis(excessHeadPitch, Vector3.right)
        );
        matchHeadToHmd();
      }

    }

    /// <summary>Called once per physics frame</summary>
    protected virtual void LateUpdate() {

      // If the player doesn't control this actor, don't do head movement.
      if(this.controllable != null) {
        if(this.controllable.ControllingPlayerIndex == -1) {
          return;
        }
      }

      // If the active input profile doesn't use mouse look, don't do anything.
      if((this.inputSelector.ActiveSource & this.EnabledInputProfiles) == 0) {
        return;
      }

      // If the head poser component is missing, we can't do anything
      // (a warning will have been logged when the component was initialized).
      if(this.headPoser == null) {
        return;
      }

      // Record the neutral head position as it was left by the animator
      // If no animation clip is playing, this will be useless and result in
      // a spectacular mess if recentering is attempted :-)
      this.neutralHeadPosition = this.headPoser.Head.position;
      this.neutralHeadOrientation = this.headPoser.Head.rotation;

      // The animation update takes place after Update() but before LateUpdate(),
      // so at this point we can pick up the position of the head as it is
      // in the current animation clip. This position is important if the player
      // wishes to recenter the HMD.
      if(this.recenterState == RecenterState.RecenterScheduled) {
        this.recenterState = RecenterState.RecenterPossible;
        Recenter();
      } else {
        this.recenterState = RecenterState.RecenterPossible;
      }

      matchHeadToHmd();

    }

    /// <summary>Fires the <see cref="ExcessHeadRotation" /> event</summary>
    /// <param name="excessRotation">
    ///   Excess rotation that will be reported through the event
    /// </param>
    protected virtual void OnExcessHeadRotation(Quaternion excessRotation) {
      if(ExcessHeadRotation != null) {
        ExcessHeadRotation(excessRotation);
      }
    }

    /// <summary>Matches the position and orientation of the head to the HMD's</summary>
    private void matchHeadToHmd() {

      // The head position and orientation have been queried during FixedUpdate(),
      // but to make extra sure we've got fresh data (any lag would be very noticable
      // and lead to dizzyness for VR glasses) we update the state once more here.
      Transform eyeCameraTransform = this.EyeCamera.transform;
      this.posedHeadPosition = eyeCameraTransform.position;
      this.posedHeadOrientation = eyeCameraTransform.rotation;

      // Match the actor's head to the direction and position of the player's
      // head in the real world.
      this.headPoser.Pose(this.posedHeadPosition, this.posedHeadOrientation);

    }

    /// <summary>Logs a warning if the eye camera's parent transform is not empty</summary>
    /// <param name="cameraRootTransform">Parent transform that will be checked</param>
    private static void warnIfCameraRootNotEmpty(Transform cameraRootTransform) {
      Component[] components = cameraRootTransform.GetComponents<Component>();
      int componentCount = components.Length;
      if(componentCount > 1) {
        Debug.LogWarning(
          "VirtualRealityHeadController was told to do a re-center. This requires " +
          "the camera to be parented to an intermediate empty game object that can " +
          "be moved into the new anchor position. The camera's parent game object " +
          "does not appear to be empty. Re-centering might introduce unwanted transforms."
        );
      }
    }

    /// <summary>Transform to which the virtual reality camera is parented</summary>
    Transform IHeadController.VirtualRealityCameraRoot {
      get { return this.EyeCamera.transform.parent; }
    }

    /// <summary>Base transform in which the player controls the look direction</summary>
    Quaternion IHeadController.HeadBaseOrientation {
      get {
        if(this.headPoser == null) {
          return Quaternion.identity;
        } else {
          return this.headPoser.GetBaseOrientation();
        }
      }
    }

    /// <summary>Where the player is looking within the head's coordinate space</summary>
    /// <remarks>
    ///   Append this rotation to the <see cref="IHeadController.HeadBaseOrientation" /> to
    ///   get the direction the player is looking at in the global coordinate frame.
    /// </remarks>
    Quaternion IHeadController.LocalHeadOrientation {
      get {
        return (
          Quaternion.Inverse(this.headPoser.GetBaseOrientation()) * this.posedHeadOrientation
        );
      }
      set {
        Transform eyeTransform = this.EyeCamera.transform;

        Recenter(eyeTransform.position, this.headPoser.GetBaseOrientation() * value);
      }
    }

    /// <summary>Whether this look handler is part of the active input profile</summary>
    /// <remarks>
    ///   It is not unusual for actors to have multiple head controllers. For example,
    ///   there might be a mouse look head controller and a virtual reality head controller
    ///   that are switched between depending on the input profile the game runs with.
    ///   This property allows the actor controller to figure out which one to talk to.
    /// </remarks>
    bool IHeadController.IsActive {
      get {
        if(this.controllable != null) {
          if(this.controllable.ControllingPlayerIndex == -1) {
            return false;
          }
        }
        return ((this.inputSelector.ActiveSource & this.EnabledInputProfiles) != 0);
      }
    }

    /// <summary>Input selector from which the active input source will be queried</summary>
    private IInputSelector inputSelector;
    /// <summary>Tracks, if present, whether the player is controlling this actor</summary>
    private IControllable controllable;

    /// <summary>Head poser the mouse look controller uses to move the head</summary>
    private HeadPoser headPoser;
    /// <summary>Controls how far the head can be moved on each axis</summary>
    private HeadMovementRange headMovementRange;
    /// <summary>Current state of the recenter functionality</summary>
    private RecenterState recenterState;

    /// <summary>Position of the head when it is neutral</summary>
    private Vector3 neutralHeadPosition;
    /// <summary>Orientation of the head when it is neutral</summary>
    private Quaternion neutralHeadOrientation;

    /// <summary>Current (global) position of the actor's head</summary>
    private Vector3 posedHeadPosition;
    /// <summary>Current (global) orientation of the actor's head</summary>
    private Quaternion posedHeadOrientation;

  }

} // namespace Framework.Actors.Shooter