using System;

using Framework.Services;

namespace Framework.Actors {

  /// <summary>Action that can be performed by an actor</summary>
  /// <remarks>
  ///   <para>
  ///     Think of a move as when someone says &quot;cool moves&quot; - these are actions,
  ///     feats or stunts an actor can perform. For player-controlled actors, possible moves
  ///     might be standing around, running, jumping, punching, falling over and so on.
  ///     For AI-controlled actors, moves are usually atomic actions such as
  ///     &quot;run to position x&quot; or &quot;jump onto the platform&quot;.
  ///   </para>
  ///   <para>
  ///     Each move can decide which other moves it can transition to. For example,
  ///     crawling while jumping doesn't make much sense, but jumping while running does.
  ///   </para>
  ///   <para>
  ///     Usually, moves have a class derived from this one to add more properties
  ///     specific to the actor implementation (eg. platformer moves would reference a
  ///     platformer actor). Overriding moves to use custom implementations can be done
  ///     through the specific move repository classes.
  ///   </para>
  ///   <para>
  ///     Moves have to be cancellable at any time and also needs to be reusable.
  ///   </para>
  /// </remarks>
  public class Move {

    /// <summary>Initializes the move on the specified actor</summary>
    /// <param name="actor">Actor that will perform the move</param>
    public void Initialize(ActorController actor) {
      if(this.isInitialized) {
        return;
      }

      ServiceInjector.InjectDependencies(this);

      Awake(actor);

      this.isInitialized = true;
    }

    /// <summary>Whether the move has completed executing</summary>
    /// <remarks>
    ///   <para>
    ///     This is checked by the <see cref="ActorController" /> to see whether its
    ///     currently active move has ended (allowing it to decide on a new move).
    ///     Moves are not required to ever finish, but they have to be interruptible at
    ///     any time. It is also okay to for the moves themselves to take care of their
    ///     transition to other moves.
    ///   </para>
    ///   <para>
    ///     If a move can finish, this property should return 'true' as soon as the move
    ///     finishes and reset to 'false' when the move receives the <see cref="OnEnded" />
    ///     notification or the <see cref="OnStarted" /> notification.
    ///   </para>
    ///   <para>
    ///     Moves that can finish are usually only used for AI characters where moves are
    ///     scheduled by a 'strategy' (or other high-level control system) that uses them
    ///     in a fashion similar to behavior tree nodes (eg. a 'MoveTowardsPlayer' strategy
    ///     or behavior tree node might use multiple 'run' and 'jump' moves to achieve its goal.
    ///   </para>
    ///   <para>
    ///     When a move completes, the <see cref="ActorController.OnMoveCompleted" />
    ///     method is invoked. By default, this just sets the active move to null, but
    ///     custom actor controllers can override this to notify their AI 'strategy' or
    ///     fall back to some kind of default move, for example.
    ///   </para>
    /// </remarks>
    public virtual bool IsCompleted { get { return false; } }

    /// <summary>Called once when the move is assigned to an actor</summary>
    /// <param name="actor">Actor the move has been assigned to</param>
    protected virtual void Awake(ActorController actor) {}

    /// <summary>Called when the actor has started the move</summary>
    public virtual void OnStarted() {}

    /// <summary>Called when the move has completed or was interrupted</summary>
    public virtual void OnEnded() {}

    /// <summary>Called once per physics frame</summary>
    /// <remarks>
    ///   Use this method to update the world position of the actor and do other
    ///   things that have an impact on game play. Input processing should happen
    ///   in this method alone.
    /// </remarks>
    public virtual void FixedUpdate() {}

    /// <summary>Called once per visual frame</summary>
    /// <remarks>
    ///   Use this method to update the visual state of the actor.
    /// </remarks>
    public virtual void Update() {}

    /// <summary>Whether the move has been initialized yet</summary>
    private bool isInitialized;

  }

} // namespace Framework.Actors