using UnityEngine;

public class CarMovement : MonoBehaviour
{
    [Header("Ship Handeling")]
    [SerializeField] private float accelaration = 50f;
    [SerializeField] private float maxSpeed = 200f;
    private float oldMaxSpeed;
    [SerializeField] private float maxBoost = 300f;
    [SerializeField] private float brakeSpeed = 70f;
    [SerializeField] private float turnSpeed = 10f;
    [SerializeField] private float airTurnSpeed = 3f;
    private float input = 0f; // horizontal axis
    [SerializeField] private float currentSpeed;
    private bool isDead;

    private bool canBoost;

    [Header("Hovering")]
    [SerializeField] private LayerMask groundLayer; // layer we can hover on
    private Rigidbody rb;
    private Vector3 prevUpDir; // stores transform.up
    [SerializeField] private float hoverHeight = 3f; // distance from the ground
    [SerializeField] private float heightSmoothing = 10f; // how fast the ship will readjust to "Hoverheight"
    [SerializeField] private float normalRotSmoothing = 50f; // how fast the ship will adjust its rotatioin to match ground normal
    private float smoothY = 1f;
    [SerializeField] private float startDelay = 0.2f;
    [SerializeField] private bool isGrounded;
    [Header("dropping")]
    [SerializeField] private float dropOffTime = 0.2f;
    private bool isDroppingOff;
    private float oldDropOffTime;
    [SerializeField] private float rotationLerp = 7f; // how fast we will rotate towards the ground if the ship is in the air
    [SerializeField] private float positionLerp = 5f; // how fast ship will sink down if is in the air
    private float oldPositionLerp;
    private bool dropOffForceAdded;

    private void Start()
    {
        // ship handeling
        currentSpeed = 0f;
        oldMaxSpeed = maxSpeed;
        canBoost = true;
        isDead = false;
        //hovering
        rb = GetComponent<Rigidbody>();
        //rb.useGravity = false;
        isGrounded = true;

        //dropping
        isDroppingOff = false;
        oldDropOffTime = dropOffTime;
        oldPositionLerp = positionLerp;
        dropOffForceAdded = false;
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            DropOff();
        }

        if (startDelay >= 0f)
        {
            startDelay -= Time.deltaTime;
        }

        input = Input.GetAxis("Horizontal");

        if (startDelay <= 0)
        {
            DrivingBehaviour();
        }
        
    }

    private void DrivingBehaviour()
    {
        if (isDead)
        {
            //stops movement if dead
            currentSpeed = 0;
            rb.velocity = Vector3.zero;
            GetComponent<CarMovement>().enabled = false;
            transform.gameObject.isStatic = true;
            return;
        }

        if (isDroppingOff)
        {
            //can boost while on ground
            canBoost = true;

            //input
            if (HasInput())
            {
                // moving
                if (!IsBoosting())
                {
                    maxSpeed = oldMaxSpeed;
                    Accelerate(accelaration);
                }
                else
                {
                    maxSpeed = maxBoost;
                    Accelerate(accelaration * 2);
                }

                if (currentSpeed >= maxSpeed)
                {
                    Brake(brakeSpeed);
                }
            }
            else
            {
                // no input? brake
                Brake(brakeSpeed);
            }

            // set velocity to zero if not moving and if not dropping off
            if (currentSpeed <=0f && isGrounded)
            {
                rb.velocity = Vector3.zero;
            }
            // get current up dir for fixedupdate calculations
            prevUpDir = transform.up;
        }
        else
        {
            // if dropping off stop boosting
            canBoost = false;

            //add little force to velocity once we take off
            if (!dropOffForceAdded)
            {
                rb.velocity += new Vector3(0, 250, 0);
                dropOffForceAdded = true;
            }
            //start brake, so we cant fly in the air
            // also decrease brakesped a little amount so we can glide a little longer
            Brake(brakeSpeed / 1.5f);

            // measure time we are in the air
            dropOffTime -= Time.deltaTime;
        }
    }

    private void FixedUpdate()
    {
        if (isDead) 
        {
            return;
        }

        // turning
        if (IsTurning())
        {
            if (isDroppingOff)
            {
                TurnShip(airTurnSpeed);
            }
            else
            {
                TurnShip(turnSpeed);
            }
        }
        else
        {
            // if we dont turn, then stop the angular rotation
            rb.angularVelocity = Vector3.Lerp(rb.angularVelocity, Vector3.zero, 0.05f * Time.deltaTime);
        }

        // if we are not in the air
        if (!isDroppingOff)
        {
            //normal alignment
            RaycastHit hit;
            if (Physics.Raycast(transform.position, /*-prevUpDir*/ Vector3.down * 10, out hit, 10f, groundLayer))
            {
                // we hit the groudn
                isGrounded = true;
                //smooth new up vector
                Vector3 desiredUp = Vector3.Lerp(prevUpDir, hit.normal, Time.deltaTime * normalRotSmoothing); // fixedDeltaTime??\
                //get the angle
                Quaternion tilt = Quaternion.FromToRotation(transform.up, desiredUp) * transform.rotation;
                // apply rotation
                transform.localRotation = tilt;
                // smoothly adjust height
                smoothY = Mathf.Lerp(smoothY, hoverHeight - hit.distance, Time.deltaTime * heightSmoothing); // fixedDeltaTime??

                smoothY = smoothY <= 0.01f ? 0f : smoothY;
                transform.localPosition += prevUpDir * smoothY;
            }
            else
            {
                // if we dont hit anything that means we are in the arir
                DropOff();
            }
        }
        else
        {
            //if we are in the air
            RaycastHit rotationHit;
            // rotate towards ground normal
            if (Physics.Raycast(transform.position, Vector3.down * 10, out rotationHit, groundLayer))
            {
                Vector3 desiredUp = Vector3.Lerp(transform.up, Vector3.up, Time.deltaTime * normalRotSmoothing); // fixedDeltatime?
                // get the angel
                Quaternion tilt = Quaternion.FromToRotation(transform.up, desiredUp) * transform.rotation;
                //apply rotation
                transform.localRotation = Quaternion.Lerp(transform.localRotation, tilt, rotationLerp * Time.deltaTime); // fixedDeltaTime?
                Debug.DrawRay(transform.position, Vector3.down * 10, Color.red);
                Debug.Log(groundLayer);
            }


            // only sink for a given amount ot time so we dont get extremely high values
            if (dropOffTime <= 0)
            {
                // increase lerp value over time so we sink faster and faster
                positionLerp += 10 * Time.deltaTime; // fixed delta time?
                //start sinking
                transform.localPosition += Vector3.down * 9.81f * positionLerp * Time.deltaTime; // fixed?
                RaycastHit hit;
                // check distance ground
                if (Physics.Raycast(transform.position, Vector3.down * 10, out hit, groundLayer))
                {
                    // if we are at our hoverheight againt
                    if (hit.distance <= hoverHeight)
                    {
                        dropOffTime = oldDropOffTime;
                        // reset bool for next dropoff
                        dropOffForceAdded = false;
                        positionLerp = oldPositionLerp;
                        //get back to the ground

                        Debug.Log("raycast" + hit);
                        DropOn();
                    }
                }
            }
        }

        // now actually move the ship
        MoveShip(currentSpeed * 80);
    }

    private void TurnShip(float speed)
    {
        rb.AddTorque(prevUpDir * speed * input * Time.fixedDeltaTime, ForceMode.Impulse);
    }

    private bool IsTurning()
    {
        return (Input.GetAxis("Horizontal") > 0 || Input.GetAxis("Horizontal") < 0);
    }


    private void Accelerate(float speed)
    {
        // if current speed is greater than max speed, only add 0f so we dont get faster and faster
        // else apply our acceleration
        currentSpeed += (currentSpeed >= maxSpeed) ? 0f : speed * Time.deltaTime;
    }

    private void MoveShip(float speed)
    {
        // move ship forard with current speed
        rb.velocity = transform.forward * speed * Time.fixedDeltaTime;
    }

    private void Brake(float brakeSpeed)
    {
        if (currentSpeed > 0)
        {
            //decrease only if it's greater than 0, so we dont start flying backwards
            currentSpeed -= brakeSpeed * Time.deltaTime;
        }
        else
        {
            //set speed to 0 if we cant brake anymore
            currentSpeed = 0;
        }
    }

    private bool HasInput()
    {
        return (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow));
    }

    private bool IsBoosting()
    {
        //only boost if we get correct input and we can boost
        return ((Input.GetKey(KeyCode.B)) && canBoost);
    }
    
    private void DropOff()
    {
        if (!isDroppingOff)
        {
            //not on the ground
            isGrounded = false;
            isDroppingOff = true;
        }
    }

    private void DropOn()
    {
        // on the ground again
        isGrounded = true;
        isDroppingOff = false;
    }


}