using SHADE;
using System;
using System.Collections.Generic;  
using static Item;

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

  public enum WalkingState
  {
    CARRY,
    AIMING,
    THROW,
    WALK,
    TOTAL
  }

  public RigidBody rb { get; set; }
  private Transform tranform;
  private Camera cam;
  private PickAndThrow pat;

  //to be remove
  public float drag = 2.0f;
  public bool holdItem { get; set; }
  [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;

  public float xAxisMove { get; set; }
  public float zAxisMove { get; set; }
  
  public Vector2 axisMove { get; set; }

  public bool isMoveKeyPress { get; set; }

  [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;

  //ItemMultipler==================================================================
  public float lightMultiper = 0.75f;
  public float mediumMultiper = 0.5f;
  public float heavyMultiper = 0.25f;

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

  protected override void awake()
  {
    //default setup
    isMoveKeyPress = false;
    holdItem = false;

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

    //rigidbody check
    rb = GetComponent<RigidBody>();
    if (rb == null)
      Debug.LogError("RigidBody is NULL!");
    else
    {
      rb.IsGravityEnabled = false;
      rb.FreezeRotationX = true;
      rb.FreezeRotationY = true;
      rb.FreezeRotationZ = true;
      rb.Drag = drag;
      rb.Interpolating = false;
    }

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

    //PickAndThrow checl
    pat = GetScript<PickAndThrow>();
    if (pat == null)
      Debug.LogError("PickAndThrow is NULL!");

    //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()
  {
    if (cam == null)
      cam = GetComponentInChildren<Camera>();

    //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);
    }

    GotCaught();
    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;*/


    xAxisMove = 0;
    zAxisMove = 0;
    axisMove = Vector2.Zero;
    if (Input.GetKey(Input.KeyCode.W))
    {
      Vector3 camerAixs = cam.GetForward();
      camerAixs.y = 0;
      camerAixs.Normalise();
      xAxisMove = camerAixs.x;
      zAxisMove = camerAixs.z;
      axisMove += new Vector2(camerAixs.x, camerAixs.z);
    }
    if (Input.GetKey(Input.KeyCode.S))
    {
      Vector3 camerAixs = cam.GetForward();
      camerAixs.y = 0;
      camerAixs.Normalise();
      xAxisMove = -camerAixs.x;
      zAxisMove = -camerAixs.z;
      axisMove -= new Vector2(camerAixs.x, camerAixs.z);
    }
    if (Input.GetKey(Input.KeyCode.A))
    {
      Vector3 camerAixs = cam.GetRight();
      camerAixs.y = 0;
      camerAixs.Normalise();
      xAxisMove = -camerAixs.x;
      zAxisMove = -camerAixs.z;
      axisMove -= new Vector2(camerAixs.x, camerAixs.z);
    }
    if (Input.GetKey(Input.KeyCode.D))
    {
      Vector3 camerAixs = cam.GetRight();
      camerAixs.y = 0;
      camerAixs.Normalise();
      xAxisMove = camerAixs.x;
      zAxisMove = camerAixs.z;
      axisMove += new Vector2(camerAixs.x, camerAixs.z);
    }
    axisMove.Normalise();
    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(axisMove.x, 0.0f,axisMove.y) * moveForce);

      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;
      holdItem = false;
      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;
        if (pat != null && pat.item.GetScript<Item>() != null && holdItem)
        {
          Item item = pat.item.GetScript<Item>();
          if (item.currCategory == ItemCategory.LIGHT)
            v.y *= lightMultiper;
          if (item.currCategory == ItemCategory.MEDIUM)
            v.y *= mediumMultiper;
          if (item.currCategory == ItemCategory.HEAVY)
            v.y *= heavyMultiper;
        }
        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;

    }
  }

  private void GotCaught()
  {
    if (currentState == RaccoonStates.CAUGHT && tranform != null)
    {
      currentState = RaccoonStates.IDILE;
      tranform.LocalPosition = new Vector3(-3.0f, -2.0f, -5.0f);
    }
  }

  protected override void onCollisionEnter(CollisionInfo info)
  {
  }


}