using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine;
using TMPro;

public class AnimateCircle : MonoBehaviour
{
    public GameObject blockObj;

    BlockObjectClass blockObjectClass;
    float inhalePeriod = 0f;
    float exhalePeriod = 0f;
    float maxRuntime = 0f;
    float runtime = 0f;

    private bool is_inhale; /* 1 if inhalation, 0 if exhaltion */
    private Vector3 scaleDiff = new Vector3(0.9f, 0.9f, 0.0f);
    private Vector3 originalScale = new Vector3(0.1f, 0.1f, 0.0f);
    private Vector3 finalScale = new Vector3(0.98f, 0.98f, 0.0f);
    private Vector3 inhaleVelocity = new Vector3(0.0f, 0.0f, 0.0f);
    private Vector3 exhaleVelocity = new Vector3(0.0f, 0.0f, 0.0f);

    private Transform parentTransform;
    private Vector3 parentCentrePosition = new Vector3(0f, 0f, 0f);
    private Vector3 parentOffsetPosition;

    // Start is called before the first frame update
    void Start()
    {
        is_inhale = true;
        originalScale = this.transform.localScale;
        scaleDiff = finalScale - originalScale;
        parentTransform = this.GetComponentInParent<Transform>().parent.transform;
        parentOffsetPosition = parentTransform.position;

        StateReset();
        this.enabled = false;
    }

    // Update is called once per frame
    void Update()
    {
        if(is_inhale)
        {
            UpdateInhaleScale();
        }
        else
        {
            UpdateExhaleScale();
        }
        UpdateRespState();
        UpdateRuntimeState();
        runtime += Time.deltaTime;
    }

    public void ResetAndRun()
    {
        this.enabled = true;
        StateReset();
    }

    public void MoveToCentre()
    {
        parentTransform.position = parentCentrePosition;
    }

    public void MoveToOffset()
    {
        parentTransform.position = parentOffsetPosition;
    }

    private void OnDisable()
    {
        StateReset();
    }

    void StateReset()
    {
        SetPeriod();
        SetMaxRuntime();
        inhaleVelocity = scaleDiff / inhalePeriod;
        exhaleVelocity = scaleDiff / exhalePeriod;
        this.transform.localScale = originalScale;
        runtime = 0f;
    }

    void SetPeriod()
    {
        blockObjectClass = blockObj.GetComponent<BlockObjectClass>();
        inhalePeriod = blockObjectClass.InhalePeriod;
        exhalePeriod = blockObjectClass.ExhalePeriod;
    }
    void SetMaxRuntime()
    {
        blockObjectClass = blockObj.GetComponent<BlockObjectClass>();
        maxRuntime = blockObjectClass.MaxRuntime;
    }

    void UpdateInhaleScale()
    {
        float dt = Time.deltaTime;
        Vector3 scale = this.transform.localScale;
        this.transform.localScale = inhaleVelocity*dt + scale;
    }

    void UpdateExhaleScale()
    {
        float dt = Time.deltaTime;
        Vector3 scale = this.transform.localScale;
        this.transform.localScale = -exhaleVelocity*dt + scale;
    }

    void UpdateRespState()
    {
        Vector3 scale = this.transform.localScale;
        if(scale.x >= finalScale.x | scale.x <= originalScale.x)
        {
            if (is_inhale)
            {
                this.transform.localScale = finalScale;
            }
            else
            {
                this.transform.localScale = originalScale;
            }
            is_inhale = !is_inhale;
        }
    }

    void UpdateRuntimeState()
    {
        if (runtime >= maxRuntime)
        {
            StateReset();
            this.enabled = false;
        }
    }
}