using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using PEAKLib.Stats;
using PeakThirst;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("PeakThirst")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PeakThirst")]
[assembly: AssemblyTitle("PeakThirst")]
[assembly: AssemblyVersion("1.0.0.0")]
[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;
		}
	}
}
[HarmonyPatch(typeof(Item), "Awake")]
public static class Item_TargetMethod_Patch
{
	private static void Postfix(Item __instance)
	{
		Debug.Log((object)((Object)((Component)__instance).gameObject).name);
		float restoration = ThirstRestorationCalculator.CalculateThirstRestoration(((Component)__instance).gameObject);
		if (restoration <= 0f)
		{
			return;
		}
		Item obj = __instance;
		obj.OnConsumed = (Action)Delegate.Combine(obj.OnConsumed, (Action)delegate
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Character holderCharacter = __instance.holderCharacter;
			CharacterAfflictions val = (((Object)(object)holderCharacter != (Object)null) ? holderCharacter.refs : null)?.afflictions;
			if ((Object)(object)val != (Object)null)
			{
				val.SubtractStatus(ThirstAffliction.DehydrationType, restoration, false);
			}
		});
	}
}
[HarmonyPatch(typeof(Action_RestoreHunger), "RunAction")]
public static class Action_RestoreHunger_TargetMethod_Patch
{
	private static readonly Func<ItemAction, Character> GetCharacter = AccessTools.MethodDelegate<Func<ItemAction, Character>>(AccessTools.PropertyGetter(typeof(ItemAction), "character"), (object)null, true);

	private static void Postfix(Action_RestoreHunger __instance)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		Character val = GetCharacter((ItemAction)(object)__instance);
		val.refs.afflictions.SubtractStatus(ThirstAffliction.DehydrationType, __instance.restorationAmount / 4f, false);
	}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateNormalStatuses")]
public static class CharacterAfflictions_TargetMethod_Patch
{
	private static void Postfix(CharacterAfflictions __instance)
	{
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		if (__instance.character.data.fullyConscious)
		{
			CharacterAfflictions afflictions = __instance.character.refs.afflictions;
			float num = 1f + afflictions.GetCurrentStatus((STATUSTYPE)8) * 20f;
			float num2 = Time.deltaTime * __instance.hungerPerSecond * Ascents.hungerRateMultiplier * 2f * num;
			afflictions.AddStatus(ThirstAffliction.DehydrationType, num2, false);
		}
	}
}
internal static class SpriteLoader
{
	public static Sprite FromEmbedded(string resourceName, float pixelsPerUnit = 100f)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
		if (stream == null)
		{
			Debug.LogError((object)("[PeakThirst] Embedded resource not found: " + resourceName));
			return null;
		}
		using MemoryStream memoryStream = new MemoryStream();
		stream.CopyTo(memoryStream);
		Texture2D val = new Texture2D(2, 2, (TextureFormat)5, false);
		if (!ImageConversion.LoadImage(val, memoryStream.ToArray()))
		{
			Debug.LogError((object)("[PeakThirst] Failed to load image data for: " + resourceName));
			return null;
		}
		((Object)val).name = Path.GetFileNameWithoutExtension(resourceName);
		((Texture)val).filterMode = (FilterMode)1;
		return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
	}
}
public static class ThirstAffliction
{
	public const string StatusName = "Dehydration";

	public static STATUSTYPE DehydrationType;

	public static void CreateThirstAffliction()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: 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)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		Sprite icon = SpriteLoader.FromEmbedded("PeakThirst.Sprites.Droplet.png");
		Status val = new Status
		{
			Name = "Dehydration",
			Color = new Color(0.075f, 0.286f, 1f),
			MaxAmount = 2f,
			AllowClear = true,
			ReductionCooldown = 0f,
			ReductionPerSecond = 0f,
			Icon = icon
		};
		new StatusContent(val).Register(Thirst.Definition);
		DehydrationType = val.Type;
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.All, Inherited = false)]
	public sealed class NullableAttribute : Attribute
	{
		public NullableAttribute(byte b)
		{
		}

		public NullableAttribute(byte[] b)
		{
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false)]
	public sealed class NullableContextAttribute : Attribute
	{
		public NullableContextAttribute(byte b)
		{
		}
	}
}
namespace PeakThirst
{
	public static class ThirstRestorationCalculator
	{
		public static float CalculateThirstRestoration(GameObject item)
		{
			string name = ((Object)item).name;
			Debug.Log((object)("Calculating thirst for " + name));
			float num = 0f;
			if (name.Contains("Apple Berry"))
			{
				num += 0.1f;
			}
			if (name.Contains("Berrynana"))
			{
				num += 0.2f;
			}
			if (name.Contains("Bugfix"))
			{
				num += 0.15f;
			}
			if (name.Contains("Clusterberry"))
			{
				num += 0.35f;
			}
			if (name.Contains("Kingberry"))
			{
				num += 0.15f;
			}
			if (name.Contains("Marshmallow"))
			{
				num += 0.45f;
			}
			if (name.Contains("Mushroom"))
			{
				num += 0.075f;
			}
			if (name.Contains("Sports Drink"))
			{
				num += 1f;
			}
			if (name.Contains("Winterberry"))
			{
				num += 0.3f;
			}
			if (name.Contains("Honeycomb"))
			{
				num += 0.15f;
			}
			if (name.Contains("Coconut_half"))
			{
				num += 0.6f;
			}
			if (name.Contains("AloeVera"))
			{
				num += 1.5f;
			}
			if (name.Contains("Turkey"))
			{
				num += 0.7f;
			}
			if (name.Contains("Napberry"))
			{
				num += 1f;
			}
			if (name.Contains("Prickleberry"))
			{
				num += 0.5f;
			}
			if (name.Contains("Cure-All"))
			{
				num += 0.9f;
			}
			if (name.Contains("MedicinalRoot"))
			{
				num += 0.2f;
			}
			if (name.Contains("Energy Drink"))
			{
				num += 0.5f;
			}
			return num;
		}
	}
	public static class OnsenThirst
	{
		public static void AddThirstToOnsens(bool includeInactive = false)
		{
			//IL_005c: 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)
			GameObject[] array = FindAllByName("heat zone", includeInactive);
			GameObject[] array2 = array;
			foreach (GameObject val in array2)
			{
				GameObject val2 = Object.Instantiate<GameObject>(val);
				val2.transform.SetParent(val.transform.parent, true);
				StatusEmitter val3 = val2.GetComponent<StatusEmitter>();
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = val2.AddComponent<StatusEmitter>();
				}
				val3.statusType = ThirstAffliction.DehydrationType;
			}
		}

		public static GameObject[] FindAllByName(string targetName, bool includeInactive = false)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(targetName))
			{
				return Array.Empty<GameObject>();
			}
			FindObjectsInactive val = (FindObjectsInactive)(includeInactive ? 1 : 0);
			Transform[] array = Object.FindObjectsByType<Transform>(val, (FindObjectsSortMode)0);
			List<GameObject> list = new List<GameObject>(array.Length);
			Transform[] array2 = array;
			foreach (Transform val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == targetName)
				{
					list.Add(((Component)val2).gameObject);
				}
			}
			return list.ToArray();
		}
	}
	public class Action_MergerAction : ItemAction
	{
		public ItemAction action1;

		public ItemAction action2;

		public override void RunAction()
		{
			((ItemActionBase)action1).RunAction();
			((ItemActionBase)action2).RunAction();
		}
	}
	[BepInPlugin("com.khakixd.thirst", "Thirst", "0.1.0")]
	public class Thirst : BaseUnityPlugin
	{
		private Harmony _harmony;

		public static ModDefinition Definition { get; set; }

		private void Awake()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			Definition = ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info.Metadata);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Thirst loaded!");
			_harmony = new Harmony("com.khakixd.thirst");
			ThirstAffliction.CreateThirstAffliction();
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			try
			{
				int num = Harmony.GetAllPatchedMethods().Count();
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Harmony: total patched methods in process = {num}");
			}
			catch
			{
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
				Debug.Log((object)"Cannot unpatch thirst!");
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode sceneMode)
		{
			OnsenThirst.AddThirstToOnsens();
		}
	}
}
namespace PeakThirst.Patches
{
	[HarmonyPatch]
	internal static class GetEatenHydrationPatch
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__2 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<Type> <>s__1;

			private Type <t>5__2;

			private MethodInfo <m>5__3;

			MethodBase IEnumerator<MethodBase>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TargetMethods>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<t>5__2 = null;
				<m>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00ae;
					}
					<>1__state = -1;
					<>s__1 = AccessTools.AllTypes().GetEnumerator();
					<>1__state = -3;
					goto IL_00bd;
					IL_00ae:
					<m>5__3 = null;
					<t>5__2 = null;
					goto IL_00bd;
					IL_00bd:
					if (<>s__1.MoveNext())
					{
						<t>5__2 = <>s__1.Current;
						<m>5__3 = AccessTools.DeclaredMethod(<t>5__2, "GetEaten", new Type[1] { typeof(Character) }, (Type[])null);
						if (<m>5__3 != null)
						{
							<>2__current = <m>5__3;
							<>1__state = 1;
							return true;
						}
						goto IL_00ae;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__2(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		private static MethodInfo Apply => AccessTools.Method(typeof(GetEatenHydrationPatch), "ApplyHydration", (Type[])null, (Type[])null);

		[IteratorStateMachine(typeof(<TargetMethods>d__2))]
		private static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__2(-2);
		}

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			CodeMatcher codes = new CodeMatcher(instructions, il);
			if (!InsertedAt("ThrowAchievement") && !InsertedAt("AddStatus") && !InsertedAt("DieInstantly"))
			{
				codes.End().Insert((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)Apply)
				});
			}
			return codes.InstructionEnumeration();
			bool InsertedAt(string methodName)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				int pos = codes.Pos;
				codes.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => (i.opcode == OpCodes.Call || i.opcode == OpCodes.Callvirt) && i.operand is MethodInfo methodInfo && methodInfo.Name == methodName), (string)null)
				});
				if (!codes.IsValid)
				{
					codes.Start().Advance(pos);
					return false;
				}
				codes.Insert((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)Apply)
				});
				return true;
			}
		}

		private static void ApplyHydration(Character eater)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)eater == (Object)null) && eater.IsLocal)
			{
				eater.refs.afflictions.SubtractStatus(ThirstAffliction.DehydrationType, 500f, false);
			}
		}
	}
	[HarmonyPatch(typeof(StormVisual))]
	internal static class StormVisualRainHydrationPatch
	{
		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void Postfix(StormVisual __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.stormType <= 0 && __instance.playerInWindZone)
			{
				Character observedCharacter = Character.observedCharacter;
				if (!((Object)(object)observedCharacter == (Object)null) && observedCharacter.IsLocal)
				{
					observedCharacter.refs.afflictions.SubtractStatus(ThirstAffliction.DehydrationType, 0.1f * Time.deltaTime, false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(WaterfallPusher))]
	internal static class WaterfallPusher_OnTriggerEnter_Patch
	{
		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			MethodInfo playCall = AccessTools.Method(typeof(SFX_PlayOneShot), "Play", (Type[])null, (Type[])null);
			MethodInfo methodInfo = AccessTools.Method(typeof(Component), "GetComponentInParent", Type.EmptyTypes, new Type[1] { typeof(Character) });
			MethodInfo methodInfo2 = AccessTools.Method(typeof(WaterfallPusher_OnTriggerEnter_Patch), "ApplyHydration", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, il).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, playCall)), (string)null)
			});
			if (!val.IsValid)
			{
				return val.InstructionEnumeration();
			}
			val.Advance(1).Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Callvirt, (object)methodInfo),
				new CodeInstruction(OpCodes.Call, (object)methodInfo2)
			});
			return val.InstructionEnumeration();
		}

		private static void ApplyHydration(Character c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)c == (Object)null))
			{
				c.refs.afflictions.SubtractStatus(ThirstAffliction.DehydrationType, 500f, false);
			}
		}
	}
}