using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
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.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OdinSaves")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OdinSaves")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("649fad21-6342-4434-8747-28db2fe311bc")]
[assembly: AssemblyFileVersion("1.5.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.0.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 OdinSaves
{
	public static class PluginConfig
	{
		public static ConfigFile CurrentConfig { get; private set; }

		public static ConfigEntry<bool> IsModEnabled { get; private set; }

		public static ConfigEntry<int> SavePlayerProfileInterval { get; private set; }

		public static ConfigEntry<bool> SetLogoutPointOnSave { get; private set; }

		public static ConfigEntry<bool> ShowMessageOnModSave { get; private set; }

		public static ConfigEntry<bool> EnableMapDataCompression { get; private set; }

		public static void BindConfig(ConfigFile config)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			CurrentConfig = config;
			IsModEnabled = config.Bind<bool>("Global", "isModEnabled", true, "Globally enable or disable this mod.");
			SavePlayerProfileInterval = config.Bind<int>("Global", "savePlayerProfileInterval", 300, new ConfigDescription("Interval (seconds) for how often to save the player profile. Game default (and maximum) is 1200s.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 1200), Array.Empty<object>()));
			SetLogoutPointOnSave = config.Bind<bool>("Global", "setLogoutPointOnSave", true, "Sets your logout point to your current position when the mod performs a save.");
			ShowMessageOnModSave = config.Bind<bool>("Global", "saveMessageOnModSave", true, "Show a message (in the middle of your screen) when the mod tries to save.");
			EnableMapDataCompression = config.Bind<bool>("MapData.Compression", "enableMapDataCompression", false, "Enables the MapData compression feature on the character select screen (restart required).");
		}
	}
	public static class SaveManager
	{
		[CompilerGenerated]
		private sealed class <CompressProfileMapDataCoroutine>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerProfile profile;

			public FejdStartup fejdStartup;

			private Selectable[] <selectables>5__2;

			private long <count>5__3;

			private TMP_Text <buttonText>5__4;

			private Dictionary<long, WorldPlayerData>.ValueCollection.Enumerator <>7__wrap4;

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

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

			[DebuggerHidden]
			public <CompressProfileMapDataCoroutine>d__14(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();
					}
				}
				<selectables>5__2 = null;
				<buttonText>5__4 = null;
				<>7__wrap4 = default(Dictionary<long, WorldPlayerData>.ValueCollection.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					Selectable[] array;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<selectables>5__2 = Object.FindObjectsOfType<Selectable>();
						array = <selectables>5__2;
						for (int i = 0; i < array.Length; i++)
						{
							array[i].interactable = false;
						}
						<count>5__3 = 0L;
						<buttonText>5__4 = ((Component)_compressMapDataButton).GetComponentInChildren<TMP_Text>();
						<>7__wrap4 = profile.m_worldData.Values.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap4.MoveNext())
					{
						WorldPlayerData current = <>7__wrap4.Current;
						<buttonText>5__4.text = $"Compressing... {++<count>5__3}/{profile.m_worldData.Count}";
						current.m_mapData = CompressMapData(ref current.m_mapData);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap4 = default(Dictionary<long, WorldPlayerData>.ValueCollection.Enumerator);
					array = <selectables>5__2;
					for (int i = 0; i < array.Length; i++)
					{
						array[i].interactable = true;
					}
					profile.SavePlayerToDisk();
					fejdStartup.UpdateCharacterList();
					_mapPackage.Clear();
					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;
				((IDisposable)<>7__wrap4).Dispose();
			}

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

		private static readonly ZPackage _mapPackage = new ZPackage();

		private static GameObject _profileCompressionRoot;

		private static Button _compressMapDataButton;

		private static TMP_Text _profileCompressionText;

		private static byte[] CompressMapData(ref byte[] mapData)
		{
			if (mapData == null || IsCompressedMapData(mapData))
			{
				return mapData;
			}
			_mapPackage.Clear();
			_mapPackage.Write(Minimap.MAPVERSION);
			_mapPackage.Write(Utils.Compress(mapData));
			return _mapPackage.GetArray();
		}

		private static bool IsCompressedMapData(byte[] data)
		{
			if (data != null && data.Length >= 4)
			{
				return BitConverter.ToInt32(data, 0) >= 7;
			}
			return false;
		}

		private static bool HasUncompressedData(PlayerProfile profile)
		{
			return profile.m_worldData.Values.Any((WorldPlayerData value) => value.m_mapData != null && !IsCompressedMapData(value.m_mapData));
		}

		public static void CreateProfileCompressionUI(FejdStartup fejdStartup)
		{
			_profileCompressionRoot = CreateCompressionRoot(fejdStartup.m_selectCharacterPanel.transform);
			_compressMapDataButton = CreateCompressMapDataButton(fejdStartup, _profileCompressionRoot.transform);
			_profileCompressionText = CreateProfileCompressionText(fejdStartup, _profileCompressionRoot.transform);
		}

		private static GameObject CreateCompressionRoot(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			GameObject val = new GameObject("CompressionRoot", new Type[2]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(parent);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0f);
			component.anchorMax = new Vector2(0.5f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(410f, 74f);
			VerticalLayoutGroup component2 = val.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((LayoutGroup)component2).childAlignment = (TextAnchor)1;
			val.SetActive(true);
			return val;
		}

		private static Button CreateCompressMapDataButton(FejdStartup fejdStartup, Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			Button obj = Object.Instantiate<Button>(fejdStartup.m_csNewButton, parent);
			((UnityEventBase)obj.onClick).RemoveAllListeners();
			obj.onClick = new ButtonClickedEvent();
			((Component)obj).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 200f);
			TMP_Text componentInChildren = ((Component)obj).GetComponentInChildren<TMP_Text>();
			((Component)componentInChildren).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 200f);
			componentInChildren.text = "Compression";
			((Object)((Component)obj).gameObject).name = "CompressMapData.Button";
			((Component)obj).gameObject.SetActive(false);
			return obj;
		}

		private static TMP_Text CreateProfileCompressionText(FejdStartup fejdStartup, Transform parent)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text obj = Object.Instantiate<TMP_Text>(fejdStartup.m_csName, parent);
			obj.fontSize = 20f;
			((Object)((Component)obj).gameObject).name = "ProfileCompression.Text";
			obj.text = "Profile Compression Text";
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.zero;
			component.pivot = Vector2.zero;
			component.anchoredPosition = new Vector2(-146f, -89f);
			component.ForceUpdateRectTransforms();
			return obj;
		}

		public static void UpdateProfileCompressionUI(FejdStartup fejdStartup)
		{
			int profileIndex = fejdStartup.m_profileIndex;
			if (Object.op_Implicit((Object)(object)_profileCompressionRoot) && profileIndex >= 0 && profileIndex < fejdStartup.m_profiles.Count)
			{
				PlayerProfile profile = fejdStartup.m_profiles[profileIndex];
				UpdateCompressMapDataButton(fejdStartup, profile);
				UpdateProfileCompressionText(profile);
			}
		}

		private static void UpdateCompressMapDataButton(FejdStartup fejdStartup, PlayerProfile profile)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			bool flag = HasUncompressedData(profile);
			((Component)_compressMapDataButton).GetComponentInChildren<TMP_Text>().text = (flag ? "Compress MapData" : "Compressed!");
			((UnityEventBase)_compressMapDataButton.onClick).RemoveAllListeners();
			((UnityEvent)_compressMapDataButton.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)fejdStartup).StartCoroutine(CompressProfileMapDataCoroutine(fejdStartup, profile));
			});
			((Selectable)_compressMapDataButton).interactable = flag;
			((Component)_compressMapDataButton).gameObject.SetActive(true);
		}

		private static void UpdateProfileCompressionText(PlayerProfile profile)
		{
			float num = profile.m_worldData.Values.Select(delegate(WorldPlayerData value)
			{
				byte[] mapData = value.m_mapData;
				return (mapData != null) ? mapData.Length : 0;
			}).Sum();
			int num2 = profile.m_worldData.Values.Select((WorldPlayerData value) => (value.m_mapData == null || IsCompressedMapData(value.m_mapData)) ? 1 : 0).Sum();
			_profileCompressionText.text = string.Format("Worlds: <color={0}>{1}</color>/<color={0}>{2}</color> compressed   MapData: <color={0}>{3}</color> KB", "orange", profile.m_worldData.Count, num2, (num / 1024f).ToString("N0"));
		}

		[IteratorStateMachine(typeof(<CompressProfileMapDataCoroutine>d__14))]
		private static IEnumerator CompressProfileMapDataCoroutine(FejdStartup fejdStartup, PlayerProfile profile)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CompressProfileMapDataCoroutine>d__14(0)
			{
				fejdStartup = fejdStartup,
				profile = profile
			};
		}
	}
	[BepInPlugin("redseiko.valheim.odinsaves", "OdinSaves", "1.5.0")]
	public sealed class OdinSaves : BaseUnityPlugin
	{
		public const string PluginGuid = "redseiko.valheim.odinsaves";

		public const string PluginName = "OdinSaves";

		public const string PluginVersion = "1.5.0";

		private static ManualLogSource _logger;

		private void Awake()
		{
			_logger = ((BaseUnityPlugin)this).Logger;
			PluginConfig.BindConfig(((BaseUnityPlugin)this).Config);
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "redseiko.valheim.odinsaves");
		}

		public static void LogInfo(object obj)
		{
			_logger.LogInfo((object)$"[{DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo)}] {obj}");
		}
	}
	[HarmonyPatch(typeof(FejdStartup))]
	internal static class FejdStartupPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void AwakePostfix(FejdStartup __instance)
		{
			if (PluginConfig.IsModEnabled.Value && PluginConfig.EnableMapDataCompression.Value)
			{
				SaveManager.CreateProfileCompressionUI(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdateCharacterList")]
		private static void UpdateCharacterListPostfix(FejdStartup __instance)
		{
			if (PluginConfig.IsModEnabled.Value && PluginConfig.EnableMapDataCompression.Value)
			{
				SaveManager.UpdateProfileCompressionUI(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Game))]
	internal static class GamePatch
	{
		private static float _savePlayerProfileTimer;

		[HarmonyPostfix]
		[HarmonyPatch("SavePlayerProfile")]
		private static void SavePlayerProfilePostfix()
		{
			_savePlayerProfileTimer = 0f;
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateSaving")]
		private static void UpdateSavingPrefix(float dt)
		{
			_savePlayerProfileTimer += dt;
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdateSaving")]
		private static void UpdateSavingPostfix(Game __instance)
		{
			if (PluginConfig.IsModEnabled.Value && !(_savePlayerProfileTimer <= 0f) && !(_savePlayerProfileTimer < (float)PluginConfig.SavePlayerProfileInterval.Value))
			{
				if (PluginConfig.ShowMessageOnModSave.Value)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Saving player profile...", 0, (Sprite)null, false);
				}
				_savePlayerProfileTimer = 0f;
				__instance.SavePlayerProfile(PluginConfig.SetLogoutPointOnSave.Value);
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnDeath")]
		private static void OnDeathPostfix(ref Player __instance)
		{
			Game.instance.m_playerProfile.ClearLoguoutPoint();
		}
	}
}