using System;
using System.Collections.Generic;
using System.Diagnostics;
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 Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("VentureValheim.LogoutTweaks")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("VentureValheim.LogoutTweaks")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("D19D40C6-9069-40E0-823D-ACEDD32A7821")]
[assembly: AssemblyFileVersion("0.6.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.6.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace VentureValheim.LogoutTweaks
{
	[BepInPlugin("com.orianaventure.mod.LogoutTweaks", "LogoutTweaks", "0.6.0")]
	public class LogoutTweaksPlugin : BaseUnityPlugin
	{
		private const string ModName = "LogoutTweaks";

		private const string ModVersion = "0.6.0";

		private const string Author = "com.orianaventure.mod";

		private const string ModGUID = "com.orianaventure.mod.LogoutTweaks";

		private readonly Harmony HarmonyInstance = new Harmony("com.orianaventure.mod.LogoutTweaks");

		public static readonly ManualLogSource LogoutTweaksLogger = Logger.CreateLogSource("LogoutTweaks");

		public void Awake()
		{
			LogoutTweaksLogger.LogInfo((object)"The cat fell in the toilet, BRB!");
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			HarmonyInstance.PatchAll(executingAssembly);
		}
	}
	public class LogoutTweaks
	{
		private readonly struct FileData
		{
			public List<StatusEffectManager.StatusEffectData> StatusEffects { get; }

			public FileData(List<StatusEffectManager.StatusEffectData> effects)
			{
				StatusEffects = effects;
			}

			public FileData(string saveString)
			{
				StatusEffects = new List<StatusEffectManager.StatusEffectData>();
				if (saveString == null)
				{
					return;
				}
				string[] array = saveString.Split(new char[1] { ';' });
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						StatusEffectManager.StatusEffectData item = new StatusEffectManager.StatusEffectData(array[i]);
						StatusEffects.Add(item);
					}
				}
			}

			public override string ToString()
			{
				string text = "";
				foreach (StatusEffectManager.StatusEffectData statusEffect in StatusEffects)
				{
					text = text + statusEffect.ToString() + ";";
				}
				return text;
			}
		}

		[HarmonyPatch(typeof(Player), "Save")]
		public static class Patch_Player_Save
		{
			private static void Prefix(Player __instance)
			{
				if (!IsInTheMainScene())
				{
					return;
				}
				try
				{
					List<StatusEffectManager.StatusEffectData> list = new List<StatusEffectManager.StatusEffectData>();
					List<StatusEffect> statusEffects = ((Character)__instance).m_seman.GetStatusEffects();
					if (statusEffects == null)
					{
						LogoutTweaksPlugin.LogoutTweaksLogger.LogInfo((object)"Unable to determine status effects, this can indicate a mod conflict.");
					}
					else
					{
						for (int i = 0; i < statusEffects.Count; i++)
						{
							if (StatusEffectManager.SupportedStatusEffect(statusEffects[i].m_nameHash))
							{
								StatusEffectManager.StatusEffectData item = new StatusEffectManager.StatusEffectData(statusEffects[i]);
								list.Add(item);
							}
						}
					}
					FileData data = new FileData(list);
					Instance.SaveData(ref __instance, data);
				}
				catch (Exception ex)
				{
					LogoutTweaksPlugin.LogoutTweaksLogger.LogError((object)"Error trying to parse and save extra data.");
					LogoutTweaksPlugin.LogoutTweaksLogger.LogError((object)ex);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		public static class Patch_Player_Load
		{
			private static void Postfix(Player __instance)
			{
				if (!IsInTheMainScene())
				{
					return;
				}
				FileData? fileData = Instance.LoadData(ref __instance);
				if (!fileData.HasValue)
				{
					return;
				}
				FileData value = fileData.Value;
				if (value.StatusEffects != null)
				{
					List<StatusEffectManager.StatusEffectData> statusEffects = value.StatusEffects;
					for (int i = 0; i < statusEffects.Count; i++)
					{
						try
						{
							StatusEffect val = StatusEffectManager.BuildStatusEffect(statusEffects[i]);
							if ((Object)(object)val != (Object)null)
							{
								((Character)__instance).m_seman.AddStatusEffect(val, false, 0, 0f);
							}
						}
						catch (Exception ex)
						{
							LogoutTweaksPlugin.LogoutTweaksLogger.LogWarning((object)$"Status Effect {statusEffects[i].Name} could not be restored.");
							LogoutTweaksPlugin.LogoutTweaksLogger.LogDebug((object)ex);
						}
					}
				}
				Instance.ClearData(ref __instance);
			}
		}

		private static readonly LogoutTweaks _instance = new LogoutTweaks();

		private const string PLAYER_SAVE_KEY = "VV_LogoutData";

		public static LogoutTweaks Instance => _instance;

		private LogoutTweaks()
		{
		}

		private void SaveData(ref Player player, FileData data)
		{
			if (!((Object)(object)player == (Object)null))
			{
				if (player.m_customData.ContainsKey("VV_LogoutData"))
				{
					player.m_customData["VV_LogoutData"] = data.ToString();
				}
				else
				{
					player.m_customData.Add("VV_LogoutData", data.ToString());
				}
			}
		}

		private void ClearData(ref Player player)
		{
			if ((Object)(object)player != (Object)null && player.m_customData.ContainsKey("VV_LogoutData"))
			{
				player.m_customData["VV_LogoutData"] = "";
			}
		}

		private FileData? LoadData(ref Player player)
		{
			if ((Object)(object)player != (Object)null && player.m_customData.ContainsKey("VV_LogoutData"))
			{
				return new FileData(player.m_customData["VV_LogoutData"]);
			}
			return null;
		}

		public static bool IsInTheMainScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name.Equals("main");
		}
	}
	public class StatusEffectManager
	{
		public readonly struct StatusEffectData
		{
			public int Name { get; }

			public float Ttl { get; }

			public float Time { get; }

			public float Value1 { get; }

			public float Value2 { get; }

			public float Value3 { get; }

			public float Value4 { get; }

			public StatusEffectData(StatusEffect se)
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				Name = se.NameHash();
				Ttl = se.m_ttl;
				Time = se.m_time;
				Value1 = 0f;
				Value2 = 0f;
				Value3 = 0f;
				Value4 = 0f;
				if (Name == Poison)
				{
					SE_Poison val = (SE_Poison)se;
					Value1 = val.m_damageLeft;
					Value2 = val.m_damagePerHit;
				}
				else if (Name == Burning || Name == Spirit)
				{
					SE_Burning val2 = (SE_Burning)se;
					Value1 = val2.m_fireDamageLeft;
					Value2 = val2.m_fireDamagePerHit;
					Value3 = val2.m_spiritDamageLeft;
					Value4 = val2.m_spiritDamagePerHit;
				}
			}

			public StatusEffectData(string data)
			{
				Name = 0;
				Ttl = 0f;
				Time = 0f;
				Value1 = 0f;
				Value2 = 0f;
				Value3 = 0f;
				Value4 = 0f;
				string[] array = data.Split(new char[1] { ':' });
				if (array.Length >= 3 && int.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3))
				{
					Name = result;
					Ttl = result2;
					Time = result3;
					if (array.Length >= 5 && float.TryParse(array[3], out var result4) && float.TryParse(array[4], out var result5))
					{
						Value1 = result4;
						Value2 = result5;
					}
					if (array.Length >= 7 && float.TryParse(array[5], out var result6) && float.TryParse(array[6], out var result7))
					{
						Value3 = result6;
						Value4 = result7;
					}
				}
			}

			public override string ToString()
			{
				if (Name == Poison)
				{
					return $"{Name}:{Ttl}:{Time}:{Value1}:{Value2}";
				}
				if (Name == Burning || Name == Spirit)
				{
					return $"{Name}:{Ttl}:{Time}:{Value1}:{Value2}:{Value3}:{Value4}";
				}
				return $"{Name}:{Ttl}:{Time}";
			}
		}

		private static readonly int Poison = StringExtensionMethods.GetStableHashCode("Poison");

		private static readonly int Burning = StringExtensionMethods.GetStableHashCode("Burning");

		private static readonly int Spirit = StringExtensionMethods.GetStableHashCode("Spirit");

		private static HashSet<int> BasicStatusEffects = new HashSet<int>
		{
			StringExtensionMethods.GetStableHashCode("Rested"),
			StringExtensionMethods.GetStableHashCode("Wet"),
			StringExtensionMethods.GetStableHashCode("GP_Eikthyr"),
			StringExtensionMethods.GetStableHashCode("GP_TheElder"),
			StringExtensionMethods.GetStableHashCode("GP_Bonemass"),
			StringExtensionMethods.GetStableHashCode("GP_Moder"),
			StringExtensionMethods.GetStableHashCode("GP_Yagluth"),
			StringExtensionMethods.GetStableHashCode("GP_Queen"),
			StringExtensionMethods.GetStableHashCode("GP_Fader"),
			StringExtensionMethods.GetStableHashCode("Potion_tasty"),
			StringExtensionMethods.GetStableHashCode("Potion_barleywine"),
			StringExtensionMethods.GetStableHashCode("Potion_frostresist"),
			StringExtensionMethods.GetStableHashCode("Potion_poisonresist"),
			StringExtensionMethods.GetStableHashCode("Potion_health_major"),
			StringExtensionMethods.GetStableHashCode("Potion_health_medium"),
			StringExtensionMethods.GetStableHashCode("Potion_health_minor"),
			StringExtensionMethods.GetStableHashCode("Potion_health_lingering"),
			StringExtensionMethods.GetStableHashCode("Potion_stamina_lingering"),
			StringExtensionMethods.GetStableHashCode("Potion_stamina_medium"),
			StringExtensionMethods.GetStableHashCode("Potion_stamina_minor"),
			StringExtensionMethods.GetStableHashCode("Potion_eitr_minor"),
			StringExtensionMethods.GetStableHashCode("Potion_eitr_lingering"),
			StringExtensionMethods.GetStableHashCode("Potion_BugRepellent"),
			StringExtensionMethods.GetStableHashCode("Potion_bzerker"),
			StringExtensionMethods.GetStableHashCode("Potion_hasty"),
			StringExtensionMethods.GetStableHashCode("Potion_LightFoot"),
			StringExtensionMethods.GetStableHashCode("Potion_strength"),
			StringExtensionMethods.GetStableHashCode("Potion_swimmer"),
			StringExtensionMethods.GetStableHashCode("Potion_tamer"),
			StringExtensionMethods.GetStableHashCode("Potion_TrollPheromones"),
			StringExtensionMethods.GetStableHashCode("CorpseRun"),
			StringExtensionMethods.GetStableHashCode("SoftDeath"),
			StringExtensionMethods.GetStableHashCode("Slimed"),
			StringExtensionMethods.GetStableHashCode("Tared"),
			StringExtensionMethods.GetStableHashCode("Lightning"),
			StringExtensionMethods.GetStableHashCode("Frost"),
			StringExtensionMethods.GetStableHashCode("Immobilized"),
			StringExtensionMethods.GetStableHashCode("ImmobilizedAshlands"),
			StringExtensionMethods.GetStableHashCode("ImmobilizedLong")
		};

		public static bool SupportedStatusEffect(int name)
		{
			if (!BasicStatusEffects.Contains(name) && name != Poison && name != Burning)
			{
				return name == Spirit;
			}
			return true;
		}

		public static StatusEffect BuildStatusEffect(StatusEffectData data)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(data.Name);
			if ((Object)(object)statusEffect == (Object)null)
			{
				return null;
			}
			StatusEffect val = statusEffect.Clone();
			if (BasicStatusEffects.Contains(data.Name))
			{
				val.m_ttl = data.Ttl;
				val.m_time = data.Time;
				return val;
			}
			if (data.Name == Poison)
			{
				SE_Poison val2 = (SE_Poison)val;
				((StatusEffect)val2).m_ttl = data.Ttl;
				((StatusEffect)val2).m_time = data.Time;
				val2.m_damageLeft = data.Value1;
				val2.m_damagePerHit = data.Value2;
				return (StatusEffect)val2;
			}
			if (data.Name == Burning || data.Name == Spirit)
			{
				SE_Burning val3 = (SE_Burning)val;
				((StatusEffect)val3).m_ttl = data.Ttl;
				((StatusEffect)val3).m_time = data.Time;
				val3.m_fireDamageLeft = data.Value1;
				val3.m_fireDamagePerHit = data.Value2;
				val3.m_spiritDamageLeft = data.Value3;
				val3.m_spiritDamagePerHit = data.Value4;
				return (StatusEffect)val3;
			}
			return null;
		}
	}
}