using System;
using System.Globalization;
using System.IO;
using System.Text;
using System.Threading;
using UnityEngine;

namespace General
{
    public class DebuggerComponent : MonoBehaviour
    {
        #region Fields

        private static readonly StringBuilder StringBuilder = new StringBuilder(5000);
        private static readonly Mutex MutexHandleInit = new Mutex();
        private static readonly Mutex MutexHandleLog = new Mutex();
        private static string oldVersion = default;
        private static bool init = false;
        private string fileName = "Debugger.txt";
        private string space = " ";
        private bool state = false;
        private string path;
        
        [SerializeField]
        public bool keepOldVersion = true;
        
        public static DebuggerComponent Instance => FindObjectOfType(typeof(DebuggerComponent)) as DebuggerComponent;

        #endregion


        #region Properties

        private string Path
        {
            get
            {
                if (!string.IsNullOrEmpty(path)) return path;
                #if UNITY_ANDROID && !UNITY_EDITOR

                path = global::System.IO.Path.Combine(Application.persistentDataPath, fileName);

                #else

                path = global::System.IO.Path.Combine(Application.dataPath, fileName);

                #endif

                return path;
            }
        }

        #endregion


        #region Unity Lifecycle

        private void Awake()
        {
            MutexHandleInit.WaitOne();
            if (init) return;
            init = true;
            Application.logMessageReceivedThreaded += HandleLog;
            if (keepOldVersion)
            {
                try
                {
                    oldVersion = File.ReadAllText(Path);
                }
                catch
                {
                    // ignored
                }
            }
            Init();
            MutexHandleInit.ReleaseMutex();
        }

        void Start()
        {
            Awake();
            state = true;
        }

        void OnApplicationPause(bool pause)
        {
            if (pause && state)
            {
                Application.logMessageReceivedThreaded -= HandleLog;
            }
        }

        void OnApplicationQuit()
        {
            Application.logMessageReceivedThreaded -= HandleLog;
        }

        #endregion


        #region Methods

        void Init()
        {
            if (!string.IsNullOrEmpty(oldVersion))
            {
                StringBuilder.AppendLine().Append(oldVersion);
            }
            StringBuilder.AppendLine()
                .Append(Application.productName)
                .Append(Application.companyName)
                .Append(space)
                .Append(Application.installerName)
                .Append(space)
                .Append(Application.version)
                .Append("v")
                .AppendLine()
                .Append(Application.buildGUID)
                .Append(space)
                .Append(Application.unityVersion)
                .Append(space)
                .Append(DateTime.Now)
                .AppendLine();
        }

        void HandleLog(string logString, string stackTrace, LogType type)
        {
            MutexHandleLog.WaitOne();
            StringBuilder.AppendLine()
                .Append(DateTime.Now.ToString(CultureInfo.InvariantCulture))
                .Append(space)
                .Append(type.ToString())
                .AppendLine()
                .AppendLine(logString)
                .AppendLine(stackTrace);
            Save();
            MutexHandleLog.ReleaseMutex();
        }

        void Save()
        {
            File.WriteAllText(Path,string.Empty);
            File.WriteAllText(Path, StringBuilder.ToString());
        }

        #endregion
    }
}