using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Water Reslotting")]
[assembly: AssemblyDescription("Exchange quickslotted Waterskin with a filled waterskin when it runs empty")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("UrbanVibes")]
[assembly: AssemblyProduct("Water Reslotting")]
[assembly: AssemblyCopyright("Copyright ©  2021 - 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2f697047-6ee8-40d5-9783-4869db3da18a")]
[assembly: AssemblyFileVersion("1.4.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.4.0.0")]
namespace WaterReslotting;

[BepInPlugin("com.outward.urbanvibes.waterreslotting", "Water Reslotting", "1.4")]
public class WaterReslotting : BaseUnityPlugin
{
	[HarmonyPatch(typeof(WaterContainer), "OnUse")]
	private class WaterContainer_OnUse
	{
		[HarmonyPostfix]
		public static void Patch(ref WaterContainer __instance)
		{
			ReslotWaterContainer(null);
		}
	}

	[HarmonyPatch(typeof(CharacterManager), "OnAllPlayersDoneLoading")]
	private class CharacterManager_OnAllPlayersDoneLoading
	{
		[HarmonyPostfix]
		public static void Patch()
		{
			ReslotWaterContainer(null);
		}
	}

	[HarmonyPatch(typeof(WaterContainer), "Empty")]
	private class WaterContainer_Empty
	{
		[HarmonyPostfix]
		public static void Patch()
		{
			ReslotWaterContainer(null);
		}
	}

	[HarmonyPatch(typeof(WaterContainer), "Fill")]
	private class WaterContainer_Fill
	{
		[HarmonyPostfix]
		public static void Patch()
		{
			ReslotWaterContainer(null);
		}
	}

	[HarmonyPatch(typeof(ItemDisplay), "TryMoveTo", new Type[] { typeof(ItemContainer) })]
	private class ItemDisplay_TryMoveTo
	{
		[HarmonyPostfix]
		public static void Patch()
		{
			ReslotWaterContainer(null);
		}
	}

	[HarmonyPatch(typeof(CharacterInventory), "TakeItem", new Type[]
	{
		typeof(Item),
		typeof(bool)
	})]
	private class CharacterInventory_TakeItem
	{
		[HarmonyPostfix]
		public static void Patch(ref Item takenItem)
		{
			Item obj = takenItem;
			ReslotWaterContainer((WaterContainer)(object)((obj is WaterContainer) ? obj : null));
		}
	}

	private const string ID = "com.outward.urbanvibes.waterreslotting";

	private const string NAME = "Water Reslotting";

	private const string VERSION = "1.4";

	private void Awake()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("com.outward.urbanvibes.waterreslotting").PatchAll(Assembly.GetExecutingAssembly());
	}

	private static void ReslotWaterContainer(WaterContainer transferredWaterContainer)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Invalid comparison between Unknown and I4
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Invalid comparison between Unknown and I4
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Invalid comparison between Unknown and I4
		WaterContainer val = null;
		int num = -1;
		Character firstLocalCharacter = CharacterManager.Instance.GetFirstLocalCharacter();
		if (!Object.op_Implicit((Object)(object)firstLocalCharacter) || !firstLocalCharacter.IsLocalPlayer || !Object.op_Implicit((Object)(object)firstLocalCharacter.Inventory) || !Object.op_Implicit((Object)(object)firstLocalCharacter.QuickSlotMngr))
		{
			return;
		}
		for (int i = 0; i < firstLocalCharacter.QuickSlotMngr.QuickSlotCount; i++)
		{
			QuickSlot quickSlot = firstLocalCharacter.QuickSlotMngr.GetQuickSlot(i);
			Item activeItem = quickSlot.ActiveItem;
			WaterContainer val2 = (WaterContainer)(object)((activeItem is WaterContainer) ? activeItem : null);
			if (Object.op_Implicit((Object)(object)quickSlot.ActiveItem) && Object.op_Implicit((Object)(object)val2) && (quickSlot.ActiveItem.RemainingAmount == 0 || (int)val2.ContainedWater == 1 || (int)val2.ContainedWater == 2 || (int)val2.ContainedWater == 3))
			{
				num = i;
				break;
			}
		}
		if (num != -1)
		{
			val = FindBestMatch(firstLocalCharacter.Inventory, transferredWaterContainer);
			if (Object.op_Implicit((Object)(object)val))
			{
				firstLocalCharacter.QuickSlotMngr.SetQuickSlot(num, (Item)(object)val, true);
			}
		}
	}

	private static WaterContainer FindBestMatch(CharacterInventory Inventory, WaterContainer TransferredWaterContainer = null)
	{
		int num = 0;
		WaterContainer result = null;
		List<WaterContainer> list = new List<WaterContainer>();
		list.AddRange(Inventory.Pouch.GetItemOfType<WaterContainer>());
		list.AddRange(((ItemContainer)Inventory.EquippedBag.Container).GetItemOfType<WaterContainer>());
		if (Object.op_Implicit((Object)(object)TransferredWaterContainer) && TransferredWaterContainer.RemainingUse > 0)
		{
			list.Add(TransferredWaterContainer);
		}
		if (list.Count == 0)
		{
			return null;
		}
		for (int i = 0; i < list.Count; i++)
		{
			int waterContainerRating = GetWaterContainerRating(list[i]);
			if (waterContainerRating > num)
			{
				result = list[i];
			}
			num = Math.Max(num, waterContainerRating);
		}
		return result;
	}

	private static int GetWaterContainerRating(WaterContainer Item)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Expected I4, but got Unknown
		int num = Enum.GetNames(typeof(WaterType)).Length;
		if (Item.RemainingUse == 0)
		{
			return 0;
		}
		return (num - Item.ContainedWater) * 10 + Item.RemainingUse;
	}
}