using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Networking;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Hardheim.Timesave")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Hardheim.Timesave")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3739dcd7-5f69-4a5a-bdde-a190eac212ba")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.2.0.0")]
[BepInPlugin("hardheim.timedsave", "Hardheim Timed Save", "1.4.0")]
public class TimedSave : BaseUnityPlugin
{
	private sealed class ConfigData
	{
		public bool enabled { get; set; }

		public List<string> saveTimes { get; set; }

		public string timezone { get; set; }

		public Announce announce { get; set; }

		public Combat combatCheck { get; set; }

		public Backup backup { get; set; }

		public Restart restart { get; set; }

		public Webhook webhook { get; set; }

		public Status status { get; set; }

		public bool logToConsole { get; set; }
	}

	private sealed class Announce
	{
		public bool enabled { get; set; }

		public int secondsBefore { get; set; }

		public string message { get; set; }
	}

	private sealed class Combat
	{
		public bool enabled { get; set; }

		public bool delayIfInCombat { get; set; }

		public int retrySeconds { get; set; }
	}

	private sealed class Backup
	{
		public bool enabled { get; set; }

		public string folder { get; set; }

		public bool zip { get; set; }

		public int keepLast { get; set; }

		public int delaySeconds { get; set; }

		public List<string> worldSearchPaths { get; set; }

		public string customWorldPath { get; set; }
	}

	private sealed class Restart
	{
		public bool enabled { get; set; }

		public List<string> restartTimes { get; set; }

		public int secondsBefore { get; set; }

		public string announceMessage { get; set; }

		public string finalMessage { get; set; }

		public bool delayIfInCombat { get; set; }

		public int retrySeconds { get; set; }

		public bool saveBeforeRestart { get; set; }

		public bool backupBeforeRestart { get; set; }

		public bool kickPlayersBeforeRestart { get; set; }

		public int kickBeforeSeconds { get; set; }

		public string kickMessage { get; set; }

		public int kickDelaySeconds { get; set; }

		public int shutdownDelaySeconds { get; set; }

		public int forceExitAfterSeconds { get; set; }

		public int kickMessageLeadSeconds { get; set; }
	}

	private sealed class Webhook
	{
		public bool enabled { get; set; }

		public string url { get; set; }

		public string username { get; set; }

		public string avatarUrl { get; set; }

		public string serverName { get; set; }

		public bool useEmbeds { get; set; }

		public bool sendOnSuccess { get; set; }

		public bool sendOnError { get; set; }

		public bool sendOnRestart { get; set; }

		public string successMessage { get; set; }

		public string errorMessage { get; set; }

		public string restartMessage { get; set; }

		public string restartErrorMessage { get; set; }
	}

	private sealed class Status
	{
		public bool enabled { get; set; }

		public string message { get; set; }

		public bool onlyWhenPlayersOnline { get; set; }
	}

	private enum WebhookEventType
	{
		BackupSuccess,
		BackupError,
		Restart,
		RestartError,
		Status
	}

	[Serializable]
	private sealed class DiscordWebhookPayload
	{
		public string content;

		public string username;

		public string avatar_url;

		public DiscordEmbed[] embeds;
	}

	[Serializable]
	private sealed class DiscordEmbed
	{
		public string title;

		public string description;

		public int color;

		public DiscordEmbedField[] fields;

		public string timestamp;

		public DiscordEmbedFooter footer;
	}

	[Serializable]
	private sealed class DiscordEmbedField
	{
		public string name;

		public string value;

		public bool inline;
	}

	[Serializable]
	private sealed class DiscordEmbedFooter
	{
		public string text;
	}

	[CompilerGenerated]
	private sealed class <ForceQuitAfterDelay>d__46 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public int seconds;

		public TimedSave <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ForceQuitAfterDelay>d__46(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds((float)seconds);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Environment.Exit(0);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <HandlePreSaveAnnounce>d__47 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public TimedSave <>4__this;

		private int <secondsBefore>5__1;

		private string <announceMessage>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <HandlePreSaveAnnounce>d__47(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<announceMessage>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				if (<>4__this.config.announce == null || !<>4__this.config.announce.enabled)
				{
					goto IL_0120;
				}
				<secondsBefore>5__1 = Mathf.Max(0, <>4__this.config.announce.secondsBefore);
				<announceMessage>5__2 = (string.IsNullOrWhiteSpace(<>4__this.config.announce.message) ? "Szerver mentés {seconds} mp múlva!" : <>4__this.config.announce.message);
				<announceMessage>5__2 = <announceMessage>5__2.Replace("{seconds}", <secondsBefore>5__1.ToString());
				<>4__this.SendCenterMessage(<announceMessage>5__2);
				if (<secondsBefore>5__1 > 0)
				{
					<>2__current = (object)new WaitForSeconds((float)<secondsBefore>5__1);
					<>1__state = 1;
					return true;
				}
			}
			<announceMessage>5__2 = null;
			goto IL_0120;
			IL_0120:
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <HandleSaveCombatDelay>d__48 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public TimedSave <>4__this;

		private int <retrySeconds>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <HandleSaveCombatDelay>d__48(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				if (<>4__this.config.combatCheck == null || !<>4__this.config.combatCheck.enabled || !<>4__this.config.combatCheck.delayIfInCombat)
				{
					goto IL_00c0;
				}
				<retrySeconds>5__1 = Mathf.Max(1, <>4__this.config.combatCheck.retrySeconds);
			}
			if (<>4__this.IsAnyoneInCombat())
			{
				<>2__current = (object)new WaitForSeconds((float)<retrySeconds>5__1);
				<>1__state = 1;
				return true;
			}
			goto IL_00c0;
			IL_00c0:
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PostWebhook>d__70 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public WebhookEventType eventType;

		public string serverName;

		public string worldName;

		public string backupFolder;

		public string pathValue;

		public string error;

		public int playerCount;

		public string uptime;

		public TimedSave <>4__this;

		private DiscordWebhookPayload <payload>5__1;

		private string <template>5__2;

		private string <message>5__3;

		private string <json>5__4;

		private byte[] <bodyRaw>5__5;

		private UnityWebRequest <request>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PostWebhook>d__70(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<payload>5__1 = null;
			<template>5__2 = null;
			<message>5__3 = null;
			<json>5__4 = null;
			<bodyRaw>5__5 = null;
			<request>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<template>5__2 = <>4__this.GetTemplateForEvent(eventType);
					<message>5__3 = <>4__this.BuildWebhookMessage(<template>5__2, serverName, worldName, backupFolder, pathValue, error, playerCount, uptime);
					if (<>4__this.config.webhook.useEmbeds && eventType != WebhookEventType.Status)
					{
						<payload>5__1 = <>4__this.BuildEmbedPayload(eventType, serverName, worldName, backupFolder, pathValue, error, playerCount, uptime);
					}
					else
					{
						<payload>5__1 = new DiscordWebhookPayload
						{
							content = <message>5__3,
							username = (string.IsNullOrWhiteSpace(<>4__this.config.webhook.username) ? "Hardheim Timed Save" : <>4__this.config.webhook.username),
							avatar_url = (string.IsNullOrWhiteSpace(<>4__this.config.webhook.avatarUrl) ? null : <>4__this.config.webhook.avatarUrl),
							embeds = null
						};
					}
					<json>5__4 = JsonUtility.ToJson((object)<payload>5__1);
					<bodyRaw>5__5 = Encoding.UTF8.GetBytes(<json>5__4);
					<request>5__6 = new UnityWebRequest(<>4__this.config.webhook.url, "POST");
					<>1__state = -3;
					<request>5__6.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__5);
					<request>5__6.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					<request>5__6.SetRequestHeader("Content-Type", "application/json");
					<>2__current = <request>5__6.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -3;
					<>m__Finally1();
					<request>5__6 = null;
					return false;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<request>5__6 != null)
			{
				((IDisposable)<request>5__6).Dispose();
			}
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RegisterClientSaveRpcLoop>d__31 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public TimedSave <>4__this;

		private WaitForSeconds <wait>5__1;

		private Exception <ex>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RegisterClientSaveRpcLoop>d__31(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<wait>5__1 = null;
			<ex>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<wait>5__1 = new WaitForSeconds(1f);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (ZRoutedRpc.instance != null && <>4__this.registeredRoutedRpcInstance != ZRoutedRpc.instance)
			{
				try
				{
					ZRoutedRpc.instance.Register("HardheimTimedSave_SavePlayerNow", (Action<long>)RPC_HardheimTimedSave_SavePlayerNow);
					<>4__this.registeredRoutedRpcInstance = ZRoutedRpc.instance;
					<>4__this.LogInfo("[CLIENT SAVE] RPC regisztrálva: HardheimTimedSave_SavePlayerNow");
				}
				catch (Exception ex)
				{
					<ex>5__2 = ex;
					<>4__this.LogWarning("[CLIENT SAVE] RPC regisztráció hiba: " + <ex>5__2.Message);
				}
			}
			<>2__current = <wait>5__1;
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RestartRoutine>d__38 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string triggerSource;

		public TimedSave <>4__this;

		private string <serverName>5__1;

		private string <worldName>5__2;

		private int <secondsBefore>5__3;

		private string <announceMessage>5__4;

		private int <kickDelaySeconds>5__5;

		private int <shutdownDelay>5__6;

		private bool <useKickWindow>5__7;

		private int <firstWait>5__8;

		private float <remainingKickWindow>5__9;

		private int <retrySeconds>5__10;

		private int <backupDelay>5__11;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RestartRoutine>d__38(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 7u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<serverName>5__1 = null;
			<worldName>5__2 = null;
			<announceMessage>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Expected O, but got Unknown
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Expected O, but got Unknown
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Expected O, but got Unknown
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Expected O, but got Unknown
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.IsServerInstance())
					{
						return false;
					}
					if (<>4__this.restartInProgress || <>4__this.saveInProgress)
					{
						return false;
					}
					<>4__this.restartInProgress = true;
					<serverName>5__1 = <>4__this.GetDisplayServerName();
					<worldName>5__2 = <>4__this.GetSafeWorldName();
					<>1__state = -3;
					<secondsBefore>5__3 = Mathf.Max(0, <>4__this.config.restart.secondsBefore);
					<announceMessage>5__4 = (string.IsNullOrWhiteSpace(<>4__this.config.restart.announceMessage) ? "Szerver restart {seconds} mp múlva!" : <>4__this.config.restart.announceMessage);
					<announceMessage>5__4 = <announceMessage>5__4.Replace("{seconds}", <secondsBefore>5__3.ToString());
					if (<secondsBefore>5__3 > 0)
					{
						<>4__this.SendCenterMessage(<announceMessage>5__4);
						<>4__this.LogInfo("Restart figyelmeztetés kiküldve: " + <announceMessage>5__4);
						<useKickWindow>5__7 = <>4__this.config.restart.kickPlayersBeforeRestart && <secondsBefore>5__3 >= <>4__this.config.restart.kickBeforeSeconds && <>4__this.config.restart.kickBeforeSeconds > 0;
						if (<useKickWindow>5__7)
						{
							<firstWait>5__8 = <secondsBefore>5__3 - <>4__this.config.restart.kickBeforeSeconds;
							if (<firstWait>5__8 > 0)
							{
								<>2__current = (object)new WaitForSeconds((float)<firstWait>5__8);
								<>1__state = 1;
								return true;
							}
							goto IL_0265;
						}
						<>2__current = (object)new WaitForSeconds((float)<secondsBefore>5__3);
						<>1__state = 4;
						return true;
					}
					goto IL_03a0;
				case 1:
					<>1__state = -3;
					goto IL_0265;
				case 2:
					<>1__state = -3;
					<>4__this.KickAllPlayersBeforeRestart();
					<remainingKickWindow>5__9 = (float)<>4__this.config.restart.kickBeforeSeconds - 3f;
					if (<remainingKickWindow>5__9 > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<remainingKickWindow>5__9);
						<>1__state = 3;
						return true;
					}
					goto IL_03a0;
				case 3:
					<>1__state = -3;
					goto IL_03a0;
				case 4:
					<>1__state = -3;
					goto IL_03a0;
				case 5:
					<>1__state = -3;
					goto IL_042d;
				case 6:
					<>1__state = -3;
					goto IL_0520;
				case 7:
					<>1__state = -3;
					goto IL_05cd;
				case 8:
					{
						<>1__state = -3;
						break;
					}
					IL_052d:
					if (!string.IsNullOrWhiteSpace(<>4__this.config.restart.finalMessage))
					{
						<>4__this.SendCenterMessage(<>4__this.config.restart.finalMessage);
					}
					<kickDelaySeconds>5__5 = Mathf.Max(0, <>4__this.config.restart.kickDelaySeconds);
					if (<kickDelaySeconds>5__5 > 0)
					{
						<>2__current = (object)new WaitForSeconds((float)<kickDelaySeconds>5__5);
						<>1__state = 7;
						return true;
					}
					goto IL_05cd;
					IL_042d:
					if (<>4__this.IsAnyoneInCombat())
					{
						<>4__this.LogInfo($"Restart halasztva, mert legalább egy játékos harcban van. Újrapróbálás {<retrySeconds>5__10} mp múlva.");
						<>2__current = (object)new WaitForSeconds((float)<retrySeconds>5__10);
						<>1__state = 5;
						return true;
					}
					goto IL_043f;
					IL_043f:
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.SendWebhookRestart(<serverName>5__1, <worldName>5__2));
					if (<>4__this.config.restart.saveBeforeRestart)
					{
						<>4__this.SaveWorld();
					}
					if (<>4__this.config.restart.backupBeforeRestart)
					{
						<backupDelay>5__11 = ((<>4__this.config != null && <>4__this.config.backup != null) ? <>4__this.config.backup.delaySeconds : 2);
						if (<backupDelay>5__11 > 0)
						{
							<>2__current = (object)new WaitForSeconds((float)<backupDelay>5__11);
							<>1__state = 6;
							return true;
						}
						goto IL_0520;
					}
					goto IL_052d;
					IL_05cd:
					<shutdownDelay>5__6 = Mathf.Max(0, <>4__this.config.restart.shutdownDelaySeconds);
					if (<shutdownDelay>5__6 > 0)
					{
						<>2__current = (object)new WaitForSeconds((float)<shutdownDelay>5__6);
						<>1__state = 8;
						return true;
					}
					break;
					IL_0265:
					if (!string.IsNullOrWhiteSpace(<>4__this.config.restart.kickMessage))
					{
						<>4__this.SendCenterMessage(<>4__this.config.restart.kickMessage);
						<>4__this.LogInfo("Kick előtti üzenet kiküldve: " + <>4__this.config.restart.kickMessage);
					}
					<>4__this.RequestClientsToSaveCharactersNow();
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 2;
					return true;
					IL_03a0:
					if (<>4__this.config.restart.delayIfInCombat)
					{
						<retrySeconds>5__10 = Mathf.Max(1, <>4__this.config.restart.retrySeconds);
						goto IL_042d;
					}
					goto IL_043f;
					IL_0520:
					<>4__this.DoBackup();
					goto IL_052d;
				}
				((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ForceQuitAfterDelay(Mathf.Max(1, <>4__this.config.restart.forceExitAfterSeconds)));
				Application.Quit();
				<announceMessage>5__4 = null;
				<>m__Finally1();
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			<>4__this.restartInProgress = false;
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SaveRoutine>d__37 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string triggerSource;

		public TimedSave <>4__this;

		private int <backupDelay>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SaveRoutine>d__37(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 2u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.IsServerInstance())
					{
						return false;
					}
					if (<>4__this.saveInProgress || <>4__this.restartInProgress)
					{
						return false;
					}
					<>4__this.saveInProgress = true;
					<>1__state = -3;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.HandlePreSaveAnnounce());
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -3;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.HandleSaveCombatDelay());
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<>4__this.SaveWorld();
					<backupDelay>5__1 = ((<>4__this.config != null && <>4__this.config.backup != null) ? <>4__this.config.backup.delaySeconds : 2);
					if (<backupDelay>5__1 > 0)
					{
						<>2__current = (object)new WaitForSeconds((float)<backupDelay>5__1);
						<>1__state = 3;
						return true;
					}
					break;
				case 3:
					<>1__state = -3;
					break;
				}
				<>4__this.DoBackup();
				<>m__Finally1();
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			<>4__this.saveInProgress = false;
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SendOnlineWebhookOnceAfterStartup>d__45 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public TimedSave <>4__this;

		private int <playerCount>5__1;

		private string <serverName>5__2;

		private string <worldName>5__3;

		private string <uptime>5__4;

		private Exception <ex>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SendOnlineWebhookOnceAfterStartup>d__45(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<serverName>5__2 = null;
			<worldName>5__3 = null;
			<uptime>5__4 = null;
			<ex>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(30f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!<>4__this.IsWebhookEnabledForStatus())
				{
					return false;
				}
				<playerCount>5__1 = 0;
				<serverName>5__2 = "Hardheim";
				<worldName>5__3 = "unknownworld";
				<uptime>5__4 = "-";
				try
				{
					<playerCount>5__1 = <>4__this.GetOnlinePlayerCount();
					if (<>4__this.config.status.onlyWhenPlayersOnline && <playerCount>5__1 <= 0)
					{
						<>4__this.LogInfo("Online webhook kihagyva, mert nincs online játékos.");
						return false;
					}
					<serverName>5__2 = <>4__this.GetDisplayServerName();
					<worldName>5__3 = <>4__this.GetSafeWorldName();
					<uptime>5__4 = <>4__this.GetFormattedUptime();
				}
				catch (Exception ex)
				{
					<ex>5__5 = ex;
					<>4__this.LogError("Egyszeri online webhook előkészítési hiba: " + <ex>5__5.Message);
					return false;
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PostWebhook(WebhookEventType.Status, <serverName>5__2, <worldName>5__3, "-", "-", string.Empty, <playerCount>5__1, <uptime>5__4));
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.LogInfo("Egyszeri online webhook elküldve.");
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SendWebhookError>d__61 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string serverName;

		public string worldName;

		public string backupFolder;

		public string error;

		public TimedSave <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SendWebhookError>d__61(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this.IsWebhookEnabledForError())
				{
					return false;
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PostWebhook(WebhookEventType.BackupError, serverName, worldName, backupFolder, string.Empty, error, <>4__this.GetOnlinePlayerCount(), <>4__this.GetFormattedUptime()));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SendWebhookRestart>d__62 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string serverName;

		public string worldName;

		public TimedSave <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SendWebhookRestart>d__62(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this.IsWebhookEnabledForRestart())
				{
					return false;
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PostWebhook(WebhookEventType.Restart, serverName, worldName, "-", "-", string.Empty, <>4__this.GetOnlinePlayerCount(), <>4__this.GetFormattedUptime()));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SendWebhookRestartError>d__63 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string serverName;

		public string worldName;

		public string error;

		public TimedSave <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SendWebhookRestartError>d__63(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this.IsWebhookEnabledForRestart())
				{
					return false;
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PostWebhook(WebhookEventType.RestartError, serverName, worldName, "-", "-", error, <>4__this.GetOnlinePlayerCount(), <>4__this.GetFormattedUptime()));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SendWebhookSuccess>d__60 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string serverName;

		public string worldName;

		public string backupFolder;

		public string pathValue;

		public TimedSave <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SendWebhookSuccess>d__60(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this.IsWebhookEnabledForSuccess())
				{
					return false;
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PostWebhook(WebhookEventType.BackupSuccess, serverName, worldName, backupFolder, pathValue, string.Empty, <>4__this.GetOnlinePlayerCount(), <>4__this.GetFormattedUptime()));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static ManualLogSource Log;

	private ConfigData config;

	private readonly HashSet<string> executedToday = new HashSet<string>();

	private readonly HashSet<string> restartedToday = new HashSet<string>();

	private DateTime lastDay;

	private bool saveInProgress;

	private bool restartInProgress;

	private Harmony harmony;

	private DateTime pluginStartUtc;

	private const string RpcSavePlayerNow = "HardheimTimedSave_SavePlayerNow";

	private ZRoutedRpc registeredRoutedRpcInstance;

	public static TimedSave Instance { get; private set; }

	private void Awake()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		pluginStartUtc = DateTime.UtcNow;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[HardheimTimedSave] Mod betöltve.");
		LoadConfig();
		harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
		harmony.PatchAll();
		((MonoBehaviour)this).InvokeRepeating("CheckTime", 5f, 30f);
		((MonoBehaviour)this).StartCoroutine(RegisterClientSaveRpcLoop());
		if (config != null && config.status != null && config.status.enabled)
		{
			((MonoBehaviour)this).StartCoroutine(SendOnlineWebhookOnceAfterStartup());
			LogInfo("Egyszeri online webhook indítása ütemezve.");
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)Instance == (Object)(object)this)
		{
			Instance = null;
		}
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	private void LoadConfig()
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Expected O, but got Unknown
		string path = Path.Combine(Paths.ConfigPath, ((BaseUnityPlugin)this).Info.Metadata.GUID + ".yml");
		if (!File.Exists(path))
		{
			string contents = "# ============================================\r\n# Hardheim Timed Save\r\n# ============================================\r\n# Automatikus szerver mentés és időzített restart\r\n# ============================================\r\n\r\nenabled: true\r\n\r\nsaveTimes:\r\n  - \"23:55\"\r\n\r\ntimezone: \"Europe/Budapest\"\r\n\r\nannounce:\r\n  enabled: true\r\n  secondsBefore: 10\r\n  message: \"Szerver mentés {seconds} mp múlva!\"\r\n\r\ncombatCheck:\r\n  enabled: true\r\n  delayIfInCombat: true\r\n  retrySeconds: 30\r\n\r\nbackup:\r\n  enabled: true\r\n  folder: \"backups\"\r\n  zip: true\r\n  keepLast: 3\r\n  delaySeconds: 2\r\n  customWorldPath: \"\"\r\n  worldSearchPaths:\r\n    - \"worlds_local\"\r\n    - \"worlds_local/worlds\"\r\n\r\nrestart:\r\n  enabled: false\r\n  restartTimes:\r\n    - \"04:00\"\r\n  secondsBefore: 60\r\n  announceMessage: \"Szerver restart {seconds} mp múlva!\"\r\n  finalMessage: \"Szerver restart indul, hamarosan visszatérünk!\"\r\n  delayIfInCombat: true\r\n  retrySeconds: 30\r\n  saveBeforeRestart: true\r\n  backupBeforeRestart: true\r\n  kickPlayersBeforeRestart: true\r\n  kickBeforeSeconds: 30\r\n  kickMessage: \"Játékosok kirúgása a szerverről, újraindítás miatt\"\r\n  kickDelaySeconds: 2\r\n  shutdownDelaySeconds: 5\r\n  forceExitAfterSeconds: 15\r\n\r\nwebhook:\r\n  enabled: false\r\n  url: \"\"\r\n  username: \"Hardheim Timed Save\"\r\n  avatarUrl: \"\"\r\n  serverName: \"Hardheim\"\r\n  useEmbeds: true\r\n  sendOnSuccess: true\r\n  sendOnError: true\r\n  sendOnRestart: true\r\n  successMessage: \"✅ Backup elkészült | Szerver: {server} | Világ: {world} | Mappa: {folder} | Fájl: {path} | Megtartott mentések: {keepLast} | Idő: {time}\"\r\n  errorMessage: \"❌ Backup hiba | Szerver: {server} | Világ: {world} | Hiba: {error} | Idő: {time}\"\r\n  restartMessage: \"\ud83d\udd01 Szerver restart indul | Szerver: {server} | Világ: {world} | Játékosok: {players} | Idő: {time}\"\r\n  restartErrorMessage: \"❌ Restart hiba | Szerver: {server} | Világ: {world} | Hiba: {error} | Idő: {time}\"\r\n\r\nstatus:\r\n  enabled: false\r\n  onlyWhenPlayersOnline: false\r\n  message: \"\ud83d\udfe2 Szerver online | Szerver: {server} | Világ: {world} | Játékosok: {players} | Uptime: {uptime} | Idő: {time}\"\r\n\r\nlogToConsole: true\r\n";
			File.WriteAllText(path, contents);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HardheimTimedSave] Alapértelmezett config létrehozva.");
		}
		IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
		config = val.Deserialize<ConfigData>(File.ReadAllText(path));
		if (config == null)
		{
			config = new ConfigData();
		}
		if (config.saveTimes == null || config.saveTimes.Count == 0)
		{
			config.saveTimes = new List<string> { "23:55" };
		}
		if (string.IsNullOrWhiteSpace(config.timezone))
		{
			config.timezone = "Europe/Budapest";
		}
		if (config.announce == null)
		{
			config.announce = new Announce
			{
				enabled = true,
				secondsBefore = 10,
				message = "Szerver mentés {seconds} mp múlva!"
			};
		}
		if (config.combatCheck == null)
		{
			config.combatCheck = new Combat
			{
				enabled = true,
				delayIfInCombat = true,
				retrySeconds = 30
			};
		}
		if (config.backup == null)
		{
			config.backup = new Backup
			{
				enabled = true,
				folder = "backups",
				zip = true,
				keepLast = 3,
				delaySeconds = 2,
				worldSearchPaths = new List<string> { "worlds_local", "worlds_local/worlds" },
				customWorldPath = ""
			};
		}
		if (config.backup.worldSearchPaths == null || config.backup.worldSearchPaths.Count == 0)
		{
			config.backup.worldSearchPaths = new List<string> { "worlds_local", "worlds_local/worlds" };
		}
		if (config.backup.customWorldPath == null)
		{
			config.backup.customWorldPath = "";
		}
		if (config.restart == null)
		{
			config.restart = new Restart
			{
				enabled = false,
				restartTimes = new List<string> { "04:00" },
				secondsBefore = 60,
				announceMessage = "Szerver restart {seconds} mp múlva!",
				finalMessage = "Szerver restart indul, hamarosan visszatérünk!",
				delayIfInCombat = true,
				retrySeconds = 30,
				saveBeforeRestart = true,
				backupBeforeRestart = true,
				kickPlayersBeforeRestart = true,
				kickBeforeSeconds = 30,
				kickMessage = "Játékosok kirúgása a szerverről, újraindítás miatt",
				kickMessageLeadSeconds = 2,
				kickDelaySeconds = 2,
				shutdownDelaySeconds = 5,
				forceExitAfterSeconds = 15
			};
		}
		if (config.restart.restartTimes == null || config.restart.restartTimes.Count == 0)
		{
			config.restart.restartTimes = new List<string> { "04:00" };
		}
		if (config.webhook == null)
		{
			config.webhook = new Webhook
			{
				enabled = false,
				url = string.Empty,
				username = "Hardheim Timed Save",
				avatarUrl = string.Empty,
				serverName = "Hardheim",
				useEmbeds = true,
				sendOnSuccess = true,
				sendOnError = true,
				sendOnRestart = true,
				successMessage = "✅ Backup elkészült | Szerver: {server} | Világ: {world} | Mappa: {folder} | Fájl: {path} | Megtartott mentések: {keepLast} | Idő: {time}",
				errorMessage = "❌ Backup hiba | Szerver: {server} | Világ: {world} | Hiba: {error} | Idő: {time}",
				restartMessage = "\ud83d\udd01 Szerver restart indul | Szerver: {server} | Világ: {world} | Játékosok: {players} | Idő: {time}",
				restartErrorMessage = "❌ Restart hiba | Szerver: {server} | Világ: {world} | Hiba: {error} | Idő: {time}"
			};
		}
		if (config.status == null)
		{
			config.status = new Status
			{
				enabled = false,
				onlyWhenPlayersOnline = false,
				message = "\ud83d\udfe2 Szerver online | Szerver: {server} | Világ: {world} | Játékosok: {players} | Uptime: {uptime} | Idő: {time}"
			};
		}
		if (string.IsNullOrWhiteSpace(config.backup.folder))
		{
			config.backup.folder = "backups";
		}
		if (config.backup.keepLast < 3)
		{
			config.backup.keepLast = 3;
			LogWarning("A keepLast túl alacsony volt, 3-ra állítva.");
		}
		else if (config.backup.keepLast > 10)
		{
			config.backup.keepLast = 10;
			LogWarning("A keepLast túl magas volt, 10-re állítva.");
		}
		if (config.backup.delaySeconds < 0)
		{
			config.backup.delaySeconds = 2;
		}
		if (config.restart.secondsBefore < 0)
		{
			config.restart.secondsBefore = 60;
		}
		if (config.restart.retrySeconds < 1)
		{
			config.restart.retrySeconds = 30;
		}
		if (config.restart.kickBeforeSeconds < 0)
		{
			config.restart.kickBeforeSeconds = 30;
		}
		if (config.restart.kickDelaySeconds < 0)
		{
			config.restart.kickDelaySeconds = 2;
		}
		if (config.restart.shutdownDelaySeconds < 0)
		{
			config.restart.shutdownDelaySeconds = 5;
		}
		if (config.restart.forceExitAfterSeconds < 1)
		{
			config.restart.forceExitAfterSeconds = 15;
		}
		if (string.IsNullOrWhiteSpace(config.restart.kickMessage))
		{
			config.restart.kickMessage = "Játékosok kirúgása a szerverről, újraindítás miatt";
		}
		if (string.IsNullOrWhiteSpace(config.webhook.username))
		{
			config.webhook.username = "Hardheim Timed Save";
		}
		if (string.IsNullOrWhiteSpace(config.webhook.serverName))
		{
			config.webhook.serverName = "Hardheim";
		}
		if (string.IsNullOrWhiteSpace(config.status.message))
		{
			config.status.message = "\ud83d\udfe2 Szerver online | Szerver: {server} | Világ: {world} | Játékosok: {players} | Uptime: {uptime} | Idő: {time}";
		}
		LogInfo("Config betöltve.");
	}

	private bool IsServerInstance()
	{
		return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();
	}

	[IteratorStateMachine(typeof(<RegisterClientSaveRpcLoop>d__31))]
	private IEnumerator RegisterClientSaveRpcLoop()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RegisterClientSaveRpcLoop>d__31(0)
		{
			<>4__this = this
		};
	}

	private static void RPC_HardheimTimedSave_SavePlayerNow(long sender)
	{
		if ((Object)(object)Instance != (Object)null)
		{
			Instance.SaveLocalPlayerProfileNow();
		}
	}

	private void SaveLocalPlayerProfileNow()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		try
		{
			if (!((Object)Game.instance == (Object)null))
			{
				Game.instance.SavePlayerProfile(true);
				LogInfo("[CLIENT SAVE] Karakterpozíció mentve restart előtt.");
			}
		}
		catch (Exception ex)
		{
			LogWarning("[CLIENT SAVE] Karaktermentés hiba: " + ex.Message);
		}
	}

	private void RequestClientsToSaveCharactersNow()
	{
		try
		{
			if (ZRoutedRpc.instance == null)
			{
				LogWarning("[CLIENT SAVE] Nem küldhető RPC, mert ZRoutedRpc.instance null.");
				return;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(0L, "HardheimTimedSave_SavePlayerNow", Array.Empty<object>());
			LogInfo("[CLIENT SAVE] Karaktermentési kérés kiküldve minden kliensnek.");
		}
		catch (Exception ex)
		{
			LogWarning("[CLIENT SAVE] RPC küldési hiba: " + ex.Message);
		}
	}

	private void CheckTime()
	{
		if (!IsServerInstance() || config == null || !config.enabled || saveInProgress || restartInProgress)
		{
			return;
		}
		DateTime time = GetTime();
		if (time.Date != lastDay.Date)
		{
			executedToday.Clear();
			restartedToday.Clear();
			lastDay = time.Date;
			LogInfo("Új nap kezdődött, a napi mentési és restart állapotok törölve lettek.");
		}
		string text = time.ToString("HH:mm");
		foreach (string saveTime in config.saveTimes)
		{
			if (text == saveTime && !executedToday.Contains(saveTime))
			{
				executedToday.Add(saveTime);
				((MonoBehaviour)this).StartCoroutine(SaveRoutine(saveTime));
				return;
			}
		}
		if (config.restart == null || !config.restart.enabled)
		{
			return;
		}
		foreach (string restartTime in config.restart.restartTimes)
		{
			if (text == restartTime && !restartedToday.Contains(restartTime))
			{
				restartedToday.Add(restartTime);
				((MonoBehaviour)this).StartCoroutine(RestartRoutine(restartTime));
				break;
			}
		}
	}

	private DateTime GetTime()
	{
		string text = ((config != null && !string.IsNullOrWhiteSpace(config.timezone)) ? config.timezone.Trim() : "Europe/Budapest");
		string text2 = text.ToUpperInvariant();
		try
		{
			switch (text2)
			{
			case "UTC":
				return DateTime.UtcNow;
			case "CET":
			case "CEST":
			case "EUROPE/BUDAPEST":
				return TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? TimeZoneInfo.FindSystemTimeZoneById("Central Europe Standard Time") : TimeZoneInfo.FindSystemTimeZoneById("Europe/Budapest"));
			default:
			{
				TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById(text);
				return TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, destinationTimeZone);
			}
			}
		}
		catch
		{
			return DateTime.Now;
		}
	}

	[IteratorStateMachine(typeof(<SaveRoutine>d__37))]
	private IEnumerator SaveRoutine(string triggerSource)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SaveRoutine>d__37(0)
		{
			<>4__this = this,
			triggerSource = triggerSource
		};
	}

	[IteratorStateMachine(typeof(<RestartRoutine>d__38))]
	private IEnumerator RestartRoutine(string triggerSource)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RestartRoutine>d__38(0)
		{
			<>4__this = this,
			triggerSource = triggerSource
		};
	}

	private void KickAllPlayersBeforeRestart()
	{
		if ((Object)(object)ZNet.instance == (Object)null)
		{
			LogWarning("Kick kihagyva, mert a ZNet.instance nem elérhető.");
			return;
		}
		try
		{
			List<object> connectedPeerObjects = GetConnectedPeerObjects();
			if (connectedPeerObjects.Count == 0)
			{
				LogInfo("Nincs kickelendő játékos.");
				return;
			}
			LogInfo($"Restart előtti játékosbontás indul. Érintett peer-ek: {connectedPeerObjects.Count}");
			foreach (object item in connectedPeerObjects)
			{
				if (item == null)
				{
					continue;
				}
				try
				{
					string peerPlayerName = GetPeerPlayerName(item);
					LogInfo("Játékos bontása restart előtt: " + peerPlayerName);
					object memberValue = GetMemberValue(item, "m_rpc");
					if (memberValue != null)
					{
						InvokeRpcError(memberValue);
					}
					if (!DisconnectPeer(item))
					{
						LogWarning("A peer bontása nem sikerült reflektíven. Név: " + peerPlayerName);
					}
				}
				catch (Exception ex)
				{
					LogError("Nem sikerült egy játékost bontani: " + ex.Message);
				}
			}
		}
		catch (Exception ex2)
		{
			LogError("KickAllPlayersBeforeRestart hiba: " + ex2.Message);
		}
	}

	private List<object> GetConnectedPeerObjects()
	{
		List<object> list = new List<object>();
		object instance = ZNet.instance;
		if (instance == null)
		{
			return list;
		}
		string[] array = new string[3] { "m_peers", "m_peerConnections", "m_connections" };
		string[] array2 = array;
		foreach (string memberName in array2)
		{
			object memberValue = GetMemberValue(instance, memberName);
			if (!(memberValue is IEnumerable enumerable))
			{
				continue;
			}
			foreach (object item in enumerable)
			{
				if (item != null)
				{
					list.Add(item);
				}
			}
			if (list.Count > 0)
			{
				return list;
			}
		}
		return list;
	}

	private string GetPeerPlayerName(object peer)
	{
		object memberValue = GetMemberValue(peer, "m_playerName");
		if (memberValue is string text && !string.IsNullOrWhiteSpace(text))
		{
			return text;
		}
		return "unknownplayer";
	}

	private bool DisconnectPeer(object peer)
	{
		object instance = ZNet.instance;
		if (instance == null || peer == null)
		{
			return false;
		}
		Type type = instance.GetType();
		Type type2 = peer.GetType();
		MethodInfo method = type.GetMethod("Disconnect", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { type2 }, null);
		if (method != null)
		{
			method.Invoke(instance, new object[1] { peer });
			return true;
		}
		object memberValue = GetMemberValue(peer, "m_rpc");
		if (memberValue != null)
		{
			Type type3 = memberValue.GetType();
			MethodInfo method2 = type.GetMethod("Disconnect", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { type3 }, null);
			if (method2 != null)
			{
				method2.Invoke(instance, new object[1] { memberValue });
				return true;
			}
			MethodInfo method3 = type3.GetMethod("Close", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method3 != null)
			{
				method3.Invoke(memberValue, null);
				return true;
			}
		}
		return false;
	}

	private void InvokeRpcError(object rpc)
	{
		if (rpc == null)
		{
			return;
		}
		Type type = rpc.GetType();
		MethodInfo methodInfo = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Invoke" && m.GetParameters().Length == 2);
		if (methodInfo == null)
		{
			return;
		}
		try
		{
			methodInfo.Invoke(rpc, new object[2] { "Error", 3 });
		}
		catch
		{
			try
			{
				methodInfo.Invoke(rpc, new object[2]
				{
					"Error",
					new object[1] { 3 }
				});
			}
			catch
			{
			}
		}
	}

	private object GetMemberValue(object instance, string memberName)
	{
		if (instance == null || string.IsNullOrWhiteSpace(memberName))
		{
			return null;
		}
		Type type = instance.GetType();
		FieldInfo field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			return field.GetValue(instance);
		}
		PropertyInfo property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (property != null)
		{
			return property.GetValue(instance, null);
		}
		return null;
	}

	[IteratorStateMachine(typeof(<SendOnlineWebhookOnceAfterStartup>d__45))]
	private IEnumerator SendOnlineWebhookOnceAfterStartup()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SendOnlineWebhookOnceAfterStartup>d__45(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<ForceQuitAfterDelay>d__46))]
	private IEnumerator ForceQuitAfterDelay(int seconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ForceQuitAfterDelay>d__46(0)
		{
			<>4__this = this,
			seconds = seconds
		};
	}

	[IteratorStateMachine(typeof(<HandlePreSaveAnnounce>d__47))]
	private IEnumerator HandlePreSaveAnnounce()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <HandlePreSaveAnnounce>d__47(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<HandleSaveCombatDelay>d__48))]
	private IEnumerator HandleSaveCombatDelay()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <HandleSaveCombatDelay>d__48(0)
		{
			<>4__this = this
		};
	}

	private bool IsAnyoneInCombat()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		foreach (Player allPlayer in Player.GetAllPlayers())
		{
			if ((Object)allPlayer != (Object)null && (((Character)allPlayer).InAttack() || ((Character)allPlayer).IsBlocking()))
			{
				return true;
			}
		}
		return false;
	}

	private void SaveWorld()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		if (IsServerInstance())
		{
			if ((Object)ZNet.instance == (Object)null)
			{
				LogWarning("A világmentés nem futott le, mert a ZNet.instance nem elérhető.");
			}
			else
			{
				ZNet.instance.Save(false, false, false);
			}
		}
	}

	private void DoBackup()
	{
		string safeWorldName = GetSafeWorldName();
		string displayServerName = GetDisplayServerName();
		string text = string.Empty;
		if (config == null || config.backup == null || !config.backup.enabled)
		{
			return;
		}
		try
		{
			string text2 = ResolveWorldsFolder();
			string path = Path.Combine(Paths.BepInExRootPath, config.backup.folder);
			text = Path.Combine(path, safeWorldName);
			Directory.CreateDirectory(text);
			List<string> worldFiles = GetWorldFiles(text2, safeWorldName);
			if (worldFiles.Count == 0)
			{
				throw new FileNotFoundException("Nem találhatók az aktuális világhoz tartozó fájlok. Világ: " + safeWorldName + " | Mappa: " + text2);
			}
			string text3 = "backup_" + safeWorldName + "_";
			string text4 = GetTime().ToString("yyyyMMdd_HHmmss");
			if (config.backup.zip)
			{
				string text5 = Path.Combine(text, text3 + text4 + ".zip");
				CreateWorldZip(text5, worldFiles);
				CleanupOldBackups(text, text3);
				((MonoBehaviour)this).StartCoroutine(SendWebhookSuccess(displayServerName, safeWorldName, text, text5));
				return;
			}
			string text6 = Path.Combine(text, text3 + text4);
			Directory.CreateDirectory(text6);
			foreach (string item in worldFiles)
			{
				string destFileName = Path.Combine(text6, Path.GetFileName(item));
				File.Copy(item, destFileName, overwrite: true);
			}
			CleanupOldBackupFolders(text, text3);
			((MonoBehaviour)this).StartCoroutine(SendWebhookSuccess(displayServerName, safeWorldName, text, text6));
		}
		catch (Exception ex)
		{
			((MonoBehaviour)this).StartCoroutine(SendWebhookError(displayServerName, safeWorldName, text, ex.Message));
		}
	}

	private string ResolveWorldsFolder()
	{
		List<string> list = new List<string>();
		if (!string.IsNullOrWhiteSpace((config != null && config.backup != null) ? config.backup.customWorldPath : null))
		{
			string text = config.backup.customWorldPath.Trim();
			string text2 = (Path.IsPathRooted(text) ? text : Path.Combine(Application.persistentDataPath, text));
			list.Add(text2);
			if (Directory.Exists(text2))
			{
				return text2;
			}
		}
		List<string> list2 = ((config != null && config.backup != null) ? config.backup.worldSearchPaths : null);
		if (list2 == null || list2.Count == 0)
		{
			list2 = new List<string> { "worlds_local", "worlds_local/worlds" };
		}
		foreach (string item in list2)
		{
			if (!string.IsNullOrWhiteSpace(item))
			{
				string path = item.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar);
				string text3 = Path.Combine(Application.persistentDataPath, path);
				list.Add(text3);
				if (Directory.Exists(text3))
				{
					return text3;
				}
			}
		}
		throw new DirectoryNotFoundException("Nem található a világ mappa. Ellenőrzött: " + string.Join(" | ", list));
	}

	private void CreateWorldZip(string zipPath, List<string> sourceFiles)
	{
		if (File.Exists(zipPath))
		{
			File.Delete(zipPath);
		}
		using FileStream stream = new FileStream(zipPath, FileMode.CreateNew);
		using ZipArchive destination = new ZipArchive(stream, ZipArchiveMode.Create);
		foreach (string sourceFile in sourceFiles)
		{
			string fileName = Path.GetFileName(sourceFile);
			destination.CreateEntryFromFile(sourceFile, fileName, CompressionLevel.Optimal);
		}
	}

	private List<string> GetWorldFiles(string worldsFolder, string worldName)
	{
		List<string> list = new List<string>();
		if (string.IsNullOrWhiteSpace(worldsFolder) || !Directory.Exists(worldsFolder))
		{
			return list;
		}
		string[] array = new string[2]
		{
			worldName + ".db",
			worldName + ".fwl"
		};
		string[] array2 = array;
		foreach (string searchPattern in array2)
		{
			try
			{
				list.AddRange(Directory.GetFiles(worldsFolder, searchPattern, SearchOption.TopDirectoryOnly));
			}
			catch
			{
			}
		}
		return (from filePath in list.Where(File.Exists).Distinct<string>(StringComparer.OrdinalIgnoreCase)
			orderby filePath
			select filePath).ToList();
	}

	private string GetSafeWorldName()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown
		string value = "unknownworld";
		try
		{
			if ((Object)ZNet.instance != (Object)null)
			{
				string worldName = ZNet.instance.GetWorldName();
				if (!string.IsNullOrWhiteSpace(worldName))
				{
					value = worldName.Trim();
				}
			}
		}
		catch
		{
		}
		return SanitizeFileName(value, "unknownworld");
	}

	private string GetDisplayServerName()
	{
		if (config == null || config.webhook == null || string.IsNullOrWhiteSpace(config.webhook.serverName))
		{
			return "Hardheim";
		}
		return config.webhook.serverName.Trim();
	}

	private string SanitizeFileName(string value, string fallback)
	{
		string text = (string.IsNullOrWhiteSpace(value) ? fallback : value.Trim());
		char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
		foreach (char oldChar in invalidFileNameChars)
		{
			text = text.Replace(oldChar, '_');
		}
		text = text.Replace(' ', '_');
		if (string.IsNullOrWhiteSpace(text))
		{
			text = fallback;
		}
		return text;
	}

	private void CleanupOldBackups(string backupFolder, string filePrefix)
	{
		try
		{
			List<FileInfo> list = (from file in new DirectoryInfo(backupFolder).GetFiles(filePrefix + "*.zip")
				orderby file.CreationTimeUtc descending
				select file).ToList();
			int keepLast = config.backup.keepLast;
			if (list.Count <= keepLast)
			{
				return;
			}
			foreach (FileInfo item in list.Skip(keepLast))
			{
				try
				{
					item.Delete();
				}
				catch
				{
				}
			}
		}
		catch
		{
		}
	}

	private void CleanupOldBackupFolders(string backupFolder, string folderPrefix)
	{
		try
		{
			List<DirectoryInfo> list = (from directory in new DirectoryInfo(backupFolder).GetDirectories(folderPrefix + "*")
				orderby directory.CreationTimeUtc descending
				select directory).ToList();
			int keepLast = config.backup.keepLast;
			if (list.Count <= keepLast)
			{
				return;
			}
			foreach (DirectoryInfo item in list.Skip(keepLast))
			{
				try
				{
					item.Delete(recursive: true);
				}
				catch
				{
				}
			}
		}
		catch
		{
		}
	}

	[IteratorStateMachine(typeof(<SendWebhookSuccess>d__60))]
	private IEnumerator SendWebhookSuccess(string serverName, string worldName, string backupFolder, string pathValue)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SendWebhookSuccess>d__60(0)
		{
			<>4__this = this,
			serverName = serverName,
			worldName = worldName,
			backupFolder = backupFolder,
			pathValue = pathValue
		};
	}

	[IteratorStateMachine(typeof(<SendWebhookError>d__61))]
	private IEnumerator SendWebhookError(string serverName, string worldName, string backupFolder, string error)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SendWebhookError>d__61(0)
		{
			<>4__this = this,
			serverName = serverName,
			worldName = worldName,
			backupFolder = backupFolder,
			error = error
		};
	}

	[IteratorStateMachine(typeof(<SendWebhookRestart>d__62))]
	private IEnumerator SendWebhookRestart(string serverName, string worldName)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SendWebhookRestart>d__62(0)
		{
			<>4__this = this,
			serverName = serverName,
			worldName = worldName
		};
	}

	[IteratorStateMachine(typeof(<SendWebhookRestartError>d__63))]
	private IEnumerator SendWebhookRestartError(string serverName, string worldName, string error)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SendWebhookRestartError>d__63(0)
		{
			<>4__this = this,
			serverName = serverName,
			worldName = worldName,
			error = error
		};
	}

	private bool IsWebhookEnabledForSuccess()
	{
		return config != null && config.webhook != null && config.webhook.enabled && config.webhook.sendOnSuccess && !string.IsNullOrWhiteSpace(config.webhook.url);
	}

	private bool IsWebhookEnabledForError()
	{
		return config != null && config.webhook != null && config.webhook.enabled && config.webhook.sendOnError && !string.IsNullOrWhiteSpace(config.webhook.url);
	}

	private bool IsWebhookEnabledForRestart()
	{
		return config != null && config.webhook != null && config.webhook.enabled && config.webhook.sendOnRestart && !string.IsNullOrWhiteSpace(config.webhook.url);
	}

	private bool IsWebhookEnabledForStatus()
	{
		return config != null && config.webhook != null && config.webhook.enabled && config.status != null && config.status.enabled && !string.IsNullOrWhiteSpace(config.webhook.url);
	}

	private string BuildWebhookMessage(string template, string serverName, string worldName, string backupFolder, string pathValue, string error, int playerCount, string uptime)
	{
		string text = (string.IsNullOrWhiteSpace(template) ? "Hardheim Timed Save webhook üzenet" : template);
		return text.Replace("{server}", string.IsNullOrWhiteSpace(serverName) ? "unknownserver" : serverName).Replace("{world}", string.IsNullOrWhiteSpace(worldName) ? "unknownworld" : worldName).Replace("{folder}", string.IsNullOrWhiteSpace(backupFolder) ? "-" : backupFolder)
			.Replace("{path}", string.IsNullOrWhiteSpace(pathValue) ? "-" : pathValue)
			.Replace("{keepLast}", config.backup.keepLast.ToString())
			.Replace("{time}", GetTime().ToString("yyyy-MM-dd HH:mm:ss"))
			.Replace("{error}", string.IsNullOrWhiteSpace(error) ? "-" : error)
			.Replace("{players}", playerCount.ToString())
			.Replace("{uptime}", string.IsNullOrWhiteSpace(uptime) ? "-" : uptime);
	}

	private string GetTemplateForEvent(WebhookEventType eventType)
	{
		return eventType switch
		{
			WebhookEventType.BackupSuccess => config.webhook.successMessage, 
			WebhookEventType.BackupError => config.webhook.errorMessage, 
			WebhookEventType.Restart => config.webhook.restartMessage, 
			WebhookEventType.RestartError => config.webhook.restartErrorMessage, 
			WebhookEventType.Status => config.status.message, 
			_ => "Hardheim Timed Save webhook üzenet", 
		};
	}

	[IteratorStateMachine(typeof(<PostWebhook>d__70))]
	private IEnumerator PostWebhook(WebhookEventType eventType, string serverName, string worldName, string backupFolder, string pathValue, string error, int playerCount, string uptime)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PostWebhook>d__70(0)
		{
			<>4__this = this,
			eventType = eventType,
			serverName = serverName,
			worldName = worldName,
			backupFolder = backupFolder,
			pathValue = pathValue,
			error = error,
			playerCount = playerCount,
			uptime = uptime
		};
	}

	private DiscordWebhookPayload BuildEmbedPayload(WebhookEventType eventType, string serverName, string worldName, string backupFolder, string pathValue, string error, int playerCount, string uptime)
	{
		List<DiscordEmbedField> list = new List<DiscordEmbedField>
		{
			new DiscordEmbedField
			{
				name = "Szerver",
				value = GetDiscordSafeValue(serverName),
				inline = true
			},
			new DiscordEmbedField
			{
				name = "Világ",
				value = GetDiscordSafeValue(worldName),
				inline = true
			},
			new DiscordEmbedField
			{
				name = "Játékosok",
				value = playerCount.ToString(),
				inline = true
			},
			new DiscordEmbedField
			{
				name = "Uptime",
				value = GetDiscordSafeValue(uptime),
				inline = true
			},
			new DiscordEmbedField
			{
				name = "Idő",
				value = GetDiscordSafeValue(GetTime().ToString("yyyy-MM-dd HH:mm:ss")),
				inline = true
			}
		};
		string title;
		string description;
		int color;
		switch (eventType)
		{
		case WebhookEventType.BackupSuccess:
			title = "✅ Backup elkészült";
			description = "Az automatikus mentés sikeresen lefutott.";
			color = 5763719;
			list.Add(new DiscordEmbedField
			{
				name = "Megtartott mentések",
				value = config.backup.keepLast.ToString(),
				inline = true
			});
			list.Add(new DiscordEmbedField
			{
				name = "Mappa",
				value = GetDiscordSafeValue(backupFolder),
				inline = false
			});
			list.Add(new DiscordEmbedField
			{
				name = "Fájl",
				value = GetDiscordSafeValue(string.IsNullOrWhiteSpace(pathValue) ? "-" : Path.GetFileName(pathValue)),
				inline = true
			});
			list.Add(new DiscordEmbedField
			{
				name = "Teljes útvonal",
				value = GetDiscordSafeValue(string.IsNullOrWhiteSpace(pathValue) ? "-" : pathValue),
				inline = false
			});
			break;
		case WebhookEventType.BackupError:
			title = "❌ Backup hiba";
			description = "Hiba történt az automatikus mentés közben.";
			color = 15548997;
			list.Add(new DiscordEmbedField
			{
				name = "Hiba",
				value = GetDiscordSafeValue(error),
				inline = false
			});
			break;
		case WebhookEventType.Restart:
			title = "\ud83d\udd01 Szerver restart indul";
			description = "Az időzített restart folyamat elindult.";
			color = 15105570;
			break;
		case WebhookEventType.RestartError:
			title = "❌ Restart hiba";
			description = "Hiba történt a restart folyamat közben.";
			color = 15548997;
			list.Add(new DiscordEmbedField
			{
				name = "Hiba",
				value = GetDiscordSafeValue(error),
				inline = false
			});
			break;
		default:
			title = "Hardheim Timed Save";
			description = "Webhook esemény";
			color = 3447003;
			break;
		}
		DiscordEmbed discordEmbed = new DiscordEmbed
		{
			title = title,
			description = description,
			color = color,
			fields = list.ToArray(),
			timestamp = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ"),
			footer = new DiscordEmbedFooter
			{
				text = "Hardheim Timed Save"
			}
		};
		DiscordWebhookPayload discordWebhookPayload = new DiscordWebhookPayload();
		discordWebhookPayload.content = BuildWebhookMessage(GetTemplateForEvent(eventType), serverName, worldName, backupFolder, pathValue, error, playerCount, uptime);
		discordWebhookPayload.username = (string.IsNullOrWhiteSpace(config.webhook.username) ? "Hardheim Timed Save" : config.webhook.username);
		discordWebhookPayload.avatar_url = (string.IsNullOrWhiteSpace(config.webhook.avatarUrl) ? null : config.webhook.avatarUrl);
		discordWebhookPayload.embeds = new DiscordEmbed[1] { discordEmbed };
		return discordWebhookPayload;
	}

	private string GetDiscordSafeValue(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "-";
		}
		string text = value.Replace("\r", " ").Replace("\n", " ").Trim();
		if (string.IsNullOrWhiteSpace(text))
		{
			return "-";
		}
		if (text.Length > 1000)
		{
			text = text.Substring(0, 1000) + "...";
		}
		return text;
	}

	private int GetOnlinePlayerCount()
	{
		try
		{
			return Player.GetAllPlayers().Count;
		}
		catch
		{
			return 0;
		}
	}

	private string GetFormattedUptime()
	{
		TimeSpan timeSpan = DateTime.UtcNow - pluginStartUtc;
		return string.Format("{0:%d} nap {0:hh\\:mm\\:ss}", timeSpan);
	}

	private void SendCenterMessage(string msg)
	{
		if (ZRoutedRpc.instance != null)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ShowMessage", new object[2] { 2, msg });
		}
	}

	private void LogInfo(string message)
	{
		if (config == null || config.logToConsole)
		{
			Log.LogInfo((object)message);
		}
	}

	private void LogWarning(string message)
	{
		Log.LogWarning((object)message);
	}

	private void LogError(string message)
	{
		Log.LogError((object)message);
	}
}
namespace HardheimTimedSave;

public class Class1
{
}