using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("coddingcat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Spam Space while restocking shelves in Shift At Midnight.")]
[assembly: AssemblyFileVersion("2.3.0.0")]
[assembly: AssemblyInformationalVersion("2.3.0")]
[assembly: AssemblyProduct("SpaceRefillMod")]
[assembly: AssemblyTitle("SpaceRefillMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 SpaceRefillMod
{
	internal static class PluginInfo
	{
		internal const string Guid = "com.coddingcat.shiftatm.spacerefill";

		internal const string Name = "Space Refill";

		internal const string Version = "2.3.0";
	}
	[BepInPlugin("com.coddingcat.shiftatm.spacerefill", "Space Refill", "2.3.0")]
	public sealed class SpaceRefillPlugin : BasePlugin
	{
		private Harmony _harmony;

		private static ConfigEntry<float> _boostPerPress;

		private static ConfigEntry<float> _drainPerSecond;

		internal static ManualLogSource LogSource { get; private set; }

		internal static float BoostPerPress => Mathf.Clamp(_boostPerPress?.Value ?? 0.12f, 0.01f, 1f);

		internal static float DrainPerSecond => Mathf.Max(0f, _drainPerSecond?.Value ?? 0.5f);

		public override void Load()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			LogSource = ((BasePlugin)this).Log;
			_boostPerPress = ((BasePlugin)this).Config.Bind<float>("Meter", "BoostPerPress", 0.12f, "Amount added to the meter by each Space press.");
			_drainPerSecond = ((BasePlugin)this).Config.Bind<float>("Meter", "DrainPerSecond", 0.5f, "Meter power lost per second. Lower values make each press last longer.");
			bool flag = default(bool);
			try
			{
				if (!ShelfGameAccess.Validate(out var error))
				{
					throw new InvalidOperationException(error);
				}
				SpamMeterUi.Create();
				_harmony = new Harmony("com.coddingcat.shiftatm.spacerefill");
				_harmony.PatchAll(typeof(RestockShelfPatches));
				ManualLogSource log = ((BasePlugin)this).Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(10, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Space Refill");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" v");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("2.3.0");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" loaded.");
				}
				log.LogInfo(val);
				((BasePlugin)this).Log.LogInfo((object)"Interact with a shelf and spam Space. A full meter places one item.");
			}
			catch (Exception ex)
			{
				SpamMeterUi.Destroy();
				ManualLogSource log2 = ((BasePlugin)this).Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(23, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Failed to initialise ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("Space Refill");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log2.LogError(val2);
				throw;
			}
		}

		public override bool Unload()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			RefillController.Reset();
			SpamMeterUi.Destroy();
			LogSource = null;
			return true;
		}
	}
	internal static class RefillController
	{
		private const float PlacementRetryDelay = 0.5f;

		private const float FailureLogCooldown = 5f;

		private static RestockShelf _activeShelf;

		private static float _meterPower;

		private static float _retryAt;

		private static float _nextFailureLogAt;

		internal static void Start(RestockShelf shelf)
		{
			if (ShelfGameAccess.IsInteracting(shelf))
			{
				_activeShelf = shelf;
				_meterPower = 0f;
				_retryAt = 0f;
				SpamMeterUi.SetLevel(0f);
				SpamMeterUi.SetVisible(visible: true);
			}
		}

		internal static void Stop(RestockShelf shelf)
		{
			if (IsActiveShelf(shelf))
			{
				Reset();
			}
		}

		internal static void Tick(RestockShelf shelf)
		{
			if (!IsActiveShelf(shelf))
			{
				return;
			}
			if (!ShelfGameAccess.IsInteracting(shelf))
			{
				Reset();
				return;
			}
			if (Input.GetKeyDown((KeyCode)32))
			{
				HandleSpacePress(shelf);
			}
			float num = Mathf.Clamp(Time.unscaledDeltaTime, 0f, 0.25f);
			_meterPower = Mathf.Max(0f, _meterPower - SpaceRefillPlugin.DrainPerSecond * num);
			SpamMeterUi.SetLevel(_meterPower);
		}

		internal static void Reset()
		{
			_activeShelf = null;
			_meterPower = 0f;
			_retryAt = 0f;
			SpamMeterUi.SetLevel(0f);
			SpamMeterUi.SetVisible(visible: false);
		}

		private static void HandleSpacePress(RestockShelf shelf)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			_meterPower = Mathf.Clamp01(_meterPower + SpaceRefillPlugin.BoostPerPress);
			if (_meterPower < 1f || Time.unscaledTime < _retryAt)
			{
				return;
			}
			string error;
			PlacementResult placementResult = ShelfGameAccess.TryPlaceNextItem(shelf, out error);
			if (placementResult == PlacementResult.Success || placementResult == PlacementResult.ShelfEmpty)
			{
				_meterPower = 0f;
				SpamMeterUi.SetLevel(0f);
				return;
			}
			_retryAt = Time.unscaledTime + 0.5f;
			if (Time.unscaledTime < _nextFailureLogAt)
			{
				return;
			}
			ManualLogSource logSource = SpaceRefillPlugin.LogSource;
			if (logSource != null)
			{
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not place the next shelf item: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(error);
				}
				logSource.LogWarning(val);
			}
			_nextFailureLogAt = Time.unscaledTime + 5f;
		}

		private static bool IsActiveShelf(RestockShelf shelf)
		{
			if ((Object)(object)shelf != (Object)null && (Object)(object)_activeShelf != (Object)null)
			{
				return ((Il2CppObjectBase)_activeShelf).Pointer == ((Il2CppObjectBase)shelf).Pointer;
			}
			return false;
		}
	}
	internal enum PlacementResult
	{
		Success,
		ShelfEmpty,
		Failed
	}
	internal static class ShelfGameAccess
	{
		private const BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly PropertyInfo InteractingProperty = typeof(RestockShelf).GetProperty("interacting", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly PropertyInfo ProductsQueueProperty = typeof(ShelfManager).GetProperty("productsQueue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly PropertyInfo LastShelfItemProperty = typeof(ShelfManager).GetProperty("lastShelfItem", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly MethodInfo CompleteItemMethod = typeof(ShelfManager).GetMethod("CompleteItem", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static Type _cachedQueueType;

		private static PropertyInfo _queueCountProperty;

		private static MethodInfo _queuePeekMethod;

		internal static bool Validate(out string error)
		{
			if (InteractingProperty == null)
			{
				error = "RestockShelf.interacting was not found. The game may have been updated.";
				return false;
			}
			if (ProductsQueueProperty == null || LastShelfItemProperty == null || CompleteItemMethod == null)
			{
				error = "Required ShelfManager members were not found. The game may have been updated.";
				return false;
			}
			error = null;
			return true;
		}

		internal static bool IsInteracting(RestockShelf shelf)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if ((Object)(object)shelf == (Object)null)
			{
				return false;
			}
			try
			{
				object value = InteractingProperty.GetValue(shelf);
				bool flag = default(bool);
				int num;
				if (value is bool)
				{
					flag = (bool)value;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception ex)
			{
				ManualLogSource logSource = SpaceRefillPlugin.LogSource;
				if (logSource != null)
				{
					bool flag2 = default(bool);
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(41, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not read RestockShelf.interacting: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					logSource.LogDebug(val);
				}
				return false;
			}
		}

		internal static PlacementResult TryPlaceNextItem(RestockShelf shelf, out string error)
		{
			error = null;
			try
			{
				ShelfManager val = ((shelf != null) ? shelf.shelfMan : null);
				if ((Object)(object)val == (Object)null)
				{
					return Fail("the shelf manager is missing", out error);
				}
				object value = ProductsQueueProperty.GetValue(val);
				if (value == null)
				{
					return Fail("the product queue is not ready", out error);
				}
				if (!TryPrepareQueueAccess(value.GetType(), out error))
				{
					return PlacementResult.Failed;
				}
				if (Convert.ToInt32(_queueCountProperty.GetValue(value)) <= 0)
				{
					return PlacementResult.ShelfEmpty;
				}
				object? obj = _queuePeekMethod.Invoke(value, null);
				object? obj2 = ((obj is GameObject) ? obj : null);
				DragItem val2 = ((obj2 != null) ? ((GameObject)obj2).GetComponent<DragItem>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return Fail("the next product has no DragItem component", out error);
				}
				ShelfItemManager val3 = FindMatchingSlot(val, val2.itemIndex);
				if ((Object)(object)val3 == (Object)null)
				{
					return Fail($"no shelf slot accepts item index {val2.itemIndex}", out error);
				}
				LastShelfItemProperty.SetValue(val, val3);
				CompleteItemMethod.Invoke(val, null);
				return PlacementResult.Success;
			}
			catch (TargetInvocationException ex)
			{
				return Fail(ex.InnerException?.Message ?? ex.Message, out error);
			}
			catch (Exception ex2)
			{
				return Fail(ex2.Message, out error);
			}
		}

		private static bool TryPrepareQueueAccess(Type queueType, out string error)
		{
			if (_cachedQueueType == queueType && _queueCountProperty != null && _queuePeekMethod != null)
			{
				error = null;
				return true;
			}
			_cachedQueueType = queueType;
			_queueCountProperty = queueType.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			_queuePeekMethod = queueType.GetMethod("Peek", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (_queueCountProperty != null && _queuePeekMethod != null)
			{
				error = null;
				return true;
			}
			error = "the product queue API was not found";
			return false;
		}

		private static ShelfItemManager FindMatchingSlot(ShelfManager manager, int itemIndex)
		{
			ShelfItemManager[] array = Il2CppArrayBase<ShelfItemManager>.op_Implicit((Il2CppArrayBase<ShelfItemManager>)(object)manager.shelfItemManagers);
			if (array == null)
			{
				return null;
			}
			foreach (ShelfItemManager val in array)
			{
				if ((Object)(object)val != (Object)null && val.itemIndex == itemIndex)
				{
					return val;
				}
			}
			return null;
		}

		private static PlacementResult Fail(string message, out string error)
		{
			error = (string.IsNullOrWhiteSpace(message) ? "unknown game error" : message);
			return PlacementResult.Failed;
		}
	}
	internal static class SpamMeterUi
	{
		private static GameObject _canvasObject;

		private static RectTransform _fillRect;

		internal static void Create()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvasObject != (Object)null))
			{
				_canvasObject = CreateUiObject<Canvas, CanvasScaler>("SpaceRefill_Canvas");
				Object.DontDestroyOnLoad((Object)(object)_canvasObject);
				Canvas component = _canvasObject.GetComponent<Canvas>();
				component.renderMode = (RenderMode)0;
				component.sortingOrder = 999;
				CanvasScaler component2 = _canvasObject.GetComponent<CanvasScaler>();
				component2.uiScaleMode = (ScaleMode)1;
				component2.referenceResolution = new Vector2(1920f, 1080f);
				component2.matchWidthOrHeight = 0.5f;
				GameObject val = CreateUiObject<Image>("SpaceRefill_Background");
				val.transform.SetParent(_canvasObject.transform, false);
				RectTransform component3 = val.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0.92f, 0.5f);
				component3.anchorMax = new Vector2(0.92f, 0.5f);
				component3.pivot = new Vector2(0.5f, 0.5f);
				component3.anchoredPosition = Vector2.zero;
				component3.sizeDelta = new Vector2(32f, 260f);
				Image component4 = val.GetComponent<Image>();
				((Graphic)component4).color = new Color(0.02f, 0.02f, 0.02f, 0.82f);
				((Graphic)component4).raycastTarget = false;
				GameObject obj = CreateUiObject<Image>("SpaceRefill_Fill");
				obj.transform.SetParent(val.transform, false);
				_fillRect = obj.GetComponent<RectTransform>();
				_fillRect.anchorMin = Vector2.zero;
				_fillRect.anchorMax = new Vector2(1f, 0f);
				_fillRect.pivot = new Vector2(0.5f, 0f);
				_fillRect.offsetMin = Vector2.zero;
				_fillRect.offsetMax = Vector2.zero;
				Image component5 = obj.GetComponent<Image>();
				((Graphic)component5).color = Color.white;
				((Graphic)component5).raycastTarget = false;
				SetVisible(visible: false);
			}
		}

		internal static void Destroy()
		{
			if ((Object)(object)_canvasObject != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObject);
			}
			_canvasObject = null;
			_fillRect = null;
		}

		internal static void SetVisible(bool visible)
		{
			if ((Object)(object)_canvasObject != (Object)null && _canvasObject.activeSelf != visible)
			{
				_canvasObject.SetActive(visible);
			}
		}

		internal static void SetLevel(float amount)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_fillRect == (Object)null))
			{
				Vector2 anchorMax = _fillRect.anchorMax;
				anchorMax.x = 1f;
				anchorMax.y = Mathf.Clamp01(amount);
				_fillRect.anchorMax = anchorMax;
			}
		}

		private static GameObject CreateUiObject<TComponent>(string name) where TComponent : Component
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			return new GameObject(name, (Type[])(object)new Type[2]
			{
				Il2CppType.Of<RectTransform>(),
				Il2CppType.Of<TComponent>()
			});
		}

		private static GameObject CreateUiObject<TFirst, TSecond>(string name) where TFirst : Component where TSecond : Component
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			return new GameObject(name, (Type[])(object)new Type[3]
			{
				Il2CppType.Of<RectTransform>(),
				Il2CppType.Of<TFirst>(),
				Il2CppType.Of<TSecond>()
			});
		}
	}
	[HarmonyPatch]
	internal static class RestockShelfPatches
	{
		[HarmonyPatch(typeof(RestockShelf), "Interact")]
		[HarmonyPostfix]
		private static void AfterInteract(RestockShelf __instance)
		{
			RefillController.Start(__instance);
		}

		[HarmonyPatch(typeof(RestockShelf), "StopInteract")]
		[HarmonyPostfix]
		private static void AfterStopInteract(RestockShelf __instance)
		{
			RefillController.Stop(__instance);
		}

		[HarmonyPatch(typeof(RestockShelf), "Update")]
		[HarmonyPostfix]
		private static void AfterUpdate(RestockShelf __instance)
		{
			RefillController.Tick(__instance);
		}
	}
}