/* author: YKMoon
 * 计时器
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace YKMoon
{
    internal abstract class ABaseTimer
    {
        protected float time;
        protected bool unscaled = false;
        public ABaseTimer(float time, bool unscaled = false)
        {
            this.time = time;
            this.unscaled = unscaled;
        }
        public virtual void Update(float deltaTime, float unscaledDeltaTime)
        {
            if(time > 0) {
                time -= unscaled ? unscaledDeltaTime : deltaTime;
            }
        }
        public abstract void OnTimeUp();
        public virtual bool IsTimeUp() { return time <= 0; }
    }

    internal class UTimerEvent : ABaseTimer
    {
        private System.Action timeupEvent;
        public UTimerEvent(System.Action timeupEvent, float time, bool unscaled = false) : 
            base(time, unscaled) 
        {
            this.timeupEvent = timeupEvent;
        }
        public override void OnTimeUp()
        {
            timeupEvent?.Invoke();
        }
    }

    internal class UTimerEvent<T> : ABaseTimer
    {
        private System.Action<T> timeupEvent;
        private T parameter;
        public UTimerEvent(System.Action<T> timeupEvent, T parameter,
            float time, bool unscaled = false) : base(time, unscaled)
        {
            this.timeupEvent = timeupEvent;
            this.parameter = parameter;
        }
        public override void OnTimeUp()
        {
            timeupEvent?.Invoke(parameter);
        }
    }

    internal class UTimerEvent<T, V> : ABaseTimer
    {
        public System.Action<T, V> timeupEvent;
        public T parameter1;
        public V parameter2;
        public UTimerEvent(System.Action<T, V> timeupEvent, T parameter1, V parameter2,
            float time, bool unscaled = false) : base(time, unscaled)
        {
            this.timeupEvent = timeupEvent;
            this.parameter1 = parameter1;
            this.parameter2 = parameter2;
        }
        public override void OnTimeUp()
        {
            timeupEvent?.Invoke(parameter1, parameter2);
        }
    }

    internal class UTimerEvent<T, V, K> : ABaseTimer
    {
        public System.Action<T, V, K> timeupEvent;
        public T parameter1;
        public V parameter2;
        public K parameter3;
        public UTimerEvent(System.Action<T, V, K> timeupEvent, T parameter1, V parameter2, K parameter3,
            float time, bool unscaled = false) : base(time, unscaled)
        {
            this.timeupEvent = timeupEvent;
            this.parameter1 = parameter1;
            this.parameter2 = parameter2;
            this.parameter3 = parameter3;
        }
        public override void OnTimeUp()
        {
            timeupEvent?.Invoke(parameter1, parameter2, parameter3);
        }
    }
    /// <summary>
    /// 延迟事件管理
    /// </summary>
    public class YKTimerManager : USingletonMono<YKTimerManager>, IUSingletonEventHandler
    {
        private Dictionary<int, ABaseTimer> delayEvents = new Dictionary<int, ABaseTimer>();
        private IDGenerator iDGeneratorDelay = new IDGenerator(200000);

        public void OnCreateSingleton()
        {
            Init();
        }

        public void Init()
        {
            delayEvents.Clear();
            iDGeneratorDelay.Clear();
        }

        private void Update()
        {
            var dict = DictPool<int, ABaseTimer>.Get();
            foreach(var pair in delayEvents) {
                dict.Add(pair.Key, pair.Value);
            }
            var removeList = QueuePool<int>.Get();
            foreach(var e in dict) {
                if(!e.Value.IsTimeUp()) {
                    e.Value.Update(Time.deltaTime, Time.unscaledDeltaTime);
                } else {
                    removeList.Enqueue(e.Key);
                }
            }
            while(removeList.Count > 0) {
                RemoveDelayEvent(removeList.Dequeue(), true);
            }
            QueuePool<int>.Release(removeList);
            DictPool<int, ABaseTimer>.Release(dict);
        }

        private int AddNewTimer(ABaseTimer newEvent)
        {
            int id = iDGeneratorDelay.GetNextUIId();
            delayEvents.Add(id, newEvent);
            return id;
        }
        #region DelayEvent
        /// <summary>
        /// 添加延迟事件
        /// </summary>
        /// <param name="delayEvent">延迟事件</param>
        /// <param name="delay">延迟时间</param>
        /// <param name="isUnScaled">是否忽略TimeScale</param>
        /// <returns>延迟事件ID，可用这个ID注销事件<seealso cref="RemoveDelayEvent(int, bool)"/></returns>
        public int AddDelayEvent(System.Action delayEvent, float delay, bool isUnScaled = false)
        {
            var newEvent = new UTimerEvent(delayEvent, delay, isUnScaled);
            return AddNewTimer(newEvent);
        }
        /// <summary>
        /// 添加延迟事件
        /// </summary>
        /// <typeparam name="T">参数类型</typeparam>
        /// <param name="delayEvent">延迟事件</param>
        /// <param name="param"><typeparamref name="T"/>事件参数</param>
        /// <param name="delay">延迟时间</param>
        /// <param name="isUnScaled">是否忽略TimeScale</param>
        /// <returns>延迟事件ID，可用这个ID注销事件<seealso cref="RemoveDelayEvent(int, bool)"/></returns>
        public int AddDelayEvent<T>(System.Action<T> delayEvent, T param, float delay, bool isUnScaled = false)
        {
            var newEvent = new UTimerEvent<T>(delayEvent, param, delay, isUnScaled);
            return AddNewTimer(newEvent);
        }
        /// <summary>
        /// 添加延迟事件
        /// </summary>
        /// <typeparam name="T">参数类型1</typeparam>
        /// <typeparam name="V">参数类型2</typeparam>
        /// <param name="delayEvent">延迟事件</param>
        /// <param name="param1"><typeparamref name="T"/>事件参数1</param>
        /// <param name="param2"><typeparamref name="T"/>事件参数2</param>
        /// <param name="delay">延迟时间</param>
        /// <param name="isUnScaled">是否忽略TimeScale</param>
        /// <returns>延迟事件ID，可用这个ID注销事件<seealso cref="RemoveDelayEvent(int, bool)"/></returns>
        public int AddDelayEvent<T, V>(System.Action<T, V> delayEvent, T param1, V param2, float delay, bool isUnScaled = false)
        {
            var newEvent = new UTimerEvent<T, V>(delayEvent, param1, param2, delay, isUnScaled);
            return AddNewTimer(newEvent);
        }
        /// <summary>
        /// 添加延迟事件
        /// </summary>
        /// <typeparam name="T">参数类型1</typeparam>
        /// <typeparam name="V">参数类型2</typeparam>
        /// <typeparam name="K">参数类型3</typeparam>
        /// <param name="delayEvent">延迟事件</param>
        /// <param name="param1"><typeparamref name="T"/>事件参数1</param>
        /// <param name="param2"><typeparamref name="T"/>事件参数2</param>
        /// <param name="param3"><typeparamref name="T"/>事件参数3</param>
        /// <param name="delay">延迟时间</param>
        /// <param name="isUnScaled">是否忽略TimeScale</param>
        /// <returns>延迟事件ID，可用这个ID注销事件<seealso cref="RemoveDelayEvent(int, bool)"/></returns>
        public int AddDelayEvent<T, V, K>(System.Action<T, V, K> delayEvent, T param1, V param2, K param3, float delay, bool isUnScaled = false)
        {
            var newEvent = new UTimerEvent<T, V, K>(delayEvent, param1, param2, param3, delay, isUnScaled);
            return AddNewTimer(newEvent);
        }
        /// <summary>
        /// 删除延迟事件
        /// </summary>
        /// <param name="id">事件ID</param>
        /// <param name="callEvent">是否在删除过程中调用事件</param>
        public void RemoveDelayEvent(int id, bool callEvent = false)
        {
            if(delayEvents.ContainsKey(id)) {
                if(callEvent) {
                    delayEvents[id].OnTimeUp();
                }
                delayEvents.Remove(id);
                iDGeneratorDelay.RemoveId(id);
            }
        }
        #endregion
    }
}