using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using System;
using System.Text;
using System.Threading;
using System.IO;
using Newtonsoft.Json;
using DG.Tweening.Core.Easing;

public class TimerManager : MonoBehaviour
{
    public UnityEvent<int> onChangeActionTimerCount;
    public UnityEvent<int> onChangeRewardActionCount;

    int _actionTimerValue = 0;
    public int ActionTimerValue
    {
        get { return _actionTimerValue; }
    }

    int _addActionCount;
    private DateTime loadTime;

    private enum TimerType
    {
        None,
        Simple,
        Hierarchy,
    }

    private class TimerInfo
    {
        public int time = 0;
        public int limiteTimerCount = 0;
        public DateTime saveTimeData = InternetTime.Ins.Time;
        public UnityAction<int> OnPassedTime;

        protected TimerType timerType = TimerType.None;
        public TimerType Type
        {
            get { return timerType; }
        }
        protected string ownerName = "";
        public string OwnerName
        {
            get { return ownerName; }
        }

        public TimerInfo()
        {
        }

        public TimerInfo(TimerType type, string ownerName, int time, DateTime saveTimeData)
        {
            timerType = type;
            this.ownerName = ownerName;
            this.time = time;
            this.saveTimeData = saveTimeData;
        }
    }

    private class SimpleTimerInfo : TimerInfo
    {
        public UnityAction<int> OnStartTimer;
        public UnityAction<int> OnPauseTimer;
        public UnityAction<int> OnStopTimer;

        public SimpleTimerInfo()
        {
        }

        public SimpleTimerInfo(string ownerName)
        {
            timerType = TimerType.Simple;
            this.ownerName = ownerName;
        }

        public SimpleTimerInfo(string ownerName, int time, DateTime timeData, UnityAction<int> OnStartTimer, UnityAction<int> OnPauseTimer, UnityAction<int> OnStopTimer, UnityAction<int> OnPassedTime)
        {
            timerType = TimerType.Simple;
            this.ownerName = ownerName;
            this.time = time;
            this.saveTimeData = timeData;

            this.OnStartTimer += OnStartTimer;
            this.OnPauseTimer += OnPauseTimer;
            this.OnStopTimer += OnStopTimer;

            this.OnPassedTime += OnPassedTime;
        }

        public void ResetEvent()
        {
            this.OnStartTimer = null;
            this.OnPauseTimer = null;
            this.OnStopTimer = null;
            this.OnPassedTime = null;
        }
    }

    private class HierarchyTimerInfo : TimerInfo
    {
        public int limiteHierarchyCount = 0;

        public UnityAction<int, int> OnStartTimer;
        public UnityAction<int, int> OnPauseTimer;
        public UnityAction<int> OnStopTimer;

        public HierarchyTimerInfo()
        {
        }

        public HierarchyTimerInfo(string ownerName)
        {
            timerType = TimerType.Hierarchy;
            this.ownerName = ownerName;
        }

        public HierarchyTimerInfo(string ownerName, int time, DateTime timeData, UnityAction<int, int> OnStartTimer, UnityAction<int, int> OnPauseTimer, UnityAction<int> OnStopTimer, UnityAction<int> OnPassedTime)
        {
            timerType = TimerType.Hierarchy;
            this.ownerName = ownerName;
            this.time = time;
            this.saveTimeData = timeData;

            this.OnStartTimer += OnStartTimer;
            this.OnPauseTimer += OnPauseTimer;
            this.OnStopTimer += OnStopTimer;

            this.OnPassedTime += OnPassedTime;
        }

        public void ResetEvent()
        {
            this.OnStartTimer = null;
            this.OnPauseTimer = null;
            this.OnStopTimer = null;
            this.OnPassedTime = null;
        }
    }

    StringBuilder sb = new StringBuilder();
    Dictionary<string, TimerInfo> timerInfoDictionary = new Dictionary<string, TimerInfo>();

    private Coroutine timerCoroutine = null;
    private WaitForSecondsRealtime waitForSeconds = null;

    private void Awake()
    {
        LoadAllTimerInfo();
    }

    private void SaveSimpleTimerInfo()
    {
        foreach (KeyValuePair<string, TimerInfo> dic in timerInfoDictionary)
        {
            sb.Clear();
            sb.Append(dic.Key).Append("TimerData");

            SimpleTimerInfo info = timerInfoDictionary[dic.Key] as SimpleTimerInfo;
            if (info != null)
            {
                info.saveTimeData = InternetTime.Ins.Time;
                ES3.Save<SimpleTimerInfo>(sb.ToString(), info, "TimerData.json", new ES3Settings()
                {
                    encryptionType = ES3.EncryptionType.AES,   // AES 또는 XOR 사용 가능
                    encryptionPassword = "MyStrongPassword123" // 원하는 암호
                });
            }
        }
    }

    private void SaveHierarchyTimerInfo()
    {
        foreach (KeyValuePair<string, TimerInfo> dic in timerInfoDictionary)
        {
            sb.Clear();
            sb.Append(dic.Key).Append("TimerData");

            HierarchyTimerInfo info = timerInfoDictionary[dic.Key] as HierarchyTimerInfo;
            if (info != null)
            {
                info.saveTimeData = InternetTime.Ins.Time;
                ES3.Save<HierarchyTimerInfo>(sb.ToString(), info, "TimerData.json", new ES3Settings()
                {
                    encryptionType = ES3.EncryptionType.AES,   // AES 또는 XOR 사용 가능
                    encryptionPassword = "MyStrongPassword123" // 원하는 암호
                });
            }
        }
    }

    private void LoadAllTimerInfo()
    {
        if (ES3.KeyExists("TimerData.json", new ES3Settings()
        {
            encryptionType = ES3.EncryptionType.AES,
            encryptionPassword = "MyStrongPassword123" // 원하는 암호
        }))
        {
            TimerInfo info = new TimerInfo();
            info = ES3.Load<TimerInfo>("TimerData.json", new ES3Settings()
            {
                encryptionType = ES3.EncryptionType.AES,   // AES 또는 XOR 사용 가능
                encryptionPassword = "MyStrongPassword123" // 원하는 암호
            });

            timerInfoDictionary.Add(info.OwnerName, info);
        }
    }

    private void LoadSimpleTimerInfo(string ownerName)
    {
        sb.Clear();
        sb.Append(ownerName).Append("TimerData");

        if (ES3.KeyExists(sb.ToString(), "TimerData.json"))
        {
            SimpleTimerInfo info = new SimpleTimerInfo(ownerName);
            info = ES3.Load<SimpleTimerInfo>(sb.ToString(), "TimerData.json", new ES3Settings()
            {
                encryptionType = ES3.EncryptionType.AES,   // AES 또는 XOR 사용 가능
                encryptionPassword = "MyStrongPassword123" // 원하는 암호
            });

            info.ResetEvent();

            if (timerInfoDictionary.ContainsKey(ownerName) == false)
            {
                timerInfoDictionary.Add(ownerName, info);
            }
            else
            {
                timerInfoDictionary.Remove(ownerName);
                timerInfoDictionary[ownerName] = info;
            }
        }
    }

    private void LoadHierarchyTimerInfo(string ownerName)
    {
        sb.Clear();
        sb.Append(ownerName).Append("TimerData");

        if (ES3.KeyExists(sb.ToString(), "TimerData.json"))
        {
            HierarchyTimerInfo info = new HierarchyTimerInfo(ownerName);
            info = ES3.Load<HierarchyTimerInfo>(sb.ToString(), "TimerData.json", new ES3Settings()
            {
                encryptionType = ES3.EncryptionType.AES,   // AES 또는 XOR 사용 가능
                encryptionPassword = "MyStrongPassword123" // 원하는 암호
            });

            info.ResetEvent();

            if (timerInfoDictionary.ContainsKey(ownerName) == false)
            {
                timerInfoDictionary.Add(ownerName, info);
            }
            else
            {
                timerInfoDictionary.Remove(ownerName);
                timerInfoDictionary[ownerName] = info;
            }
        }
    }

    private void DelTimerInfo(string ownerName)
    {
        sb.Clear();
        sb.Append(ownerName).Append("TimerData");

        if (ES3.KeyExists(sb.ToString(), "TimerData.json"))
        {
            ES3.DeleteKey(sb.ToString(), "TimerData.json");
        }
    }

    public void ActivateLoadSimpleTimer(string ownerName, int limiteTimerCount, UnityAction<int> OnStartTimer, UnityAction<int> OnPauseTimer, UnityAction<int> OnStopTimer, UnityAction<int> OnPassedTime)
    {
        int timerCount = limiteTimerCount;

        LoadSimpleTimerInfo(ownerName);
        if (timerInfoDictionary.ContainsKey(ownerName) == true)
        {
            if (timerInfoDictionary[ownerName].saveTimeData != null && timerInfoDictionary[ownerName].saveTimeData.Year != 1)
            {
                double passedTimeSecond = (InternetTime.Ins.Time - timerInfoDictionary[ownerName].saveTimeData).TotalSeconds;
                int totalPassedTimeSecond = (limiteTimerCount - timerInfoDictionary[ownerName].time) + (Int32)passedTimeSecond;

                if (totalPassedTimeSecond >= 0)
                {
                    timerCount = limiteTimerCount - totalPassedTimeSecond;
                }
            }
            // 새로 타이머를 시작해야 한다.
            if (IsStartedTimer() == false)
            {
                // 기존에 시작하는 타이머가 없다면 타이머를 시작한다.
                StartTimer();
            }

            SimpleTimerInfo info = timerInfoDictionary[ownerName] as SimpleTimerInfo;
            if (info != null)
            {
                info.time = timerCount;
                info.limiteTimerCount = limiteTimerCount;

                if (info.OnStartTimer == null)
                {
                    info.OnStartTimer += OnStartTimer;
                }
                if (info.OnPauseTimer == null)
                {
                    info.OnPauseTimer += OnPauseTimer;
                }
                if (info.OnStopTimer == null)
                {
                    info.OnStopTimer += OnStopTimer;
                }
                if (info.OnPassedTime == null)
                {
                    info.OnPassedTime += OnPassedTime;
                }

                info.OnStartTimer?.Invoke(timerCount);
            }

            SaveSimpleTimerInfo();
        }
    }

    public void ActivateSimpleTimer(string ownerName, int limiteTimerCount, UnityAction<int> OnStartTimer, UnityAction<int> OnPauseTimer, UnityAction<int> OnStopTimer, UnityAction<int> OnPassedTime)
    {
        int timerCount = limiteTimerCount;

        LoadSimpleTimerInfo(ownerName);
        if (timerInfoDictionary.ContainsKey(ownerName) == true)
        {
            if (timerInfoDictionary[ownerName].saveTimeData != null && timerInfoDictionary[ownerName].saveTimeData.Year != 1)
            {
                double passedTimeSecond = (InternetTime.Ins.Time - timerInfoDictionary[ownerName].saveTimeData).TotalSeconds;
                int totalPassedTimeSecond = (limiteTimerCount - timerInfoDictionary[ownerName].time) + (Int32)passedTimeSecond;

                if (totalPassedTimeSecond >= 0)
                {
                    timerCount = limiteTimerCount - totalPassedTimeSecond;
                }
            }
        }
        else
        {
            timerInfoDictionary.Add(ownerName, new SimpleTimerInfo(ownerName, timerCount, InternetTime.Ins.Time, OnStartTimer, OnPauseTimer, OnStopTimer, OnPassedTime));
        }

        // 새로 타이머를 시작해야 한다.
        if (IsStartedTimer() == false)
        {
            // 기존에 시작하는 타이머가 없다면 타이머를 시작한다.
            StartTimer();
        }

        SimpleTimerInfo info = timerInfoDictionary[ownerName] as SimpleTimerInfo;
        if (info != null)
        {
            info.time = timerCount;
            info.limiteTimerCount = limiteTimerCount;

            if (info.OnStartTimer == null)
            {
                info.OnStartTimer += OnStartTimer;
            }
            if (info.OnPauseTimer == null)
            {
                info.OnPauseTimer += OnPauseTimer;
            }
            if (info.OnStopTimer == null)
            {
                info.OnStopTimer += OnStopTimer;
            }
            if (info.OnPassedTime == null)
            {
                info.OnPassedTime += OnPassedTime;
            }

            info.OnStartTimer?.Invoke(timerCount);
        }

        SaveSimpleTimerInfo();
    }

    public void ActivateHierarchyTimer(string ownerName, int limiteTimerCount, int limiteHierarchyCount, UnityAction<int, int> OnStartTimer, UnityAction<int, int> OnPauseTimer, UnityAction<int> OnStopTimer, UnityAction<int> OnPassedTime)
    {
        int timerCount = limiteTimerCount;
        int hierarchyCount = 0;

        LoadHierarchyTimerInfo(ownerName);
        if (timerInfoDictionary.ContainsKey(ownerName) == true)
        {
            // 로드 한 정보가 있으면 작동 중인 타이머가 존재 하는 것
            // 타이머 계산을 해야 한다.

            if (timerInfoDictionary[ownerName].saveTimeData != null && timerInfoDictionary[ownerName].saveTimeData.Year != 1)
            {
                double passedTimeSecond = (InternetTime.Ins.Time - timerInfoDictionary[ownerName].saveTimeData).TotalSeconds;
                int totalPassedTimeSecond = (limiteTimerCount - timerInfoDictionary[ownerName].time) + (Int32)passedTimeSecond;

                if (totalPassedTimeSecond >= 0)
                {
                    hierarchyCount = totalPassedTimeSecond / limiteTimerCount;

                    timerCount = totalPassedTimeSecond - (hierarchyCount * limiteTimerCount);
                    timerCount = limiteTimerCount - timerCount;

                    //timerCount = limiteTimerCount - (totalPassedTimeSecond % limiteTimerCount);
                }
            }

            // 로드 된 정보에 따라 타이머가 바뀌어야 한다.
        }
        else
        {
            // 로드 한 정보가 없으면 작동 중인 타이머가 없는 것

            // 새로 시작한 타이머의 정보를 등록해야 한다.
            timerInfoDictionary.Add(ownerName, new HierarchyTimerInfo(ownerName, timerCount, InternetTime.Ins.Time, OnStartTimer, OnPauseTimer, OnStopTimer, OnPassedTime));
        }

        // 새로 타이머를 시작해야 한다.
        if (IsStartedTimer() == false)
        {
            // 기존에 시작하는 타이머가 없다면 타이머를 시작한다.
            StartTimer();
        }

        HierarchyTimerInfo info = timerInfoDictionary[ownerName] as HierarchyTimerInfo;
        if (info != null)
        {
            info.time = timerCount;
            info.limiteTimerCount = limiteTimerCount;
            info.limiteHierarchyCount = limiteHierarchyCount;

            if (info.OnStartTimer == null)
            {
                info.OnStartTimer += OnStartTimer;
            }
            if (info.OnPauseTimer == null)
            {
                info.OnPauseTimer += OnPauseTimer;
            }
            if (info.OnStopTimer == null)
            {
                info.OnStopTimer += OnStopTimer;
            }
            if (info.OnPassedTime == null)
            {
                info.OnPassedTime += OnPassedTime;
            }

            info.OnStartTimer?.Invoke(timerCount, hierarchyCount);
        }

        SaveHierarchyTimerInfo();
    }

    public void DeactivateTimer(string ownerName)
    {
        timerInfoDictionary.Remove(ownerName);
        DelTimerInfo(ownerName);

        if (timerInfoDictionary.Count <= 0)
        {
            EndTiemr();
        }
    }

    public void PauseTimer(string ownerName)
    {
        SaveSimpleTimerInfo();
        SaveHierarchyTimerInfo();
        SaveTime();

        /*timerInfoDictionary.Remove(ownerName);
        if (timerInfoDictionary.Count <= 0)
        {
            EndTiemr();
        }*/
    }

    public bool IsVaildTimer(string ownerName)
    {
        return timerInfoDictionary.ContainsKey(ownerName);
    }

    public bool IsVaildSimpleTimer(string ownerName)
    {
        // LoadSimpleTimerInfo(ownerName);
        return timerInfoDictionary.ContainsKey(ownerName);
    }

    public void SetWaitForSeconds(float time)
    {
        waitForSeconds = new WaitForSecondsRealtime(1.0f);
    }

    private bool IsStartedTimer()
    {
        return timerCoroutine != null;
    }

    private void StartTimer()
    {
        waitForSeconds = new WaitForSecondsRealtime(1.0f);
        timerCoroutine = StartCoroutine(Timer());
    }

    private void EndTiemr()
    {
        if (IsStartedTimer() == true)
        {
            StopCoroutine(timerCoroutine);
            timerCoroutine = null;
        }
    }

    IEnumerator Timer()
    {
        SimpleTimerInfo simpleTimerInfo = null;
        HierarchyTimerInfo hierarchyTimerInfo = null;

        while (true)
        {
            yield return waitForSeconds;

            foreach (KeyValuePair<string, TimerInfo> keyValue in timerInfoDictionary)
            {
                simpleTimerInfo = timerInfoDictionary[keyValue.Key] as SimpleTimerInfo;
                if (simpleTimerInfo != null)
                {
                    if (simpleTimerInfo.time <= 0)
                    {
                        simpleTimerInfo.time = simpleTimerInfo.limiteTimerCount;
                    }
                    else
                    {
                        simpleTimerInfo.time -= 1;
                    }

                    simpleTimerInfo.OnPassedTime?.Invoke(simpleTimerInfo.time);

                    if (simpleTimerInfo.time <= 0)
                    {
                        simpleTimerInfo.OnStopTimer?.Invoke(0);
                        break;
                    }
                }
                else
                {
                    hierarchyTimerInfo = timerInfoDictionary[keyValue.Key] as HierarchyTimerInfo;
                    if (hierarchyTimerInfo != null)
                    {
                        if (hierarchyTimerInfo.time <= 0)
                        {
                            hierarchyTimerInfo.time = hierarchyTimerInfo.limiteTimerCount;
                        }
                        else
                        {
                            hierarchyTimerInfo.time -= 1;
                        }

                        hierarchyTimerInfo.OnPassedTime?.Invoke(hierarchyTimerInfo.time);

                        if (hierarchyTimerInfo.time <= 0)
                        {
                            hierarchyTimerInfo.OnStopTimer?.Invoke(0);
                            break;
                        }
                    }
                }
            }
        }
    }

    private const string TIME_KEY = "SavedTime";
    public void SaveTime()
    {
        // 인터넷 시간을 저장
        ES3.Save<DateTime>(TIME_KEY, InternetTime.Ins.Time, new ES3Settings()
        {
            encryptionType = ES3.EncryptionType.AES,
            encryptionPassword = "MyStrongPassword123" // 원하는 암호
        });
    }

    public DateTime LoadTime()
    {
        if (!ES3.KeyExists(TIME_KEY, new ES3Settings()
        {
            encryptionType = ES3.EncryptionType.AES,
            encryptionPassword = "MyStrongPassword123" // 원하는 암호
        }))
        {
            SaveTime();
            loadTime = InternetTime.Ins.Time;
            return loadTime;
        }

        loadTime = ES3.Load<DateTime>(TIME_KEY, InternetTime.Ins.Time, new ES3Settings()
        {
            encryptionType = ES3.EncryptionType.AES,
            encryptionPassword = "MyStrongPassword123" // 원하는 암호
        });
        return loadTime;
    }

    private void OnApplicationQuit()
    {
        SaveSimpleTimerInfo();
        SaveHierarchyTimerInfo();
        SaveTime();
    }

#if UNITY_EDITOR
    private void OnApplicationFocus(bool focusStatus)
    {
        if (timerInfoDictionary.Count > 0)
        {
            if (focusStatus)
            {
                SimpleTimerInfo simpleTimerInfo = null;
                HierarchyTimerInfo hierarchyTimerInfo = null;

                if (IsStartedTimer() == false)
                {
                    StartTimer();
                }

                foreach (KeyValuePair<string, TimerInfo> dic in timerInfoDictionary)
                {
                    simpleTimerInfo = dic.Value as SimpleTimerInfo;
                    if (simpleTimerInfo != null)
                    {
                        if (simpleTimerInfo.saveTimeData != null && simpleTimerInfo.saveTimeData.Year != 1)
                        {
                            double passedTimeSecond = (InternetTime.Ins.Time - simpleTimerInfo.saveTimeData).TotalSeconds;
                            int totalPassedTimeSecond = (simpleTimerInfo.limiteTimerCount - simpleTimerInfo.time) + (Int32)passedTimeSecond;

                            if (totalPassedTimeSecond >= 0)
                            {
                                simpleTimerInfo.time = simpleTimerInfo.limiteTimerCount - totalPassedTimeSecond;
                            }
                            simpleTimerInfo.OnPauseTimer(simpleTimerInfo.time);
                        }
                    }
                    else
                    {
                        hierarchyTimerInfo = dic.Value as HierarchyTimerInfo;
                        if (hierarchyTimerInfo != null)
                        {
                            int hierarchyCount = 0;

                            if (hierarchyTimerInfo.saveTimeData != null && hierarchyTimerInfo.saveTimeData.Year != 1)
                            {
                                double passedTimeSecond = (InternetTime.Ins.Time - hierarchyTimerInfo.saveTimeData).TotalSeconds;
                                int totalPassedTimeSecond = (hierarchyTimerInfo.limiteTimerCount - hierarchyTimerInfo.time) + (Int32)passedTimeSecond;

                                if (totalPassedTimeSecond >= 0)
                                {
                                    hierarchyCount = totalPassedTimeSecond / hierarchyTimerInfo.limiteTimerCount;

                                    hierarchyTimerInfo.time = totalPassedTimeSecond - (hierarchyCount * hierarchyTimerInfo.limiteTimerCount);
                                    hierarchyTimerInfo.time = hierarchyTimerInfo.limiteTimerCount - hierarchyTimerInfo.time;

                                    //hierarchyTimerInfo.time = hierarchyTimerInfo.limiteTimerCount - (totalPassedTimeSecond % hierarchyTimerInfo.limiteTimerCount);
                                }
                                hierarchyTimerInfo.OnPauseTimer(hierarchyTimerInfo.time, hierarchyCount);
                            }
                        }
                    }
                }
            }
            else
            {
                SaveSimpleTimerInfo();
                SaveHierarchyTimerInfo();
                SaveTime();

                EndTiemr();
            }
        }
    }

#else
    private void OnApplicationPause(bool pauseStatus)
    {
        if (timerInfoDictionary.Count > 0)
        {
            if (!pauseStatus)
            {
                SimpleTimerInfo simpleTimerInfo = null;
                HierarchyTimerInfo hierarchyTimerInfo = null;

                if (IsStartedTimer() == false)
                {
                    StartTimer();
                }

                foreach (KeyValuePair<string, TimerInfo> dic in timerInfoDictionary)
                {
                    simpleTimerInfo = dic.Value as SimpleTimerInfo;
                    if (simpleTimerInfo != null)
                    {
                        if (simpleTimerInfo.saveTimeData != null && simpleTimerInfo.saveTimeData.Year != 1)
                        {
                            double passedTimeSecond = (InternetTime.Ins.Time - simpleTimerInfo.saveTimeData).TotalSeconds;
                            int totalPassedTimeSecond = (simpleTimerInfo.limiteTimerCount - simpleTimerInfo.time) + (Int32)passedTimeSecond;

                            if (totalPassedTimeSecond >= 0)
                            {
                                simpleTimerInfo.time = simpleTimerInfo.limiteTimerCount - totalPassedTimeSecond;
                            }
                            simpleTimerInfo.OnPauseTimer(simpleTimerInfo.time);
                        }
                    }
                    else
                    {
                        hierarchyTimerInfo = dic.Value as HierarchyTimerInfo;
                        if (hierarchyTimerInfo != null)
                        {
                            int hierarchyCount = 0;

                            if (hierarchyTimerInfo.saveTimeData != null && hierarchyTimerInfo.saveTimeData.Year != 1)
                            {
                                double passedTimeSecond = (InternetTime.Ins.Time - hierarchyTimerInfo.saveTimeData).TotalSeconds;
                                int totalPassedTimeSecond = (hierarchyTimerInfo.limiteTimerCount - hierarchyTimerInfo.time) + (Int32)passedTimeSecond;

                                if (totalPassedTimeSecond >= 0)
                                {
                                    hierarchyCount = totalPassedTimeSecond / hierarchyTimerInfo.limiteTimerCount;

                                    hierarchyTimerInfo.time = totalPassedTimeSecond - (hierarchyCount * hierarchyTimerInfo.limiteTimerCount);
                                    hierarchyTimerInfo.time = hierarchyTimerInfo.limiteTimerCount - hierarchyTimerInfo.time;

                                    //hierarchyTimerInfo.time = hierarchyTimerInfo.limiteTimerCount - (totalPassedTimeSecond % hierarchyTimerInfo.limiteTimerCount);
                                }
                                hierarchyTimerInfo.OnPauseTimer(hierarchyTimerInfo.time, hierarchyCount);
                            }
                        }
                    }
                }
            }
            else
            {
                SaveSimpleTimerInfo();
                SaveHierarchyTimerInfo();
                SaveTime();

                EndTiemr();
            }
        }
    }
#endif
}