using System;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using ResetFailedSave.Patches;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ResetFailedSave")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ResetFailedSave")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("82615b87-dec4-4e89-8dd2-dad35a8e319c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class ChangeLevelStateData
{
	public Level LevelCurrent { get; set; }

	public int LevelsCompleted { get; set; }

	public bool Gg { get; set; }

	public ChangeLevelStateData()
	{
	}

	public ChangeLevelStateData(Level levelCurrent, int levelsCompleted, bool gg)
	{
		LevelCurrent = levelCurrent;
		LevelsCompleted = levelsCompleted;
		Gg = gg;
	}
}
public static class Utils
{
	public static void CompressFolder(string sourceFolder, string compressedFile)
	{
		string text = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
		try
		{
			if (File.Exists(compressedFile))
			{
				File.Delete(compressedFile);
			}
			CopyFolder(sourceFolder, text);
			ZipFile.CreateFromDirectory(text, compressedFile);
		}
		catch (Exception ex)
		{
			Console.WriteLine("压缩文件夹时发生错误: " + ex.Message);
			throw;
		}
		finally
		{
			if (Directory.Exists(text))
			{
				Directory.Delete(text, recursive: true);
			}
		}
	}

	public static void CopyFolder(string sourceFolder, string destFolder)
	{
		if (!Directory.Exists(destFolder))
		{
			Directory.CreateDirectory(destFolder);
		}
		string[] files = Directory.GetFiles(sourceFolder);
		foreach (string text in files)
		{
			string destFileName = Path.Combine(destFolder, Path.GetFileName(text));
			File.Copy(text, destFileName);
		}
		string[] directories = Directory.GetDirectories(sourceFolder);
		foreach (string text2 in directories)
		{
			string destFolder2 = Path.Combine(destFolder, Path.GetFileName(text2));
			CopyFolder(text2, destFolder2);
		}
	}

	public static void DecompressFolder(string compressedFile, string targetFolder)
	{
		try
		{
			if (Directory.Exists(targetFolder))
			{
				Directory.Delete(targetFolder, recursive: true);
			}
			Directory.CreateDirectory(targetFolder);
			ZipFile.ExtractToDirectory(compressedFile, targetFolder);
		}
		catch (Exception ex)
		{
			Log.LogInfo("解压文件夹时发生错误: " + ex.Message);
		}
	}
}
public static class Log
{
	public static ManualLogSource _logSource;

	static Log()
	{
		_logSource = Logger.CreateLogSource("Reset Failed Save");
	}

	public static void LogInfo(object data)
	{
		_logSource.LogInfo(data);
	}

	public static void LogWarning(object data)
	{
		_logSource.LogWarning(data);
	}

	public static void LogError(object data)
	{
		_logSource.LogError(data);
	}

	public static void LogDebug(object data)
	{
		_logSource.LogDebug(data);
	}

	public static void LogFatal(object data)
	{
		_logSource.LogFatal(data);
	}

	public static void LogMessage(object data)
	{
		_logSource.LogMessage(data);
	}
}
namespace ResetFailedSave
{
	[BepInPlugin("arpen.REPO.ResetFailedSave", "Reset Failed Save", "1.0.0")]
	public class PluginBase : BaseUnityPlugin
	{
		public const string PluginGUID = "arpen.REPO.ResetFailedSave";

		public const string PluginName = "Reset Failed Save";

		public const string PluginVersion = "1.0.0";

		private readonly Harmony _harmony = new Harmony("arpen.REPO.ResetFailedSave");

		private static PluginBase Instance;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if ((Object)Instance == (Object)null)
			{
				Instance = this;
			}
			Log.LogInfo("<失败存档保留>加载成功! Successfully loaded plugin: arpen.REPO.ResetFailedSave!");
			_harmony.PatchAll(typeof(PluginBase));
			_harmony.PatchAll(typeof(StatsManager_SaveFileSave_Patch));
			_harmony.PatchAll(typeof(MenuPageSaves_OnDeleteGame_Patch));
			_harmony.PatchAll(typeof(DataDirector_SaveDeleteCheck_Patch));
			_harmony.PatchAll(typeof(RunManager_ChangeLevel_Patch));
		}

		private void Start()
		{
			Debug.Log((object)"Start 方法执行！");
		}
	}
}
namespace ResetFailedSave.Patches
{
	[HarmonyPatch(typeof(StatsManager), "SaveFileSave")]
	internal class StatsManager_SaveFileSave_Patch
	{
		private static void Prefix(ref string ___saveFileCurrent)
		{
			string text = Application.persistentDataPath + "/saves";
			Utils.CompressFolder(text + "/" + ___saveFileCurrent, text + "/" + ___saveFileCurrent + ".zip");
		}

		private static void Postfix()
		{
		}
	}
	[HarmonyPatch(typeof(MenuPageSaves), "OnDeleteGame")]
	internal class MenuPageSaves_OnDeleteGame_Patch
	{
		public static void Postfix(ref string ___currentSaveFileName)
		{
			string text = Application.persistentDataPath + "/saves/" + ___currentSaveFileName;
			if (Directory.Exists(text))
			{
				Directory.Delete(text, recursive: true);
			}
			if (File.Exists(text + ".zip"))
			{
				File.Delete(text + ".zip");
			}
		}
	}
	[HarmonyPatch(typeof(DataDirector), "SaveDeleteCheck")]
	internal class DataDirector_SaveDeleteCheck_Patch
	{
		private static readonly FieldRef<StatsManager, string> _getSaveFileCurrent;

		static DataDirector_SaveDeleteCheck_Patch()
		{
			FieldInfo field = typeof(StatsManager).GetField("saveFileCurrent", BindingFlags.Instance | BindingFlags.NonPublic);
			_getSaveFileCurrent = AccessTools.FieldRefAccess<StatsManager, string>(field);
		}

		private static void Prefix(bool _leaveGame, out string __state)
		{
			StatsManager val = Object.FindObjectOfType<StatsManager>();
			__state = _getSaveFileCurrent.Invoke(val);
		}

		private static void Postfix(string __state)
		{
			if (SemiFunc.RunIsArena())
			{
				string text = Application.persistentDataPath + "/saves";
				Utils.DecompressFolder(text + "/" + __state + ".zip", text + "/" + __state);
			}
		}
	}
	[HarmonyPatch(typeof(RunManager), "ChangeLevel")]
	internal class RunManager_ChangeLevel_Patch
	{
		private static readonly FieldRef<StatsManager, string> _getSaveFileCurrent;

		static RunManager_ChangeLevel_Patch()
		{
			FieldInfo field = typeof(StatsManager).GetField("saveFileCurrent", BindingFlags.Instance | BindingFlags.NonPublic);
			_getSaveFileCurrent = AccessTools.FieldRefAccess<StatsManager, string>(field);
		}

		private static bool Prefix(out ChangeLevelStateData __state, bool _completedLevel, bool _levelFailed, ChangeLevelType _changeLevelType, bool ___gameOver, Level ___levelPrevious)
		{
			if (SemiFunc.DebugDev())
			{
				__state = new ChangeLevelStateData();
				return true;
			}
			if (!_completedLevel && _levelFailed && !___gameOver)
			{
				Level levelCurrent = ((!SemiFunc.IsMultiplayer()) ? RunManager.instance.levelMainMenu : RunManager.instance.levelLobbyMenu);
				string name = ((Object)RunManager.instance.levelCurrent).name;
				string text = name;
				if (text == "Level - Arena")
				{
					__state = new ChangeLevelStateData(levelCurrent, RunManager.instance.levelsCompleted, gg: true);
					return false;
				}
				levelCurrent = ___levelPrevious;
				__state = new ChangeLevelStateData(levelCurrent, RunManager.instance.levelsCompleted, gg: false);
				return true;
			}
			__state = new ChangeLevelStateData();
			return true;
		}

		private static void Postfix(ChangeLevelStateData __state, bool _completedLevel, bool _levelFailed, ChangeLevelType _changeLevelType, ref Level ___previousRunLevel, ref bool ___gameOver)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (__state.Gg)
			{
				___previousRunLevel = __state.LevelCurrent;
				RunManager.instance.levelCurrent = __state.LevelCurrent;
				RunManager.instance.levelsCompleted = __state.LevelsCompleted;
				___gameOver = false;
				SemiFunc.SaveFileLoad(_getSaveFileCurrent.Invoke(StatsManager.instance));
				ChangeLevelType val = ((!SemiFunc.IsMultiplayer()) ? ((ChangeLevelType)1) : ((ChangeLevelType)3));
				RunManager.instance.ChangeLevel(true, false, val);
			}
		}
	}
}