using System;

using UnityEngine;

using Framework.Services;
using Framework.State;

namespace Framework.Actors {

  /// <summary>Controls an animated character in a scene</summary>
  public class ActorController : ScriptComponent {

#if UNITY_EDITOR
    /// <summary>Name of the current move the actor is running (for debugging)</summary>
    public string ActiveMoveName;
#endif // UNITY_EDITOR

    /// <summary>Presenter driving the Mecanim animation state machine</summary>
    public ActorPresenter Presenter {
      get {
        if(this.presenter == null) {
          this.presenter = gameObject.GetComponentInChildren<ActorPresenter>();
        }
#if UNITY_EDITOR
        if((this.presenter == null) && !this.warnedAboutMissingPresenter) {
          Debug.LogWarning(
            "Actor controller on '" + gameObject.name + "' could not locate a presenter. " +
            "The actor's animation state will not be updated."
          );
          this.warnedAboutMissingPresenter = true;
        }
#endif
        return this.presenter;
      }
    }

    /// <summary>Helper used to check whether the actor is grounded or airborne</summary>
    /// <remarks>
    ///   This is component is created lazily - if your actor doesn't need ground
    /// </remarks>
    public GroundChecker GroundChecker {
      get {
        if(this.groundChecker == null) {
          this.groundChecker = new GroundChecker();
        }

        return this.groundChecker;
      }
    }

    /// <summary>Actor physics provider, if present</summary>
    public ActorPhysics ActorPhysics {
      get {
        if(!this.checkedForActorPhysics) {
          this.actorPhysics = GetComponent<ActorPhysics>();
          this.checkedForActorPhysics = true;
        }

        return this.actorPhysics;
      }
    }

    /// <summary>Rigid body physics component, if present</summary>
    public Rigidbody Rigidbody {
      get {
        if(!this.checkedForRigidBody) {
          this.rigidBody = GetComponent<Rigidbody>();
          this.checkedForRigidBody = true;
        }

        return this.rigidBody;
      }
    }


    /// <summary>Move that is currently being executed by the actor controller</summary>
    /// <remarks>
    ///   'Moves' are micro-actions that can be performed by actors, such as jumping,
    ///   falling or sitting down. See the <see cref="Move" /> class for a more thorough
    ///   description. If no move is active, the actor will remain passive.
    /// </remarks>
    public Move ActiveMove {
      get { return this.activeMove; }
      set {
        if(this.activeMove != null) {
          this.activeMove.OnEnded();
        }

        this.activeMove = value;
#if UNITY_EDITOR
        if(this.activeMove == null) {
          this.ActiveMoveName = null;
        } else {
          this.ActiveMoveName = this.activeMove.GetType().Name;
        }
#endif

        if(value != null) {
          value.Initialize(this); // Does nothing if already initialized
          value.OnStarted();
        }
      }
    }

    /// <summary>Called when the component gets added to a gameObject</summary>
    /// <remarks>
    ///   Unity calls this method right after all components have been constructed.
    ///   This is the place to look up other components and GameObjects, but no calls
    ///   should be made to them yet (because the Awake() order is undefined and
    ///   the other component might not have set up its dependencies yet).
    /// </remarks>
    protected override void Awake() {
      base.Awake();

      // If the control framework is used (lets players 'possess' actors to decide
      // which actor should respond to input), sign up for it.
      this.controllable = GetComponent<IControllable>();
      if(this.controllable == null) {
        OnControlTaken(0);
      } else {
        this.onControlTakenDelegate = new Action<int>(OnControlTaken);
        this.onControlReleasedDelegate = new Action<int>(OnControlReleased);
        this.controllable.ControlTaken += this.onControlTakenDelegate;
        this.controllable.ControlReleased += this.onControlReleasedDelegate;
      }
    }

    /// <summary>Called once per physics frame to update the positions of game object</summary>
    protected virtual void FixedUpdate() {
      if(this.activeMove != null) {
        this.activeMove.FixedUpdate();

        if(this.activeMove.IsCompleted) {
          OnMoveCompleted();
        }
      }
    }

    /// <summary>Called once per visual frame</summary>
    protected virtual void Update() {
      if(this.activeMove != null) {
        this.activeMove.Update();

        if(this.activeMove.IsCompleted) {
          OnMoveCompleted();
        }
      }
    }

    /// <summary>Called when the currently active move has completed</summary>
    protected virtual void OnMoveCompleted() {
      ActiveMove = null; // Using property setter to ensure OnEnded() call.
    }

    /// <summary>Called when a player assumes control of the actor</summary>
    /// <param name="playerIndex">Index of the player that has assumed control</param>
    protected virtual void OnControlTaken(int playerIndex) {}

    /// <summary>Called when a player releases control of the actor</summary>
    /// <param name="playerIndex">Index of the player that has released control</param>
    protected virtual void OnControlReleased(int playerIndex) {}

    /// <summary>Helper used to check whether the actor is grounded or airborne</summary>
    private GroundChecker groundChecker;
    /// <summary>Presenter driving the Mecanim animation state machine</summary>
    private ActorPresenter presenter;

    /// <summary>Rigid body physics component, if present</summary>
    private Rigidbody rigidBody;
    /// <summary>Whether the presence of a Rigidbody component has been checked</summary>
    private bool checkedForRigidBody;
    /// <summary>Actor physics provider, if present</summary>
    private ActorPhysics actorPhysics;
    /// <summary>Whether the presence of an ActorPhysics component has been checked</summary>
    private bool checkedForActorPhysics;

    /// <summary>Move the actor is currently executing</summary>
    private Move activeMove;

    /// <summary>Tracks, if present, whether the player is controlling this actor</summary>
    private IControllable controllable;
    /// <summary>Delegate for the OnControlTaken() method</summary>
    private Action<int> onControlTakenDelegate;
    /// <summary>Delegate for the OnControlReleased() method</summary>
    private Action<int> onControlReleasedDelegate;

#if UNITY_EDITOR
    /// <summary>Whether the missing presenter warning has been displayed</summary>
    private bool warnedAboutMissingPresenter;
#endif

  }

} // namespace Framework.Actors