using System;

using UnityEngine;

using Framework.Input;
using Framework.Layers;

namespace Framework.Actors.Platformer {

  /// <summary>Move that can be performed by the player</summary>
  public class PlayerMove : PlatformerMove {

    /// <summary>Called when the actor has started the move</summary>
    public override void OnStarted() {
      base.OnStarted();

      SetPresenterState();
    }

    /// <summary>
    ///   Switches the presenter to the animation state appropriate for this move
    /// </summary>
    /// <remarks>
    ///   This is called when the move becomes active. It is typically used to trigger
    ///   the animation related to the move (or change exposed variables in Mecanim
    ///   to switch to the correct animation state).
    /// </remarks>
    protected virtual void SetPresenterState() {}

    /// <summary>Injects the instance's dependencies</summary>
    /// <param name="inputManager">
    ///   Input selector the instance uses to determine the active input source
    /// </param>
    /// <remarks>
    ///   This method is called automatically by the services framework. Any parameters
    ///   it requires will be filled out by looking up the respective services and creating
    ///   them as needed.
    /// </remarks>
    protected void Inject(IInputManager inputManager) {
      this.inputManager = inputManager;
    }

    /// <summary>Called once when the movement is assigned to an actor</summary>
    /// <param name="actor">Actor the movement has been assigned to</param>
    protected override void Awake(ActorController actor) {
      base.Awake(actor);

      this.moveRepository = actor.GetComponent<PlayerMoveRepository>();
      this.abilities = ActorController.Abilities;
    }

    /// <summary>Abilities the actor possesses</summary>
    protected Abilities Abilities {
      get { return this.abilities; }
    }

    /// <summary>Input manager from which the input state can be queried</summary>
    protected IInputManager InputManager {
      get { return this.inputManager; }
    }

    /// <summary>Adds a jump impulse to the actor</summary>
    /// <param name="apexHeight">Apex height the actor should achieve from the jump</param>
    protected void GiveVerticalJumpImpulse(float apexHeight) {
      Vector3 groundVelocity = ActorController.GroundChecker.GetMostRecentGroundVelocity();
      float gravityStrength = Physics.gravity.magnitude;

      if(Rigidbody != null) {
        float jumpImpulse = PhysicsHelper.GetJumpOffImpulse(
          gravityStrength, apexHeight, Time.fixedDeltaTime
        );

        float relativeImpulse = groundVelocity.y + jumpImpulse;
        relativeImpulse -= Rigidbody.velocity.y;

        Rigidbody.AddForce(
          new Vector3(0.0f, relativeImpulse * Rigidbody.mass, 0.0f), ForceMode.Impulse
        );
      } else if(ActorPhysics != null) {
        gravityStrength *= ActorPhysics.GravityScale;
        float jumpImpulse = PhysicsHelper.GetJumpOffImpulse(
          gravityStrength, apexHeight, Time.fixedDeltaTime
        );

        float relativeImpulse = groundVelocity.y + jumpImpulse;
        relativeImpulse -= ActorPhysics.Velocity.y;

        ActorPhysics.QueueImpulse(
          new Vector3(0.0f, relativeImpulse * ActorPhysics.Mass, 0.0f)
        );
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, cannot give jump impulse."
        );
      }
    }

    /// <summary>Sets the vertical velocity of the actor to zero</summary>
    protected void ClearVerticalVelocity() {
      if(Rigidbody != null) {
        Vector3 velocity = Rigidbody.velocity;
        velocity.y = 0.0f;
        Rigidbody.velocity = velocity;
      } else if(ActorPhysics != null) {
        Vector3 velocity = ActorPhysics.Velocity;
        velocity.y = 0.0f;
        ActorPhysics.Velocity = velocity;
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, cannot clear vertical velocity."
        );
      }
    }

    /// <summary>Changes the character's velocity to the specified velocity</summary>
    /// <param name="targetVelocity">Velocity the character will assume</param>
    protected void ChangeVelocity(float targetVelocity) {
      if(Rigidbody != null) {
        float currentVelocity = Rigidbody.velocity.x;
        float impulse = (targetVelocity - currentVelocity) * Rigidbody.mass;

        Rigidbody.AddForce(new Vector3(impulse, 0.0f, 0.0f), ForceMode.Impulse);
      } else if(ActorPhysics != null) {
        float currentVelocity = ActorPhysics.Velocity.x;
        float impulse = (targetVelocity - currentVelocity) * ActorPhysics.Mass;

        ActorPhysics.QueueImpulse(new Vector3(impulse, 0.0f, 0.0f));
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, cannot set velocity."
        );
      }
    }

    /// <summary>Accelerates the character to the specified target velocity</summary>
    /// <param name="targetVelocity">Velocity the character should reach</param>
    /// <param name="acceleration">Acceleration in units per second squared</param>
    protected void AccelerateToVelocity(float targetVelocity, float acceleration) {
      float deltaTime = Time.fixedDeltaTime;

      if(Rigidbody != null) {
        float currentVelocity = Rigidbody.velocity.x;

        // Get force that would be required to achieve target velocity instantly
        // and limit it to the acceleration specified by the caller
        float force = (targetVelocity - currentVelocity) / deltaTime;
        force = Mathf.Clamp(force, -acceleration, acceleration);
        force *= Rigidbody.mass;

        Rigidbody.AddForce(new Vector3(force, 0.0f, 0.0f), ForceMode.Force);
      } else if(ActorPhysics != null) {
        float currentVelocity = ActorPhysics.Velocity.x;

        // Get force that would be required to achieve target velocity instantly
        // and limit it to the acceleration specified by the caller
        float force = (targetVelocity - currentVelocity) / deltaTime;
        force = Mathf.Clamp(force, -acceleration, acceleration);
        force *= ActorPhysics.Mass;

        ActorPhysics.QueueForce(new Vector3(force, 0.0f, 0.0f));
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, cannot accelerate."
        );
      }
    }

    /// <summary>Enables or disables gravity for the actor</summary>
    /// <param name="active">True to enable gravity, false to disable it</param>
    protected void EnableGravity(bool active = true) {
      if(Rigidbody != null) {
        Rigidbody.useGravity = active;
      } else if(ActorPhysics != null) {
        ActorPhysics.IsAffectedByGravity = active;
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, cannot toggle gravity."
        );
      }
    }

    /// <summary>
    ///   Uses the GroundChecker component to update the grounded state of the actor
    /// </summary>
    protected bool RecheckGrounding() {
      if(ActorPhysics != null) {
        return
          ActorController.GroundChecker.CheckIfGrounded(ActorPhysics) ||
          ActorPhysics.UnreliableIsGrounded;
      } else {
        Collider collider = ActorController.GetComponent<Collider>();
        if(collider != null) {
          int layerMask = LayerMaskHelper.GetLayerCollisionMaskFor(
            ActorController.gameObject.layer
          );
          return ActorController.GroundChecker.CheckIfGrounded(collider, layerMask);
        }
      }

      return false;
    }

    /// <summary>Checks whether the actor is standing on solid ground</summary>
    protected bool IsGrounded {
      get {
        if(ActorPhysics != null) {
          return
            ActorController.GroundChecker.WasGroundedInMostRecentCheck ||
            ActorPhysics.UnreliableIsGrounded;
        } else {
          return ActorController.GroundChecker.WasGroundedInMostRecentCheck;
        }
      }
    }

    /// <summary>Retrieves the current velocity of the actor</summary>
    /// <returns>The actor's current velocity</returns>
    protected Vector3 GetVelocity() {
      if(Rigidbody != null) {
        return Rigidbody.velocity;
      } else if(ActorPhysics != null) {
        return ActorPhysics.Velocity;
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, velocity retrieval impossible"
        );
        return Vector3.zero;
      }
    }

    /// <summary>Retrieves the current vertical velocity of the actor</summary>
    /// <returns>The actor's current vertical velocity</returns>
    protected float GetVerticalVelocity() {
      if(Rigidbody != null) {
        return Rigidbody.velocity.y;
      } else if(ActorPhysics != null) {
        return ActorPhysics.Velocity.y;
      } else {
        Debug.LogError(
          "No Rigidbody and no ActorPhysics component present, velocity check impossible"
        );
        return float.NaN;
      }
    }

    /// <summary>Switches the actor controller to the ground move</summary>
    /// <param name="impactVelocity">Velocity the actor had when hitting the ground</param>
    protected void SwitchToGroundMove(float impactVelocity = 0.0f) {
      Move groundMode;
      if(this.moveRepository == null) {
        groundMode = new GroundMove();
      } else {
        groundMode = this.moveRepository.GetGroundMove();
      }

      ActorController.ActiveMove = groundMode;
    }

    /// <summary>Switches the actor controller to the air move</summary>
    /// <param name="jumped">Whether the character has jumped</param>
    protected void SwitchToAirMove(bool jumped) {
      Move airMove;
      if(this.moveRepository == null) {
        airMove = new AirMove() { WasActivatedByJumping = jumped };
      } else {
        airMove = this.moveRepository.GetAirMove(jumped);
      }

      ActorController.ActiveMove = airMove;
    }

    /// <summary>Switches the actor controller to the dash move</summary>
    protected void SwitchToDashMove() {
      Move dashMove;
      if(this.moveRepository == null) {
        dashMove = new DashMove();
      } else {
        dashMove = this.moveRepository.GetDashMove();
      }

      ActorController.ActiveMove = dashMove;
    }

    /// <summary>Switches the actor controller to the squat move</summary>
    protected void SwitchToSquatMove() {
      Move squatMove;
      if(this.moveRepository == null) {
        squatMove = new SquatMove();
      } else {
        squatMove = this.moveRepository.GetSquatMove();
      }

      ActorController.ActiveMove = squatMove;
    }

    /// <summary>Switches the actor controller to the squat move</summary>
    protected void SwitchToSlideMove() {
      Move slideMove;
      if(this.moveRepository == null) {
        slideMove = new SlideMove();
      } else {
        slideMove = this.moveRepository.GetSlideMove();
      }

      ActorController.ActiveMove = slideMove;
    }

    /// <summary>Repository storing other moves to which this one can switch</summary>
    private PlayerMoveRepository moveRepository;

    /// <summary>Input manager from which inputs states will be queried</summary>
    private IInputManager inputManager;

    /// <summary>Defines the abilities of the platformer actor</summary>
    private Abilities abilities;

  }

} // namespace Framework.Actors.Platformer