using SHADE;
using System;

//in air controls?

public class PlayerController : Script
{
  public enum RaccoonStates
  {
    IDILE,
    WALKING,
    RUNNING,
    JUMP,
    FALLING,
    HOLDING,
    CAUGHT,
    TOTAL
  }

  private RigidBody rb;
  private Transform tranform;

  //to be remove
  public float drag = 2.0f;
  [SerializeField]
  [Tooltip("The current state fo the raccoon")]
  public RaccoonStates currentState = RaccoonStates.IDILE;

  //Movement variables============================================================
  [SerializeField]
  [Tooltip("Max vel for walking")]
  public float maxMoveVel = 2.0f;
  [SerializeField]
  [Tooltip("how much force is apply for walking")]
  public float moveForce = 50.0f;
  [SerializeField]
  [Tooltip("increase the moveForce and maxMoveVel by its amt")]
  public float sprintMultiplier = 2.0f;

  private float oldForce;
  private float maxOldVel;
  private bool sprintIncreaseOnce = false;
  private int xAxisMove;
  private int zAxisMove;
  private bool isMoveKeyPress = false;

  [SerializeField]
  [Tooltip("curr not working")]
  public float rotationFactorPerFrame = 1.0f;

  //Jumping vars==================================================================
  [SerializeField]
  [Tooltip("max height of the jump")]
  public float maxJumpHeight = 4.0f;
  [SerializeField]
  [Tooltip("max amt of time it will take for the jump")]
  public float maxJumpTime = 0.75f;
  [SerializeField]
  [Tooltip("increase gravity when falling")]
  public float fallMultipler = 2.0f;
  private float initialJumpVel;
  private bool isGrounded = true;
  private float gravity = -9.8f;
  private float groundGravity = -0.5f;

  public PlayerController(GameObject gameObj) : base(gameObj) { }

  protected override void awake()
  {
    //rigidbody check
    rb = GetComponent<RigidBody>();
    if (rb == null)
      Debug.LogError("RigidBody is NULL!");
    else
      rb.Drag = drag;

    //Transform check
    tranform = GetComponent<Transform>();
    if(tranform == null)
      Debug.LogError("tranform is NULL!");

    //Jump setup
    float timeToApex = maxJumpTime / 2;
    gravity = (-2 * maxJumpHeight) / MathF.Pow(timeToApex, 2);
    initialJumpVel = (2 * maxJumpHeight) / timeToApex;

    //toRemove
    tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
    tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
  }

  protected override void update()
  {
    //toRemove
    if (Input.GetKey(Input.KeyCode.G))
    {
      tranform.LocalRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
      tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
    }

    MoveKey();


    //Debug.Log(currentState.ToString() + " x:" + rb.LinearVelocity.x.ToString() + " y:" + rb.LinearVelocity.y.ToString() + " z:" + rb.LinearVelocity.z.ToString());
  }

  protected override void fixedUpdate()
  {
    //Rotation();
    Move();
    Sprint();
    Jump();
    Gravity();
  }


  private void MoveKey()
  {
    if (Input.GetKey(Input.KeyCode.A))
      xAxisMove = -1;
    else if (Input.GetKey(Input.KeyCode.D))
      xAxisMove = 1;
    else
      xAxisMove = 0;

    if (Input.GetKey(Input.KeyCode.W))
      zAxisMove = -1;
    else if (Input.GetKey(Input.KeyCode.S))
      zAxisMove = 1;
    else
      zAxisMove = 0;

    isMoveKeyPress = xAxisMove != 0 || zAxisMove != 0;

    if(isMoveKeyPress && currentState != RaccoonStates.RUNNING && isGrounded)
      currentState = RaccoonStates.WALKING;

    if (!isMoveKeyPress && isGrounded)
      currentState = RaccoonStates.IDILE;
  }

  private void Move()
  {
    if (rb != null)
    {
      rb.AddForce(new Vector3(moveForce * xAxisMove, 0.0f, moveForce * zAxisMove));

      if (isMoveKeyPress)
      {
        if (rb.LinearVelocity.x > maxMoveVel || rb.LinearVelocity.x < -maxMoveVel)
        {
          Vector3 v = rb.LinearVelocity;
          v.x = System.Math.Clamp(v.x, -maxMoveVel, maxMoveVel);
          rb.LinearVelocity = v;
        }
        if (rb.LinearVelocity.z > maxMoveVel || rb.LinearVelocity.z < -maxMoveVel)
        {
          Vector3 v = rb.LinearVelocity;
          v.z = System.Math.Clamp(v.z, -maxMoveVel, maxMoveVel);
          rb.LinearVelocity = v;
        }
      }
    }
  }

  private void Sprint()
  {
    if (Input.GetKey(Input.KeyCode.LeftShift) && isMoveKeyPress && isGrounded)
    {
      currentState = RaccoonStates.RUNNING;
      if(!sprintIncreaseOnce)
      {
        sprintIncreaseOnce = true;
        oldForce = moveForce;
        moveForce *= sprintMultiplier;

        maxOldVel = maxMoveVel;
        maxMoveVel *= sprintMultiplier;
      }
    }

    if (Input.GetKeyUp(Input.KeyCode.LeftShift))
    {
      if(isMoveKeyPress)
        currentState = RaccoonStates.WALKING;
      sprintIncreaseOnce = false;
      moveForce = oldForce;
      maxMoveVel = maxOldVel;
    }
  }

  //press and hold jump 
  private void Jump()
  {
    if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING || currentState == RaccoonStates.IDILE)
    {
      if (Input.GetKeyDown(Input.KeyCode.Space) && isGrounded && rb != null)
      {
        currentState = RaccoonStates.JUMP;
        Vector3 v = rb.LinearVelocity;
        v.y = initialJumpVel * 0.5f;
        rb.LinearVelocity = v;
      }
    }

    if(rb != null && !isGrounded && (rb.LinearVelocity.y < 0.0f || Input.GetKeyUp(Input.KeyCode.Space)))
      currentState = RaccoonStates.FALLING;
  }

  private void Rotation()
  {
    Vector3 poitionToLookAt;
    poitionToLookAt.x = xAxisMove;
    poitionToLookAt.y = 0.0f;
    poitionToLookAt.z = zAxisMove;

    if (tranform != null)
    {
      Quaternion currentRotation = tranform.LocalRotation;
      if (currentState == RaccoonStates.WALKING || currentState == RaccoonStates.RUNNING)
      {
        Quaternion targetRotation = Quaternion.LookRotation(poitionToLookAt, new Vector3(0.0f, 1.0f, 0.0f));
        tranform.LocalRotation = Quaternion.Slerp(currentRotation, targetRotation, rotationFactorPerFrame * (float)Time.DeltaTime);
      }
    }
  }

  private void Gravity()
  {
    if (rb != null)
    {
      //check player vel.y if its close to zero its on the ground
      if (SHADE.Math.CompareFloat(rb.LinearVelocity.y, 0.0f))
        isGrounded = true;
      else
        isGrounded = false;

      Vector3 v = rb.LinearVelocity;

      if (isGrounded)
        v.y = groundGravity;
      else if (currentState == RaccoonStates.FALLING)
      {
        float prevYVel = v.y;
        float newYVel = v.y + (gravity * fallMultipler * (float)Time.DeltaTime);
        float nextYVel = (prevYVel + newYVel) * 0.5f;
        v.y = nextYVel;
      }
      else
      {
        float prevYVel = v.y;
        float newYVel = v.y + (gravity * (float)Time.DeltaTime);
        float nextYVel = (prevYVel + newYVel) * 0.5f;
        v.y = nextYVel;
      }

      rb.LinearVelocity = v;

    }
  }

  protected override void onCollisionEnter(CollisionInfo info)
  {
  }


}