using UnityEngine;

/// Eonir Studio UST
/// For any informations, questions or ideas feel free to contact me on Discord https://discord.com/invite/wXR2mWY
/// Thanks for purchasing this asset!

public class WeaponMovement : MonoBehaviour
{
    [Header("Idle")]
    public float moveRotX;
    public float moveRotY;
    public float moveRotZ;
    public float moveScaleIdle;
    public Vector3 idleBreathSpeed = Vector3.one;

    [Header("Walking")]
    public float walkingSpeed;
    [Space]
    public float walkingPosAmountX;
    public float walkingPosAmountY;
    public float walkingPosAmountZ;
    [Space]
    public float walkingRotAmountX;
    public float walkingRotAmountY;
    public float walkingRotAmountZ;

    [Header("Running")]
    public float runningSpeed;
    [Space]
    public float runningPosAmountX;
    public float runningPosAmountY;
    public float runningPosAmountZ;
    [Space]
    public float runningRotAmountX;
    public float runningRotAmountY;
    public float runningRotAmountZ;

    [Header("Walk Tiny Rotation ")]
    public float walkTinyRotX;
    public float walkTinyRotY;
    public float walkTinyRotZ;
    public float walkMoveScale;
    public Vector3 walkingMovingSpeed = Vector3.one;

    [Header("Run Tiny Rotation ")]
    public float runTinyRotX;
    public float runTinyRotY;
    public float runTinyRotZ;
    public float runMoveScale;
    public Vector3 runningMovingSpeed = Vector3.one;

    UstController ust;

    Transform positionPoint;
    ItemPosition positionPointScript;
    //Transform globalRotationPoint;
    Transform tinyRotationPoint;
    TinyRotation tinyRotationPointScript;

    Vector3 progression;

    float defaultPosX;
    float defaultPosY;
    float defaultPosZ;

    //float defaultRotX;
    //float defaultRotY;
    //float defaultRotZ;

    float tinydefaultPosX;
    float tinydefaultPosY;
    float tinydefaultPosZ;

    float tinydefaultRotX;
    float tinydefaultRotY;
    float tinydefaultRotZ;

    float timer;

    void Start()
    {
        ust = GetComponentInParent<UstController>();

        //globalRotationPoint = GameObject.FindGameObjectWithTag("GlobalRotation").transform;
        //positionPoint = GameObject.FindGameObjectWithTag("ItemPosition").transform;

        positionPointScript = GetComponentInParent<ItemPosition>();
        positionPoint = positionPointScript.transform;

        //tinyRotationPoint = GameObject.FindGameObjectWithTag("TinyRotation").transform;

        tinyRotationPointScript = GetComponentInParent<TinyRotation>();
        tinyRotationPoint = tinyRotationPointScript.transform;

        defaultPosX = positionPointScript.defaultPosX;
        defaultPosY = positionPointScript.defaultPosY;
        defaultPosZ = positionPointScript.defaultPosZ;

        //defaultRotX = globalRotationPoint.transform.localRotation.x;
        //defaultRotY = globalRotationPoint.transform.localRotation.y;
        //defaultRotZ = globalRotationPoint.transform.localRotation.z;

        tinydefaultPosX = tinyRotationPointScript.tinydefaultPosX;
        tinydefaultPosY = tinyRotationPointScript.tinydefaultPosY;
        tinydefaultPosZ = tinyRotationPointScript.tinydefaultPosZ;

        tinydefaultRotX = tinyRotationPointScript.tinydefaultRotX;
        tinydefaultRotY = tinyRotationPointScript.tinydefaultRotY;
        tinydefaultRotZ = tinyRotationPointScript.tinydefaultRotZ;
    }

    void UpdateMovementBaseOnSpeed(float moveScale, float x, float y, float z)
    {
        Vector3 currentPosition = tinyRotationPoint.localPosition;

        Vector3 magnetPosition = moveScale * new Vector3(
        x * Mathf.Sin(progression.x),
        y * Mathf.Cos(progression.y),
        z * (Mathf.Cos(progression.z) + Mathf.Sin(progression.z)));
        Vector3 newPosition = Vector3.Lerp(currentPosition, magnetPosition, Time.deltaTime * 2);
        tinyRotationPoint.localPosition = newPosition;
    }

    private void MovePositionAndRotation(float moveSpeed, float posAmountx, float posAmounty, float posAmountz, float rotAmountx, float rotAmounty, float rotAmountz)
    {
        timer += Time.deltaTime * moveSpeed;

        positionPoint.transform.localPosition = new Vector3(
        defaultPosX + Mathf.Sin(timer) * posAmountx,
        defaultPosY + Mathf.Sin(timer) * posAmounty,
        defaultPosZ + Mathf.Sin(timer) * posAmountz);

        tinyRotationPoint.transform.localRotation = Quaternion.Euler(new Vector3(
        tinydefaultRotX + Mathf.Sin(timer) * rotAmountx,
        tinydefaultRotY + Mathf.Sin(timer) * rotAmounty,
        tinydefaultRotZ + Mathf.Sin(timer) * rotAmountz));
    }

    void ResetPositionAndRotationOnIdle()
    {
        timer = 0;
        progression = new Vector3(0,0,0);

        positionPoint.localPosition = new Vector3(
        Mathf.Lerp(positionPoint.localPosition.x, defaultPosX, Time.deltaTime * 10),
        Mathf.Lerp(positionPoint.localPosition.y, defaultPosY, Time.deltaTime * 10),
        Mathf.Lerp(positionPoint.localPosition.z, defaultPosZ, Time.deltaTime * 10));

        //globalRotationPoint.localRotation = Quaternion.Euler(new Vector3(
        //Mathf.Lerp(globalRotationPoint.localRotation.x, defaultRotX, Time.deltaTime * 10),
        //Mathf.Lerp(globalRotationPoint.localRotation.y, defaultRotY, Time.deltaTime * 10),
        //Mathf.Lerp(globalRotationPoint.localRotation.z, defaultRotZ, Time.deltaTime * 10)));

        tinyRotationPoint.localPosition = new Vector3(
        Mathf.Lerp(tinyRotationPoint.localPosition.x, tinydefaultPosX, Time.deltaTime * 10),
        Mathf.Lerp(tinyRotationPoint.localPosition.y, tinydefaultPosY, Time.deltaTime * 10),
        Mathf.Lerp(tinyRotationPoint.localPosition.z, tinydefaultPosZ, Time.deltaTime * 10));

        tinyRotationPoint.localRotation = Quaternion.Euler(new Vector3(
        Mathf.Lerp(tinyRotationPoint.localRotation.x, tinydefaultRotX, Time.deltaTime * 10),
        Mathf.Lerp(tinyRotationPoint.localRotation.y, tinydefaultRotY, Time.deltaTime * 10),
        Mathf.Lerp(tinyRotationPoint.localRotation.z, tinydefaultRotZ, Time.deltaTime * 10)));
    }

    void Update()
    {
        if (!ust.isMoving && !Inventory.isInInventory && ust.charController.isGrounded)
        {
            if (!ust.isAiming)
            {
                UpdateMovementBaseOnSpeed(moveScaleIdle, moveRotX, moveRotY, moveRotZ);
                progression += Time.deltaTime * idleBreathSpeed;
                //MovePositionAndRotation(idleSpeed, idlePosAmountX, idlePosAmountY, idlePosAmountZ, idleRotAmountX, idleRotAmountY, idleRotAmountZ);
            }
        }

        if (ust.isAiming)
        {
            ResetPositionAndRotationOnIdle();
        }

        if (ust.isMoving)
        {
            if (!ust.isAiming)
            {
                if (ust.charController.isGrounded && !Inventory.isInInventory)
                {
                    if (ust.isRunning && ust.canRun)
                    {
                        UpdateMovementBaseOnSpeed(runMoveScale, runTinyRotX, runTinyRotY, runTinyRotZ);
                        progression += Time.deltaTime * runningMovingSpeed;

                        MovePositionAndRotation(runningSpeed, runningPosAmountX, runningPosAmountY, runningPosAmountZ, runningRotAmountX, runningRotAmountY, runningRotAmountZ);
                    }
                    else
                    {
                        UpdateMovementBaseOnSpeed(walkMoveScale, walkTinyRotX, walkTinyRotY, walkTinyRotZ);
                        progression += Time.deltaTime * walkingMovingSpeed;

                        MovePositionAndRotation(walkingSpeed, walkingPosAmountX, walkingPosAmountY, walkingPosAmountZ, walkingRotAmountX, walkingRotAmountY, walkingRotAmountZ);
                    }
                }
            }
            else
            {
                ResetPositionAndRotationOnIdle();
            }
        }
        //else
        //{
        //    ResetPositionAndRotationOnIdle();
        //}
    }
}