using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using MimesisItemSpawner;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "MimesisItemSpawner", "1.0.0", "corbyn.barker", null)]
[assembly: MelonGame("ReLUGames", "MIMESIS")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("MimesisItemSpawner")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("MimesisItemSpawner")]
[assembly: AssemblyTitle("MimesisItemSpawner")]
[assembly: AssemblyVersion("1.0.1.0")]
[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 MimesisItemSpawner
{
	public class Core : MelonMod
	{
		private MelonPreferences_Entry<string> _toggleKeyPref;

		private MelonPreferences_Entry<string> _reasonPref;

		private MelonPreferences_Entry<int> _amountPref;

		private bool _open;

		private bool _itemsLoaded;

		private string _search = "";

		private string _amountText = "1";

		private string _status = "Press the toggle key in-game to open.";

		private Vector2 _scroll;

		private Rect _window = new Rect(40f, 40f, 480f, 600f);

		private readonly List<GameBridge.ItemEntry> _allItems = new List<GameBridge.ItemEntry>();

		private readonly List<GameBridge.ItemEntry> _filtered = new List<GameBridge.ItemEntry>();

		private string _lastSearch;

		private int _pendingSpawnId = -1;

		private const int MaxRows = 300;

		private const int WindowId = 1296651088;

		public override void OnInitializeMelon()
		{
			MelonPreferences_Category val = MelonPreferences.CreateCategory("MimesisItemSpawner");
			_toggleKeyPref = val.CreateEntry<string>("HotKey", "F6", "Toggle key (Input System key name, e.g. F6, Backquote, F1..F12)", (string)null, false, false, (ValueValidator)null, (string)null);
			_reasonPref = val.CreateEntry<string>("ReasonOfSpawn", "Admin", "Spawn reason (None/Spawn/Admin/ItemSpawn/...)", (string)null, false, false, (ValueValidator)null, (string)null);
			_amountPref = val.CreateEntry<int>("DefaultAmount", 1, "Default stack amount", (string)null, false, false, (ValueValidator)null, (string)null);
			_amountText = _amountPref.Value.ToString();
			MelonLogger.Msg("MimesisItemSpawner loaded. Toggle key: " + _toggleKeyPref.Value);
		}

		public override void OnUpdate()
		{
			if (GameBridge.WasKeyPressed(_toggleKeyPref.Value))
			{
				_open = !_open;
				if (_open && !_itemsLoaded)
				{
					TryLoadItems();
				}
			}
			if (_pendingSpawnId >= 0)
			{
				int pendingSpawnId = _pendingSpawnId;
				_pendingSpawnId = -1;
				DoSpawn(pendingSpawnId);
			}
		}

		public override void OnGUI()
		{
			//IL_0010: 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)
			//IL_002b: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (_open)
			{
				_window = GUI.Window(1296651088, _window, new WindowFunction(DrawWindow), "Mimesis Item Spawner");
			}
		}

		private void TryLoadItems()
		{
			if (!GameBridge.EnsureReady(out var error))
			{
				_status = "Cannot load items: " + error;
				return;
			}
			try
			{
				_allItems.Clear();
				_allItems.AddRange(GameBridge.GetAllItems());
				_itemsLoaded = _allItems.Count > 0;
				_lastSearch = null;
				_status = (_itemsLoaded ? $"Loaded {_allItems.Count} items." : "Item table not ready yet (enter a session, then Refresh).");
			}
			catch (Exception ex)
			{
				_status = "Error loading items: " + ex.Message;
				MelonLogger.Error((object)ex);
			}
		}

		private void RebuildFilter()
		{
			if (_lastSearch == _search)
			{
				return;
			}
			_lastSearch = _search;
			_filtered.Clear();
			string text = _search?.Trim();
			bool flag = string.IsNullOrEmpty(text);
			string value = (flag ? null : text.ToLowerInvariant());
			foreach (GameBridge.ItemEntry allItem in _allItems)
			{
				if (flag || allItem.Id.ToString().Contains(text) || (allItem.Name != null && allItem.Name.ToLowerInvariant().Contains(value)) || (allItem.Display != null && allItem.Display.ToLowerInvariant().Contains(value)))
				{
					_filtered.Add(allItem);
					if (_filtered.Count >= 300)
					{
						break;
					}
				}
			}
		}

		private void DrawWindow(int id)
		{
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Search:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			_search = GUILayout.TextField(_search ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(250f) });
			if (GUILayout.Button("Refresh", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				TryLoadItems();
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Amount:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			_amountText = GUILayout.TextField(_amountText ?? "1", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			GUILayout.FlexibleSpace();
			GUILayout.Label(_itemsLoaded ? $"{_allItems.Count} items" : "not loaded", Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			GUILayout.Label(_status, Array.Empty<GUILayoutOption>());
			GUILayout.Space(2f);
			RebuildFilter();
			if (_filtered.Count >= 300)
			{
				GUILayout.Label($"Showing first {300} matches — refine search.", Array.Empty<GUILayoutOption>());
			}
			_scroll = GUILayout.BeginScrollView(_scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(440f) });
			foreach (GameBridge.ItemEntry item in _filtered)
			{
				if (GUILayout.Button($"[{item.Id}] {item.Display}", Array.Empty<GUILayoutOption>()))
				{
					_pendingSpawnId = item.Id;
					_status = $"Spawning [{item.Id}] {item.Display} ...";
				}
			}
			if (_filtered.Count == 0)
			{
				GUILayout.Label(_itemsLoaded ? "No matches." : "Open a session and press Refresh.", Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndScrollView();
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Close", Array.Empty<GUILayoutOption>()))
			{
				_open = false;
			}
			GUILayout.EndHorizontal();
			GUI.DragWindow();
		}

		private void DoSpawn(int id)
		{
			int result = 1;
			int.TryParse(_amountText, out result);
			if (result < 1)
			{
				result = 1;
			}
			if (!GameBridge.EnsureReady(out var error))
			{
				_status = "Not ready: " + error;
				return;
			}
			string message;
			bool flag = GameBridge.SpawnItem(id, result, _reasonPref.Value, out message);
			_status = message ?? (flag ? "Spawned." : "Spawn failed.");
			if (flag)
			{
				MelonLogger.Msg(message);
			}
			else
			{
				MelonLogger.Warning(message);
			}
		}
	}
	internal static class GameBridge
	{
		public struct ItemEntry
		{
			public int Id;

			public string Name;

			public string Display;
		}

		private const BindingFlags AnyInstance = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private const BindingFlags AnyStatic = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static Assembly _gameAsm;

		private static Type _hubType;

		private static Type _ivroomType;

		private static Type _posWithRotType;

		private static Type _reasonType;

		private static bool _inputResolved;

		private static Type _keyboardType;

		private static Type _keyEnumType;

		private static PropertyInfo _keyboardCurrent;

		private static MethodInfo _keyboardIndexer;

		private static void ResolveInput()
		{
			if (_inputResolved)
			{
				return;
			}
			_inputResolved = true;
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "Unity.InputSystem");
			if (!(assembly == null))
			{
				_keyboardType = assembly.GetType("UnityEngine.InputSystem.Keyboard");
				_keyEnumType = assembly.GetType("UnityEngine.InputSystem.Key");
				if (!(_keyboardType == null) && !(_keyEnumType == null))
				{
					_keyboardCurrent = _keyboardType.GetProperty("current", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					_keyboardIndexer = _keyboardType.GetMethod("get_Item", new Type[1] { _keyEnumType });
				}
			}
		}

		public static bool WasKeyPressed(string keyName)
		{
			ResolveInput();
			if (_keyboardCurrent == null || _keyboardIndexer == null)
			{
				return false;
			}
			try
			{
				object value = _keyboardCurrent.GetValue(null);
				if (value == null)
				{
					return false;
				}
				object obj;
				try
				{
					obj = Enum.Parse(_keyEnumType, keyName, ignoreCase: true);
				}
				catch
				{
					obj = Enum.Parse(_keyEnumType, "F6", ignoreCase: true);
				}
				object obj3 = _keyboardIndexer.Invoke(value, new object[1] { obj });
				if (obj3 == null)
				{
					return false;
				}
				PropertyInfo property = obj3.GetType().GetProperty("wasPressedThisFrame", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return property != null && (bool)property.GetValue(obj3);
			}
			catch
			{
				return false;
			}
		}

		public static bool EnsureReady(out string error)
		{
			error = null;
			if (_gameAsm == null)
			{
				_gameAsm = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "Assembly-CSharp");
				if (_gameAsm == null)
				{
					error = "Assembly-CSharp not loaded yet.";
					return false;
				}
			}
			if ((object)_hubType == null)
			{
				_hubType = _gameAsm.GetType("Hub");
			}
			if ((object)_ivroomType == null)
			{
				_ivroomType = _gameAsm.GetType("IVroom");
			}
			if ((object)_posWithRotType == null)
			{
				_posWithRotType = _gameAsm.GetType("ReluProtocol.PosWithRot");
			}
			if ((object)_reasonType == null)
			{
				_reasonType = _gameAsm.GetType("ReluProtocol.Enum.ReasonOfSpawn");
			}
			if (_hubType == null)
			{
				error = "Hub type not found.";
				return false;
			}
			if (_ivroomType == null)
			{
				error = "IVroom type not found.";
				return false;
			}
			if (_posWithRotType == null)
			{
				error = "PosWithRot type not found.";
				return false;
			}
			if (_reasonType == null)
			{
				error = "ReasonOfSpawn type not found.";
				return false;
			}
			return true;
		}

		private static object GetHub()
		{
			return _hubType.GetField("s", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
		}

		private static object GetField(object obj, string name)
		{
			if (obj == null)
			{
				return null;
			}
			Type type = obj.GetType();
			while (type != null)
			{
				FieldInfo field = type.GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field.GetValue(obj);
				}
				type = type.BaseType;
			}
			return null;
		}

		private static object GetFieldOn(Type declaring, object obj, string name)
		{
			return declaring.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj);
		}

		private static object GetProp(object obj, string name)
		{
			if (obj == null)
			{
				return null;
			}
			Type type = obj.GetType();
			while (type != null)
			{
				PropertyInfo property = type.GetProperty(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null)
				{
					return property.GetValue(obj);
				}
				type = type.BaseType;
			}
			return null;
		}

		private static object GetVWorld()
		{
			return GetField(GetHub(), "<vworld>k__BackingField");
		}

		private static int GetMyActorId(out object hub, out object pdata)
		{
			hub = GetHub();
			pdata = GetField(hub, "pdata");
			if (pdata == null)
			{
				return 0;
			}
			FieldInfo field = pdata.GetType().GetField("MyActorID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field != null))
			{
				return 0;
			}
			return (int)field.GetValue(pdata);
		}

		private static bool GetLocalRoomAndPlayer(out object room, out object player, out string error)
		{
			room = null;
			player = null;
			error = null;
			object vWorld = GetVWorld();
			if (vWorld == null)
			{
				error = "Not in game yet (no VWorld). Join/host a session first.";
				return false;
			}
			object field = GetField(vWorld, "_vRoomManager");
			if (field == null)
			{
				error = "No room manager (host the session to spawn).";
				return false;
			}
			if (!(GetField(field, "_vrooms") is IDictionary { Count: not 0 } dictionary))
			{
				error = "No active rooms found.";
				return false;
			}
			object hub;
			object pdata;
			int myActorId = GetMyActorId(out hub, out pdata);
			if (myActorId == 0)
			{
				error = "Local actor id is 0 (not spawned in a room yet).";
				return false;
			}
			foreach (object value in dictionary.Values)
			{
				object fieldOn = GetFieldOn(_ivroomType, value, "_vPlayerDict");
				if (fieldOn == null)
				{
					continue;
				}
				MethodInfo method = fieldOn.GetType().GetMethod("FindActor", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(method == null))
				{
					object obj = method.Invoke(fieldOn, new object[1] { myActorId });
					if (obj != null)
					{
						room = value;
						player = obj;
						return true;
					}
				}
			}
			IEnumerator enumerator = dictionary.Values.GetEnumerator();
			try
			{
				if (enumerator.MoveNext())
				{
					object current2 = enumerator.Current;
					room = current2;
				}
			}
			finally
			{
				IDisposable disposable = enumerator as IDisposable;
				if (disposable != null)
				{
					disposable.Dispose();
				}
			}
			if (room == null)
			{
				error = "Could not resolve a room for the local player.";
				return false;
			}
			return true;
		}

		public static List<ItemEntry> GetAllItems()
		{
			List<ItemEntry> list = new List<ItemEntry>();
			object hub = GetHub();
			object field = GetField(hub, "<dataman>k__BackingField");
			if (field == null)
			{
				return list;
			}
			object prop = GetProp(field, "ExcelDataManager");
			if (prop == null)
			{
				return list;
			}
			if (!(GetProp(prop, "ItemInfoDict") is IEnumerable enumerable))
			{
				return list;
			}
			object field2 = GetField(hub, "pdata");
			MethodInfo methodInfo = field2?.GetType().GetMethod("GetItemDisplayName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo method = _hubType.GetMethod("GetL10NText", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (object item in enumerable)
			{
				Type type = item.GetType();
				object obj = type.GetProperty("Key")?.GetValue(item);
				object obj2 = type.GetProperty("Value")?.GetValue(item);
				if (obj == null || obj2 == null)
				{
					continue;
				}
				int num = (int)obj;
				string text = (obj2.GetType().GetField("Name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) as string) ?? num.ToString();
				string text2 = text;
				try
				{
					if (methodInfo != null)
					{
						string text3 = methodInfo.Invoke(field2, new object[2] { num, text }) as string;
						if (!string.IsNullOrEmpty(text3))
						{
							text2 = text3;
						}
					}
					if (method != null)
					{
						string text4 = method.Invoke(null, new object[1] { text2 }) as string;
						if (!string.IsNullOrEmpty(text4))
						{
							text2 = text4;
						}
					}
				}
				catch
				{
				}
				list.Add(new ItemEntry
				{
					Id = num,
					Name = text,
					Display = text2
				});
			}
			list.Sort((ItemEntry a, ItemEntry b) => a.Id.CompareTo(b.Id));
			return list;
		}

		public static bool SpawnItem(int masterId, int qty, string reasonName, out string message)
		{
			message = null;
			try
			{
				if (!GetLocalRoomAndPlayer(out var room, out var player, out var error))
				{
					message = error;
					return false;
				}
				MethodInfo method = _ivroomType.GetMethod("GetNewItemElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					message = "GetNewItemElement not found.";
					return false;
				}
				object obj = method.Invoke(room, new object[6]
				{
					masterId,
					false,
					Math.Max(1, qty),
					0,
					0,
					0
				});
				if (obj == null)
				{
					message = $"Item {masterId} is invalid (GetNewItemElement returned null).";
					return false;
				}
				object obj2 = Activator.CreateInstance(_posWithRotType);
				bool flag = false;
				if (player != null)
				{
					object prop = GetProp(player, "PositionVector");
					if (prop != null)
					{
						_posWithRotType.GetMethod("set_pos", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj2, new object[1] { prop });
					}
					if (GetProp(player, "IsIndoor") is bool flag2)
					{
						flag = flag2;
					}
				}
				object obj3;
				try
				{
					obj3 = Enum.Parse(_reasonType, reasonName, ignoreCase: true);
				}
				catch
				{
					obj3 = Enum.ToObject(_reasonType, 8);
				}
				MethodInfo method2 = _ivroomType.GetMethod("SpawnLootingObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method2 == null)
				{
					message = "SpawnLootingObject not found.";
					return false;
				}
				int num = ((method2.Invoke(room, new object[9] { obj, obj2, flag, obj3, 0, 0, 0L, false, false }) is int num2) ? num2 : 0);
				if (num == 0)
				{
					message = $"Spawn rejected by game for item {masterId}.";
					return false;
				}
				message = $"Spawned item {masterId} x{Math.Max(1, qty)} (objId {num}).";
				return true;
			}
			catch (Exception ex)
			{
				message = "Spawn error: " + ex.Message;
				MelonLogger.Error((object)ex);
				return false;
			}
		}
	}
}