Stopwatch.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using KongZEE.Timer.Delay;
using UnityEngine;
using UnityEngine.Events;

namespace KongZEE.Timer
{
    [Serializable]
    public class Stopwatch
    {
        private MonoBehaviour monoBehaviour;
        Dictionary<StopwatchKey, Coroutine> coroutines = new();
        private StopwatchKey _stopwatchKeyDisposable;

        public Stopwatch(MonoBehaviour monoBehaviour)
        {
            this.monoBehaviour = monoBehaviour;
        }

        public void StartTimerDisposable(UnityAction<float> action = null)
        {
            if (coroutines.Count > 0 && coroutines.ContainsKey(_stopwatchKeyDisposable))
            {
                monoBehaviour.StopCoroutine(coroutines[_stopwatchKeyDisposable]);
                coroutines.Remove(_stopwatchKeyDisposable);
            }            
            
            _stopwatchKeyDisposable = StartTimer(0, action);
        }

        public StopwatchKey StartTimer(UnityAction<float> action = null)
        {
            return StartTimer(0, action);
        }

        public StopwatchKey StartTimer(float startTime = 0, UnityAction<float> action = null)
        {
            StopwatchKey stopwatchKey = new StopwatchKey();
            
            stopwatchKey.time = startTime;

            if (action != null)
            {
                action += time => { stopwatchKey.time = time;};
            }

            Coroutine coroutine = monoBehaviour.StartCoroutine(StopwatchRunner(() => stopwatchKey.time, () => stopwatchKey.paused, () => stopwatchKey.stop, action));
            coroutines.Add(stopwatchKey, coroutine);
            stopwatchKey.action = action;

            return stopwatchKey;
        }
        
        public void ResumeTimer(StopwatchKey stopwatchKey = null)
        {
            if (stopwatchKey == null)
            {
                if (coroutines.Count > 0)
                {
                    coroutines.Keys.ElementAt(0).paused = false;
                }
            }
            else if (coroutines.ContainsKey(stopwatchKey))
            {
                stopwatchKey.paused = false;
            }
        }

        public void PauseTimer(StopwatchKey stopwatchKey = null)
        {
            if (stopwatchKey == null)
            {
                if (coroutines.Count > 0)
                {
                    coroutines.Keys.ElementAt(0).paused = true;
                    
                    Debug.Log($"Pause Timer Name : {monoBehaviour.gameObject.name}");
                }
            }
            else if (coroutines.ContainsKey(stopwatchKey))
            {
                stopwatchKey.paused = true;
                
                Debug.Log($"Pause Timer Name : {monoBehaviour.gameObject.name}");
            }
        }

        public void StopTimer(StopwatchKey stopwatchKey = null)
        {
            if (stopwatchKey == null)
            {
                if (coroutines.Count > 0)
                {
                    monoBehaviour.StopCoroutine(coroutines.Values.ElementAt(0));
                }
            }
            else if (coroutines.ContainsKey(stopwatchKey))
            {
                stopwatchKey.stop = true;
                stopwatchKey.paused = true;
                stopwatchKey.action = null;
                monoBehaviour.StopCoroutine(coroutines[stopwatchKey]);
                coroutines.Remove(stopwatchKey);
            }
        }

        public void ResetTimer(StopwatchKey stopwatchKey = null)
        {
            if (coroutines.Count < 0) return;

            if (stopwatchKey == null)
            {
                if (coroutines.Count > 0)
                {
                    monoBehaviour.StopCoroutine(coroutines.Values.ElementAt(0));
                    coroutines.Remove(coroutines.Keys.ElementAt(0));
                }
            }
            else if (coroutines.ContainsKey(stopwatchKey))
            {
                monoBehaviour.StopCoroutine(coroutines[stopwatchKey]);
                coroutines.Remove(stopwatchKey);
            }

            StopwatchKey currentDelayKey = stopwatchKey ?? coroutines.Keys.ElementAt(0);
            currentDelayKey.paused = false;
            currentDelayKey.stop = false;
            currentDelayKey.action?.Invoke(0.0f);
            currentDelayKey.time = 0.0f;
            Coroutine coroutine = monoBehaviour.StartCoroutine(StopwatchRunner(() => currentDelayKey.time, () => currentDelayKey.paused, () => currentDelayKey.stop, currentDelayKey.action));
            coroutines.Add(currentDelayKey, coroutine);
        }

        public void StopAllTimers()
        {
            foreach (var coroutine in coroutines)
            {
                monoBehaviour.StopCoroutine(coroutine.Value);
            }
        }

        private IEnumerator StopwatchRunner(Func<float> startTime, Func<bool> pauseFunc, Func<bool> stopFunc, UnityAction<float> action)
        {
            bool pause = pauseFunc?.Invoke() ?? true;
            
            while (!stopFunc?.Invoke() ?? true)
            {
                pause = pauseFunc?.Invoke() ?? true;
                float time = startTime?.Invoke() ?? 0.0f;
                
                if (!pause)
                {
                    time += Time.deltaTime;
                    action?.Invoke(time);
                }

                yield return null;
            }
        }
    }

    [Serializable]
    public class StopwatchKey
    {
        public bool paused;
        public bool stop;
        public float time;
        public UnityAction<float> action;

        public StopwatchKey()
        {

        }

        public StopwatchKey(bool paused, bool stop, float time, UnityAction<float> action)
        {
            this.paused = paused;
            this.stop = stop;
            this.time = time;
            this.action = action;
        }
    }
}