using System;

using UnityEngine;

using Framework.Actors;

namespace Framework.Actors.Shooter {

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

    /// <summary>Name of the animator parameter for the forward velocity</summary>
    private const string ForwardVelocityParameterName = "ForwardVelocity";
    /// <summary>Name of the animator parameter for the strafing velocity</summary>
    private const string StrafingVelocityParameterName = "StrafingVelocity";
    /// <summary>Name of the animator parameter for the vertical / jump velocity</summary>
    private const string VerticalVelocityParameterName = "VerticalVelocity";

    #region enum AnimatorProperties

    /// <summary>Properties this presenter is accessing</summary>
    [Flags]
    private enum AnimatorProperties {

      /// <summary>The actor's forward velocity</summary>
      ForwardVelocity = (1 << 0),
      /// <summary>The actor's strafing velocity</summary>
      StrafingVelocity = (1 << 1),
      /// <summary>The actor's vertical / jump velocity</summary>
      VerticalVelocity = (1 << 2),

    }

    #endregion // enum AnimatorProperties

    /// <summary>Direction the player is facing in horizontally</summary>
    public Vector2 HorizontalDirection;

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

    /// <summary>Speed at which the actor is sidestepping in units/second</summary>
    public float StrafingVelocity;

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

    /// <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>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) && (animator.runtimeAnimatorController != null)) {
        if(!this.presentProperties.HasValue) {
          checkAnimatorProperties(animator);
        }

        if(this.ForwardVelocity != this.forwardVelocity) {
          this.forwardVelocity = this.ForwardVelocity;
          if((this.presentProperties & AnimatorProperties.ForwardVelocity) != 0) {
            animator.SetFloat(ForwardVelocityParameterName, this.ForwardVelocity);
          }
        }
        if(this.StrafingVelocity != this.strafingVelocity) {
          this.strafingVelocity = this.StrafingVelocity;
          if((this.presentProperties & AnimatorProperties.StrafingVelocity) != 0) {
            animator.SetFloat(StrafingVelocityParameterName, this.StrafingVelocity);
          }
        }
        if(this.VerticalVelocity != this.verticalVelocity) {
          this.verticalVelocity = this.VerticalVelocity;
          if((this.presentProperties & AnimatorProperties.VerticalVelocity) != 0) {
            animator.SetFloat(VerticalVelocityParameterName, this.VerticalVelocity);
          }
        }
      }
    }

    /// <summary>Checks for the presence of animator properties</summary>
    /// <param name="animator">Animator that will be checked for its properties</param>
    private void checkAnimatorProperties(Animator animator) {
      AnimatorControllerParameter[] parameters = animator.parameters;

      AnimatorProperties presentProperties = 0;

      int parameterCount = parameters.Length;
      for(int index = 0; index < parameterCount; ++index) {
        if(parameters[index].type == AnimatorControllerParameterType.Float) {
          switch(parameters[index].name) {
            case ForwardVelocityParameterName: {
              presentProperties |= AnimatorProperties.ForwardVelocity;
              break;
            }
            case StrafingVelocityParameterName: {
              presentProperties |= AnimatorProperties.ForwardVelocity;
              break;
            }
            case VerticalVelocityParameterName: {
              presentProperties |= AnimatorProperties.ForwardVelocity;
              break;
            }
          }
        }
      }

      this.presentProperties = presentProperties;
    }

    /// <summary>Direction the character is currently facing</summary>
    private float direction;
    /// <summary>Speed at which the character is moving horizontally</summary>
    private float forwardVelocity;
    /// <summary>Speed at which the character is sidestepping</summary>
    private float strafingVelocity;
    /// <summary>Speed at which the character is moving vertically</summary>
    private float verticalVelocity;
    /// <summary>Properites that are present on the animator</summary>
    private AnimatorProperties? presentProperties;

  }

} // namespace Framework.Actors.Shooter