using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Obeliskial_Essentials;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.shazixnar.RealVoodooWitchTraits")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Real Voodoo Witch Traits, made by Shazixnar")]
[assembly: AssemblyFileVersion("1.1.4.0")]
[assembly: AssemblyInformationalVersion("1.1.4+2ad297b2ef835e85e65422d9f46917e0798ac638")]
[assembly: AssemblyProduct("Real Voodoo Witch Malukah")]
[assembly: AssemblyTitle("com.shazixnar.RealVoodooWitchTraits")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.4.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 TraitMod
{
	[HarmonyPatch]
	internal class Traits
	{
		[HarmonyPatch(typeof(Trait), "DoTrait")]
		public static class Trait_DoTrait_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(EventActivation __0, string __1, Character __2, Character __3, int __4, string __5, CardData __6, Trait __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (myTraitList.Contains(__1))
				{
					myDoTrait(__1, __0, __2, __3, __4, __5, __6);
					return false;
				}
				return true;
			}
		}

		public static string[] myTraitList = new string[2] { "shazixnarjinx", "shazixnarhealingbrew" };

		private static readonly Traits _instance = new Traits();

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "DamageBonus")]
		public static void DamageBonusPostfix(ref Character __instance, ref float[] __result)
		{
			if (AtOManager.Instance.TeamHaveTrait("shazixnarhealingbrew") && __instance.GetMaxHP() > 120 && __instance.IsHero)
			{
				int num = __instance.GetMaxHP() - 120;
				if (num >= 9)
				{
					__result[0] += (float)((double)((float)num / 9f) * 0.2);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitDamagePercentModifiers")]
		public static void GetTraitDamagePercentModifiersPostfix(ref Character __instance, ref float __result)
		{
			if (AtOManager.Instance.TeamHaveTrait("shazixnarhealingbrew") && __instance.GetMaxHP() > 120 && __instance.IsHero)
			{
				int num = __instance.GetMaxHP() - 120;
				if (num >= 9)
				{
					float num2 = (float)num / 9f;
					float num3 = 2f;
					__result += num2 * num3;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "HealReceivedBonus")]
		public static void HealReceivedPostfix(ref Character __instance, ref float[] __result)
		{
			if (AtOManager.Instance.TeamHaveTrait("shazixnarhealingbrew") && __instance.GetMaxHP() > 120 && __instance.IsHero)
			{
				int num = __instance.GetMaxHP() - 120;
				if (num >= 9)
				{
					__result[0] += (float)((double)((float)num / 9f) * 0.2);
					__result[1] += (float)num / 9f * 2f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CardData), "SetDescriptionNew")]
		public static void SetDescriptionNewPostfix(ref CardData __instance)
		{
			if ((Object)(object)__instance.Item != (Object)null && __instance.Item.AuracurseCustomString == "itemCustomTextExplodeChargesMonsters")
			{
				if (__instance.Item.AuracurseCustomModValue1 - 25 >= 0)
				{
					__instance.DescriptionNormalized = Regex.Replace(__instance.DescriptionNormalized, "monsters explode at [0-9]*", "monsters explosion charges <color=#263ABC><size=+.1>+" + (__instance.Item.AuracurseCustomModValue1 - 25) + "</color></size> stacks");
				}
				else if (__instance.Item.AuracurseCustomModValue1 - 25 < 0)
				{
					__instance.DescriptionNormalized = Regex.Replace(__instance.DescriptionNormalized, "monsters explode at [0-9]*", "monsters explosion charges <color=#263ABC><size=+.1>-" + (25 - __instance.Item.AuracurseCustomModValue1) + "</color></size> stacks");
				}
			}
		}

		public static void myDoTrait(string trait, EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!(trait == "shazixnarjinx"))
			{
				if (trait == "shazixnarhealingbrew")
				{
					_instance.shazixnarhealingbrew(evt, character, target, auxInt, auxString, castedCard, trait);
				}
			}
			else
			{
				_instance.shazixnarjinx(evt, character, target, auxInt, auxString, castedCard, trait);
			}
		}

		public void shazixnarjinx(EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard, string trait)
		{
			if (character != null && target != null && target.Alive)
			{
				target.SetAuraTrait(character, "dark", 2);
				target.SetAuraTrait(character, "poison", 2);
				HeroItem heroItem = character.HeroItem;
				if (heroItem != null)
				{
					((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_Jinx", ""), (CombatScrollEffectType)7);
				}
			}
		}

		public void shazixnarhealingbrew(EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard, string trait)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (character == null || (Object)(object)castedCard == (Object)null || (int)evt != 7 || MatchManager.Instance.energyJustWastedByHero <= 0 || (!castedCard.HasCardType((CardType)12) && !castedCard.HasCardType((CardType)9)) || (Object)(object)character.HeroData == (Object)null)
			{
				return;
			}
			TraitData traitData = Globals.Instance.GetTraitData(trait);
			int num = (MatchManager.Instance.activatedTraits.ContainsKey(trait) ? MatchManager.Instance.activatedTraits[trait] : 0);
			if (num >= traitData.TimesPerTurn)
			{
				return;
			}
			MatchManager.Instance.activatedTraits[trait] = num + 1;
			MatchManager.Instance.SetTraitInfoText();
			character.ModifyEnergy(1, true);
			HeroItem heroItem = character.HeroItem;
			if (heroItem != null)
			{
				((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_Healing Brew", "") + Functions.TextChargesLeft(num + 1, traitData.TimesPerTurn), (CombatScrollEffectType)7);
			}
			EffectsManager instance = EffectsManager.Instance;
			HeroItem heroItem2 = character.HeroItem;
			instance.PlayEffectAC("energy", true, (heroItem2 != null) ? ((CharacterItem)heroItem2).CharImageT : null, false, 0f, false);
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			Hero val = null;
			int num2 = int.MaxValue;
			Hero[] array = teamHero;
			foreach (Hero val2 in array)
			{
				if (val2 != null && (Object)(object)((Character)val2).HeroData != (Object)null && ((Character)val2).Alive && ((Character)val2).HpCurrent < num2)
				{
					num2 = ((Character)val2).HpCurrent;
					val = val2;
				}
			}
			if (val != null)
			{
				((Character)val).SetAuraTrait(character, "regeneration", 2);
				((Character)val).SetAuraTrait(character, "vitality", 1);
				if ((Object)(object)((Character)val).HeroItem != (Object)null)
				{
					EffectsManager.Instance.PlayEffectAC("regeneration", true, ((CharacterItem)((Character)val).HeroItem).CharImageT, false, 0f, false);
					EffectsManager.Instance.PlayEffectAC("vitality", true, ((CharacterItem)((Character)val).HeroItem).CharImageT, false, 0f, false);
				}
			}
		}

		public static string TextChargesLeft(int currentCharges, int chargesTotal)
		{
			int num = currentCharges;
			int num2 = chargesTotal;
			return "<br><color=#FFF>" + num + "/" + num2 + "</color>";
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GlobalAuraCurseModificationByTraitsAndItems")]
		public static void GlobalAuraCurseModificationByTraitsAndItemsPostfix(ref AtOManager __instance, ref AuraCurseData __result, string _type, string _acId, Character _characterCaster, Character _characterTarget)
		{
			bool flag = false;
			bool flag2 = false;
			if (_characterCaster != null && _characterCaster.IsHero)
			{
				flag = _characterCaster.IsHero;
			}
			if (_characterTarget != null && _characterTarget.IsHero)
			{
				flag2 = true;
			}
			if (_acId == "dark")
			{
				int num = 25;
				if (_type == "set")
				{
					float num2 = 2f;
					if (!flag2)
					{
						if (__instance.TeamHaveItem("thedarkone", 0, true))
						{
							num += Globals.Instance.GetItemData("thedarkone").AuracurseCustomModValue1 - 25;
						}
						if (__instance.TeamHaveItem("blackdeck", 0, true))
						{
							num += Globals.Instance.GetItemData("blackdeck").AuracurseCustomModValue1 - 25;
						}
						if (__instance.TeamHaveItem("cupofdeath", 0, true))
						{
							num += Globals.Instance.GetItemData("cupofdeath").AuracurseCustomModValue1 - 25;
						}
						if (__instance.TeamHaveTrait("shazixnarshadowform"))
						{
							num += 5;
							num2 += 0.5f;
						}
						if (__instance.TeamHavePerk("mainperkdark2c"))
						{
							num2 += 0.7f;
						}
						__result.ExplodeAtStacks = num;
						__result.DamageWhenConsumedPerCharge = num2;
					}
				}
				else
				{
					if (!(_type == "consume"))
					{
						return;
					}
					float num3 = 2f;
					if (!flag)
					{
						if (__instance.TeamHaveTrait("shazixnarshadowform"))
						{
							num3 += 0.5f;
						}
						if (__instance.TeamHavePerk("mainperkdark2c"))
						{
							num3 += 0.7f;
						}
						__result.DamageWhenConsumedPerCharge = num3;
					}
				}
			}
			else if (_acId == "sharp" && _type == "set" && flag2)
			{
				if (__instance.TeamHavePerk("mainperkSharp1d"))
				{
					__result.AuraDamageType3 = (DamageType)9;
					__result.AuraDamageIncreasedPerStack3 = 1f;
				}
				if (__instance.TeamHaveTrait("shrilltone"))
				{
					__result.AuraDamageType4 = (DamageType)7;
					__result.AuraDamageIncreasedPerStack4 = 1f;
				}
			}
			else if (_acId == "regeneration" && _type == "set" && flag2)
			{
				if (__instance.TeamHavePerk("mainperkregeneration1c"))
				{
					__result.ResistModified = (DamageType)10;
					__result.ResistModifiedPercentagePerStack = 0.5f;
					__result.CharacterStatModified = (CharacterStat)1;
					__result.CharacterStatModifiedValuePerStack = 1f;
				}
				if (__instance.TeamHaveTrait("shazixnarjinx"))
				{
					__result.AuraDamageType = (DamageType)9;
					__result.AuraDamageIncreasedPerStack = 0.5f;
				}
				if (__instance.TeamHaveTrait("shazixnarmojo"))
				{
					__result.MaxMadnessCharges = 75;
				}
			}
			else if (_acId == "vitality" && _type == "set" && flag2)
			{
				if (__instance.TeamHaveTrait("shazixnarmojo"))
				{
					__result.MaxMadnessCharges = 75;
				}
				if (__instance.TeamHavePerk("mainperkvitality1a") && _characterTarget != null)
				{
					__result.CharacterStatModifiedValuePerStack = 8f;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "SetEvent")]
		public static void SetEventPrefix(ref Character __instance, ref EventActivation theEvent, Character target = null)
		{
		}
	}
}
namespace RealVoodooWitchMalukah
{
	[BepInPlugin("com.shazixnar.RealVoodooWitchTraits", "Real Voodoo Witch Malukah", "1.1.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("AcrossTheObelisk.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal const int ModDate = 20251211;

		private readonly Harmony harmony = new Harmony("com.shazixnar.RealVoodooWitchTraits");

		internal static ManualLogSource Log;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"com.shazixnar.RealVoodooWitchTraits 1.1.4 has loaded!");
			Essentials.RegisterMod("Real Voodoo Witch Malukah", "Shazixnar", "Make Malukah gain more curse or support.", "1.1.4", 20251211, "https://across-the-obelisk.thunderstore.io/package/Shazixnar/Real_Voodoo_Witch_Malukah/", (string[])null, "Real Voodoo Witch Malukah", 100, new string[5] { "content", "hero", "trait", "card", "perk" }, "", true);
			Essentials.medsTexts["custommainperksharp1d"] = "Sharp on heroes also increases the Shadow damage by 1 per charge.";
			Essentials.medsTexts["custommainperkregeneration1c"] = "Regeneration on heroes also increases all resistance by 0.5% per charge and increases Max HP by 1 per charge.";
			Essentials.medsTexts["custommainperkvitality1a"] = "Vitality on heroes instead increases Max HP by 8 per charge.";
			Essentials.medsTexts["custommainperkdark2c"] = "Dark explosion on enemies deals 0.7 more damage per charge.";
			harmony.PatchAll();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.shazixnar.RealVoodooWitchTraits";

		public const string PLUGIN_NAME = "Real Voodoo Witch Malukah";

		public const string PLUGIN_VERSION = "1.1.4";
	}
}