using System;

using UnityEngine;

using Framework.Services;
using Framework.State;

namespace Framework.Actors {

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

    /// <summary>Fired to pass on head rotation that was clamped</summary>
    /// <remarks>
    ///   This is not used by the AI head controller. If the AI can't look at
    ///   something (without turning its body), it won't. This is debatable,
    ///   but turning an AI's body would introduce a lot of complexity into
    ///   the steering code.
    /// </remarks>
    event Action<Quaternion> IHeadController.ExcessHeadRotation { add { } remove { } }

    /// <summary>How fast the actor's head will rotate on the yaw axis</summary>
    public float YawDegreesPerSecond = 120.0f;
    /// <summary>How fast the actor's head will rotate on the pitch axis</summary>
    public float PitchDegreesPerSecond = 120.0f;

    /// <summary>Transform the actor's head will be looking at</summary>
    public Transform TrackedTransform;

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

      // Look up the head poser by which the mesh's head bones are controlled
      this.headPoser = GetComponent<HeadPoser>();
      if(this.headPoser == null) {
        Debug.LogError(
          "AI head controller assigned to '" + gameObject.name + "' found " +
          "no head poser component and will not work."
        );
      }

      // Use the control framework, if present, to disable AI head control
      // whenever a human player takes control of the actor
      this.controllable = GetComponentInParent<IControllable>();
    }

    // Do AI head movement in FixedUpdate(), too?
    // PRO: If visibility checks (sneak game) are needed, this is fps independent
    // CONTRA: Lots of pointless processing if only visuals are used
#if false
    /// <summary>Called once per physics frame to step the simulation</summary>
    protected void FixedUpdate() {

      // If the control framework isn't being used, assume the AI head controller
      // is on the actor because it's purely an AI actor.
      if(this.controllable != null) {
        // Otherwise, if a player is controlling the actor, do not do AI head movements.
        if(this.controllable.ControllingPlayerIndex >= 0) {
          return;
        }
      }

      // TODO: Head movement logic here

    }
#endif

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

      // If the control framework isn't being used, assume the AI head controller
      // is on the actor because it's purely an AI actor.
      if(this.controllable != null) {
        // Otherwise, if a player is controlling the actor, do not do AI head movements.
        if(this.controllable.ControllingPlayerIndex >= 0) {
          return;
        }
      }

      // TODO: Interpolate towards target rotation rather than flicking towards it
      this.headPoser.Orient(getTargetTrackingOrientation());

    }

    /// <summary>
    ///   Determines the orientation the head target to look at the tracked transform
    /// </summary>
    /// <returns>The orientation for the head to look at the tracked transform</returns>
    private Quaternion getTargetTrackingOrientation() {
      if(this.TrackedTransform == null) {
        return this.headPoser.GetBaseOrientation();
      }

      // Find the orientation the head has to point towards to look at the target
      Quaternion globalTargetOrientation;
      {
        Vector3 forward = Vector3.Normalize(
          this.TrackedTransform.position -
          (this.headPoser.Head.position + this.headPoser.EyeOffset)
        );

        globalTargetOrientation = Quaternion.LookRotation(
          forward, this.headPoser.GetBaseOrientation() * Vector3.up
        );
      }

      return globalTargetOrientation;
    }

#if false // Trick from Unity's MouseLook script. Extendable to X + Y axes?
    Quaternion ClampRotationAroundXAxis(Quaternion q) {
      q.x /= q.w;
      q.y /= q.w;
      q.z /= q.w;
      q.w = 1.0f;

      float angleX = 2.0f * Mathf.Rad2Deg * Mathf.Atan(q.x);
      angleX = Mathf.Clamp(angleX, MinimumX, MaximumX);
      q.x = Mathf.Tan(0.5f * Mathf.Deg2Rad * angleX);

      return q;
    }
#endif

    /// <summary>Transform to which the virtual reality camera is parented</summary>
    Transform IHeadController.VirtualRealityCameraRoot {
      get { return null; } // We're not a virtual reality head controller
    }

    /// <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 this.lookOrientation; }
      set { this.lookOrientation = 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 { return (this.controllable.ControllingPlayerIndex == -1); }
    }

    /// <summary>Tracks, if present, whether the player is controlling this actor</summary>
    private IControllable controllable;

    /// <summary>Head poser used to rotate the head bones</summary>
    private HeadPoser headPoser;
    /// <summary>Direction the head is currently pointing at</summary>
    private Quaternion lookOrientation;

  }

} // namespace Framework.Actors