using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SkillLimitExtenderDamagePatch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SkillLimitExtenderDamagePatch")]
[assembly: AssemblyTitle("SkillLimitExtenderDamagePatch")]
[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 SkillLimitExtenderDamagePatch
{
	[BepInPlugin("snuffy.skilllimitextenderdamagepatch", "Skill Limit Extender Damage Patch", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Skills), "GetRandomSkillRange")]
		private static class GetRandomSkillRangePatch
		{
			private static bool Prefix(Skills __instance, ref float min, ref float max, SkillType skillType)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				float skillFactor = __instance.GetSkillFactor(skillType);
				GetDamageRange(skillFactor, out min, out max);
				if (skillFactor > 1f)
				{
					GetExtendedDamageMultiplier(skillFactor);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Skills), "GetRandomSkillFactor", new Type[] { typeof(SkillType) })]
		private static class GetRandomSkillFactorPatch
		{
			private static bool Prefix(Skills __instance, SkillType skillType, ref float __result)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				float skillFactor = __instance.GetSkillFactor(skillType);
				GetDamageRange(skillFactor, out var min, out var max);
				__result = Mathf.Lerp(min, max, Random.value);
				if (skillFactor > 1f)
				{
					GetExtendedDamageMultiplier(skillFactor);
				}
				return false;
			}
		}

		internal static ManualLogSource Log;

		private static ConfigEntry<int> ReferenceSkillLevel;

		private static ConfigEntry<float> ReferenceDamageMultiplier;

		private static ConfigEntry<float> VanillaDamageMultiplier;

		private static ConfigEntry<float> VanillaDamageExponent;

		private void Awake()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			ReferenceSkillLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Damage", "ReferenceSkillLevel", 200, "The skill level at which the extended damage curve reaches ReferenceDamageMultiplier.\nFor example, with ReferenceSkillLevel = 200 and ReferenceDamageMultiplier = 1.5,\nthe damage at skill level 200 will be 1.5 times the damage at skill level 100.\nThe multiplier follows an exponential curve:\n    multiplier = (level / 100) ^ exponent\nThe exponent is calculated automatically from ReferenceSkillLevel\nand ReferenceDamageMultiplier.");
			ReferenceDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Damage", "ReferenceDamageMultiplier", 1.5f, "The damage multiplier reached at ReferenceSkillLevel.\nFor example, 1.5 means that at skill level 200 the damage will be\n150% of the damage at skill level 100\n1.0 means that no additional damage increase is applied above skill level 100.");
			VanillaDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Damage", "VanillaDamageMultiplier", 1f, "Controls how much of the vanilla skill-based damage increase is applied.\n1.0 preserves the full vanilla damage increase.\n0.5 means skills provide 50% of their normal additional damage.\n0.0 means skill level does not increase the center damage factor at all.\nThis does NOT multiply the entire weapon damage.\nInstead, it modifies only the damage increase provided by skill levels.\nFormula:\n    center = 0.4 + 0.6 * ((level / 100) ^ VanillaDamageExponent) * VanillaDamageMultiplier\nThe resulting damage at level 100 becomes the baseline for all levels above 100.");
			VanillaDamageExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Damage", "VanillaDamageExponent", 1f, "Controls the shape of the skill-damage progression from level 0 to 100.\n1.0 preserves the vanilla progression shape.\nValues above 1.0 make damage increase more slowly at lower skill levels\nand catch up toward level 100.\nValues below 1.0 make damage increase faster at lower skill levels.\nThis value changes the progression curve but does not directly control\nthe final level-100 damage; VanillaDamageMultiplier controls that.\nFormula:\n    progression = (level / 100) ^ VanillaDamageExponent");
			new Harmony("snuffy.skilllimitextenderdamagepatch").PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"SkillLimitExtenderDamagePatch loaded!");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"VanillaDamageMultiplier = {VanillaDamageMultiplier.Value:F3}");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"VanillaDamageExponent = {VanillaDamageExponent.Value:F3}");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"ReferenceSkillLevel = {ReferenceSkillLevel.Value}");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"ReferenceDamageMultiplier = {ReferenceDamageMultiplier.Value:F3}");
		}

		internal static void LogStatic(string message)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)message);
			}
		}

		internal static float GetBaseDamageCenter(float skillFactor)
		{
			float num = Mathf.Clamp01(skillFactor);
			float num2 = VanillaDamageMultiplier.Value;
			float num3 = VanillaDamageExponent.Value;
			if (num2 < 0f)
			{
				num2 = 0f;
			}
			if (num3 <= 0f)
			{
				num3 = 1f;
			}
			float num4 = Mathf.Pow(num, num3);
			return 0.4f + 0.6f * num4 * num2;
		}

		internal static void GetBaseDamageRange(float skillFactor, out float min, out float max)
		{
			float baseDamageCenter = GetBaseDamageCenter(skillFactor);
			min = Mathf.Clamp01(baseDamageCenter - 0.15f);
			max = Mathf.Clamp01(baseDamageCenter + 0.15f);
		}

		internal static float GetExtendedDamageMultiplier(float skillFactor)
		{
			if (skillFactor <= 1f)
			{
				return 1f;
			}
			float num = (float)ReferenceSkillLevel.Value / 100f;
			float num2 = ReferenceDamageMultiplier.Value;
			if (num <= 1f)
			{
				num = 2f;
			}
			if (num2 <= 0f)
			{
				num2 = 1f;
			}
			if (Mathf.Approximately(num2, 1f))
			{
				return 1f;
			}
			float num3 = Mathf.Log(num2) / Mathf.Log(num);
			return Mathf.Pow(skillFactor, num3);
		}

		internal static void GetDamageRange(float skillFactor, out float min, out float max)
		{
			if (skillFactor <= 1f)
			{
				GetBaseDamageRange(skillFactor, out min, out max);
				return;
			}
			GetBaseDamageRange(1f, out var min2, out var max2);
			float extendedDamageMultiplier = GetExtendedDamageMultiplier(skillFactor);
			min = min2 * extendedDamageMultiplier;
			max = max2 * extendedDamageMultiplier;
		}
	}
}