using System;
using System.Collections.Generic;
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 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.TheRatinFrozenDarkTraits")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("The Rat in Frozen Dark Traits, made by Shazixnar")]
[assembly: AssemblyFileVersion("1.1.8.0")]
[assembly: AssemblyInformationalVersion("1.1.8+5070cc5204eb5e8ca165628a7ce5d93ed3f3b73d")]
[assembly: AssemblyProduct("The Rat in Frozen Dark")]
[assembly: AssemblyTitle("com.shazixnar.TheRatinFrozenDarkTraits")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.8.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[3] { "zekdarkfeast", "zekcursepower", "zekfrozendark" };

		private static readonly Traits _instance = new Traits();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "IndirectDamage")]
		public static void IndirectDamagePrefix(ref Character __instance, ref int damage, ref DamageType damageType, ref string effect)
		{
			if ((int)damageType == 9 && AtOManager.Instance.TeamHaveTrait("zekdarkestabyss") && !__instance.IsHero && effect == "dark")
			{
				int auraCharges = __instance.GetAuraCharges("dark");
				damage += Functions.FuncRoundToInt((float)damage * 0.05f * (float)auraCharges);
				damage += Functions.FuncRoundToInt((float)damage * 0.3f);
			}
		}

		public static void myDoTrait(string trait, EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			switch (trait)
			{
			case "zekdarkfeast":
				_instance.zekdarkfeast(evt, character, target, auxInt, auxString, castedCard, trait);
				break;
			case "zekcursepower":
				_instance.zekcursepower(evt, character, target, auxInt, auxString, castedCard, trait);
				break;
			case "zekfrozendark":
				_instance.zekfrozendark(evt, character, target, auxInt, auxString, castedCard, trait);
				break;
			}
		}

		public void zekdarkfeast(EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard, string trait)
		{
			if (character == null || (Object)(object)character.HeroData == (Object)null)
			{
				return;
			}
			int num = character.EffectCharges("dark");
			int num2 = 0;
			if (num >= 5 && num < 20)
			{
				num2 = 1;
			}
			else if (num >= 20)
			{
				num2 = 2;
			}
			if (num2 <= 0)
			{
				return;
			}
			List<string> heroHand = MatchManager.Instance.GetHeroHand(character.HeroIndex);
			List<CardData> list = new List<CardData>();
			foreach (string item in heroHand)
			{
				CardData cardData = MatchManager.Instance.GetCardData(item, true);
				if (cardData.GetCardFinalCost() > 0)
				{
					list.Add(cardData);
				}
			}
			foreach (CardData item2 in list)
			{
				item2.EnergyReductionTemporal += num2;
				MatchManager.Instance.UpdateHandCards();
				CardItem cardFromTableByIndex = MatchManager.Instance.GetCardFromTableByIndex(item2.InternalId);
				if (cardFromTableByIndex != null)
				{
					cardFromTableByIndex.PlayDissolveParticle();
				}
				if (cardFromTableByIndex != null)
				{
					cardFromTableByIndex.ShowEnergyModification(-num2);
				}
				HeroItem heroItem = character.HeroItem;
				if (heroItem != null)
				{
					((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_Dark Feast", ""), (CombatScrollEffectType)7);
				}
				MatchManager.Instance.CreateLogCardModification(item2.InternalId, MatchManager.Instance.GetHero(character.HeroIndex));
			}
		}

		public void zekcursepower(EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard, string trait)
		{
			//IL_003b: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if (character != null && character.GetHp() > 0)
			{
				int num = Functions.FuncRoundToInt((float)auxInt * 0.15f);
				CardClass val = (CardClass)((!((Object)(object)castedCard != (Object)null)) ? 11 : ((int)castedCard.CardClass));
				num = character.HealWithCharacterBonus(num, val, 0);
				num = character.HealReceivedFinal(num, false, (CardData)null);
				character.ModifyHp(num, true, true);
				CastResolutionForCombatText val2 = new CastResolutionForCombatText
				{
					heal = num
				};
				if ((Object)(object)character.HeroItem != (Object)null)
				{
					((CharacterItem)character.HeroItem).ScrollCombatTextDamageNew(val2);
				}
				else if ((Object)(object)character.NPCItem != (Object)null)
				{
					((CharacterItem)character.NPCItem).ScrollCombatTextDamageNew(val2);
				}
			}
		}

		public void zekfrozendark(EventActivation evt, Character character, Character target, int auxInt, string auxString, CardData castedCard, string trait)
		{
			if (character == null || (Object)(object)castedCard == (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;
			}
			bool flag = castedCard.HasCardType((CardType)6);
			bool flag2 = castedCard.HasCardType((CardType)9);
			if ((!flag && !flag2) || (Object)(object)character.HeroData == (Object)null)
			{
				return;
			}
			MatchManager.Instance.activatedTraits[trait] = num + 1;
			MatchManager.Instance.SetTraitInfoText();
			if (flag)
			{
				character.ModifyEnergy(1, true);
				HeroItem heroItem = character.HeroItem;
				if (heroItem != null)
				{
					((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_Frozen Dark", "") + 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);
				NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
				NPC[] array = teamNPC;
				foreach (NPC val in array)
				{
					if (val != null && ((Character)val).Alive)
					{
						((Character)val).SetAuraTrait(character, "dark", 1);
					}
				}
			}
			else
			{
				if (!flag2)
				{
					return;
				}
				NPC[] teamNPC2 = MatchManager.Instance.GetTeamNPC();
				NPC[] array2 = teamNPC2;
				foreach (NPC val2 in array2)
				{
					if (val2 != null && ((Character)val2).Alive)
					{
						((Character)val2).SetAuraTrait(character, "scourge", 1);
						((Character)val2).SetAuraTrait(character, "chill", 1);
					}
				}
			}
		}

		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;
			}
			float num = 2f;
			if (_acId == "dark")
			{
				if (_type == "set")
				{
					if (!flag2)
					{
						if (__instance.TeamHaveTrait("zekdarkfeast"))
						{
							__result.ResistModifiedPercentagePerStack = -1.5f;
						}
						if (__instance.TeamHaveTrait("malukahshadowform"))
						{
							num += 0.5f;
						}
						if (__instance.TeamHavePerk("mainperkdark2c"))
						{
							num += 0.7f;
						}
						if (__instance.TeamHavePerk("mainperkChill2d"))
						{
							int auraCharges = _characterTarget.GetAuraCharges("chill");
							num += (float)(auraCharges / 20) * 0.1f;
						}
					}
					else if (flag2 && _characterTarget != null && __instance.CharacterHaveTrait(_characterTarget.SubclassName, "zekcursepower"))
					{
						__result.AuraDamageType = (DamageType)10;
						__result.ExplodeAtStacks = 44;
						__result.AuraDamageIncreasedPercentPerStack = 10f;
						__result.Removable = false;
						__result.ResistModifiedPercentagePerStack = 0f;
					}
				}
				else if (_type == "consume" && !flag)
				{
					if (__instance.TeamHaveTrait("malukahshadowform"))
					{
						num += 0.5f;
					}
					if (__instance.TeamHavePerk("mainperkdark2c"))
					{
						num += 0.7f;
					}
					if (__instance.TeamHavePerk("mainperkChill2d"))
					{
						int auraCharges2 = _characterCaster.GetAuraCharges("chill");
						num += (float)(auraCharges2 / 20) * 0.1f;
					}
				}
				__result.DamageWhenConsumedPerCharge = num;
			}
			else
			{
				if (!(_acId == "chill") || !(_type == "set"))
				{
					return;
				}
				if (!flag2)
				{
					if (__instance.TeamHaveTrait("zekfrozendark"))
					{
						__result.MaxCharges = 100;
						__result.MaxMadnessCharges = 100;
					}
				}
				else if (_characterTarget != null && __instance.CharacterHavePerk(_characterTarget.SubclassName, "mainperkChill2d"))
				{
					__result.CharacterStatChargesMultiplierNeededForOne = 5;
				}
			}
		}
	}
}
namespace TheRatinFrozenDark
{
	[BepInPlugin("com.shazixnar.TheRatinFrozenDarkTraits", "The Rat in Frozen Dark", "1.1.8")]
	[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.TheRatinFrozenDarkTraits");

		internal static ManualLogSource Log;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"com.shazixnar.TheRatinFrozenDarkTraits 1.1.8 has loaded!");
			Essentials.RegisterMod("The Rat in Frozen Dark", "Shazixnar", "Zek is better at curse or corrupting Cold cards now.", "1.1.8", 20251211, "https://across-the-obelisk.thunderstore.io/package/Shazixnar/The_Rat_in_Frozen_Dark/", (string[])null, "The Rat in Frozen Dark", 100, new string[5] { "content", "hero", "trait", "card", "perk" }, "", true);
			Essentials.medsTexts["custommainperkdark2c"] = "Dark explosion on enemies deals 0.7 more damage per charge.";
			Essentials.medsTexts["custommainperkchill2d"] = "Chill on enemies increases Dark explosion 0.1 more damage per 20 charges and this hero grants 1 Reinforce per 14 charges at the end of the turn.";
			harmony.PatchAll();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.shazixnar.TheRatinFrozenDarkTraits";

		public const string PLUGIN_NAME = "The Rat in Frozen Dark";

		public const string PLUGIN_VERSION = "1.1.8";
	}
}