using System;

using UnityEngine;

using Framework.Actors;

namespace Framework.Actors.Platformer {

  /// <summary>Manages the visual state of a character in a platformer game</summary>
  public class PlatformerActorPresenter : ActorPresenter, IWalkingActorPresenter {

    /// <summary>Whether the presenter should manage the character's direction</summary>
    /// <remarks>
    ///   If this is enabled, the character will be facing either left, center or
    ///   right and any custom rotations will likely be lost (depending on script
    ///   update order). For characters that don't just move left or right but freely
    ///   rotate, set this to false.
    /// </remarks>
    public bool ManageDirection = true;

    /// <summary>Direction the actor is looking at</summary>
    /// <remarks>>
    ///   This value works like a normalized angle:
    ///   -1.0 means the actor is facing left
    ///    0.0 means the actor is facing the camera
    ///    1.0 means the actor is facing right
    /// </remarks>
    public float Direction = 0.0f;

    /// <summary>How quickly the character will turn to face the desired direction</summary>
    /// <remarks>
    ///   A rate of 4 would mean that the actor turns by 4 units (quarter turns)
    ///   per second, requiring 1/4th of a second to turn from the camera to a side
    ///   and 2/4ths to turn from one side to the other.
    /// </remarks>
    public float TurnRate = 10.0f;

    /// <summary>Speed at which the actor is moving horizontally in units/second</summary>
    public float HorizontalVelocity;

    /// <summary>Speed at which the actor is moving vertically in units/second</summary>
    public float VerticalVelocity;

    /// <summary>Orients the character to face the left side (negative X)</summary>
    public void FaceLeft() {
      Direction = -1.0f;
    }

    /// <summary>Orients the character to face the left side (negative X)</summary>
    /// <param name="instantly">Whether to turn without interpolation</param>
    public void FaceLeft(bool instantly) {
      Direction = -1.0f;

      if(instantly) {
        this.direction = -1.0f;
      }
    }

    /// <summary>Orients the character to face the right side (positive X)</summary>
    public void FaceRight() {
      Direction = +1.0f;
    }

    /// <summary>Orients the character to face the right side (positive X)</summary>
    /// <param name="instantly">Whether to turn without interpolation</param>
    public void FaceRight(bool instantly) {
      Direction = +1.0f;

      if(instantly) {
        this.direction = +1.0f;
      }
    }

    /// <summary>Orients the character to face the camera</summary>
    public void FaceCamera() {
      Direction = 0.0f;
    }

    /// <summary>Shows the actor during normal ground movement</summary>
    /// <remarks>
    ///   Override this to transition your actor's animations into the grounded state,
    ///   used while standing on solid ground, walking and running.
    /// </remarks>
    public virtual void SetGroundedState() {
      State = 0;
    }

    /// <summary>Shows the actor while it is airborne</summary>
    /// <remarks>
    ///   Override this to show your actor while it is airborne. Using different
    ///   animations depending on the actor's vertical velocity is recommended.
    /// </remarks>
    public virtual void SetAirState() {
      State = 1;
    }

    /// <summary>Shows the actor squatting while standing still</summary>
    /// <remarks>
    ///   This is a lowered stance often used to make actors shoot enemies
    ///   that wouldn't be hit from an upright stance. If sneaking is
    ///   enabled, you may want to use the same animation state.
    /// </remarks>
    public virtual void SetSquatState() {
      State = 2;
    }

    /// <summary>Shows the actor sneaking in a lowered stance</summary>
    /// <remarks>
    ///   This is a lowered stance often used to indicate silent / covert
    ///   movement. Can be shared with the squat animation.
    /// </remarks>
    public virtual void SetSneakState() {
      State = 3;
    }

    /// <summary>Shows the actor crawling on all fours</summary>
    /// <remarks>
    ///   Allows the actor to crawl through tight spaces. Can be used for
    ///   covert movement, too.
    /// </remarks>
    public virtual void SetCrawlState() {
      State = 4;
    }

    /// <summary>Shows the actor dashing across the ground</summary>
    /// <remarks>
    ///   Dashing is very quick forward movement used for evasion and to make
    ///   extra far jumps. This can be a rocket-propelled forward lunge as seen
    ///   in Megaman titles or a sideways jump as seen in Castlevania games,
    ///   for example.
    /// </remarks>
    public virtual void SetDashState() {
      State = 5;
    }

    /// <summary>Shows the actor sliding over the ground</summary>
    /// <remarks>
    ///   This is a more realistic variant of the dash. Rather than keeping
    ///   speed and ignoring gravity, a slide works like in an action move,
    ///   the actor throws itself to the ground and covers a limited distance
    ///   while rapidly losing momentum.
    /// </remarks>
    public virtual void SetSlideState() {
      State = 6;
    }

    /// <summary>Called once per physics update frame</summary>
    protected virtual void FixedUpdate() {
      if(this.Direction < this.direction) {
        float amount = this.TurnRate * Time.deltaTime;
        this.direction = Math.Max(this.direction - amount, -1.0f);
      }
      if(this.Direction > this.direction) {
        float amount = this.TurnRate * Time.deltaTime;
        this.direction = Math.Min(this.direction + amount, 1.0f);
      }
    }

    /// <summary>Called once per visual frame</summary>
    protected override void Update() {
      base.Update();

      // Update speed if it has changed. If the user doesn't use speed at all,
      // we will simply leave it alone.
      Animator animator = Animator;
      if(animator != null) {
        if(this.HorizontalVelocity != this.horizontalVelocity) {
          this.horizontalVelocity = this.HorizontalVelocity;
          Animator.SetFloat("HorizontalVelocity", this.HorizontalVelocity);
        }
        if(this.VerticalVelocity != this.verticalVelocity) {
          this.verticalVelocity = this.VerticalVelocity;
          Animator.SetFloat("VerticalVelocity", this.VerticalVelocity);
        }
      }

      if(this.ManageDirection) {
        updateDirection();
      }
    }

#if false
    /// <summary>Speed at which the actor is moving horizontally in units/second</summary>
    float IWalkingActorPresenter.HorizontalSpeed {
      get { return this.HorizontalSpeed; }
      set { this.HorizontalSpeed = value; }
    }

    /// <summary>Speed at which the actor is moving vertically in units/second</summary>
    float IWalkingActorPresenter.VerticalSpeed {
      get { return this.VerticalSpeed; }
      set { this.VerticalSpeed = value; }
    }
#endif

    /// <summary>Faces the character to the left, right or an intermediate angle</summary>
    private void updateDirection() {
      Vector3 target = gameObject.transform.position;
      {
        float x = Math.Min(Math.Max(this.direction, -1.0f), +1.0f);
        target.x += x;

        // Calculate the Z coordinate using the square root of the sine function
        // to achieve a linear progression of the viewing angle.
        float z = (float)Math.Sqrt(Math.Sin(((x + 1.0) / 2.0) * Math.PI));
        target.z -= z;
      }

      gameObject.transform.LookAt(target);
    }

    /// <summary>Direction the character is currently facing</summary>
    private float direction;
    /// <summary>Speed at which the character is moving horizontally</summary>
    private float horizontalVelocity;
    /// <summary>Speed at which the character is moving vertically</summary>
    private float verticalVelocity;

  }

} // namespace Framework.Actors.Platformer