using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using ConditionalConfigSync;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("IncreasedVitality")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("IncreasedVitality")]
[assembly: AssemblyTitle("IncreasedVitality")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 IncreasedVitality
{
	public enum BonusMode
	{
		Percent,
		Flat
	}
	[BepInPlugin("com.dreich.increasedvitality", "Increased Vitality", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class IncreasedVitalityPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.dreich.increasedvitality";

		public const string PluginName = "Increased Vitality";

		public const string PluginVersion = "1.0.0";

		internal const string ConfigSyncGuid = "_shudnal.ConditionalConfigSync";

		internal static bool ConfigSyncAvailable;

		internal static ConfigEntry<bool> Enabled;

		private static ConfigEntry<bool> lockConfigurationSetting;

		private static Harmony harmony;

		private void Awake()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			ConfigSyncAvailable = Chainloader.PluginInfos.ContainsKey("_shudnal.ConditionalConfigSync");
			if (ConfigSyncAvailable)
			{
				ConfigSyncCompat.Initialize("com.dreich.increasedvitality", "Increased Vitality", "1.0.0");
			}
			lockConfigurationSetting = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Lock Configuration", true, "If on, the configuration is locked and can be changed by server admins only. Requires ConditionalConfigSync.");
			if (ConfigSyncAvailable)
			{
				ConfigSyncCompat.AddLockingConfigEntry(lockConfigurationSetting);
			}
			Enabled = BindServerControlled("General", "Enabled", defaultValue: true, "If on, creatures get extra health based on the biome they are in.");
			BonusSettings.Bind(this);
			harmony = new Harmony("com.dreich.increasedvitality");
			harmony.PatchAll();
		}

		internal ConfigEntry<T> BindServerControlled<T>(string section, string key, T defaultValue, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return BindServerControlled(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		internal ConfigEntry<T> BindServerControlled<T>(string section, string key, T defaultValue, ConfigDescription description)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(section, key, defaultValue, description);
			if (ConfigSyncAvailable)
			{
				ConfigSyncCompat.AddServerControlled<T>(val);
			}
			return val;
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			harmony = null;
		}
	}
	internal class HealthBonus
	{
		internal ConfigEntry<bool> Enabled;

		internal ConfigEntry<BonusMode> Mode;

		internal ConfigEntry<float> Minimum;

		internal ConfigEntry<float> Maximum;

		internal ConfigEntry<float> PerStar;
	}
	internal static class BonusSettings
	{
		private struct BiomeDefault
		{
			internal Biome Biome;

			internal string Section;

			internal float Minimum;

			internal float Maximum;
		}

		private const float SmallestBonus = 0f;

		private const float LargestBonus = 10000f;

		private const float DefaultPerStar = 10f;

		private const float DefaultBossMinimum = 25f;

		private const float DefaultBossMaximum = 50f;

		private const float DefaultTamedMinimum = 10f;

		private const float DefaultTamedMaximum = 20f;

		private const string BossSection = "10 - Bosses";

		private const string TamedSection = "11 - Tamed creatures";

		private static readonly AcceptableValueRange<float> BonusRange = new AcceptableValueRange<float>(0f, 10000f);

		private static readonly Dictionary<Biome, HealthBonus> biomeBonuses = new Dictionary<Biome, HealthBonus>();

		internal static HealthBonus Bosses;

		internal static HealthBonus Tamed;

		private static readonly BiomeDefault[] Defaults = new BiomeDefault[9]
		{
			new BiomeDefault
			{
				Biome = (Biome)1,
				Section = "1 - Meadows",
				Minimum = 0f,
				Maximum = 10f
			},
			new BiomeDefault
			{
				Biome = (Biome)8,
				Section = "2 - Black Forest",
				Minimum = 10f,
				Maximum = 20f
			},
			new BiomeDefault
			{
				Biome = (Biome)2,
				Section = "3 - Swamp",
				Minimum = 15f,
				Maximum = 30f
			},
			new BiomeDefault
			{
				Biome = (Biome)4,
				Section = "4 - Mountain",
				Minimum = 20f,
				Maximum = 35f
			},
			new BiomeDefault
			{
				Biome = (Biome)16,
				Section = "5 - Plains",
				Minimum = 25f,
				Maximum = 40f
			},
			new BiomeDefault
			{
				Biome = (Biome)512,
				Section = "6 - Mistlands",
				Minimum = 30f,
				Maximum = 50f
			},
			new BiomeDefault
			{
				Biome = (Biome)32,
				Section = "7 - Ashlands",
				Minimum = 35f,
				Maximum = 55f
			},
			new BiomeDefault
			{
				Biome = (Biome)64,
				Section = "8 - Deep North",
				Minimum = 40f,
				Maximum = 60f
			},
			new BiomeDefault
			{
				Biome = (Biome)256,
				Section = "9 - Ocean",
				Minimum = 10f,
				Maximum = 25f
			}
		};

		internal static void Bind(IncreasedVitalityPlugin plugin)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			BiomeDefault[] defaults = Defaults;
			for (int i = 0; i < defaults.Length; i++)
			{
				BiomeDefault biomeDefault = defaults[i];
				biomeBonuses[biomeDefault.Biome] = BindBonus(plugin, biomeDefault.Section, biomeDefault.Minimum, biomeDefault.Maximum, "If on, creatures in this biome get extra health.");
			}
			Bosses = BindBonus(plugin, "10 - Bosses", 25f, 50f, "If on, bosses get this bonus instead of their biome's bonus. If off, bosses keep their normal health.");
			Tamed = BindBonus(plugin, "11 - Tamed creatures", 10f, 20f, "If on, tamed creatures get this bonus instead of their biome's bonus. If off, tamed creatures keep their normal health.");
		}

		private static HealthBonus BindBonus(IncreasedVitalityPlugin plugin, string section, float minimum, float maximum, string enabledDescription)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			return new HealthBonus
			{
				Enabled = plugin.BindServerControlled(section, "Enabled", defaultValue: true, enabledDescription),
				Mode = plugin.BindServerControlled(section, "Mode", BonusMode.Percent, "Percent: the bonus is a percentage of the creature's normal health. Flat: the bonus is added as health points."),
				Minimum = plugin.BindServerControlled(section, "Minimum bonus", minimum, new ConfigDescription("Smallest bonus a creature can roll. Set minimum and maximum the same for a fixed bonus.", (AcceptableValueBase)(object)BonusRange, Array.Empty<object>())),
				Maximum = plugin.BindServerControlled(section, "Maximum bonus", maximum, new ConfigDescription("Largest bonus a creature can roll.", (AcceptableValueBase)(object)BonusRange, Array.Empty<object>())),
				PerStar = plugin.BindServerControlled(section, "Bonus per star", 10f, new ConfigDescription("Extra bonus added for each star the creature has, on top of the vanilla star health.", (AcceptableValueBase)(object)BonusRange, Array.Empty<object>()))
			};
		}

		internal static HealthBonus For(Character character)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (character.IsBoss())
			{
				return Bosses;
			}
			if (character.IsTamed())
			{
				return Tamed;
			}
			Biome key = VitalityCalculator.FindBiome(((Component)character).transform.position);
			if (!biomeBonuses.TryGetValue(key, out var value))
			{
				return null;
			}
			return value;
		}
	}
	internal static class VitalityCalculator
	{
		private const float Percent = 100f;

		private const int NoStarLevel = 1;

		internal static Biome FindBiome(Vector3 position)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			if (WorldGenerator.instance != null)
			{
				return WorldGenerator.instance.GetBiome(position);
			}
			return Heightmap.FindBiome(position);
		}

		internal static float RollFor(ZDO zdo)
		{
			return (float)new Random(((object)Unsafe.As<ZDOID, ZDOID>(ref zdo.m_uid)/*cast due to .constrained prefix*/).GetHashCode()).NextDouble();
		}

		internal static float Boost(float normalHealth, int level, HealthBonus bonus, float roll)
		{
			float num = Mathf.Min(bonus.Minimum.Value, bonus.Maximum.Value);
			float num2 = Mathf.Max(bonus.Minimum.Value, bonus.Maximum.Value);
			int num3 = Mathf.Max(0, level - 1);
			float num4 = Mathf.Lerp(num, num2, roll) + bonus.PerStar.Value * (float)num3;
			if (bonus.Mode.Value == BonusMode.Flat)
			{
				return normalHealth + num4;
			}
			return normalHealth * (1f + num4 / 100f);
		}
	}
	[HarmonyPatch(typeof(Character), "SetupMaxHealth")]
	internal static class SetupMaxHealthPatch
	{
		private static void Prefix(Character __instance, out bool __state)
		{
			__state = __instance.GetHealth() >= __instance.GetMaxHealth();
		}

		private static void Postfix(Character __instance, ZNetView ___m_nview, bool __state)
		{
			if (!IncreasedVitalityPlugin.Enabled.Value || __instance.IsPlayer())
			{
				return;
			}
			ZDO val = (((Object)(object)___m_nview != (Object)null) ? ___m_nview.GetZDO() : null);
			if (val == null)
			{
				return;
			}
			HealthBonus healthBonus = BonusSettings.For(__instance);
			if (healthBonus == null || !healthBonus.Enabled.Value)
			{
				return;
			}
			float maxHealth = __instance.GetMaxHealth();
			float num = VitalityCalculator.Boost(maxHealth, __instance.GetLevel(), healthBonus, VitalityCalculator.RollFor(val));
			if (!(num <= maxHealth))
			{
				__instance.SetMaxHealth(num);
				if (__state && ___m_nview.IsOwner())
				{
					__instance.SetHealth(num);
				}
			}
		}
	}
	internal static class ConfigSyncCompat
	{
		private static object configSync;

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void Initialize(string guid, string name, string version)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			configSync = (object)new ConfigSync(guid)
			{
				DisplayName = name,
				CurrentVersion = version,
				MinimumRequiredVersion = version,
				ModRequired = true
			};
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void AddLockingConfigEntry(ConfigEntry<bool> entry)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			((ConditionalConfigSync)(ConfigSync)configSync).AddLockingConfigEntry<bool>(entry);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void AddServerControlled<T>(ConfigEntry<T> entry)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			((ConditionalConfigSync)(ConfigSync)configSync).AddConfigEntry<T>(entry, (ConfigSyncMode)0);
		}
	}
}