using System;
using System.Collections;
using System.Collections.Concurrent;
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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.Win32;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("NativeBackup")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A simple backup valheim mod")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+d4f9f3bb7c02247faff8e1b72c55fa167c6c79e2")]
[assembly: AssemblyProduct("NativeBackup")]
[assembly: AssemblyTitle("NativeBackup")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NativeBackup
{
	public static class BackupCoordinator
	{
		public enum BackupStartResult
		{
			Started,
			AlreadyRunning,
			CooldownActive
		}

		private const int MinimumBackupIntervalSeconds = 5;

		private static readonly object _backupGate = new object();

		private static int _backupInProgress;

		private static long _lastBackupStartTicks;

		public static bool IsBackupInProgress => Volatile.Read(ref _backupInProgress) == 1;

		public static bool IsCooldownActive => IsWithinCooldown(DateTime.UtcNow.Ticks);

		public static BackupStartResult TryStartBackup(string targetWorld, string targetCharacter)
		{
			long ticks = DateTime.UtcNow.Ticks;
			lock (_backupGate)
			{
				if (Volatile.Read(ref _backupInProgress) == 1)
				{
					return BackupStartResult.AlreadyRunning;
				}
				if (IsWithinCooldown(ticks))
				{
					return BackupStartResult.CooldownActive;
				}
				_backupInProgress = 1;
				_lastBackupStartTicks = ticks;
			}
			Task.Run(delegate
			{
				try
				{
					BackupManager.PerformFullBackup(targetWorld, targetCharacter);
				}
				catch (Exception ex)
				{
					ManualLogSource log = NativeBackupPlugin.Log;
					if (log != null)
					{
						log.LogError((object)ex);
					}
					NativeBackupPlugin.QueueUIMessage("Backup failed unexpectedly.");
				}
				finally
				{
					lock (_backupGate)
					{
						Volatile.Write(ref _backupInProgress, 0);
					}
				}
			});
			return BackupStartResult.Started;
		}

		private static bool IsWithinCooldown(long nowTicks)
		{
			long num = Volatile.Read(ref _lastBackupStartTicks);
			if (num == 0L)
			{
				return false;
			}
			return nowTicks - num < TimeSpan.FromSeconds(5.0).Ticks;
		}
	}
	public static class BackupManager
	{
		public enum BackupSaveType
		{
			Unknown,
			Character,
			World
		}

		public struct BackupArchiveInfo
		{
			public string TargetName;

			public string SourceCategory;

			public string ArchivePath;

			public BackupSaveType SaveType;

			public DateTime CreatedAt;
		}

		public struct BackupTargetInfo
		{
			public string TargetName;

			public string LatestBackupPath;

			public string SourceCategory;

			public BackupSaveType SaveType;

			public DateTime CreatedAt;
		}

		public struct BackupMetrics
		{
			public int Count;

			public long Bytes;
		}

		private sealed class SaveWriteProbe
		{
			public string Label;

			public string Path;

			public DateTime BaselineWriteUtc;
		}

		private const int SaveSyncTimeoutMs = 10000;

		private const int SavePollIntervalMs = 100;

		private const int SaveSettleDelayMs = 1000;

		private const int SaveWriteConfirmationTimeoutMs = 2500;

		public static string GetBackupRootDirectory()
		{
			string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low", "IronGate", "Valheim", "NativeBackup");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return text;
		}

		public static void PerformFullBackup(string targetWorld = null, string targetCharacter = null)
		{
			bool flag = !string.IsNullOrEmpty(targetWorld) || !string.IsNullOrEmpty(targetCharacter);
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				string text = "Backup unavailable in this scene.";
				NativeBackupPlugin.QueueUIMessage(text);
				NativeBackupPlugin.Log.LogWarning((object)text);
				return;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			NativeBackupPlugin.SetBackupIndicatorActive(active: true);
			try
			{
				if (!TrySyncLiveStateBeforeBackup(targetWorld, targetCharacter))
				{
					string text2 = $"Backup canceled ({stopwatch.Elapsed.TotalSeconds:0.0}s): could not confirm current save state.";
					NativeBackupPlugin.QueueUIMessage(text2);
					NativeBackupPlugin.Log.LogWarning((object)text2);
					return;
				}
				List<string> list = new List<string>();
				if (!string.IsNullOrEmpty(targetWorld) && TryCreateNativeBackup(targetWorld, (SaveDataType)0))
				{
					list.Add(DescribeNativeTarget(BackupSaveType.World, targetWorld));
				}
				if (!string.IsNullOrEmpty(targetCharacter) && TryCreateNativeBackup(targetCharacter, (SaveDataType)1))
				{
					list.Add(DescribeNativeTarget(BackupSaveType.Character, targetCharacter));
				}
				if (!flag && list.Count == 0)
				{
					if (ZNet.instance.IsServer())
					{
						string worldName = ZNet.instance.GetWorldName();
						if (!string.IsNullOrEmpty(worldName) && TryCreateNativeBackup(worldName, (SaveDataType)0))
						{
							list.Add(DescribeNativeTarget(BackupSaveType.World, worldName));
						}
					}
					string currentCharacterSaveName = GetCurrentCharacterSaveName();
					if (!string.IsNullOrEmpty(currentCharacterSaveName) && TryCreateNativeBackup(currentCharacterSaveName, (SaveDataType)1))
					{
						list.Add(DescribeNativeTarget(BackupSaveType.Character, currentCharacterSaveName));
					}
				}
				if (list.Count > 0)
				{
					string arg = string.Join(" and ", list.Distinct().ToArray());
					string text3 = $"Backup complete ({stopwatch.Elapsed.TotalSeconds:0.0}s): {arg}.";
					NativeBackupPlugin.QueueUIMessage(text3);
					NativeBackupPlugin.Log.LogInfo((object)text3);
				}
				else
				{
					string arg2 = (flag ? "requested target unavailable" : "no eligible save target found");
					string text4 = $"Backup failed ({stopwatch.Elapsed.TotalSeconds:0.0}s): {arg2}.";
					NativeBackupPlugin.QueueUIMessage(text4);
					NativeBackupPlugin.Log.LogWarning((object)text4);
				}
			}
			finally
			{
				NativeBackupPlugin.SetBackupIndicatorActive(active: false);
			}
		}

		private static bool TrySyncLiveStateBeforeBackup(string targetWorld, string targetCharacter)
		{
			try
			{
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					NativeBackupPlugin.Log.LogWarning((object)"Could not sync save because ZNet is unavailable.");
					return false;
				}
				List<SaveWriteProbe> probes = CollectSaveWriteProbes(targetWorld, targetCharacter);
				float baselineStartTime = 0f;
				float baselineDoneTime = 0f;
				if (!NativeBackupPlugin.TryInvokeOnMainThread(delegate
				{
					baselineStartTime = ZNet.instance.SaveStartTime;
					baselineDoneTime = ZNet.instance.SaveDoneTime;
				}))
				{
					NativeBackupPlugin.Log.LogWarning((object)"Could not read baseline save timestamp before triggering save.");
					return false;
				}
				string saveTriggerRoute = null;
				bool nativeSaveTriggered = false;
				if (!NativeBackupPlugin.TryInvokeOnMainThread(delegate
				{
					nativeSaveTriggered = TryTriggerNativeSaveLikeMenuButton(out saveTriggerRoute);
				}) || !nativeSaveTriggered)
				{
					NativeBackupPlugin.Log.LogWarning((object)"Failed to trigger native Save-button flow before backup.");
					return false;
				}
				NativeBackupPlugin.Log.LogDebug((object)("Triggered native save via " + saveTriggerRoute + "."));
				DateTime dateTime = DateTime.UtcNow.AddMilliseconds(10000.0);
				bool flag = false;
				while (DateTime.UtcNow < dateTime)
				{
					float currentStartTime = baselineStartTime;
					float currentDoneTime = baselineDoneTime;
					if (!NativeBackupPlugin.TryInvokeOnMainThread(delegate
					{
						currentStartTime = ZNet.instance.SaveStartTime;
						currentDoneTime = ZNet.instance.SaveDoneTime;
					}))
					{
						NativeBackupPlugin.Log.LogWarning((object)"Could not read save completion timestamp from ZNet.");
						return false;
					}
					if (!flag && currentStartTime > baselineStartTime)
					{
						flag = true;
					}
					if (flag && currentDoneTime > baselineDoneTime && currentDoneTime >= currentStartTime)
					{
						Thread.Sleep(1000);
						if (!WaitForProbeWrites(probes))
						{
							NativeBackupPlugin.Log.LogWarning((object)"Save synchronization completed but file writes were not confirmed in time.");
							return false;
						}
						return true;
					}
					Thread.Sleep(100);
				}
				NativeBackupPlugin.Log.LogWarning((object)$"Timed out waiting for ZNet save completion after {10000} ms.");
				return false;
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogWarning((object)("Failed while syncing live save state before backup: " + ex.Message));
				return false;
			}
		}

		private static List<SaveWriteProbe> CollectSaveWriteProbes(string targetWorld, string targetCharacter)
		{
			List<SaveWriteProbe> list = new List<SaveWriteProbe>();
			if (!string.IsNullOrEmpty(targetWorld))
			{
				TryAddSaveWriteProbe(targetWorld, (SaveDataType)0, "world", list);
			}
			if (!string.IsNullOrEmpty(targetCharacter))
			{
				TryAddSaveWriteProbe(targetCharacter, (SaveDataType)1, "character", list);
			}
			return list;
		}

		private static bool TryTriggerNativeSaveLikeMenuButton(out string triggerRoute)
		{
			triggerRoute = "unknown route";
			Menu val = Object.FindAnyObjectByType<Menu>();
			if ((Object)(object)val == (Object)null)
			{
				triggerRoute = "menu unavailable";
				return false;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(Menu), "OnManualSave", Type.EmptyTypes, (Type[])null);
			if (methodInfo != null)
			{
				try
				{
					methodInfo.Invoke(val, null);
					triggerRoute = "Menu.OnManualSave()";
					return true;
				}
				catch (Exception ex)
				{
					NativeBackupPlugin.Log.LogWarning((object)("Native save method 'OnManualSave' failed: " + ex.Message));
				}
			}
			Button val2 = FindNativeSaveButton(val);
			if ((Object)(object)val2 != (Object)null)
			{
				((UnityEvent)val2.onClick).Invoke();
				triggerRoute = "Menu Save button onClick";
				return true;
			}
			triggerRoute = "no native save method or button found";
			return false;
		}

		private static Button FindNativeSaveButton(Menu menu)
		{
			if ((Object)(object)menu == (Object)null || (Object)(object)menu.m_menuDialog == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)menu.m_menuDialog).transform;
			Button[] componentsInChildren = ((Component)(transform.Find("MenuEntries") ?? transform.Find("menu") ?? transform.Find("MENU") ?? transform.Find("MenuContainer") ?? transform)).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (string.Equals(((Object)val).name, "Save", StringComparison.OrdinalIgnoreCase) || string.Equals(((Object)val).name, "ButtonSave", StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
					TMP_Text componentInChildren = ((Component)val).GetComponentInChildren<TMP_Text>(true);
					if (string.Equals(((Object)(object)componentInChildren != (Object)null && componentInChildren.text != null) ? componentInChildren.text.Trim() : string.Empty, "Save", StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			return null;
		}

		private static void TryAddSaveWriteProbe(string saveName, SaveDataType saveDataType, string labelPrefix, List<SaveWriteProbe> probes)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SaveWithBackups val = default(SaveWithBackups);
				if (SaveSystem.TryGetSaveByName(saveName, saveDataType, ref val) && val != null && val.PrimaryFile != null)
				{
					string pathPrimary = val.PrimaryFile.PathPrimary;
					if (!string.IsNullOrEmpty(pathPrimary) && File.Exists(pathPrimary))
					{
						probes.Add(new SaveWriteProbe
						{
							Label = labelPrefix + " '" + saveName + "'",
							Path = pathPrimary,
							BaselineWriteUtc = File.GetLastWriteTimeUtc(pathPrimary)
						});
					}
				}
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogDebug((object)("Failed to collect save write probe for " + labelPrefix + " '" + saveName + "': " + ex.Message));
			}
		}

		private static bool WaitForProbeWrites(List<SaveWriteProbe> probes)
		{
			if (probes == null || probes.Count == 0)
			{
				return true;
			}
			DateTime dateTime = DateTime.UtcNow.AddMilliseconds(2500.0);
			while (DateTime.UtcNow < dateTime)
			{
				bool flag = true;
				foreach (SaveWriteProbe probe in probes)
				{
					if (!File.Exists(probe.Path))
					{
						flag = false;
						break;
					}
					if (File.GetLastWriteTimeUtc(probe.Path) <= probe.BaselineWriteUtc)
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return true;
				}
				Thread.Sleep(100);
			}
			return false;
		}

		private static bool TryCreateNativeBackup(string saveName, SaveDataType saveDataType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SaveWithBackups val = default(SaveWithBackups);
				if (!SaveSystem.TryGetSaveByName(saveName, saveDataType, ref val) || val == null)
				{
					NativeBackupPlugin.Log.LogWarning((object)$"Native backup skipped because save '{saveName}' was not found for type {saveDataType}.");
					return false;
				}
				SaveFile primaryFile = val.PrimaryFile;
				if (primaryFile == null)
				{
					NativeBackupPlugin.Log.LogWarning((object)("Native backup skipped because no primary file exists for '" + saveName + "'."));
					return false;
				}
				bool num = InvokeMoveToBackup(primaryFile, DateTime.Now);
				if (num)
				{
					NativeBackupPlugin.Log.LogDebug((object)("Native backup created for " + DescribeNativeTarget(((int)saveDataType != 0) ? BackupSaveType.Character : BackupSaveType.World, saveName)));
					PruneNativeBackupsForTarget(primaryFile);
				}
				else
				{
					NativeBackupPlugin.Log.LogWarning((object)("Native backup call did not create a backup entry for " + DescribeNativeTarget(((int)saveDataType != 0) ? BackupSaveType.Character : BackupSaveType.World, saveName) + "."));
				}
				return num;
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogError((object)("Native backup failed for " + saveName + ": " + ex.Message));
				return false;
			}
		}

		private static string DescribeNativeTarget(BackupSaveType saveType, string saveName)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				if (saveType != BackupSaveType.World)
				{
					return "character";
				}
				return "world";
			}
			if (saveType != BackupSaveType.World)
			{
				return "character '" + saveName + "'";
			}
			return "world '" + saveName + "'";
		}

		private static void PruneNativeBackupsForTarget(SaveFile primaryFile)
		{
			try
			{
				int num = ((NativeBackupPlugin.MaxBackupsPerSave != null) ? NativeBackupPlugin.MaxBackupsPerSave.Value : 0);
				if (num <= 0 || primaryFile == null)
				{
					return;
				}
				string pathPrimary = primaryFile.PathPrimary;
				if (string.IsNullOrEmpty(pathPrimary))
				{
					return;
				}
				string directoryName = Path.GetDirectoryName(pathPrimary);
				if (string.IsNullOrEmpty(directoryName))
				{
					return;
				}
				string path2 = Path.Combine(directoryName, "backups");
				if (!Directory.Exists(path2))
				{
					return;
				}
				string fileName = primaryFile.FileName;
				if (string.IsNullOrEmpty(fileName))
				{
					fileName = Path.GetFileName(pathPrimary);
				}
				if (string.IsNullOrEmpty(fileName))
				{
					return;
				}
				List<FileInfo> list = (from path in Directory.GetFiles(path2, fileName + "*")
					select new FileInfo(path) into file
					orderby file.CreationTimeUtc descending
					select file).ToList();
				if (list.Count <= num)
				{
					return;
				}
				for (int i = num; i < list.Count; i++)
				{
					try
					{
						list[i].Delete();
						NativeBackupPlugin.Log.LogDebug((object)("Pruned native backup: " + list[i].Name));
					}
					catch (Exception ex)
					{
						NativeBackupPlugin.Log.LogWarning((object)("Failed to prune native backup " + list[i].Name + ": " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				NativeBackupPlugin.Log.LogWarning((object)("Native backup pruning failed: " + ex2.Message));
			}
		}

		private static bool InvokeMoveToBackup(SaveFile saveFile, DateTime now)
		{
			try
			{
				MethodInfo method = typeof(SaveSystem).GetMethod("MoveToBackup", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					NativeBackupPlugin.Log.LogWarning((object)"Could not find native SaveSystem.MoveToBackup method.");
					return false;
				}
				object obj = method.Invoke(null, new object[2] { saveFile, now });
				return obj is bool && (bool)obj;
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogError((object)("Reflection call to MoveToBackup failed: " + ex.Message));
				return false;
			}
		}

		public static string GetCurrentCharacterSaveName()
		{
			try
			{
				if ((Object)(object)Game.instance != (Object)null)
				{
					PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
					if (playerProfile != null)
					{
						string filename = playerProfile.GetFilename();
						if (!string.IsNullOrEmpty(filename))
						{
							return filename;
						}
					}
				}
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogWarning((object)("Failed to resolve canonical character save name: " + ex.Message));
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				return Player.m_localPlayer.GetPlayerName();
			}
			return null;
		}

		public static List<string> GetValheimSaveDirectories()
		{
			List<string> list = new List<string>();
			string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low", "IronGate", "Valheim");
			string[] array = new string[4] { "characters", "characters_local", "worlds", "worlds_local" };
			foreach (string path2 in array)
			{
				string text = Path.Combine(path, path2);
				if (Directory.Exists(text))
				{
					list.Add(text);
				}
			}
			try
			{
				string text2 = Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Valve\\Steam", "InstallPath", null) as string;
				if (string.IsNullOrEmpty(text2))
				{
					text2 = Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Valve\\Steam", "InstallPath", null) as string;
				}
				if (!string.IsNullOrEmpty(text2))
				{
					string path3 = Path.Combine(text2, "userdata");
					if (Directory.Exists(path3))
					{
						array = Directory.GetDirectories(path3);
						foreach (string path4 in array)
						{
							string text3 = Path.Combine(path4, "892970", "remote", "characters");
							string text4 = Path.Combine(path4, "892970", "remote", "worlds");
							if (Directory.Exists(text3))
							{
								list.Add(text3);
							}
							if (Directory.Exists(text4))
							{
								list.Add(text4);
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				NativeBackupPlugin.Log.LogWarning((object)("Failed to read Steam path from registry: " + ex.Message));
			}
			return list;
		}

		public static List<string> GetAllAvailableBackups()
		{
			List<string> list = new List<string>();
			string backupRootDirectory = GetBackupRootDirectory();
			if (!Directory.Exists(backupRootDirectory))
			{
				return list;
			}
			string[] directories = Directory.GetDirectories(backupRootDirectory);
			foreach (string path in directories)
			{
				list.AddRange(Directory.GetFiles(path, "*.zip"));
			}
			return list;
		}

		public static List<BackupTargetInfo> GetLatestBackupTargets()
		{
			Dictionary<string, BackupTargetInfo> dictionary = new Dictionary<string, BackupTargetInfo>(StringComparer.OrdinalIgnoreCase);
			foreach (BackupArchiveInfo allBackupArchive in GetAllBackupArchives())
			{
				string targetName = allBackupArchive.TargetName;
				if (!string.IsNullOrEmpty(targetName))
				{
					string key = BuildTargetKey(allBackupArchive.SaveType, targetName);
					if (!dictionary.TryGetValue(key, out var value) || allBackupArchive.CreatedAt > value.CreatedAt)
					{
						dictionary[key] = new BackupTargetInfo
						{
							TargetName = targetName,
							LatestBackupPath = allBackupArchive.ArchivePath,
							SourceCategory = allBackupArchive.SourceCategory,
							SaveType = allBackupArchive.SaveType,
							CreatedAt = allBackupArchive.CreatedAt
						};
					}
				}
			}
			return dictionary.Values.OrderByDescending((BackupTargetInfo entry) => entry.CreatedAt).ToList();
		}

		public static List<BackupArchiveInfo> GetAllBackupArchives()
		{
			List<BackupArchiveInfo> list = new List<BackupArchiveInfo>();
			string backupRootDirectory = GetBackupRootDirectory();
			if (!Directory.Exists(backupRootDirectory))
			{
				return list;
			}
			string[] directories = Directory.GetDirectories(backupRootDirectory);
			foreach (string path in directories)
			{
				string name = new DirectoryInfo(path).Name;
				string[] files = Directory.GetFiles(path, "*.zip");
				for (int j = 0; j < files.Length; j++)
				{
					if (TryCreateBackupArchiveInfo(files[j], name, out var archiveInfo))
					{
						list.Add(archiveInfo);
					}
				}
			}
			return list.OrderByDescending((BackupArchiveInfo archive) => archive.CreatedAt).ToList();
		}

		public static bool TryCreateBackupArchiveInfo(string archivePath, string sourceCategory, out BackupArchiveInfo archiveInfo)
		{
			archiveInfo = default(BackupArchiveInfo);
			if (string.IsNullOrEmpty(archivePath) || !File.Exists(archivePath))
			{
				return false;
			}
			string targetNameFromBackupFile = GetTargetNameFromBackupFile(archivePath);
			if (string.IsNullOrEmpty(targetNameFromBackupFile))
			{
				return false;
			}
			archiveInfo = new BackupArchiveInfo
			{
				TargetName = targetNameFromBackupFile,
				SourceCategory = sourceCategory,
				ArchivePath = archivePath,
				SaveType = GetSaveTypeFromCategory(sourceCategory),
				CreatedAt = File.GetCreationTime(archivePath)
			};
			return true;
		}

		public static string GetTargetNameFromBackupFile(string backupPath)
		{
			if (string.IsNullOrEmpty(backupPath))
			{
				return null;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(backupPath);
			if (string.IsNullOrEmpty(fileNameWithoutExtension))
			{
				return null;
			}
			Match match = Regex.Match(fileNameWithoutExtension, "^\\d{8}_\\d{6}-(.+)$");
			if (match.Success)
			{
				return match.Groups[1].Value.Trim();
			}
			int num = fileNameWithoutExtension.IndexOf('-');
			if (num >= 0 && num < fileNameWithoutExtension.Length - 1)
			{
				return fileNameWithoutExtension.Substring(num + 1).Trim();
			}
			return fileNameWithoutExtension.Trim();
		}

		public static BackupSaveType GetSaveTypeFromCategory(string sourceCategory)
		{
			if (string.IsNullOrEmpty(sourceCategory))
			{
				return BackupSaveType.Unknown;
			}
			string text = sourceCategory.ToLowerInvariant();
			if (text.Contains("character"))
			{
				return BackupSaveType.Character;
			}
			if (text.Contains("world"))
			{
				return BackupSaveType.World;
			}
			return BackupSaveType.Unknown;
		}

		private static string BuildTargetKey(BackupSaveType saveType, string targetName)
		{
			return $"{saveType}:{targetName}";
		}
	}
	[BepInPlugin("com.aloncifer.nativebackup", "NativeBackup", "0.1.1")]
	public class NativeBackupPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.aloncifer.nativebackup";

		public const string PluginName = "NativeBackup";

		public const string PluginVersion = "0.1.1";

		private Harmony _harmony;

		public static NativeBackupPlugin Instance;

		private static readonly ConcurrentQueue<string> _uiMessageQueue = new ConcurrentQueue<string>();

		private static readonly ConcurrentQueue<Action> _mainThreadActions = new ConcurrentQueue<Action>();

		private static int _backupIndicatorActive;

		private static Texture2D _backupIndicatorTexture;

		private static bool _iconLoadInProgress;

		private static bool _iconLoadCompleted;

		private static int _nativeFallbackActive;

		private static readonly string[] _indicatorMethodNames = new string[4] { "ShowSavingIcon", "SetSavingIcon", "SetSavingIndicator", "SetSaving" };

		private static readonly string[] _indicatorEnableMethodNames = new string[3] { "ShowSavingIcon", "ShowSaving", "StartSavingIcon" };

		private static readonly string[] _indicatorDisableMethodNames = new string[3] { "HideSavingIcon", "HideSaving", "StopSavingIcon" };

		private static readonly string[] _indicatorFieldNames = new string[3] { "m_showSavingIcon", "m_showSaving", "m_saving" };

		public static ManualLogSource Log;

		public static ConfigEntry<int> BackupIntervalMinutes;

		public static ConfigEntry<int> MaxBackupsPerSave;

		private float _timeSinceLastBackup;

		private float _commandCheckTimer;

		public static void QueueUIMessage(string msg)
		{
			_uiMessageQueue.Enqueue(msg);
		}

		public static void SetBackupIndicatorActive(bool active)
		{
			Interlocked.Exchange(ref _backupIndicatorActive, active ? 1 : 0);
			_mainThreadActions.Enqueue(delegate
			{
				try
				{
					if (active)
					{
						if (!TryEnsureBackupIndicatorIconLoaded() && _iconLoadCompleted && Volatile.Read(ref _nativeFallbackActive) == 0 && TrySetNativeSavingIndicator(active: true))
						{
							Interlocked.Exchange(ref _nativeFallbackActive, 1);
						}
					}
					else if (Volatile.Read(ref _nativeFallbackActive) == 1 && !IsNativeSaveStillRunning())
					{
						TrySetNativeSavingIndicator(active: false);
						Interlocked.Exchange(ref _nativeFallbackActive, 0);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogDebug((object)("Failed to toggle native saving indicator: " + ex.Message));
					}
				}
			});
		}

		public static bool TryInvokeOnMainThread(Action action, int timeoutMs = 3000)
		{
			if (action == null || (Object)(object)Instance == (Object)null)
			{
				return false;
			}
			Exception actionException = null;
			ManualResetEventSlim completed = new ManualResetEventSlim(initialState: false);
			try
			{
				_mainThreadActions.Enqueue(delegate
				{
					try
					{
						action();
					}
					catch (Exception ex)
					{
						actionException = ex;
					}
					finally
					{
						completed.Set();
					}
				});
				if (!completed.Wait(timeoutMs))
				{
					return false;
				}
			}
			finally
			{
				if (completed != null)
				{
					((IDisposable)completed).Dispose();
				}
			}
			if (actionException != null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Main-thread action failed: " + actionException.Message));
				}
				return false;
			}
			return true;
		}

		private void Awake()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			BackupIntervalMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("General", "BackupIntervalMinutes", 0, "Time in minutes between automatic backups. Set to 0 to disable automatic backups.");
			MaxBackupsPerSave = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxBackupsPerSave", 5, "Maximum number of native backups to keep per save.");
			_harmony = new Harmony("com.aloncifer.nativebackup");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			StartIconLoadIfNeeded();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"NativeBackup v0.1.1 loaded!");
		}

		private void Update()
		{
			_commandCheckTimer += Time.deltaTime;
			if (_commandCheckTimer > 2f)
			{
				_commandCheckTimer = 0f;
				if (RestoreCommandLogic.IsBackupCommandMissing())
				{
					RestoreCommandLogic.RegisterCommands();
				}
			}
			string result;
			while (_uiMessageQueue.TryDequeue(out result))
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)1, result, 0, (Sprite)null, false);
				}
			}
			List<Action> list = new List<Action>();
			Action result2;
			while (_mainThreadActions.TryDequeue(out result2))
			{
				list.Add(result2);
			}
			foreach (Action item in list)
			{
				item?.Invoke();
			}
			if (BackupIntervalMinutes.Value <= 0 || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			_timeSinceLastBackup += Time.deltaTime;
			float num = (float)BackupIntervalMinutes.Value * 60f;
			if (_timeSinceLastBackup >= num)
			{
				_timeSinceLastBackup = 0f;
				string text = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? ZNet.instance.GetWorldName() : null);
				string currentCharacterSaveName = BackupManager.GetCurrentCharacterSaveName();
				switch (BackupCoordinator.TryStartBackup(text, currentCharacterSaveName))
				{
				case BackupCoordinator.BackupStartResult.Started:
					((BaseUnityPlugin)this).Logger.LogDebug((object)("Scheduled backup started for world='" + text + "', character='" + currentCharacterSaveName + "'."));
					break;
				case BackupCoordinator.BackupStartResult.CooldownActive:
					((BaseUnityPlugin)this).Logger.LogDebug((object)"Skipped scheduled backup due to cooldown.");
					break;
				default:
					((BaseUnityPlugin)this).Logger.LogDebug((object)"Skipped scheduled backup because another backup is running.");
					break;
				}
			}
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			if ((Object)(object)_backupIndicatorTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_backupIndicatorTexture);
				_backupIndicatorTexture = null;
			}
		}

		private void OnGUI()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (Volatile.Read(ref _backupIndicatorActive) != 1)
			{
				return;
			}
			if (!TryEnsureBackupIndicatorIconLoaded())
			{
				if (_iconLoadCompleted && Volatile.Read(ref _nativeFallbackActive) == 0 && TrySetNativeSavingIndicator(active: true))
				{
					Interlocked.Exchange(ref _nativeFallbackActive, 1);
				}
			}
			else
			{
				float num = 0.35f + 0.65f * Mathf.Abs(Mathf.Sin(Time.unscaledTime * 5f));
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, num);
				GUI.DrawTexture(new Rect(18f, 18f, 40f, 40f), (Texture)(object)_backupIndicatorTexture, (ScaleMode)2, true);
				GUI.color = color;
			}
		}

		private static bool TryEnsureBackupIndicatorIconLoaded()
		{
			if ((Object)(object)_backupIndicatorTexture != (Object)null)
			{
				return true;
			}
			StartIconLoadIfNeeded();
			return false;
		}

		private static void StartIconLoadIfNeeded()
		{
			if (!((Object)(object)Instance == (Object)null) && !((Object)(object)_backupIndicatorTexture != (Object)null) && !_iconLoadCompleted && !_iconLoadInProgress)
			{
				((MonoBehaviour)Instance).StartCoroutine(Instance.LoadBackupIndicatorIconCoroutine());
			}
		}

		private IEnumerator LoadBackupIndicatorIconCoroutine()
		{
			_iconLoadInProgress = true;
			foreach (string path in GetIconCandidatePaths())
			{
				if (string.IsNullOrEmpty(path) || !File.Exists(path))
				{
					continue;
				}
				string text = Path.GetFullPath(path).Replace("\\", "/");
				UnityWebRequest request = UnityWebRequestTexture.GetTexture("file:///" + text, false);
				try
				{
					yield return request.SendWebRequest();
					if ((int)request.result != 1)
					{
						continue;
					}
					Texture2D content = DownloadHandlerTexture.GetContent(request);
					if ((Object)(object)content != (Object)null)
					{
						((Texture)content).wrapMode = (TextureWrapMode)1;
						((Texture)content).filterMode = (FilterMode)1;
						_backupIndicatorTexture = content;
						_iconLoadInProgress = false;
						_iconLoadCompleted = true;
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogDebug((object)("Loaded backup indicator icon from '" + path + "'."));
						}
						yield break;
					}
				}
				finally
				{
					((IDisposable)request)?.Dispose();
				}
			}
			_iconLoadInProgress = false;
			_iconLoadCompleted = true;
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogDebug((object)"Backup indicator icon load failed; native indicator fallback will be used.");
			}
		}

		private static IEnumerable<string> GetIconCandidatePaths()
		{
			string assemblyDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (!string.IsNullOrEmpty(assemblyDir))
			{
				yield return Path.Combine(assemblyDir, "icon.png");
				yield return Path.Combine(assemblyDir, "NativeBackup", "icon.png");
			}
			yield return Path.Combine(Paths.PluginPath, "icon.png");
			yield return Path.Combine(Paths.PluginPath, "NativeBackup", "icon.png");
			yield return Path.Combine(Paths.BepInExRootPath, "icon.png");
			yield return Path.Combine(Environment.CurrentDirectory, "icon.png");
		}

		private static bool IsNativeSaveStillRunning()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			return ZNet.instance.SaveStartTime > ZNet.instance.SaveDoneTime;
		}

		private static bool TrySetNativeSavingIndicator(bool active)
		{
			object[] array = new object[2]
			{
				MessageHud.instance,
				Hud.instance
			};
			foreach (object obj in array)
			{
				if (obj == null)
				{
					continue;
				}
				Type type = obj.GetType();
				string[] indicatorMethodNames = _indicatorMethodNames;
				foreach (string text in indicatorMethodNames)
				{
					MethodInfo methodInfo = AccessTools.Method(type, text, new Type[1] { typeof(bool) }, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(obj, new object[1] { active });
						return true;
					}
				}
				indicatorMethodNames = (active ? _indicatorEnableMethodNames : _indicatorDisableMethodNames);
				foreach (string text2 in indicatorMethodNames)
				{
					MethodInfo methodInfo2 = AccessTools.Method(type, text2, Type.EmptyTypes, (Type[])null);
					if (methodInfo2 != null)
					{
						methodInfo2.Invoke(obj, null);
						return true;
					}
				}
				indicatorMethodNames = _indicatorFieldNames;
				foreach (string text3 in indicatorMethodNames)
				{
					FieldInfo fieldInfo = AccessTools.Field(type, text3);
					if (fieldInfo != null && fieldInfo.FieldType == typeof(bool))
					{
						fieldInfo.SetValue(obj, active);
						return true;
					}
				}
			}
			return false;
		}
	}
	public static class RestoreCommandLogic
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__3_0;

			public static ConsoleEvent <>9__3_1;

			public static ConsoleEvent <>9__3_2;

			public static Func<string, DateTime> <>9__7_0;

			public static Func<string, DateTime> <>9__9_1;

			internal void <RegisterCommands>b__3_0(ConsoleEventArgs args)
			{
				HandleRestoreCommand(args.Context, args.Args);
			}

			internal void <RegisterCommands>b__3_1(ConsoleEventArgs args)
			{
				HandleBackupCommand(args.Context, args.Args);
			}

			internal void <RegisterCommands>b__3_2(ConsoleEventArgs args)
			{
				HandleListCommand(args.Context);
			}

			internal DateTime <HandleListCommand>b__7_0(string f)
			{
				return File.GetCreationTime(f);
			}

			internal DateTime <TryRestoreLatestBackup>b__9_1(string b)
			{
				return File.GetCreationTime(b);
			}
		}

		private static FieldInfo _terminalCommandsField;

		public static bool IsBackupCommandMissing()
		{
			return !CommandExists("sb.backup");
		}

		private static bool CommandExists(string cmd)
		{
			try
			{
				if (_terminalCommandsField == null)
				{
					_terminalCommandsField = typeof(Terminal).GetField("commands", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_terminalCommandsField != null)
				{
					return _terminalCommandsField.GetValue(null) is IDictionary dictionary && dictionary.Contains(cmd);
				}
			}
			catch
			{
			}
			return true;
		}

		public static void RegisterCommands()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			bool flag = false;
			if (!CommandExists("sb.restore"))
			{
				object obj = <>c.<>9__3_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						HandleRestoreCommand(args.Context, args.Args);
					};
					<>c.<>9__3_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("sb.restore", "Restores a backup.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				flag = true;
			}
			if (!CommandExists("sb.backup"))
			{
				object obj2 = <>c.<>9__3_1;
				if (obj2 == null)
				{
					ConsoleEvent val2 = delegate(ConsoleEventArgs args)
					{
						HandleBackupCommand(args.Context, args.Args);
					};
					<>c.<>9__3_1 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("sb.backup", "Triggers a backup.", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				flag = true;
			}
			if (!CommandExists("sb.list"))
			{
				object obj3 = <>c.<>9__3_2;
				if (obj3 == null)
				{
					ConsoleEvent val3 = delegate(ConsoleEventArgs args)
					{
						HandleListCommand(args.Context);
					};
					<>c.<>9__3_2 = val3;
					obj3 = (object)val3;
				}
				new ConsoleCommand("sb.list", "Lists backups.", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				flag = true;
			}
			if (flag)
			{
				NativeBackupPlugin.Log.LogInfo((object)"sb. Commands forcefully registered into Terminal dictionary.");
			}
		}

		private static void HandleBackupCommand(Terminal context, string[] args)
		{
			string text = ((args.Length >= 2) ? args[1].ToLower() : "both");
			string currentCharacterSaveName = BackupManager.GetCurrentCharacterSaveName();
			string text2 = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? ZNet.instance.GetWorldName() : null);
			if (text == "char")
			{
				if (string.IsNullOrEmpty(currentCharacterSaveName))
				{
					context.AddString("ERROR: No active character found.");
				}
				else
				{
					StartBackupFromConsole(context, null, currentCharacterSaveName, "Backup started: character '" + currentCharacterSaveName + "'.");
				}
			}
			else if (text == "world")
			{
				if (string.IsNullOrEmpty(text2))
				{
					context.AddString("ERROR: You can only backup a world if you are actively hosting it locally.");
				}
				else
				{
					StartBackupFromConsole(context, text2, null, "Backup started: world '" + text2 + "'.");
				}
			}
			else if (string.IsNullOrEmpty(currentCharacterSaveName) && string.IsNullOrEmpty(text2))
			{
				context.AddString("ERROR: No active world or character found.");
			}
			else
			{
				string text3 = DescribeTarget(text2, currentCharacterSaveName);
				StartBackupFromConsole(context, text2, currentCharacterSaveName, "Backup started: " + text3 + ".");
			}
		}

		private static void StartBackupFromConsole(Terminal context, string worldName, string characterName, string startMessage)
		{
			switch (BackupCoordinator.TryStartBackup(worldName, characterName))
			{
			case BackupCoordinator.BackupStartResult.Started:
				context.AddString(startMessage);
				break;
			case BackupCoordinator.BackupStartResult.CooldownActive:
				context.AddString("Backup on cooldown.");
				break;
			default:
				context.AddString("Backup already running.");
				break;
			}
		}

		private static string DescribeTarget(string worldName, string characterName)
		{
			if (!string.IsNullOrEmpty(worldName) && !string.IsNullOrEmpty(characterName))
			{
				return "world '" + worldName + "' and character '" + characterName + "'";
			}
			if (!string.IsNullOrEmpty(worldName))
			{
				return "world '" + worldName + "'";
			}
			if (!string.IsNullOrEmpty(characterName))
			{
				return "character '" + characterName + "'";
			}
			return "the current save targets";
		}

		private static void HandleListCommand(Terminal context)
		{
			List<string> allAvailableBackups = BackupManager.GetAllAvailableBackups();
			if (allAvailableBackups.Count == 0)
			{
				context.AddString("No backups found.");
				return;
			}
			int num = Math.Min(15, allAvailableBackups.Count);
			context.AddString($"Found {allAvailableBackups.Count} backups. Showing last {num}:");
			foreach (string item in allAvailableBackups.OrderByDescending((string f) => File.GetCreationTime(f)).Take(num).ToList())
			{
				context.AddString("- " + Path.GetFileName(item));
			}
		}

		private static void HandleRestoreCommand(Terminal context, string[] args)
		{
			if (args.Length < 2)
			{
				context.AddString("Usage: sb.restore <SaveName>");
			}
			else
			{
				TryRestoreLatestBackup(args[1], ((Object)(object)context != (Object)null) ? new Action<string>(context.AddString) : null);
			}
		}

		public static bool TryRestoreLatestBackup(string saveName, Action<string> reportMessage)
		{
			if ((Object)(object)ZNet.instance != (Object)null || (Object)(object)Player.m_localPlayer != (Object)null)
			{
				Emit(reportMessage, "ERROR: Restoring while actively loaded into a world is extremely dangerous and can corrupt your game! Please return to the Main Menu to restore.");
				return false;
			}
			List<string> list = (from b in BackupManager.GetAllAvailableBackups()
				where string.Equals(BackupManager.GetTargetNameFromBackupFile(b), saveName, StringComparison.OrdinalIgnoreCase)
				orderby File.GetCreationTime(b) descending
				select b).ToList();
			if (list.Count == 0)
			{
				Emit(reportMessage, "No backups found for target: " + saveName);
				return false;
			}
			string text = list.First();
			Emit(reportMessage, "Found latest backup: " + Path.GetFileName(text));
			try
			{
				string text2 = FindOriginalSaveDirectory(saveName);
				if (string.IsNullOrEmpty(text2))
				{
					Emit(reportMessage, "Could not locate original save file location in Steam/Local. You may need to manually extract this zip from: \n" + text);
					return false;
				}
				Emit(reportMessage, "Original location found: " + text2);
				foreach (string item in (from f in Directory.GetFiles(text2)
					where Path.GetFileNameWithoutExtension(f) == saveName && !f.EndsWith(".old") && !f.EndsWith(".zip")
					select f).ToList())
				{
					string text3 = item + ".old";
					if (File.Exists(text3))
					{
						File.Delete(text3);
					}
					File.Move(item, text3);
					Emit(reportMessage, "Renamed current active save to " + Path.GetFileName(text3));
				}
				using (ZipArchive zipArchive = ZipFile.OpenRead(text))
				{
					foreach (ZipArchiveEntry entry in zipArchive.Entries)
					{
						string destinationFileName = Path.Combine(text2, entry.FullName);
						entry.ExtractToFile(destinationFileName, overwrite: true);
						Emit(reportMessage, "Extracted: " + entry.FullName);
					}
				}
				Emit(reportMessage, "Restore complete! Please restart your game session or reload from Main Menu if necessary.");
				return true;
			}
			catch (Exception ex)
			{
				Emit(reportMessage, "Error during restore: " + ex.Message);
				NativeBackupPlugin.Log.LogError((object)ex);
				return false;
			}
		}

		public static bool TryRestoreLatestBackup(string saveName, Terminal context)
		{
			return TryRestoreLatestBackup(saveName, ((Object)(object)context != (Object)null) ? new Action<string>(context.AddString) : null);
		}

		public static List<BackupManager.BackupTargetInfo> GetAvailableRestoreTargets()
		{
			return BackupManager.GetLatestBackupTargets();
		}

		private static void Emit(Action<string> reportMessage, string message)
		{
			if (reportMessage != null)
			{
				reportMessage(message);
			}
			else
			{
				NativeBackupPlugin.Log.LogInfo((object)message);
			}
		}

		private static string FindOriginalSaveDirectory(string saveName)
		{
			foreach (string valheimSaveDirectory in BackupManager.GetValheimSaveDirectories())
			{
				if (Directory.Exists(valheimSaveDirectory) && Directory.GetFiles(valheimSaveDirectory).Any((string f) => Path.GetFileNameWithoutExtension(f) == saveName && !f.EndsWith(".old") && !f.EndsWith(".zip")))
				{
					return valheimSaveDirectory;
				}
			}
			return null;
		}
	}
	public sealed class BackupButtonStateController : MonoBehaviour
	{
		private Button _button;

		public void Initialize(Button button)
		{
			_button = button;
			RefreshState();
		}

		private void Update()
		{
			RefreshState();
		}

		private void RefreshState()
		{
			if (!((Object)(object)_button == (Object)null))
			{
				((Selectable)_button).interactable = !BackupCoordinator.IsBackupInProgress && !BackupCoordinator.IsCooldownActive;
			}
		}
	}
	[HarmonyPatch(typeof(Menu))]
	public static class MenuPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__0_0;

			internal void <Start_Postfix>b__0_0()
			{
				string text = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? ZNet.instance.GetWorldName() : null);
				string currentCharacterSaveName = BackupManager.GetCurrentCharacterSaveName();
				object msg;
				switch (BackupCoordinator.TryStartBackup(text, currentCharacterSaveName))
				{
				case BackupCoordinator.BackupStartResult.Started:
					NativeBackupPlugin.Log.LogDebug((object)("Manual UI backup triggered for world='" + text + "', character='" + currentCharacterSaveName + "'."));
					return;
				default:
					msg = "Backup already running.";
					break;
				case BackupCoordinator.BackupStartResult.CooldownActive:
					msg = "Backup on cooldown.";
					break;
				}
				NativeBackupPlugin.QueueUIMessage((string)msg);
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start_Postfix(Menu __instance)
		{
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_menuDialog == (Object)null)
			{
				return;
			}
			Transform val = ((Component)__instance.m_menuDialog).transform.Find("MenuEntries");
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)__instance.m_menuDialog).transform.Find("menu") ?? ((Component)__instance.m_menuDialog).transform.Find("MENU") ?? ((Component)__instance.m_menuDialog).transform.Find("MenuContainer");
			}
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			Transform val2 = FindButton(val, "Settings", "ButtonSettings");
			Transform val3 = FindButton(val, "Save", "ButtonSave");
			if (!((Object)(object)val2 != (Object)null))
			{
				return;
			}
			NativeBackupPlugin.Log.LogInfo((object)"Injecting Backup button under Save.");
			GameObject val4 = Object.Instantiate<GameObject>(((Component)val2).gameObject, val);
			((Object)val4).name = "BackupGame";
			if ((Object)(object)val3 != (Object)null)
			{
				val4.transform.SetSiblingIndex(val3.GetSiblingIndex() + 1);
			}
			else
			{
				val4.transform.SetSiblingIndex(val2.GetSiblingIndex() + 1);
			}
			TMP_Text componentInChildren = val4.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = "Backup";
			}
			Button component = val4.GetComponent<Button>();
			if (!((Object)(object)component != (Object)null))
			{
				return;
			}
			for (int i = 0; i < ((UnityEventBase)component.onClick).GetPersistentEventCount(); i++)
			{
				((UnityEventBase)component.onClick).SetPersistentListenerState(i, (UnityEventCallState)0);
			}
			((UnityEventBase)component.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = component.onClick;
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				UnityAction val5 = delegate
				{
					string text = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? ZNet.instance.GetWorldName() : null);
					string currentCharacterSaveName = BackupManager.GetCurrentCharacterSaveName();
					object msg;
					switch (BackupCoordinator.TryStartBackup(text, currentCharacterSaveName))
					{
					case BackupCoordinator.BackupStartResult.Started:
						NativeBackupPlugin.Log.LogDebug((object)("Manual UI backup triggered for world='" + text + "', character='" + currentCharacterSaveName + "'."));
						return;
					default:
						msg = "Backup already running.";
						break;
					case BackupCoordinator.BackupStartResult.CooldownActive:
						msg = "Backup on cooldown.";
						break;
					}
					NativeBackupPlugin.QueueUIMessage((string)msg);
				};
				<>c.<>9__0_0 = val5;
				obj = (object)val5;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Button component2 = ((Component)val2).GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Selectable)component).navigation = ((Selectable)component2).navigation;
			}
			val4.AddComponent<BackupButtonStateController>().Initialize(component);
		}

		private static Transform FindButton(Transform root, params string[] labels)
		{
			Button[] componentsInChildren = ((Component)root).GetComponentsInChildren<Button>(true);
			foreach (Button button in componentsInChildren)
			{
				if ((Object)(object)button == (Object)null)
				{
					continue;
				}
				if (labels.Any((string label) => string.Equals(((Object)button).name, label, StringComparison.OrdinalIgnoreCase)))
				{
					return ((Component)button).transform;
				}
				TMP_Text componentInChildren = ((Component)button).GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					string value = ((componentInChildren.text != null) ? componentInChildren.text.Trim() : string.Empty);
					if (labels.Any((string label) => string.Equals(value, label, StringComparison.OrdinalIgnoreCase)))
					{
						return ((Component)button).transform;
					}
				}
			}
			return root.Find(labels.FirstOrDefault());
		}
	}
}