using System;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;

public class playerMovement : MonoBehaviour
{
    //Assingables
    public Transform playerCam;
    public Transform orientation;

    //Other
    private Rigidbody rb;

    //Rotation and look
    public bool lockLook;
    private float xRotation;
    private float sensitivity = 50f;
    private float sensMultiplier = 1f;

    public int health, regen;
    int maxHealth;

    //Movement
    public Vector3 inputVector;
    public float moveSpeed = 4500;
    public bool grounded, onSlope, fullAirControl;
    public LayerMask whatIsGround;

    public float counterMovement = 0.175f;
    private float threshold = 0.01f;
    public float maxSlopeAngle = 35f;

    //Base speed handling
    public float startBaseSpeed = 15f, baseSpeed, maxBaseSpeed;
    public float baseSpeedAccel, baseSpeedDeccel;
    public float bSAccelPoint, bSDeccelPoint, slowDownPoint;
    public float dragToSlowDown;

    //Crouch & Slide
    private Vector3 crouchScale = new Vector3(1, 0.5f, 1);
    private Vector3 playerScale;
    public float slideForce = 400;
    public float slideCounterMovement = 0.2f;
    public float crouchGravityMultiplier;

    //Jumping
    private bool readyToJump = true;
    private float jumpCooldown = 0.25f;
    public float jumpForce = 550f;

    public int startDoubleJumps = 1;
    int doubleJumpsLeft;

    //Input
    public float x, y;
    bool jumping, sprinting, crouching;

    //Air contorl
    public float airForwardForce;

    //AirDash

    //Sliding
    private Vector3 normalVector = Vector3.up;
    private Vector3 wallNormalVector;
    public float slopeDownwardForce;

    //Wallrunning
    public LayerMask whatIsWall;
    RaycastHit wallHitR, wallHitL;
    public bool isWallRight, isWallLeft;
    public float maxWallrunTime;
    public float wallrunForce, wallrunUpwardForce, wallSpeedAdd;
    public int wallJumps, wallJumpsLeft;
    public bool readyToWallrun, isWallRunning;
    public bool resetDoubleJumpsOnWall;
    public GameObject lastWall;
    //CamTilt
    public float maxWallRunCameraTilt;
    public float wallRunCameraTilt = 0;

    //Climbing
    public float climbForce, climbSpeedAdd;
    public LayerMask whatIsLadder;
    bool alreadyStoppedAtLadder;

    //Slow-Mo
    public GameObject slowMoPlane;
    public float slowMoCooldown, slowMoTime;
    [Range(0f, 1f)] 
    public float slowMoStrength;
  //  bool readyForSlowMo = true;

    //Speed Display
    public float speedRecord;
    public TextMeshProUGUI baseVelocityDisplay, currentVelocityDisplay, recordVelocityDisplay;
    void Awake()
    {
        rb = GetComponent<Rigidbody>();
        maxHealth = health;
        baseSpeed = startBaseSpeed;
    }
    void Start()
    {
        playerScale = transform.localScale;
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
        allowDrag = true;
    }

    private void FixedUpdate()
    {
        Movement();
    }
    private void Update()
    {
        MyInput();
        if (!lockLook) Look();
        CheckForWall();

        //Stuff
        if (Input.GetKeyDown(KeyCode.L)) SceneManager.LoadScene(1);

        //Trail renderer
        //if (rb.velocity.magnitude <= 25) GetComponent<TrailRenderer>().startWidth 

        //Set speed display
        if (currentVelocityDisplay != null)
            currentVelocityDisplay.SetText("currVel: " + Mathf.RoundToInt(rb.velocity.magnitude));
        if (baseVelocityDisplay != null)
            baseVelocityDisplay.SetText("baseVel: " + baseSpeed);
        if (recordVelocityDisplay != null)
            recordVelocityDisplay.SetText("recordVel: " + speedRecord);

        //new speed record
        if (speedRecord < rb.velocity.magnitude)
            speedRecord = Mathf.RoundToInt(rb.velocity.magnitude);
        //reset Record
        if (Input.GetKeyDown(KeyCode.R)) speedRecord = 0;

    }
    private void MyInput()
    {
        x = Input.GetAxisRaw("Horizontal");
        y = Input.GetAxisRaw("Vertical");
        jumping = Input.GetButton("Jump");
        crouching = Input.GetKey(KeyCode.LeftControl);

        //Crouching
        if (Input.GetKeyDown(KeyCode.LeftControl))
            StartCrouch();
        if (Input.GetKeyUp(KeyCode.LeftControl))
            StopCrouch();

        //If holding jump && ready to jump, then jump
        if (readyToJump && jumping && grounded) Jump();
        //Double Jumping
        if (Input.GetButtonDown("Jump") && !grounded && doubleJumpsLeft >= 1)
        {
            Jump();
        }
        //Wall jumping
        if(Input.GetButtonDown("Jump") && wallJumpsLeft >= 1 && isWallRunning)
        {
            Jump();
        }

        //Dashing


        //Wallrun
        if (isWallRight && !grounded && readyToWallrun) StartWallrun();
        if (isWallLeft && !grounded && readyToWallrun) StartWallrun();
        //reset wallrun
        if (!isWallRight && !isWallLeft && !readyToWallrun) readyToWallrun = true;

        //Climbing
        if (Physics.Raycast(transform.position, orientation.forward, 1, whatIsLadder) && y > .9f)
            Climb();
        else alreadyStoppedAtLadder = false;

        //Slow-Mo
       // if (Input.GetKeyDown(KeyCode.LeftControl) && readyForSlowMo) StartSlowMo();
    }


    private void Movement()
    {
        //Extra gravity
        //Needed that the Ground Check works better!
        float gravityMultiplier = 10f;

        if (crouching) gravityMultiplier = crouchGravityMultiplier;

        rb.AddForce(Vector3.down * Time.deltaTime * gravityMultiplier);

        //Find actual velocity relative to where player is looking
        Vector2 mag = FindVelRelativeToLook();
        float xMag = mag.x, yMag = mag.y;

        //Counteract sliding and sloppy movement
        CounterMovement(x, y, mag);

        //Air Control
        //if (!grounded) rb.AddForce(orientation.forward * Time.deltaTime * airForwardForce);

        //ResetStuff when touching ground
        if (grounded){
            doubleJumpsLeft = startDoubleJumps;
            wallJumpsLeft = wallJumps;
        }

        //Set max speed
        float maxSpeed = this.baseSpeed;

        if (crouching && grounded && readyToJump)
        {
            rb.AddForce(Vector3.down * Time.deltaTime * 3000);
            return;
        }
        //Build up speed on slope
        if (crouching && onSlope)
        {
            rb.AddForce(Vector3.down * Time.deltaTime * slopeDownwardForce);
        }

        //If speed is larger than maxSpeed, cancel out the input so you don't go over max speed
        if (x > 0 && xMag > maxSpeed) x = 0;
        if (x < 0 && xMag < -maxSpeed) x = 0;
        if (y > 0 && yMag > maxSpeed) y = 0;
        if (y < 0 && yMag < -maxSpeed) y = 0;

        //Slow down, don't allow going to fast
        ///if (rb.velocity.magnitude > baseSpeed) SlowDown();

        //Some multipliers
        float multiplier = 1f, multiplierV = 1f;

        // Movement in air
        if (!grounded && !fullAirControl)
        {
            multiplier = 0.5f;
            multiplierV = 0.5f;
        }
        if (fullAirControl)
        {
            multiplier = 0.35f;
        }

        // Movement while sliding
        if (grounded && crouching) multiplierV = 0f;

        //Apply forces to move player
        rb.AddForce(orientation.transform.forward * y * moveSpeed * Time.deltaTime * multiplier * multiplierV);
        rb.AddForce(orientation.transform.right * x * moveSpeed * Time.deltaTime * multiplier);

        //Base speed handling (old
        ///if (rb.velocity.magnitude > baseSpeed - 3) IncreaseBaseSpeed();
        ///else if (baseSpeed > startBaseSpeed) DecreaseBaseSpeed();

        //Base speed handling
        if (rb.velocity.magnitude > baseSpeed + bSAccelPoint) IncreaseBaseSpeed();
        if (rb.velocity.magnitude < baseSpeed - bSDeccelPoint) DecreaseBaseSpeed();
        //Slow down if curr vel reaches slowDownPoint
        if (rb.velocity.magnitude > baseSpeed + slowDownPoint) SlowDown();
        else rb.drag = 0;
    }

    private void StartCrouch()
    {
        transform.localScale = crouchScale;
        transform.position = new Vector3(transform.position.x, transform.position.y - 0.5f, transform.position.z);
        if (rb.velocity.magnitude > 0.5f)
        {
            if (grounded)
            {
                rb.AddForce(orientation.transform.forward * slideForce);
            }
        }
    }

    private void StopCrouch()
    {
        transform.localScale = playerScale;
        transform.position = new Vector3(transform.position.x, transform.position.y + 0.5f, transform.position.z);
    }

    private void Jump()
    {
        if (grounded) { 
            readyToJump = false;

            //Add jump forces
            rb.AddForce(Vector3.up * jumpForce * 1.5f);
            rb.AddForce(normalVector * jumpForce * 0.5f);

            //If jumping while falling, reset y velocity.
            Vector3 vel = rb.velocity;
            if (rb.velocity.y < 0.5f)
                rb.velocity = new Vector3(vel.x, 0, vel.z);
            else if (rb.velocity.y > 0)
                rb.velocity = new Vector3(vel.x, vel.y / 2, vel.z);

            Invoke(nameof(ResetJump), jumpCooldown);
        }
        if (!grounded && !isWallRunning && doubleJumpsLeft >= 1){
            
            readyToJump = false;
            doubleJumpsLeft--;

            //Debug.Log("DoubleJump");

            //Add jump forces
            rb.AddForce(orientation.forward * jumpForce * 1f);
            rb.AddForce(Vector2.up * jumpForce * 1.7f);
            rb.AddForce(normalVector * jumpForce * 0.7f);

            //Dampen y velocity
            rb.velocity = new Vector3(rb.velocity.x, rb.velocity.y * 0.4f, rb.velocity.z);

            Invoke(nameof(ResetJump), jumpCooldown);
        }

        //Walljump
        if (isWallRunning && wallJumpsLeft >= 1)
        {

            //Debug.Log("WallJump");

            readyToJump = false;
            wallJumpsLeft--;

            //normal jump
            rb.AddForce(Vector2.up * jumpForce * 0.85f);
            rb.AddForce(normalVector * jumpForce * 0.5f);
            rb.AddForce(orientation.forward * jumpForce * 0.5f);
            if (isWallRight) rb.AddForce(-orientation.right * jumpForce * 1.5f);
            if (isWallLeft) rb.AddForce(orientation.right * jumpForce * 1.5f);

            /*sidwards wallhop
            if (isWallRight||isWallLeft && Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.D)) rb.AddForce(-orientation.up * jumpForce * 1f);
            if (isWallRight && Input.GetKey(KeyCode.A)) rb.AddForce(-orientation.right * jumpForce * 3.2f);
            if (isWallLeft && Input.GetKey(KeyCode.D)) rb.AddForce(orientation.right * jumpForce * 3.2f);
            */

            //Always add forward force
            rb.AddForce(orientation.forward * jumpForce * 1f);

            //Reset Velocity
            rb.velocity = Vector3.zero;

            Invoke(nameof(ResetJump), jumpCooldown);
        }
    }
    private void ResetJump()
    {
        readyToJump = true;
    }


    float elapsedWallTime;
    private void StartWallrun()
    {
        //Debug.Log("Wallrunning");

        //When to stop
        if (grounded) StopWallRun();

        //Count up timer
        elapsedWallTime += Time.deltaTime;

        //Leave wall run when timer reaches maximum
        if (elapsedWallTime > maxWallrunTime)
        {
            //StopWallRun();
        }

        //rb.useGravity = false;
        isWallRunning = true;

        //Add upward force
        rb.AddForce(orientation.up * wallrunUpwardForce * Time.deltaTime);

        if (rb.velocity.magnitude <= baseSpeed + wallSpeedAdd)
        {
            rb.AddForce(orientation.forward * wallrunForce * Time.deltaTime);

            //Make sure char sticks to wall
            if (isWallRight)
            rb.AddForce(orientation.right * wallrunForce / 5 * Time.deltaTime);
            else
                rb.AddForce(-orientation.right * wallrunForce / 5* Time.deltaTime);
        }
    }
    private void StopWallRun()
    {
        isWallRunning = false;
        readyToWallrun = false;

        //Reset timer
        elapsedWallTime = 0;
    }
    private void CheckForWall()
    {
       isWallRight = Physics.Raycast(transform.position, orientation.right, out wallHitR, 1f, whatIsGround);
       isWallLeft = Physics.Raycast(transform.position, -orientation.right, out wallHitL, 1f, whatIsGround);

        //if (!isWallLeft && !isWallRight) wallJumpsLeft = wallJumps;
        if (!isWallLeft && !isWallRight && isWallRunning) StopWallRun();
        if ((isWallLeft || isWallRight) && resetDoubleJumpsOnWall) doubleJumpsLeft = startDoubleJumps;
    }
    private void Climb()
    {
        //Makes possible to climb even when falling down fast
        Vector3 vel = rb.velocity;
        if (rb.velocity.y < 0.5f && !alreadyStoppedAtLadder){
            rb.velocity = new Vector3(vel.x, 0, vel.z);
            //Make sure char get's at wall
            alreadyStoppedAtLadder = true;
            rb.AddForce(orientation.forward * 500 * Time.deltaTime);
        }

        //Push character up
        if (rb.velocity.magnitude < baseSpeed + climbSpeedAdd)
        rb.AddForce(orientation.up * climbForce * Time.deltaTime);

        //Doesn't Push into the wall
        if (!Input.GetKey(KeyCode.S)) y = 0;
    }

    private void StartSlowMo()
    {
       // readyForSlowMo = false;
        slowMoPlane.SetActive(true);

        Time.timeScale = slowMoStrength;

        Invoke(nameof(StopSlowMo), slowMoTime * slowMoStrength);
    }
    private void StopSlowMo()
    {
        slowMoPlane.SetActive(false);

        Time.timeScale = 1f;

        Invoke(nameof(ResetSlowMo), slowMoCooldown);
    }
    private void ResetSlowMo()
    {
       // readyForSlowMo = true;
    }

    private float desiredX;
    private void Look()
    {
        float mouseX = Input.GetAxis("Mouse X") * sensitivity * Time.fixedDeltaTime * sensMultiplier;
        float mouseY = Input.GetAxis("Mouse Y") * sensitivity * Time.fixedDeltaTime * sensMultiplier;

        //Find current look rotation
        Vector3 rot = playerCam.transform.localRotation.eulerAngles;
        desiredX = rot.y + mouseX;

        //Rotate, and also make sure we dont over- or under-rotate.
        xRotation -= mouseY;
        xRotation = Mathf.Clamp(xRotation, -90f, 90f);

        //Perform the rotations
        playerCam.transform.localRotation = Quaternion.Euler(xRotation, desiredX, wallRunCameraTilt);
        orientation.transform.localRotation = Quaternion.Euler(0, desiredX, 0);

        //While Wallrunning
        //Tilts camera in .5 second
        if (Math.Abs(wallRunCameraTilt) < maxWallRunCameraTilt && isWallRunning && isWallRight)
            wallRunCameraTilt += Time.deltaTime * maxWallRunCameraTilt * 2;
        if (Math.Abs(wallRunCameraTilt) < maxWallRunCameraTilt && isWallRunning && isWallLeft)
            wallRunCameraTilt -= Time.deltaTime * maxWallRunCameraTilt * 2;

        //Tilts camera back again
        if (wallRunCameraTilt > 0 && !isWallRight && !isWallLeft)
            wallRunCameraTilt -= Time.deltaTime * maxWallRunCameraTilt * 2;
        if (wallRunCameraTilt < 0 && !isWallRight && !isWallLeft)
            wallRunCameraTilt += Time.deltaTime * maxWallRunCameraTilt * 2;
    }

    float timer1, timer2;
    float extraBaseDeccel; //Exponentially decrease base speed
    private void IncreaseBaseSpeed()
    {
        if (baseSpeed >= maxBaseSpeed) return;

        ///Debug.Log("Decreasing BaseSpeed");

        //Only increase in .1 ticks
        timer1 += Time.deltaTime * baseSpeedAccel;

        extraBaseDeccel = 0;

        if (timer1 > 1f)
        {
            baseSpeed += 0.1f;
            timer1 = 0;
        }
    }
    private void DecreaseBaseSpeed()
    {
        if (baseSpeed <= startBaseSpeed) return;

        ///Debug.Log("Increasing BaseSpeed");

        //Only decrease in .1 ticks
        timer2 += Time.deltaTime * baseSpeedDeccel * extraBaseDeccel;
        extraBaseDeccel += Time.deltaTime * 0.5f;

        if (timer2 > 1f)
        {
            baseSpeed -= 0.1f;
            timer2 = 0;
        }     
    }

    private bool allowDrag = true;
    private void SlowDown()
    {
        //Debug.Log("SlowingDown");

        ///Vector3 baseVelVector = rb.velocity.normalized * baseSpeed;

        ///rb.AddForce(-rb.velocity * 1f * Time.deltaTime, ForceMode.Impulse);

        //Debug.Log("Drag = 1");
        if (allowDrag) rb.drag = 1;
    }
    private void CounterMovement(float x, float y, Vector2 mag)
    {
        /*Limit diagonal running. Only when holding down W and D or W and A
        if (x != 0 && y != 0)
        {
            if (Mathf.Sqrt((Mathf.Pow(rb.velocity.x, 2) + Mathf.Pow(rb.velocity.z, 2))) > baseSpeed)
            {
                float fallspeed = rb.velocity.y;
                Vector3 n = rb.velocity.normalized * baseSpeed;
                rb.velocity = new Vector3(n.x, fallspeed, n.z);
            }
        } */

        //if (!grounded || jumping) return;
        if (!grounded || jumping || isWallRunning) return;

        //Slow down sliding
        if (crouching)
        {
            rb.AddForce(moveSpeed * Time.deltaTime * -rb.velocity.normalized * slideCounterMovement);
            return;
        }

        //Counter movement:
        ///Counters when no Input and still moving || Input in opposite direction then velocity
        if (Math.Abs(mag.x) > threshold && Math.Abs(x) < 0.05f || (mag.x < -threshold && x > 0) || (mag.x > threshold && x < 0))
        {
            rb.AddForce(moveSpeed * orientation.transform.right * Time.deltaTime * -mag.x * counterMovement);
        }
        if (Math.Abs(mag.y) > threshold && Math.Abs(y) < 0.05f || (mag.y < -threshold && y > 0) || (mag.y > threshold && y < 0))
        {
            rb.AddForce(moveSpeed * orientation.transform.forward * Time.deltaTime * -mag.y * counterMovement);
        }

        //Limit diagonal running. This will also cause a full stop if sliding fast and un-crouching, so not optimal.
        if (Mathf.Sqrt((Mathf.Pow(rb.velocity.x, 2) + Mathf.Pow(rb.velocity.z, 2))) > baseSpeed)
        {
            float fallspeed = rb.velocity.y;
            Vector3 n = rb.velocity.normalized * baseSpeed;
            rb.velocity = new Vector3(n.x, fallspeed, n.z);
        }
    }

    /// Find the velocity relative to where the player is looking
    /// Useful for vectors calculations regarding movement and limiting movement
    public Vector2 FindVelRelativeToLook()
    {
        float lookAngle = orientation.transform.eulerAngles.y;
        float moveAngle = Mathf.Atan2(rb.velocity.x, rb.velocity.z) * Mathf.Rad2Deg;

        float u = Mathf.DeltaAngle(lookAngle, moveAngle);
        float v = 90 - u;

        float magnitue = rb.velocity.magnitude;
        float yMag = magnitue * Mathf.Cos(u * Mathf.Deg2Rad);
        float xMag = magnitue * Mathf.Cos(v * Mathf.Deg2Rad);

        return new Vector2(xMag, yMag);
    }

    private bool IsFloor(Vector3 v)
    {
        float angle = Vector3.Angle(Vector3.up, v);
        return angle < maxSlopeAngle;
    }

    private bool cancellingGrounded;

    /// Handle ground detection
    private void OnCollisionEnter(Collision collision)
    {
        //Debug.Log(Vector3.Angle(transform.up, collision.contacts[0].normal));
    }
    private void OnCollisionStay(Collision other)
    {
        //Make sure we are only checking for walkable layers
        int layer = other.gameObject.layer;
        if (whatIsGround != (whatIsGround | (1 << layer))) return;

        //Iterate through every collision in a physics update
        for (int i = 0; i < other.contactCount; i++)
        {
            Vector3 normal = other.contacts[i].normal;
            //FLOOR
            if (IsFloor(normal))
            {
                onSlope = false;
                grounded = true;
                cancellingGrounded = false;
                normalVector = normal;
                CancelInvoke(nameof(StopGrounded));
            }
            else
            {
                onSlope = true;
            }

            //Save lastWall
            if (isWallRunning)
            {
                if (lastWall != other.gameObject)
                {
                   // Debug.Log("WallChanged!");
                    lastWall = other.gameObject;
                    wallJumpsLeft = wallJumps;
                }
            }
        }

        //Invoke ground/wall cancel, since we can't check normals with CollisionExit
        float delay = 3f;
        if (!cancellingGrounded)
        {
            cancellingGrounded = true;
            Invoke(nameof(StopGrounded), Time.deltaTime * delay);
        }
    }

    private void StopGrounded()
    {
        grounded = false;
    }

    #region abilityFunctions

    public void DashInDirection(Vector3 dir, float force)
    {
        rb.AddForce(dir * force, ForceMode.Impulse);
    }

    public void PreventDrag(float time)
    {
        allowDrag = false;
        Invoke(nameof(ResetAllowDrag), time);
    }
    private void ResetAllowDrag()
    {
        allowDrag = true;
    }

    #endregion
}