using System;
using System.Collections.Generic;

using UnityEngine;

using Framework.Services;

namespace Framework.Actors {

  /// <summary>Controls the animation state of the Mecanim animator</summary>
  public class ActorPresenter : ScriptComponent {

    #region struct TaggedState

    /// <summary>State with its assigned tag</summary>
    private struct TaggedState {

      /// <summary>Tag that has been assigned to the state</summary>
      public string Tag;
      /// <summary>State ID, usually taken from an actor-specific enumation</summary>
      public int State;
      /// <summary>Layer the state switch will happen on</summary>
      public int Layer;

    }

    #endregion // struct TaggedState

    /// <summary>State the character is currently in</summary>
    /// <remarks>
    ///   This is usually backed by an enumeration of possible states that is kept
    ///   in sync with your Mecanim animation controller (animator).
    /// </remarks>
    public int State;

    /// <summary>Name of the variable used to feed random numbers to the animator</summary>
    /// <remarks>
    ///   If this string is filled with a name, a variable of that name (of type integer)
    ///   will be set to a random number from 0 to 99 once per second, allowing
    ///   the animator to randomly select between multiple transitions.
    /// </remarks>
    public string RandomProvider;

    /// <summary>Initializes a new actor presenter</summary>
    public ActorPresenter() {
      this.queuedStateSwitches = new Queue<TaggedState>();
    }

    /// <summary>Mecanim animator that the presenter is feeding</summary>
    public Animator Animator {
      get { return this.animator; }
    }

    /// <summary>Selects the state showing the character idling</summary>
    public virtual void SetIdleState() { }

    /// <summary>Removes all queued states</summary>
    public void ClearStateQueue() {
      this.queuedStateSwitches.Clear();
    }

    /// <summary>Switches a state and waits for the specific tag to become active</summary>
    /// <param name="newState">State to switch to</param>
    /// <param name="tagToWaitFor">Tag that should become active when the state was set</param>
    /// <param name="layer">Layer for which the state switch will bequeued</param>
    /// <remarks>
    ///   If the presenter is already waiting for another state to be reached, this method
    ///   will queue the state switch until the awaited state has been reached. 
    /// </remarks>
    public void SwitchState(int newState, string tagToWaitFor, int layer) {
      var taggedState = new TaggedState() {
        State = newState,
        Tag = tagToWaitFor,
        Layer = layer
      };
      this.queuedStateSwitches.Enqueue(taggedState);
    }

    /// <summary>Forces an immediate state switch, ignoring transitions</summary>
    /// <param name="newState">New state the animator should switch to</param>
    /// <param name="newStateName">Name of the new state to switch to</param>
    public void ForceState(int newState, string newStateName) {
      ClearStateQueue();
      State = state;

      // Force the presenter to assign the state to Mecanim so there's no risk of
      // Mecanim jumping to any other animation between the call to Play() and
      // the next update.
      Update();

      Animator.Play(Animator.StringToHash(newStateName));
    }

    /// <summary>Forces an immediate state switch, ignoring transitions</summary>
    /// <param name="newState">New state the animator should switch to</param>
    /// <param name="newStateName">Name of the new state to switch to</param>
    /// <param name="layer">Layer on which the state switch will happen</param>
    public void ForceState(int newState, string newStateName, int layer) {
      ClearStateQueue();
      State = state;

      // Force the presenter to assign the state to Mecanim so there's no risk of
      // Mecanim jumping to any other animation between the call to Play() and
      // the next update.
      Update();

      Animator.Play(Animator.StringToHash(newStateName), layer);
    }

    /// <summary>Called when the script instance is being loaded</summary>
    /// <remarks>
    ///   Awake is used to initialize any variables or game state before
    ///   the game starts. Awake is called only once during the lifetime of
    ///   the script instance. Awake is called after all objects are initialized
    ///   so you can safely speak to other objects.
    /// </remarks>
    protected override void Awake() {
      base.Awake();

      this.animator = gameObject.GetComponentInChildren<Animator>();
      if(this.animator == null) {
        Debug.LogWarning(
          "Could not locate Mecanim animator. The presenter attached to the game object '" +
          gameObject.name + "' either doesn't contain an animated model, has no animator " +
          "assigned or is using the legacy animation system. Animations will not work!"
        );
      }
    }

    /// <summary>Called once per frame</summary>
    protected virtual void Update() {
      if(this.animator == null) {
        return;
      }

      // If state switches have been queued, keep the state the queue is currently
      // waiting for set until the tag is reached (also preventing any manual state
      // switches that might confuse the state machine).
      if(this.queuedStateSwitches.Count > 0) {
        TaggedState top = this.queuedStateSwitches.Peek();
        this.State = top.State;

        if(this.animator.GetCurrentAnimatorStateInfo(top.Layer).IsTag(top.Tag)) {
          this.queuedStateSwitches.Dequeue();
        }
      }

      // If a manual or queued state switch resulted in a different target state,
      // send the state to the animator (we try to avoid hitting the animator as little
      // as possible - string lookups, internal processing and all)
      if(this.State != this.state) {
        this.state = this.State;
        this.animator.SetInteger("State", this.State);
      }

      // Provide the animator with a random value if desired. This can be used to
      // select random animations.
      if(!string.IsNullOrEmpty(this.RandomProvider)) {
        float time = Time.time;
        if(time > this.nextRandomUpdateTime) {
          this.nextRandomUpdateTime = time + 1.0f;
          this.animator.SetInteger(this.RandomProvider, UnityEngine.Random.Range(0, 100));
        }
      }
    }

    /// <summary>Mecanim animator that the presenter is feeding</summary>
    private Animator animator;
    /// <summary>Next time the random variable is updated</summary>
    private float nextRandomUpdateTime;

    /// <summary>Currently established state of the character</summary>
    private int state;
    /// <summary>State switches that are waiting for a specific tag to become set</summary>
    private Queue<TaggedState> queuedStateSwitches;

  }

} // namespace Framework.Actors