/// **** LOGGING CLASS ###########

public static class Logger
{
	public static void Write(string message) => Log.Write(message);
	public static void Close() => Log.Close();

	private static LogIntern Log = new LogIntern();

	public static int CheckIntervalHours { get; set; } = 1;
	public static int MaxLogLength { get; set; } = 50 * 1024 * 1024;
	public static int DeleteLogAfterDays { get; set; } = 14;
	public static string LogDirPath = "log";

	private class LogIntern
	{
		private Queue<string> MessageQueue = new Queue<string>();
		private AutoResetEvent SignalMessage = new AutoResetEvent(false);
		private AutoResetEvent SignalStopped = new AutoResetEvent(false);
		private AutoResetEvent SignalStopCheck = new AutoResetEvent(false);
		private bool Stopping = false;
		private StreamWriter _Writer;
		private string _FileName;
		private DateTime _LastDeleteDate = DateTime.Now.AddDays(-1).Date;
		private string _NameOfApp;

		private StreamWriter Writer
		{
			get
			{
				lock (this)
					if (_Writer == null)
						this._Writer = new StreamWriter(GetFileName(true), true);
				return this._Writer;
			}
		}

		private string GetFileName(bool newName)
		{
			//string nameofApp = Assembly.GetExecutingAssembly().GetName().Name;  //  FullName;

			string fileName0 = $"{LogDirPath}\\{_NameOfApp}-{Assembly.GetExecutingAssembly().GetName().Version}-{DateTime.Now:yyyy-MM-dd}";
			this._FileName = $"{fileName0}.log";
			int nr = 1;
			while (File.Exists(this._FileName))
			{
				//this._FileName = $"{fileName0.Split(new string[] { ".log" }, StringSplitOptions.None)[0]}-{nr++}.log";
				this._FileName = $"{fileName0}-{nr++}.log";
			}
			return this._FileName;
		}

		private void CloseWriter()
		{
			lock (this)
				if (Writer != null)
				{
					Writer.Flush();
					Writer.Close();
					Writer.Dispose();
					this._Writer = null;
				}
		}

		internal void Write(string message)
		{
			MessageQueue.Enqueue($"{DateTime.Now:dd.MM.yy HH:mm:ss.ffff} {message}");
			SignalMessage.Set();
		}

		~LogIntern()
		{
			Close();
		}

		public void Close()
		{
			Stopping = true;
			SignalStopCheck.Set();
			SignalMessage.Set();
			Thread.Sleep(10);
			//SignalStopCheck.Set();
			//SignalStopped.WaitOne();
		}

		public LogIntern()
		{
			this._NameOfApp = Assembly.GetExecutingAssembly().GetName().Name;  //  FullName;

			Thread th1 = new Thread(() =>
			{
				do
				{
					SignalMessage.WaitOne();

					while (MessageQueue.Count > 0)
					{
						Writer.Write($"{MessageQueue.Dequeue()}{Environment.NewLine}");
						Writer.Flush();
					}
				} while (!Stopping);

				if (Writer != null)
				{
					Writer.Flush();
					Writer.Close();
					Writer.Dispose();
					this._Writer = null;
				}
			});
			th1.Start();

			Thread th2 = new Thread(() =>
			{
				do
				{
					//if (!SignalStopCheck.WaitOne(Logger.CheckIntervalHours * 3600000))
					//    break;
					if (SignalStopCheck.WaitOne(Logger.CheckIntervalHours * 1000)) // 3600000))
						break;

					if (new FileInfo(this._FileName).Length > Logger.MaxLogLength)
						CloseWriter();

					if (this._LastDeleteDate < DateTime.Now.Date)
					{
						this._LastDeleteDate = DateTime.Now.Date;
						foreach (FileSystemInfo fsi in (new DirectoryInfo(Logger.LogDirPath)).GetFileSystemInfos())
							if (fsi.Name.StartsWith(this._NameOfApp) &&
									this._LastDeleteDate.Subtract(fsi.LastWriteTime).TotalDays > Logger.DeleteLogAfterDays)
							{
								File.Delete(fsi.FullName);
							}

					}

				} while (true);                  
			});
			th2.Start();
		}
	}
}