using UnityEngine;

public class ApplyForceController : MonoBehaviour
{
    //replicates the same functions as the normal apply force but for a controller.
    //unable to perform small movements. Joystick movement is only detected after 0.5 on an axis.

    private Rigidbody2D playerObject;
    private LineRenderer dragLine;
    private InputManager inputMgr;
    private LevelCameraEffects levelCamera;
    private AchievementSystem achSys;
    private PlayerTrailParticles playerParticles;
    private Vector2 dragLineStartPos;
    private Vector2 dragLineEndPos;
    private Vector2 joyStartPos;
    private Vector2 joyEndPos;
    private bool forceApplied = false;
    private float timeSinceForce = 0.0f;
    private bool overUI;
    private bool manuallyDisabledMovement;
    private bool invertedMovementEnabled;
    private bool unlockBoosted;

    public int forceMultiplier;
    public AnimationCurve forceCurve;
    private int defaultForceMultiplierValue;
    private float timeBeforeNextForce = 1.0f;
    public float forceMaxDistance;

    public float TimeBeforeNextForce { get => timeBeforeNextForce; set => timeBeforeNextForce = value; }
    public bool ForceApplied { get => forceApplied; set => forceApplied = value; }
    public bool ManuallyDisabledMovement { get => manuallyDisabledMovement; set => manuallyDisabledMovement = value; }

    private void Start()
    {
        playerObject = ObjectManager.GetObject(0).GetComponent<Rigidbody2D>();
        playerParticles = ObjectManager.GetObject(0).GetComponent<PlayerTrailParticles>();
        dragLine = ObjectManager.GetObject(1).GetComponent<LineRenderer>();
        inputMgr = ObjectManager.GetObject(4).GetComponent<InputManager>();
        levelCamera = GUIManager.GetObject(12).GetComponent<LevelCameraEffects>();
        achSys = ObjectManager.GetObject(4).GetComponent<AchievementSystem>();
        defaultForceMultiplierValue = forceMultiplier;

        GUIManager.SetSpeedBoostTextState(false);
    }

    private void Update()
    {
        if (!manuallyDisabledMovement)
        {
            dragLineStartPos = playerObject.transform.position;

            if (!forceApplied)
            {
                float positionDifferece;

                positionDifferece = Vector2.Distance(joyStartPos, joyEndPos);

                float curveValue = forceCurve.Evaluate(Mathf.InverseLerp(0, forceMaxDistance, positionDifferece));

                float redColor = curveValue;
                float greenColor = 1 - redColor;
                Color lineColor = new Color(redColor, greenColor, 0);
                dragLine.startColor = lineColor;
                dragLine.endColor = lineColor;
            }

            if (forceApplied)
            {
                timeSinceForce += Time.deltaTime;
                GUIManager.SetCooldownCircleValue(timeSinceForce, timeBeforeNextForce);

                if (timeSinceForce >= timeBeforeNextForce)
                {
                    GUIManager.FadeOutCooldownCircle();
                    forceApplied = false;
                    timeSinceForce = 0.0f;
                }
            }
        }
        else
            dragLine.enabled = false;
    }

    public void AdjustForceMultiplier(int newValue)
    {
        forceMultiplier += newValue;

        AdjustSpeedBoostTextVisibility();
    }

    public void SetUnlockBoosted(bool state)
    {
        //when true, the force multiplier gets boosted by 30
        unlockBoosted = state;

        if (unlockBoosted)
            forceMultiplier = defaultForceMultiplierValue + 30;
        else
            forceMultiplier = defaultForceMultiplierValue;

        AdjustSpeedBoostTextVisibility();
    }

    public void ResetForceMultiplier()
    {
        if (unlockBoosted)
            forceMultiplier = defaultForceMultiplierValue + 30;
        else
            forceMultiplier = defaultForceMultiplierValue;

        AdjustSpeedBoostTextVisibility();
    }

    public void AdjustSpeedBoostTextVisibility()
    {
        if (forceMultiplier < defaultForceMultiplierValue)
            forceMultiplier = defaultForceMultiplierValue;

        if (forceMultiplier - defaultForceMultiplierValue > 0)
        {
            GUIManager.SetSpeedBoostTextState(true);
            GUIManager.ChangeSpeedBoostText(forceMultiplier - defaultForceMultiplierValue);

            if ((forceMultiplier - defaultForceMultiplierValue) > 140)
                achSys.SetMaxSpeedBoost(forceMultiplier - defaultForceMultiplierValue);
        }
        else
            GUIManager.SetSpeedBoostTextState(false);
    }

    public void SetInvertedMovementState(bool newState)
    {
        invertedMovementEnabled = newState;
    }

    public void ResetCoolDown()
    {
        //called to reset cooldown instantly.
        if (forceApplied)
            timeSinceForce = timeBeforeNextForce;
    }

    public void OnJoystickBeginMove()
    {
        if (!manuallyDisabledMovement && this.enabled)
        {
            if (inputMgr != null)
            {
                if (!inputMgr.GetMouseOverUI())
                {
                    dragLine.enabled = true;

                    joyStartPos = new Vector2(0, 0);


                    dragLine.SetPosition(0, dragLineStartPos);
                    dragLine.SetPosition(1, dragLineStartPos);
                }
                else
                    overUI = true;
            }
        }
    }

    public void OnJoystickHeld()
    {
        if (!manuallyDisabledMovement && this.enabled)
        {
            if (inputMgr != null && !overUI)
            {
                //get the vector for the joystick instead
                Vector2 joyVector = inputMgr.GetJoystickPosition();

                joyEndPos = joyVector;

                float xPosDifference = joyEndPos.x - joyStartPos.x;
                float yPosDifference = joyEndPos.y - joyStartPos.y;

                dragLineEndPos = new Vector2(dragLineStartPos.x + xPosDifference, dragLineStartPos.y + yPosDifference);


                if (!invertedMovementEnabled)
                {
                    dragLine.SetPosition(0, dragLineStartPos);
                    dragLine.SetPosition(1, dragLineEndPos);
                }
                else
                {
                    dragLine.SetPosition(1, dragLineStartPos);
                    dragLine.SetPosition(0, dragLineEndPos);
                }
            }
        }

    }

    public void OnTriggerPull()
    {
        if (!manuallyDisabledMovement && this.enabled)
        {
            if (inputMgr != null && !overUI)
            {
                dragLine.enabled = false;

                float positionDifferece = Vector2.Distance(dragLineStartPos, dragLineEndPos);

                if (positionDifferece > forceMaxDistance)
                    positionDifferece = forceMaxDistance;

                Transform linePos = dragLine.gameObject.transform.parent.transform;

                if (forceApplied == false && positionDifferece > 0.0001f)
                {
                    //using a custom curve and the position difference of the drag line, find the interpolated value that determines how much force should be applied
                    float curveValue = forceCurve.Evaluate(Mathf.InverseLerp(0, forceMaxDistance, positionDifferece));

                    //multiply the curve value by 10 to get a value between 0 and 10 and then multiply that by the force multiplier
                    playerObject.AddForce(linePos.forward * (curveValue * 10 * forceMultiplier));

                    levelCamera.ApplyZoomEffect(positionDifferece);
                    GUIManager.FadeInCooldownCircle();
                    forceApplied = true;
                    playerParticles.EmitBurst();
                }
            }
            else
                overUI = false;
        }
    }

    public void HideDragLine()
    {
        if (this.enabled)
            dragLine.enabled = false;
    }

    public void OnDisable()
    {
        ForceApplied = false;
        overUI = false;

        ResetCoolDown();
        ResetForceMultiplier();
        timeSinceForce = 0;
    }
}