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.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[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("BuffsTimer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2+a20da1e04cd8f2eae27dd43288f4eed370f046a5")]
[assembly: AssemblyProduct("Buffs Timer")]
[assembly: AssemblyTitle("BuffsTimer")]
[assembly: AssemblyVersion("1.1.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BuffsTimer
{
	public static class BuffNames
	{
		public static Dictionary<string, string> Dict;

		static BuffNames()
		{
			Dict = new Dictionary<string, string>
			{
				{ "addJump", "Jump higher" },
				{ "addSpeed", "Run faster" },
				{ "addClimb", "Climb faster" },
				{ "addGripStrength", "Increased grip strength" },
				{ "pilled", "Decreased stamina consumption" },
				{ "addStrike", "Increased melee damage" },
				{ "addHammer", "Increased piton-hammering ability" },
				{ "gripResist", "Reduced grip loss" },
				{ "damageResist", "Increased damage resist" },
				{ "regenerateGripStrength", "Increased stamina regeneration" },
				{ "addClimbSpeed", "Climb faster" },
				{ "roided", "Climb faster (???)" },
				{ "grabAnything", "Grab any surface" },
				{ "addStaminaRegen", "Stamina regen faster" },
				{ "addReach", "Long arm" },
				{ "boosted", "Boosted (How?)" },
				{ "divideJumpStrain", "Divides climb-jumps cost" },
				{ "addGravity", "Gravity changed" },
				{ "addExtraJumps", "Extra jump" }
			};
		}
	}
	public class BuffsMonitorComponent : MonoBehaviour
	{
		private Text _targetText;

		public void Setup(Text targetText)
		{
			_targetText = targetText;
		}

		private void FixedUpdate()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (Plugin.Buffs.Count > 0)
			{
				foreach (ItemBuff buff in Plugin.Buffs)
				{
					if (buff.IsBuffEnded())
					{
						return;
					}
					stringBuilder.AppendLine(buff.ToString());
					List<BuffStat> buffs = buff.GetBuffs();
					foreach (BuffStat item in buffs.Where((BuffStat b) => Math.Round(b.Amount, 2) != 0.0))
					{
						if (BuffNames.Dict.TryGetValue(item.BuffId, out string value))
						{
							stringBuilder.AppendLine($"\t<color=\"lightblue\">{value} {item.Amount:F2} ({item.MaxAmount:F2})</color>");
						}
					}
				}
			}
			_targetText.text = stringBuilder.ToString();
		}
	}
	[HarmonyPatch(typeof(HandItem_Buff))]
	public class HandItem_BuffP
	{
		[HarmonyPostfix]
		[HarmonyPatch("Activate")]
		public static void Postfix(HandItem_Buff __instance)
		{
			string prefabName = ((HandItem)__instance).item.prefabName;
			Plugin.Logger.LogInfo((object)prefabName);
			BuffContainer buff = __instance.buff;
			if (Plugin.Buffs.Any((ItemBuff b) => b.ItemPrefabName.Equals(prefabName)))
			{
				Plugin.Buffs.FirstOrDefault((ItemBuff b) => b.ItemPrefabName.Equals(prefabName))?.Buffs.Add(buff);
			}
			else
			{
				Plugin.AddBuff(prefabName, buff);
			}
		}
	}
	[HarmonyPatch(typeof(HandItem_Buff_Grub))]
	public class HandItem_Buff_GrubP
	{
		[HarmonyPostfix]
		[HarmonyPatch("Activate")]
		public static void Postfix(HandItem_Buff_Grub __instance)
		{
			if (!__instance.CanPet())
			{
				return;
			}
			string prefabName = ((HandItem)__instance).item.prefabName;
			BuffContainer buffContainer = __instance.grubPetBuff;
			ItemBuff itemBuff = Plugin.Buffs.FirstOrDefault((ItemBuff b) => b.Buffs.Any((BuffContainer bc) => bc.id == buffContainer.id));
			if (itemBuff == null)
			{
				Plugin.AddBuff(prefabName, buffContainer);
			}
		}
	}
	[HarmonyPatch(typeof(HandItem_Food))]
	public class HandItem_FoodP
	{
		[HarmonyPostfix]
		[HarmonyPatch("Eat")]
		public static void Postfix(HandItem_Food __instance)
		{
			if (!__instance.useBuff)
			{
				return;
			}
			string prefabName = ((HandItem)__instance).item.prefabName;
			if (Plugin.Buffs.Any((ItemBuff b) => (b.ItemPrefabName.Contains("Item_Milk") && prefabName.Contains("Item_Cocoa")) || (b.ItemPrefabName.Contains("Item_Cocoa") && prefabName.Contains("Item_Milk"))))
			{
				return;
			}
			BuffContainer buff = __instance.buff;
			ItemBuff itemBuff = Plugin.Buffs.FirstOrDefault((ItemBuff b) => b.ItemPrefabName.Equals("Item_Beans_Periphery"));
			if (itemBuff != null)
			{
				itemBuff.Buffs[0] = buff;
			}
			else if (Plugin.Buffs.Any((ItemBuff b) => b.ItemPrefabName.Equals(prefabName)))
			{
				Plugin.Buffs.FirstOrDefault((ItemBuff b) => b.ItemPrefabName.Equals(prefabName))?.Buffs.Add(buff);
			}
			else
			{
				Plugin.AddBuff(prefabName, buff);
			}
		}
	}
	public class ItemBuff
	{
		private readonly string _itemNameFormated;

		public string ItemPrefabName { get; }

		public List<BuffContainer> Buffs { get; }

		public ItemBuff(string itemName, BuffContainer buff)
		{
			ItemPrefabName = itemName;
			_itemNameFormated = ItemPrefabName.Replace('_', ' ').Replace("Item", "").Replace("Denizen", "")
				.Replace("Empty", "");
			Buffs = new List<BuffContainer>(1) { buff };
		}

		public override string ToString()
		{
			float timer = GetTimer();
			return $"{_itemNameFormated}: {timer:F2}s";
		}

		public bool IsBuffEnded()
		{
			if (!((double)GetTimer() <= 0.01))
			{
				return false;
			}
			Plugin.RemoveBuff(this);
			return true;
		}

		private float GetTimer()
		{
			float buff = ((GameEntity)ENT_Player.playerObject).curBuffs.GetBuff("buffTimeMult");
			float num = 1f / Mathf.Max(1f + buff, 0.1f);
			return Buffs.Last().buffTime / (Buffs.Last().loseRate * num);
		}

		public List<BuffStat> GetBuffs()
		{
			List<BuffStat> list = new List<BuffStat>();
			foreach (Buff hiddenBuff in Buffs.SelectMany((BuffContainer buff) => buff.buffs))
			{
				BuffStat buffStat = list.FirstOrDefault((BuffStat b) => b.BuffId == hiddenBuff.id);
				if (buffStat != null)
				{
					buffStat.Amount += hiddenBuff.amount;
					buffStat.MaxAmount += hiddenBuff.maxAmount;
				}
				else
				{
					list.Add(new BuffStat(hiddenBuff.id, hiddenBuff.amount, hiddenBuff.maxAmount));
				}
			}
			return list;
		}
	}
	public class BuffStat(string buffId, float amount, float maxAmount)
	{
		public string BuffId { get; } = buffId;

		public float Amount { get; set; } = amount;

		public float MaxAmount { get; set; } = maxAmount;
	}
	[BepInPlugin("com.crusifixknight.whiteknuckle-buffstimer", "Buffs Timer", "1.1.2")]
	public class Plugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		private static readonly List<ItemBuff> _buffs = new List<ItemBuff>();

		internal static ManualLogSource Logger { get; private set; } = null;

		public static IReadOnlyList<ItemBuff> Buffs => _buffs;

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			_harmony = new Harmony("com.crusifixknight.whiteknuckle-buffstimer.harmony");
			_harmony.PatchAll();
			Logger.LogInfo((object)"Plugin Buffs Timer is loaded!");
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)4;
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0066: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("GameManager/Canvas/Game UI/GameStateTrackers");
			if ((Object)(object)val != (Object)null)
			{
				_buffs.Clear();
				GameObject val2 = new GameObject("BuffTimer");
				val2.transform.SetParent(val.transform, false);
				Text val3 = val2.AddComponent<Text>();
				val3.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				val3.fontSize = 18;
				((Graphic)val3).color = Color.white;
				((Graphic)val3).raycastTarget = false;
				RectTransform component = val2.GetComponent<RectTransform>();
				Vector2 val4 = default(Vector2);
				((Vector2)(ref val4))..ctor(0f, 1f);
				component.pivot = val4;
				Vector2 anchorMin = (component.anchorMax = val4);
				component.anchorMin = anchorMin;
				component.sizeDelta = new Vector2(400f, 700f);
				val2.AddComponent<BuffsMonitorComponent>().Setup(val3);
			}
		}

		public static void AddBuff(string prefabName, BuffContainer buffContainer)
		{
			_buffs.Add(new ItemBuff(prefabName, buffContainer));
		}

		public static void RemoveBuff(ItemBuff buff)
		{
			_buffs.Remove(buff);
		}
	}
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.crusifixknight.whiteknuckle-buffstimer";

		public const string PLUGIN_NAME = "Buffs Timer";

		public const string PLUGIN_VERSION = "1.1.2";
	}
}