using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
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.Logging;
using EnhancedPotions.Core;
using EnhancedPotions.StatusEffects;
using EnhancedPotions.Utils;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Newtonsoft.Json;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EnhancedPotions")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EnhancedPotions")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("94846a4f-5726-49f3-9804-38c4f58a4d96")]
[assembly: AssemblyFileVersion("0.3.26")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.26.0")]
[module: UnverifiableCode]
namespace EnhancedPotions
{
	[BepInPlugin("hbocao.EnhancedPotions", "EnhancedPotions", "0.3.26")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class EnhancedPotions : BaseUnityPlugin
	{
		public const string PluginGuid = "hbocao.EnhancedPotions";

		public const string PluginVersion = "0.3.26";

		private static readonly Harmony Harmony = new Harmony("mod.EnhancedPotions");

		private EnhancedPotionSettings _settings;

		public static ManualLogSource MainLogger { get; private set; }

		private void Awake()
		{
			MainLogger = ((BaseUnityPlugin)this).Logger;
			_settings = SettingsManager.Initialize();
			if (_settings == null)
			{
				MainLogger.LogWarning((object)"No settings found. Mod is disabled. Check installation guide: https://henriquedeaguiar.com/project/EnhancedPotions/#installation");
				return;
			}
			MigrateSettingsIfNecessary();
			if (!_settings.Enabled)
			{
				MainLogger.LogWarning((object)"Mod is disabled.");
				return;
			}
			ItemManager.OnVanillaItemsAvailable += RegisterPrefabs;
			Harmony.PatchAll();
		}

		private void MigrateSettingsIfNecessary()
		{
			if (File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
			{
				try
				{
					MainLogger.LogInfo((object)"Migrating from old config file...");
					PotionConfig potionConfig = CreatePotionRecipe("WeightMeadBase", "WeightPotion", "Megingjord's extract", "TrophyFrostTroll:10,DragonEgg:1,BeltStrength:1,LoxPie:5", 1, 5, 600, "Increased max carry weight", "Gives the drinker a god's strength", "You feel strong like a god", $"{PotionEffects.Weight}:250");
					PotionConfig potionConfig2 = CreatePotionRecipe("PortalMeadBase", "PortalPotion", "Bifröst's apozem", "GreydwarfEye:200,SurtlingCore:10,DragonEgg:1,Needle:15", 1, 5, 450, "Portal usage without any restrictions", "Allows unrestricted Portal use", "You feel transcendent", $"{PotionEffects.Portal}:0");
					_settings.MigratePotionCfgFile(potionConfig);
					_settings.MigratePotionCfgFile(potionConfig2);
					_settings.Save();
					File.Move(((BaseUnityPlugin)this).Config.ConfigFilePath, ((BaseUnityPlugin)this).Config.ConfigFilePath + $".migrated_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}");
					MainLogger.LogInfo((object)"Migrating completed!");
				}
				catch (Exception arg)
				{
					MainLogger.LogWarning((object)$"Migrating failed! Reason: {arg}");
				}
			}
			PotionConfig CreatePotionRecipe(string meadPrefabName, string potionPrefabName, string itemName, string requirements, int meadOutputQuantity, int potionOutputQuantity, int cooldown, string effectTooltip, string potionDescription, string consumptionMessage, string effects)
			{
				string text = meadPrefabName + " Recipe";
				bool value = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Enabled", true, "Enables/Disables the recipe").Value;
				string[] commaSeparatedValues = ((BaseUnityPlugin)this).Config.Bind<string>(text, "Requirements", requirements, "Recipe requirements separated by commas. **MAXIMUM** of 4 requirements. Format: ItemId:Quantity").Value.GetCommaSeparatedValues();
				string value2 = ((BaseUnityPlugin)this).Config.Bind<string>(text, "ItemName", itemName, "Name of the item. **Caution** changing it after unlocking recipes or creating the items in game. For example in English it will show: \"Mead Base: {ItemName}\" for a mead base and just \"{ItemName}\" for a potion").Value;
				int value3 = ((BaseUnityPlugin)this).Config.Bind<int>(text, "MeadOutputQuantity", meadOutputQuantity, "Quantity of mead base that the recipe makes").Value;
				int value4 = ((BaseUnityPlugin)this).Config.Bind<int>(text, "PotionOutputQuantity", potionOutputQuantity, "Quantity of the potions after fermenting").Value;
				int value5 = ((BaseUnityPlugin)this).Config.Bind<int>(text, "Cooldown", cooldown, "How long the effect will last in seconds").Value;
				string value6 = ((BaseUnityPlugin)this).Config.Bind<string>(text, "EffectTooltip", effectTooltip, "Message shown in the effects panel").Value;
				string value7 = ((BaseUnityPlugin)this).Config.Bind<string>(text, "PotionDescription", potionDescription, "Shown in potion's tooltip").Value;
				string value8 = ((BaseUnityPlugin)this).Config.Bind<string>(text, "ConsumptionMessage", consumptionMessage, "Message to show when the potion in consumed").Value;
				string[] commaSeparatedValues2 = effects.GetCommaSeparatedValues();
				return new PotionConfig(value, meadPrefabName, potionPrefabName, value2, commaSeparatedValues, value3, value4, value5, value6, value7, value8, commaSeparatedValues2);
			}
		}

		private void RegisterPrefabs()
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			ItemManager.OnVanillaItemsAvailable -= RegisterPrefabs;
			foreach (PotionConfig recipe in _settings.Recipes)
			{
				if (!recipe.Enabled)
				{
					MainLogger.LogWarning((object)("Skipping " + recipe.ItemName + "'s recipe."));
					continue;
				}
				MeadToPotionRecipe meadToPotionRecipe = MeadToPotionRecipe.Create((PotionConfig s) => new MeadBasePrefabConfig(s), (PotionConfig s) => new PotionPrefabConfig(s), recipe);
				ItemManager.Instance.AddItem((CustomItem)(object)meadToPotionRecipe.MeadPrefabConfig);
				ItemManager.Instance.AddItem((CustomItem)(object)meadToPotionRecipe.PotionPrefabConfig);
				if (meadToPotionRecipe.PotionConfig.HasValidRequirements())
				{
					ItemManager.Instance.AddRecipe(meadToPotionRecipe.Recipe);
				}
				else
				{
					MainLogger.LogWarning((object)("Invalid recipe (" + meadToPotionRecipe.PotionConfig.ItemName + ") found! Skipping it. The maximum amount of requirements is 4."));
				}
				ItemManager.Instance.AddItemConversion(new CustomItemConversion((ConversionConfig)new FermenterConversionConfig
				{
					FromItem = meadToPotionRecipe.PotionConfig.MeadPrefabName,
					ToItem = meadToPotionRecipe.PotionConfig.PotionPrefabName,
					ProducedItems = meadToPotionRecipe.PotionConfig.PotionOutputQuantity
				}));
			}
		}
	}
}
namespace EnhancedPotions.Utils
{
	public static class DictionaryExtensions
	{
		public static float GetValueOrDefault<T>(this IDictionary<T, float> dictionary, T key, float defaultValue = 0f)
		{
			if (!dictionary.ContainsKey(key))
			{
				return defaultValue;
			}
			return dictionary[key];
		}

		public static void AddOrUpdate<T, TW>(this IDictionary<T, TW> original, T key, TW value)
		{
			if (!original.ContainsKey(key))
			{
				original.Add(key, value);
			}
			else
			{
				original[key] = value;
			}
		}
	}
	public static class EnumExtensions
	{
		public static T ParseEnum<T>(this string value) where T : Enum
		{
			return (T)Enum.Parse(typeof(T), value);
		}
	}
	public class PathHelper
	{
		private const string PluginDirectoryName = "EnhancedPotions";

		private readonly string _pluginPath;

		private readonly string _assetPath;

		private static PathHelper _instance;

		private PathHelper()
		{
			string text = Path.Combine(Paths.PluginPath, "hbocao-EnhancedPotions");
			if (Directory.Exists(text))
			{
				_assetPath = (_pluginPath = text);
				return;
			}
			_pluginPath = Path.Combine(Paths.PluginPath, "EnhancedPotions");
			_assetPath = Path.Combine(_pluginPath, "Assets");
		}

		public static PathHelper GetInstance()
		{
			return _instance ?? (_instance = new PathHelper());
		}

		public string GetPluginPath()
		{
			return _pluginPath;
		}

		public string GetAssetsPath()
		{
			return _assetPath;
		}
	}
	internal static class PrefabUtils
	{
		internal static Sprite GetSprite(string prefabName)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = AssetUtils.LoadTexture(Path.Combine(PathHelper.GetInstance().GetAssetsPath(), prefabName + "-sprite.png"), true);
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.zero);
		}
	}
	public static class SEManExtensions
	{
		public static bool HasEffect(this SEMan seMan, PotionEffects potionEffect)
		{
			return seMan.GetExtendedStatusEffects().Any((StatusEffectExtended effect) => effect.PotionEffectsConfig.Effects.ContainsKey(potionEffect));
		}

		public static bool HasEffect(this Character player, PotionEffects potionEffect)
		{
			return player.GetSEMan().HasEffect(potionEffect);
		}

		public static bool HasFlyEffect(this Character player)
		{
			return player.HasEffect(PotionEffects.Fly);
		}

		public static bool HasWaterSinkEffect(this Character player)
		{
			return player.HasEffect(PotionEffects.WaterSink);
		}

		public static float? GetEffectValue(this Character player, PotionEffects activeEffect)
		{
			return player.GetExtendedStatusEffects().FirstOrDefault((StatusEffectExtended effect) => effect.PotionEffectsConfig.Effects.ContainsKey(activeEffect))?.PotionEffectsConfig.Effects[activeEffect];
		}

		public static float? GetEffectTotalMultiplier(this Character player, PotionEffects activeEffect)
		{
			return (from effect in player.GetExtendedStatusEffects()
				where effect.PotionEffectsConfig.Effects.ContainsKey(activeEffect)
				select effect).Aggregate(null, (float? current, StatusEffectExtended effect) => (current ?? 1f) * effect.PotionEffectsConfig.Effects[activeEffect]);
		}

		private static IEnumerable<StatusEffectExtended> GetExtendedStatusEffects(this Character player)
		{
			return player.GetSEMan().GetExtendedStatusEffects();
		}

		private static IEnumerable<StatusEffectExtended> GetExtendedStatusEffects(this SEMan seMan)
		{
			StatusEffect[] array = seMan.GetStatusEffects().ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] is StatusEffectExtended statusEffectExtended)
				{
					yield return statusEffectExtended;
				}
			}
		}
	}
	public static class StringExtensions
	{
		public static bool EqualsIgnoreCase(this string value, string compareTo)
		{
			return value.Equals(compareTo, StringComparison.InvariantCultureIgnoreCase);
		}

		public static string[] GetCommaSeparatedValues(this string value)
		{
			if (value == null)
			{
				return null;
			}
			return value.GetValueSeparatedBy(",");
		}

		public static string[] GetColonSeparatedValues(this string value)
		{
			if (value == null)
			{
				return null;
			}
			return value.GetValueSeparatedBy(":");
		}

		private static string[] GetValueSeparatedBy(this string value, string separator)
		{
			return value?.Split(separator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
		}
	}
}
namespace EnhancedPotions.StatusEffects
{
	public class StatusEffectExtended : SE_Stats
	{
		public PotionEffectsConfig PotionEffectsConfig { get; set; } = new PotionEffectsConfig();

	}
}
namespace EnhancedPotions.Patches
{
	[HarmonyPatch(typeof(Character), "Jump")]
	public static class Character_Jump_Patch
	{
		private static bool Prefix(ref Character __instance)
		{
			if (__instance.HasWaterSinkEffect() && __instance.IsSwimming())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "UpdateMotion")]
	public static class Character_UpdateMotion_Patch
	{
		private enum FlyingDirection
		{
			None,
			Up,
			Down
		}

		private static float _flightActivationTimer = 0.5f;

		private static int _jumpTriggeredCount;

		private static bool _flyActivated;

		private const float WalkingUnderWaterStaminaDelay = 2f;

		private const float WalkingUnderWaterStaminaConsumption = 3.5f;

		private static void Postfix(ref Character __instance, ref float dt)
		{
			if (__instance.IsPlayer())
			{
				Character obj = __instance;
				Character _instance = ((obj is Player) ? obj : null);
				UpdateWaterSink((Player)(object)_instance, dt);
				UpdateFly(_instance, dt);
			}
		}

		private static void UpdateFly(Character __instance, float dt)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.HasFlyEffect())
			{
				return;
			}
			if (ZInput.GetButtonDown("Jump"))
			{
				if (_flightActivationTimer > 0f && _jumpTriggeredCount == 1)
				{
					_flyActivated = !_flyActivated;
					if (_flyActivated)
					{
						__instance.m_sliding = true;
						Vector3 currentVel = __instance.m_currentVel;
						currentVel.y += 30f;
						__instance.m_currentVel = Vector3.Lerp(__instance.m_currentVel, currentVel, 0.5f);
						__instance.m_body.velocity = __instance.m_currentVel;
						__instance.m_maxAirAltitude = ((Component)__instance).transform.position.y;
						__instance.m_sliding = false;
					}
				}
				else
				{
					_flightActivationTimer = 0.5f;
					_jumpTriggeredCount++;
				}
			}
			if (_flightActivationTimer > 0f)
			{
				_flightActivationTimer -= 1f * dt;
			}
			else
			{
				_jumpTriggeredCount = 0;
			}
			if (_flyActivated && __instance.CanMove() && !__instance.IsSwimming() && !__instance.IsEncumbered())
			{
				float num = __instance.GetRunSpeedFactor() * (__instance.m_run ? __instance.m_runSpeed : 6f);
				float num2 = 0f;
				FlyingDirection flyingDirection = FlyingDirection.None;
				if (ZInput.GetButton("Jump"))
				{
					flyingDirection = FlyingDirection.Up;
					num2 = 0.012f * num;
				}
				else if (ZInput.GetButton("Crouch"))
				{
					flyingDirection = FlyingDirection.Down;
					num2 = 0.0085f * num;
				}
				Vector3 currentVel2 = __instance.m_currentVel;
				if (flyingDirection != 0 && __instance.HaveStamina(num2))
				{
					currentVel2.y = num * (float)((flyingDirection == FlyingDirection.Up) ? 1 : (-1));
					__instance.UseStamina(num2, false);
				}
				if (!__instance.IsOnGround())
				{
					currentVel2.y -= 75f * dt;
				}
				__instance.m_body.useGravity = false;
				__instance.m_currentVel = Vector3.Lerp(__instance.m_currentVel, currentVel2, 0.5f);
				__instance.m_body.velocity = __instance.m_currentVel;
				__instance.m_maxAirAltitude = ((Component)__instance).transform.position.y;
				__instance.m_body.angularVelocity = Vector3.zero;
				if (!__instance.IsOnGround())
				{
					__instance.m_zanim.SetFloat(Character.s_forwardSpeed, 0f);
					__instance.m_zanim.SetBool(Character.s_inWater, false);
					__instance.m_zanim.SetBool(Character.s_onGround, true);
				}
			}
		}

		private static void UpdateWaterSink(Player __instance, float dt)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (((Character)(object)__instance).HasWaterSinkEffect() && ((Character)__instance).IsSwimming())
			{
				GameCamera.instance.m_minWaterDistance = -100f;
				((Character)__instance).m_canSwim = false;
				__instance.m_staminaRegenDelay = 2f;
				Vector3 velocity = ((Character)__instance).m_body.velocity;
				if (((Vector3)(ref velocity)).magnitude > 0.1f && ((Character)__instance).m_moveDir != Vector3.zero)
				{
					((Character)__instance).UseStamina(3.5f * dt, false);
				}
				Vector3 currentVel = ((Character)__instance).m_currentVel;
				if (!((Character)__instance).IsOnGround())
				{
					currentVel.y -= 75f * dt;
				}
				((Character)__instance).m_currentVel = Vector3.Lerp(((Character)__instance).m_currentVel, currentVel, 0.5f);
				((Character)__instance).m_body.velocity = ((Character)__instance).m_currentVel;
				((Character)__instance).m_maxAirAltitude = ((Component)__instance).transform.position.y;
				((Character)__instance).m_body.angularVelocity = Vector3.zero;
				((Character)__instance).m_zanim.SetBool(Character.s_onGround, true);
				((Character)__instance).m_zanim.SetBool(Character.s_encumbered, !((Character)__instance).HaveStamina(0f));
			}
			else
			{
				GameCamera.instance.m_minWaterDistance = 0.3f;
				((Character)__instance).m_canSwim = true;
				__instance.m_staminaRegenDelay = 1f;
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "IsTeleportable")]
	public static class Humanoid_IsTeleportable_Patch
	{
		private static bool Prefix(ref Humanoid __instance, ref bool __result)
		{
			if (((Character)(object)__instance).HasEffect(PotionEffects.Portal))
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "CanMove")]
	public static class Player_CanMove_Patch
	{
		private static void Postfix(ref Player __instance, ref bool __result)
		{
			if (((Character)(object)__instance).HasWaterSinkEffect() && !((Character)__instance).HaveStamina(0f))
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeItem")]
	public static class Player_ConsumeItem_Patch
	{
		private static void Postfix(ref Player __instance, ref bool __result)
		{
			if (!(((Character)(object)__instance).HasEffect(PotionEffects.Puke) & __result))
			{
				return;
			}
			foreach (StatusEffect item in ((Character)__instance).GetSEMan().GetStatusEffects().Where(delegate(StatusEffect e)
			{
				if (!(e.m_ttl > 0f) || ((Object)e).name.IndexOf("potion", StringComparison.InvariantCultureIgnoreCase) < 0 || !(e is SE_Stats))
				{
					StatusEffectExtended obj = e as StatusEffectExtended;
					if (obj == null)
					{
						return false;
					}
					return obj.PotionEffectsConfig?.Effects.ContainsKey(PotionEffects.Puke) == false;
				}
				return true;
			})
				.ToList())
			{
				((Character)__instance).GetSEMan().RemoveStatusEffect(item, true);
			}
			__instance.ClearFood();
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeResources")]
	public static class Player_ConsumeResources_Patch
	{
		private static void Prefix(ref Player __instance, ref Requirement[] requirements)
		{
			Requirement[] array = requirements;
			foreach (Requirement val in array)
			{
				foreach (ItemData allItem in ((Humanoid)__instance).GetInventory().GetAllItems())
				{
					SharedData shared = val.m_resItem.m_itemData.m_shared;
					if (allItem.m_equipped && shared.m_name.EqualsIgnoreCase(allItem.m_shared.m_name))
					{
						((Humanoid)__instance).UnequipItem(allItem, true);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetJogSpeedFactor")]
	public static class Player_GetJogSpeedFactor_Patch
	{
		private static void Postfix(ref Player __instance, ref float __result)
		{
			float? effectTotalMultiplier = ((Character)(object)__instance).GetEffectTotalMultiplier(PotionEffects.OnLandSpeedMultiplier);
			if (effectTotalMultiplier.HasValue)
			{
				__result *= effectTotalMultiplier.Value;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetRunSpeedFactor")]
	public static class Player_GetRunSpeedFactor_Patch
	{
		private static void Postfix(ref Player __instance, ref float __result)
		{
			float? effectTotalMultiplier = ((Character)(object)__instance).GetEffectTotalMultiplier(PotionEffects.OnLandSpeedMultiplier);
			if (effectTotalMultiplier.HasValue)
			{
				__result *= effectTotalMultiplier.Value;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "IsCrouching")]
	public static class Player_IsCrouching_Patch
	{
		private static bool Prefix(ref Player __instance, ref bool __result)
		{
			if (((Character)(object)__instance).HasFlyEffect() && !((Character)__instance).IsOnGround())
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "OnSwimming")]
	public static class Player_OnSwimming_Patch
	{
		private static float? _startingSwimStaminaDrainMaxSkill;

		private static float? _startingSwimStaminaDrainMinSkill;

		private static void Prefix(ref Player __instance)
		{
			float? effectTotalMultiplier = ((Character)(object)__instance).GetEffectTotalMultiplier(PotionEffects.SwimDrainFactor);
			if (effectTotalMultiplier.HasValue)
			{
				float valueOrDefault = _startingSwimStaminaDrainMinSkill.GetValueOrDefault();
				if (!_startingSwimStaminaDrainMinSkill.HasValue)
				{
					valueOrDefault = __instance.m_swimStaminaDrainMinSkill;
					_startingSwimStaminaDrainMinSkill = valueOrDefault;
				}
				__instance.m_swimStaminaDrainMinSkill = _startingSwimStaminaDrainMinSkill.Value * effectTotalMultiplier.Value;
				valueOrDefault = _startingSwimStaminaDrainMaxSkill.GetValueOrDefault();
				if (!_startingSwimStaminaDrainMaxSkill.HasValue)
				{
					valueOrDefault = __instance.m_swimStaminaDrainMaxSkill;
					_startingSwimStaminaDrainMaxSkill = valueOrDefault;
				}
				__instance.m_swimStaminaDrainMaxSkill = _startingSwimStaminaDrainMaxSkill.Value * effectTotalMultiplier.Value;
			}
			else if (_startingSwimStaminaDrainMinSkill.HasValue && _startingSwimStaminaDrainMaxSkill.HasValue)
			{
				__instance.m_swimStaminaDrainMinSkill = _startingSwimStaminaDrainMinSkill.Value;
				__instance.m_swimStaminaDrainMaxSkill = _startingSwimStaminaDrainMaxSkill.Value;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "SetCrouch")]
	public static class Player_SetCrouch_Patch
	{
		private static bool Prefix(ref Player __instance)
		{
			if (((Character)(object)__instance).HasFlyEffect() && !((Character)__instance).IsOnGround())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
	{
		typeof(int),
		typeof(bool),
		typeof(int),
		typeof(float)
	})]
	public static class SEMan_AddStatusEffect_Patch
	{
		private static bool Prefix(ref int nameHash, ref bool resetTime, ref int itemLevel, ref float skillLevel, ref SEMan __instance)
		{
			if (SEMan_HaveStatusEffect_Patch.HasWetEffectAndWaterproofPotion(nameHash, __instance))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SEMan), "HaveStatusEffect", new Type[] { typeof(string) })]
	public static class SEMan_HaveStatusEffect_Patch
	{
		private const string WetStatusEffectName = "Wet";

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

		private static void Postfix(ref string name, ref bool __result, ref SEMan __instance)
		{
			if (HasWetEffectAndWaterproofPotion(WetStatusEffectNameHash, __instance))
			{
				__instance.RemoveStatusEffect(WetStatusEffectNameHash, true);
				__result = false;
			}
		}

		public static bool HasWetEffectAndWaterproofPotion(int nameHash, SEMan __instance)
		{
			if (nameHash == WetStatusEffectNameHash)
			{
				return __instance.HasEffect(PotionEffects.Waterproof);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(SEMan), "ModifyMaxCarryWeight")]
	public static class SEMan_ModifyMaxCarryWeight_Patch
	{
		private static bool? _valheimPlusPlayerConfigIsEnable;

		private static bool IsValheimPlusPlayerConfigIsEnable()
		{
			try
			{
				if (!Harmony.GetAllPatchedMethods().Any((MethodBase method) => method.Name.EqualsIgnoreCase("ModifyMaxCarryWeight")))
				{
					return false;
				}
				object obj = Type.GetType("ValheimPlus.Configurations.Configuration, ValheimPlus", throwOnError: true).GetProperty("Current")?.GetValue(null);
				object obj2 = obj?.GetType().GetProperty("Player")?.GetValue(obj);
				if (obj2 != null)
				{
					return (bool)obj2.GetType().GetField("IsEnabled").GetValue(obj2);
				}
			}
			catch (Exception)
			{
			}
			return false;
		}

		private static void Postfix(ref SEMan __instance, ref float baseLimit, ref float limit)
		{
			bool valueOrDefault = _valheimPlusPlayerConfigIsEnable.GetValueOrDefault();
			if (!_valheimPlusPlayerConfigIsEnable.HasValue)
			{
				valueOrDefault = IsValheimPlusPlayerConfigIsEnable();
				_valheimPlusPlayerConfigIsEnable = valueOrDefault;
			}
			if (!_valheimPlusPlayerConfigIsEnable.Value)
			{
				return;
			}
			foreach (StatusEffect item in from statusEffect in __instance.GetStatusEffects()
				where statusEffect is StatusEffectExtended
				select statusEffect)
			{
				item.ModifyMaxCarryWeight(baseLimit, ref limit);
			}
		}
	}
	[HarmonyPatch(typeof(SE_Rested), "UpdateTTL")]
	public static class SE_Rested_UpdateTTL_Patch
	{
		private static float? _startingTtlPerComfortLevel;

		public static void Prefix(ref SE_Rested __instance)
		{
			float? effectValue = ((StatusEffect)__instance).m_character.GetEffectValue(PotionEffects.RestedBonusPerComfortLevel);
			if (effectValue.HasValue)
			{
				float valueOrDefault = _startingTtlPerComfortLevel.GetValueOrDefault();
				if (!_startingTtlPerComfortLevel.HasValue)
				{
					valueOrDefault = __instance.m_TTLPerComfortLevel;
					_startingTtlPerComfortLevel = valueOrDefault;
				}
				__instance.m_TTLPerComfortLevel = effectValue.Value;
			}
			else if (_startingTtlPerComfortLevel.HasValue)
			{
				__instance.m_TTLPerComfortLevel = _startingTtlPerComfortLevel.Value;
			}
		}
	}
	[HarmonyPatch(typeof(SE_Stats), "ModifyAttack")]
	public static class SE_Stats_ModifyAttack_Patch
	{
		private static bool Prefix(ref SE_Stats __instance, ref SkillType skill, ref HitData hitData)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			StatusEffectExtended statusEffectExtended = __instance as StatusEffectExtended;
			if ((Object)(object)statusEffectExtended == (Object)null)
			{
				return true;
			}
			if (((Enum)__instance.m_modifyAttackSkill).HasFlag((Enum)(object)skill) && statusEffectExtended.PotionEffectsConfig.AttackModifiers.ContainsKey(skill))
			{
				((DamageTypes)(ref hitData.m_damage)).Modify(statusEffectExtended.PotionEffectsConfig.AttackModifiers[skill]);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SE_Stats), "ModifyRaiseSkill")]
	public static class SE_Stats_ModifyRaiseSkill_Patch
	{
		private static bool Prefix(ref SE_Stats __instance, ref SkillType skill, ref float value)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			StatusEffectExtended statusEffectExtended = __instance as StatusEffectExtended;
			if ((Object)(object)statusEffectExtended == (Object)null)
			{
				return true;
			}
			if (((Enum)__instance.m_raiseSkill).HasFlag((Enum)(object)skill) && statusEffectExtended.PotionEffectsConfig.RaiseSkillModifiers.ContainsKey(skill))
			{
				value += statusEffectExtended.PotionEffectsConfig.RaiseSkillModifiers[skill];
				return false;
			}
			return true;
		}
	}
}
namespace EnhancedPotions.Core
{
	[Serializable]
	public class DamageModifierEntry
	{
		[JsonConverter(typeof(SimpleStringEnumConverter))]
		public DamageType Type { get; set; }

		[JsonConverter(typeof(SimpleStringEnumConverter))]
		public DamageModifier Modifier { get; set; }
	}
	public class MeadBasePrefabConfig : PrefabConfigExtended
	{
		public MeadBasePrefabConfig(PotionConfig potionConfig)
			: base(potionConfig, potionConfig.MeadPrefabName, "MeadBaseTasty")
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop itemDrop = ((CustomItem)this).ItemDrop;
			itemDrop.m_itemData.m_shared.m_itemType = (ItemType)1;
			itemDrop.m_itemData.m_dropPrefab = ((CustomItem)this).ItemPrefab;
			itemDrop.m_itemData.m_shared.m_weight = 1f;
			itemDrop.m_itemData.m_shared.m_maxStackSize = 1;
			itemDrop.m_itemData.m_shared.m_icons[0] = PrefabUtils.GetSprite(base.PotionConfig.MeadPrefabName);
			string text = Localization.instance.Localize("$item_meadbasetasty");
			int num = text.IndexOf(": ", StringComparison.OrdinalIgnoreCase);
			int num2 = num + 2;
			string name = ((num >= 0 && text.Length >= num2) ? (text.Substring(0, num2) + base.PotionConfig.ItemName) : base.PotionConfig.ItemName);
			itemDrop.m_itemData.m_shared.m_name = name;
			itemDrop.m_itemData.m_shared.m_description = base.PotionConfig.EffectTooltip;
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_consumeStatusEffect = (StatusEffect)(object)CreateStatusEffect();
		}
	}
	public class MeadToPotionRecipe
	{
		public PrefabConfigExtended MeadPrefabConfig { get; }

		public PrefabConfigExtended PotionPrefabConfig { get; }

		public PotionConfig PotionConfig { get; }

		public CustomRecipe Recipe { get; }

		private MeadToPotionRecipe(PrefabConfigExtended meadPrefabConfig, PrefabConfigExtended potionPrefabConfig, PotionConfig potionConfig)
		{
			MeadPrefabConfig = meadPrefabConfig;
			PotionPrefabConfig = potionPrefabConfig;
			PotionConfig = potionConfig;
			Recipe = CreateRecipe();
		}

		public static MeadToPotionRecipe Create<T, TW>(Func<PotionConfig, T> creatorT, Func<PotionConfig, TW> creatorTw, PotionConfig potionConfig) where T : PrefabConfigExtended where TW : PrefabConfigExtended
		{
			return new MeadToPotionRecipe(creatorT(potionConfig), creatorTw(potionConfig), potionConfig);
		}

		private CustomRecipe CreateRecipe()
		{
			//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)
			//IL_0020: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			return new CustomRecipe(new RecipeConfig
			{
				Name = "Recipe_" + PotionConfig.MeadPrefabName,
				Item = PotionConfig.MeadPrefabName,
				Amount = PotionConfig.MeadOutputQuantity,
				CraftingStation = "piece_cauldron",
				Requirements = PotionConfig.Requirements.ToArray()
			});
		}
	}
	[Serializable]
	public class PotionConfig
	{
		public bool Enabled { get; set; }

		public string MeadPrefabName { get; set; }

		public string PotionPrefabName { get; set; }

		public string ItemName { get; set; }

		public List<RequirementConfig> Requirements { get; set; } = new List<RequirementConfig>();


		public int MeadOutputQuantity { get; set; }

		public int PotionOutputQuantity { get; set; }

		[Obsolete("Use Duration")]
		public int? Cooldown
		{
			get
			{
				return null;
			}
			set
			{
				Duration = value.Value;
			}
		}

		public int Duration { get; set; }

		public string EffectTooltip { get; set; }

		public string PotionDescription { get; set; }

		public string ConsumptionMessage { get; set; }

		public string Instructions { get; set; }

		[Obsolete("Use PotionEffectsConfig.Effects")]
		public IDictionary<PotionEffects, float> EffectsConfig { get; set; } = new Dictionary<PotionEffects, float>();


		public PotionEffectsConfig PotionEffectsConfig { get; set; }

		public PotionConfig()
		{
		}

		public bool ShouldSerializeEffectsConfig()
		{
			return EffectsConfig?.Any() ?? false;
		}

		public PotionConfig(bool enabled, string meadPrefabName, string potionPrefabName, string itemName, IEnumerable<string> requirementsConfig, int meadOutputQuantity, int potionOutputQuantity, int cooldown, string effectTooltip, string potionDescription, string consumptionMessage = null, string[] effectsConfig = null)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			Enabled = enabled;
			MeadPrefabName = meadPrefabName;
			PotionPrefabName = potionPrefabName;
			ItemName = itemName;
			MeadOutputQuantity = meadOutputQuantity;
			PotionOutputQuantity = potionOutputQuantity;
			Duration = cooldown;
			EffectTooltip = effectTooltip;
			PotionDescription = potionDescription;
			ConsumptionMessage = consumptionMessage;
			foreach (string item in requirementsConfig)
			{
				string[] colonSeparatedValues = item.GetColonSeparatedValues();
				Requirements.Add(new RequirementConfig
				{
					Item = colonSeparatedValues[0],
					Amount = int.Parse(colonSeparatedValues[1])
				});
			}
			if (effectsConfig == null)
			{
				return;
			}
			for (int i = 0; i < effectsConfig.Length; i++)
			{
				string[] colonSeparatedValues2 = effectsConfig[i].GetColonSeparatedValues();
				PotionEffects key = colonSeparatedValues2[0].ParseEnum<PotionEffects>();
				if (!PotionEffectsConfig.Effects.ContainsKey(key))
				{
					PotionEffectsConfig.Effects.Add(key, 0f);
				}
				PotionEffectsConfig.Effects[key] = int.Parse(colonSeparatedValues2[1]);
			}
		}

		public bool HasValidRequirements()
		{
			return Requirements.Count <= 4;
		}
	}
	public enum PotionEffects
	{
		Weight,
		Portal,
		Fly,
		WaterSink,
		StaminaRegenMultiplier,
		HealthRegenMultiplier,
		Puke,
		HealthOverTime,
		StaminaOverTime,
		RunStaminaDrainModifier,
		JumpStaminaDrainModifier,
		Moder,
		Waterproof,
		[Obsolete("Use OnLandSpeedMultiplier")]
		Speed,
		OnLandSpeedMultiplier,
		RestedBonusPerComfortLevel,
		SwimDrainFactor,
		TickInterval,
		HealthPerTickMinHealthPercentage,
		HealthPerTick,
		HealthOverTimeDuration,
		HealthOverTimeInterval,
		StaminaOverTimeDuration,
		StaminaDrainPerSec,
		NoiseModifier,
		StealthModifier
	}
	[Serializable]
	public class PotionEffectsConfig
	{
		public Dictionary<SkillType, float> AttackModifiers { get; set; } = new Dictionary<SkillType, float>();


		public List<DamageModifierEntry> DamageModifiers { get; set; } = new List<DamageModifierEntry>();


		public Dictionary<PotionEffects, float> Effects { get; set; } = new Dictionary<PotionEffects, float>();


		public Dictionary<SkillType, float> RaiseSkillModifiers { get; set; } = new Dictionary<SkillType, float>();


		public bool ShouldSerializeAttackModifiers()
		{
			return AttackModifiers?.Any() ?? false;
		}

		public bool ShouldSerializeEffects()
		{
			return Effects?.Any() ?? false;
		}

		public bool ShouldSerializeDamageModifiers()
		{
			return DamageModifiers?.Any() ?? false;
		}

		public bool ShouldSerializeRaiseSkillModifiers()
		{
			return RaiseSkillModifiers?.Any() ?? false;
		}
	}
	public class PotionPrefabConfig : PrefabConfigExtended
	{
		public PotionPrefabConfig(PotionConfig potionConfig)
			: base(potionConfig, potionConfig.PotionPrefabName, "MeadTasty")
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_itemType = (ItemType)2;
			((CustomItem)this).ItemDrop.m_itemData.m_dropPrefab = ((CustomItem)this).ItemPrefab;
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_ammoType = "mead";
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_weight = 1f;
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_maxStackSize = 20;
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_icons[0] = PrefabUtils.GetSprite(base.PotionConfig.PotionPrefabName);
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_name = base.PotionConfig.ItemName;
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_description = base.PotionConfig.PotionDescription;
			StatusEffectExtended statusEffectExtended = CreateStatusEffect();
			ItemManager.Instance.AddStatusEffect(new CustomStatusEffect((StatusEffect)(object)statusEffectExtended, false));
			((CustomItem)this).ItemDrop.m_itemData.m_shared.m_consumeStatusEffect = (StatusEffect)(object)statusEffectExtended;
		}
	}
	public abstract class PrefabConfigExtended : CustomItem
	{
		public PotionConfig PotionConfig { get; }

		protected PrefabConfigExtended(PotionConfig potionConfig, string prefabName, string baseName)
			: base(prefabName, baseName)
		{
			PotionConfig = potionConfig;
		}

		protected StatusEffectExtended CreateStatusEffect()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			StatusEffectExtended statusEffectExtended = ScriptableObject.CreateInstance<StatusEffectExtended>();
			((Object)statusEffectExtended).name = (((StatusEffect)statusEffectExtended).m_name = PotionConfig.ItemName);
			((StatusEffect)statusEffectExtended).m_cooldownIcon = true;
			((StatusEffect)statusEffectExtended).m_icon = PrefabUtils.GetSprite(PotionConfig.PotionPrefabName);
			((StatusEffect)statusEffectExtended).m_startMessageType = (MessageType)2;
			((StatusEffect)statusEffectExtended).m_activationAnimation = "gpower";
			((StatusEffect)statusEffectExtended).m_ttl = PotionConfig.Duration;
			PotionEffectsConfig potionEffectsConfig2 = (statusEffectExtended.PotionEffectsConfig = PotionConfig.PotionEffectsConfig);
			((StatusEffect)statusEffectExtended).m_tooltip = PotionConfig.EffectTooltip;
			((StatusEffect)statusEffectExtended).m_startMessage = PotionConfig.ConsumptionMessage;
			((SE_Stats)statusEffectExtended).m_staminaRegenMultiplier = ((SE_Stats)statusEffectExtended).m_staminaRegenMultiplier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.StaminaRegenMultiplier);
			((SE_Stats)statusEffectExtended).m_healthRegenMultiplier = ((SE_Stats)statusEffectExtended).m_healthRegenMultiplier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthRegenMultiplier);
			((SE_Stats)statusEffectExtended).m_healthOverTime = ((SE_Stats)statusEffectExtended).m_healthOverTime + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthOverTime);
			((SE_Stats)statusEffectExtended).m_staminaOverTime = ((SE_Stats)statusEffectExtended).m_staminaOverTime + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.StaminaOverTime);
			((SE_Stats)statusEffectExtended).m_addMaxCarryWeight = ((SE_Stats)statusEffectExtended).m_addMaxCarryWeight + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.Weight);
			((SE_Stats)statusEffectExtended).m_runStaminaDrainModifier = ((SE_Stats)statusEffectExtended).m_runStaminaDrainModifier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.RunStaminaDrainModifier);
			((SE_Stats)statusEffectExtended).m_jumpStaminaUseModifier = ((SE_Stats)statusEffectExtended).m_jumpStaminaUseModifier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.JumpStaminaDrainModifier);
			((SE_Stats)statusEffectExtended).m_tickInterval = ((SE_Stats)statusEffectExtended).m_tickInterval + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.TickInterval);
			((SE_Stats)statusEffectExtended).m_healthPerTickMinHealthPercentage = ((SE_Stats)statusEffectExtended).m_healthPerTickMinHealthPercentage + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthPerTickMinHealthPercentage);
			((SE_Stats)statusEffectExtended).m_healthPerTick = ((SE_Stats)statusEffectExtended).m_healthPerTick + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthPerTick);
			((SE_Stats)statusEffectExtended).m_healthOverTimeDuration = ((SE_Stats)statusEffectExtended).m_healthOverTimeDuration + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthOverTimeDuration);
			((SE_Stats)statusEffectExtended).m_healthOverTimeInterval = DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.HealthOverTimeInterval);
			((SE_Stats)statusEffectExtended).m_staminaOverTimeDuration = ((SE_Stats)statusEffectExtended).m_staminaOverTimeDuration + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.StaminaOverTimeDuration);
			((SE_Stats)statusEffectExtended).m_staminaDrainPerSec = ((SE_Stats)statusEffectExtended).m_staminaDrainPerSec + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.StaminaDrainPerSec);
			((SE_Stats)statusEffectExtended).m_noiseModifier = ((SE_Stats)statusEffectExtended).m_noiseModifier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.NoiseModifier);
			((SE_Stats)statusEffectExtended).m_stealthModifier = ((SE_Stats)statusEffectExtended).m_stealthModifier + DictionaryExtensions.GetValueOrDefault(potionEffectsConfig2.Effects, PotionEffects.StealthModifier);
			if (potionEffectsConfig2.AttackModifiers.Any())
			{
				((SE_Stats)statusEffectExtended).m_modifyAttackSkill = potionEffectsConfig2.AttackModifiers.Keys.Aggregate((SkillType result, SkillType skillType) => (SkillType)(result | skillType));
			}
			if (potionEffectsConfig2.Effects.ContainsKey(PotionEffects.Moder))
			{
				((StatusEffect)statusEffectExtended).m_attributes = (StatusAttribute)4;
			}
			foreach (DamageModifierEntry damageModifier in potionEffectsConfig2.DamageModifiers)
			{
				((SE_Stats)statusEffectExtended).m_mods.Add(new DamageModPair
				{
					m_type = damageModifier.Type,
					m_modifier = damageModifier.Modifier
				});
			}
			if (potionEffectsConfig2.RaiseSkillModifiers.Any())
			{
				((SE_Stats)statusEffectExtended).m_raiseSkill = potionEffectsConfig2.RaiseSkillModifiers.Keys.Aggregate((SkillType result, SkillType skillType) => (SkillType)(result | skillType));
			}
			return statusEffectExtended;
		}
	}
	[Serializable]
	public class EnhancedPotionSettings
	{
		public int Version { get; set; } = 1;


		public bool Enabled { get; set; } = true;


		public List<PotionConfig> Recipes { get; set; } = new List<PotionConfig>();

	}
	public static class SettingsManager
	{
		private static readonly string DefaultSettingsFile = Path.Combine(PathHelper.GetInstance().GetPluginPath(), "DefaultEnhancedPotions.json");

		private static readonly string UserSettingsFile = Path.Combine(Paths.ConfigPath, "hbocao.EnhancedPotions.json");

		public static EnhancedPotionSettings Initialize()
		{
			if (!File.Exists(DefaultSettingsFile))
			{
				EnhancedPotions.MainLogger.LogWarning((object)("Enhanced Potions *default* settings file is missing (" + DefaultSettingsFile + "). This is unexpected. Going to try to use the player settings."));
			}
			bool flag = false;
			EnhancedPotionSettings enhancedPotionSettings = LoadSettings(DefaultSettingsFile);
			EnhancedPotionSettings enhancedPotionSettings2 = LoadSettings(UserSettingsFile, userSettingsFile: true);
			if (enhancedPotionSettings2 == null && enhancedPotionSettings != null)
			{
				EnhancedPotions.MainLogger.LogInfo((object)"Creating user settings from default settings...");
				BackupUserSettings();
				enhancedPotionSettings2 = enhancedPotionSettings;
				flag = true;
			}
			if (enhancedPotionSettings2?.Version < enhancedPotionSettings?.Version)
			{
				EnhancedPotions.MainLogger.LogInfo((object)"Updating user settings...");
				flag = true;
				BackupUserSettings();
				int version = enhancedPotionSettings2.Version;
				enhancedPotionSettings2.Version = enhancedPotionSettings.Version;
				PotionConfig userRecipe2;
				foreach (PotionConfig recipe in enhancedPotionSettings.Recipes)
				{
					PotionConfig defaultRecipe = recipe;
					foreach (PotionConfig item in enhancedPotionSettings2.Recipes.Where((PotionConfig userRecipe) => IsSamePotionConfig(userRecipe, defaultRecipe)))
					{
						userRecipe2 = item;
						if (userRecipe2.PotionEffectsConfig == null)
						{
							userRecipe2.PotionEffectsConfig = defaultRecipe.PotionEffectsConfig;
							IDictionary<PotionEffects, float> userEffects = userRecipe2.EffectsConfig;
							if (userEffects.Any())
							{
								userRecipe2.PotionEffectsConfig.Effects = userEffects.Keys.ToDictionary((PotionEffects key) => key, (PotionEffects key) => userEffects[key]);
								userRecipe2.EffectsConfig = null;
							}
						}
						float? num = null;
						if (userRecipe2.PotionEffectsConfig.Effects.ContainsKey(PotionEffects.Speed))
						{
							num = 1f + userRecipe2.PotionEffectsConfig.Effects[PotionEffects.Speed];
						}
						else if (defaultRecipe.PotionEffectsConfig.Effects.ContainsKey(PotionEffects.OnLandSpeedMultiplier))
						{
							num = defaultRecipe.PotionEffectsConfig.Effects[PotionEffects.OnLandSpeedMultiplier];
						}
						if (num.HasValue)
						{
							userRecipe2.PotionEffectsConfig.Effects.AddOrUpdate(PotionEffects.OnLandSpeedMultiplier, num.Value);
							userRecipe2.PotionEffectsConfig.Effects.Remove(PotionEffects.Speed);
						}
						if (version < 7)
						{
							if (IsSamePotionConfig(userRecipe2, "GreaterHealthMeadBase", "GreaterHealthPotion"))
							{
								UpdatePotionEffect(PotionEffects.HealthOverTimeDuration);
								UpdatePotionEffect(PotionEffects.HealthOverTimeInterval);
							}
							if (IsSamePotionConfig(userRecipe2, "GreaterStaminaMeadBase", "GreaterStaminaPotion"))
							{
								UpdatePotionEffect(PotionEffects.StaminaOverTimeDuration);
								UpdatePotionEffect(PotionEffects.StaminaOverTime);
							}
						}
					}
					if (!enhancedPotionSettings2.Recipes.Any((PotionConfig recipe) => IsSamePotionConfig(recipe, defaultRecipe)))
					{
						enhancedPotionSettings2.Recipes.Add(defaultRecipe);
					}
					void UpdatePotionEffect(PotionEffects potionEffects)
					{
						if (defaultRecipe.PotionEffectsConfig.Effects.ContainsKey(potionEffects))
						{
							userRecipe2.PotionEffectsConfig.Effects.AddOrUpdate(potionEffects, defaultRecipe.PotionEffectsConfig.Effects[potionEffects]);
						}
					}
				}
			}
			if (flag)
			{
				EnhancedPotions.MainLogger.LogInfo((object)"Saving user settings...");
				enhancedPotionSettings2.Save();
			}
			return enhancedPotionSettings2;
		}

		private static void BackupUserSettings()
		{
			if (File.Exists(UserSettingsFile))
			{
				File.Move(UserSettingsFile, UserSettingsFile + $".bkp_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}");
			}
		}

		private static bool IsSamePotionConfig(PotionConfig potionConfig, PotionConfig otherPotionConfig)
		{
			return IsSamePotionConfig(potionConfig, otherPotionConfig.MeadPrefabName, otherPotionConfig.PotionPrefabName);
		}

		private static bool IsSamePotionConfig(PotionConfig potionConfig, string meadPrefabName, string potionPrefabName)
		{
			if (potionConfig.MeadPrefabName.EqualsIgnoreCase(meadPrefabName))
			{
				return potionConfig.PotionPrefabName.EqualsIgnoreCase(potionPrefabName);
			}
			return false;
		}

		private static EnhancedPotionSettings LoadSettings(string settingsFile, bool userSettingsFile = false)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0053: Expected O, but got Unknown
			if (!File.Exists(settingsFile))
			{
				if (userSettingsFile)
				{
					EnhancedPotions.MainLogger.LogInfo((object)("Enhanced Potions settings file not found (" + settingsFile + "). Creating it."));
				}
				return null;
			}
			string text = string.Empty;
			try
			{
				text = File.ReadAllText(settingsFile);
				JsonSerializerSettings val = new JsonSerializerSettings
				{
					DefaultValueHandling = (DefaultValueHandling)1,
					Formatting = (Formatting)1,
					Culture = CultureInfo.InvariantCulture
				};
				return JsonConvert.DeserializeObject<EnhancedPotionSettings>(text, val);
			}
			catch (Exception arg)
			{
				EnhancedPotions.MainLogger.LogError((object)$"Error loading settings file. ({settingsFile}). Error: {arg} \n Contents: {text}");
				return null;
			}
		}

		public static void Save(this EnhancedPotionSettings settings)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			string contents = JsonConvert.SerializeObject((object)settings, new JsonSerializerSettings
			{
				DefaultValueHandling = (DefaultValueHandling)1,
				Formatting = (Formatting)1
			});
			File.WriteAllText(UserSettingsFile, contents);
		}

		public static void MigratePotionCfgFile(this EnhancedPotionSettings settings, PotionConfig potionConfig)
		{
			int num = settings.Recipes.FindIndex((PotionConfig p) => IsSamePotionConfig(p, potionConfig));
			if (num >= 0)
			{
				settings.Recipes[num] = potionConfig;
			}
		}
	}
	public class SimpleStringEnumConverter : JsonConverter
	{
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			if (value == null)
			{
				writer.WriteNull();
			}
			else
			{
				writer.WriteValue(value.ToString());
			}
		}

		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			string value = reader.Value?.ToString();
			if (string.IsNullOrWhiteSpace(value))
			{
				return null;
			}
			try
			{
				return Enum.Parse(objectType, value, ignoreCase: true);
			}
			catch
			{
				return null;
			}
		}

		public override bool CanConvert(Type objectType)
		{
			return objectType.IsEnum;
		}
	}
}