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 System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GeneralPurposeCommands.Patches;
using GeneralPurposeCommands.Utilities;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GeneralPurposeCommands")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+cc2e155a3ebb5b9af24ff59d833a27515495997f")]
[assembly: AssemblyProduct("General Purpose Commands")]
[assembly: AssemblyTitle("GeneralPurposeCommands")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[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;
		}
	}
}
namespace GeneralPurposeCommands
{
	[BepInPlugin("GeneralPurposeCommands", "General Purpose Commands", "1.3.0")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("GeneralPurposeCommands");

		private static Plugin Instance;

		public static ManualLogSource Logger;

		public void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"General Purpose Commands is loaded!");
			harmony.PatchAll(typeof(Plugin));
			harmony.PatchAll(typeof(Commands));
			harmony.PatchAll(typeof(MessageSystem));
			harmony.PatchAll(typeof(ChatControl));
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "GeneralPurposeCommands";

		public const string PLUGIN_NAME = "General Purpose Commands";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}
namespace GeneralPurposeCommands.Utilities
{
	public class Result<T>
	{
		public bool IsOk { get; set; }

		public T Value { get; set; }

		public string ErrorMessage { get; set; }

		public Result(T value)
		{
			IsOk = true;
			Value = value;
		}

		public Result(string errorMessage)
		{
			IsOk = false;
			ErrorMessage = errorMessage;
		}

		public static Result<T> Ok(T value)
		{
			return new Result<T>(value);
		}

		public static Result<T> Err(string errorMessage)
		{
			return new Result<T>(errorMessage);
		}

		public void Match(Action<Result<T>> Ok, Action<Result<T>> Err)
		{
			if (IsOk)
			{
				Ok(this);
			}
			else
			{
				Err(this);
			}
		}
	}
}
namespace GeneralPurposeCommands.Patches
{
	[HarmonyPatch(typeof(ChatManager))]
	internal class ChatControl
	{
		public static InputAction Ctrl = new InputAction("Ctrl", (InputActionType)1, "<Keyboard>/ctrl", (string)null, (string)null, (string)null);

		public static InputAction V = new InputAction("V", (InputActionType)1, "<Keyboard>/v", (string)null, (string)null, (string)null);

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void Awake()
		{
			Ctrl.Enable();
			V.Enable();
		}

		[HarmonyPatch("StateActive")]
		[HarmonyPostfix]
		public static void StateActive()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (Ctrl.IsPressed() && V.WasPressedThisFrame())
			{
				string text = (string)typeof(ChatManager).GetField("chatMessage", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(ChatManager.instance);
				typeof(ChatManager).GetField("chatMessage", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(ChatManager.instance, text + GUIUtility.systemCopyBuffer);
				((TMP_Text)ChatManager.instance.chatText).text = text + GUIUtility.systemCopyBuffer;
				((SemiUI)ChatUI.instance).SemiUITextFlashColor(Color.cyan, 0.2f);
				((SemiUI)ChatUI.instance).SemiUISpringShakeY(2f, 5f, 0.2f);
				MenuManager.instance.MenuEffectClick((MenuClickEffectType)4, (MenuPage)null, 1f, 0.2f, true);
			}
		}
	}
	[HarmonyPatch(typeof(SemiFunc))]
	[HarmonyPatch("Command")]
	public class Commands : MonoBehaviour
	{
		[HarmonyPostfix]
		public static void Additional_Command(string _command)
		{
			string[] array = _command.Trim().Split(" ");
			string text = array[0].ToLower();
			string[] args = ((array.Length >= 2) ? new Span<string>(array, 1, array.Length - 1).ToArray() : Array.Empty<string>());
			Result<string> result2 = text switch
			{
				"addmoney" => AddMoney(args), 
				"listitems" => ListItems(), 
				"spawnitem" => SpawnItem(args), 
				_ => Result<string>.Err("NO_COMMAND_CALLED"), 
			};
			try
			{
				result2.Match(delegate(Result<string> result)
				{
					MessageSystem.Instance.SendMessage(result.Value);
				}, delegate(Result<string> err)
				{
					if (!err.ErrorMessage.Equals("NO_COMMAND_CALLED"))
					{
						MessageSystem.Instance.SendMessage(err.ErrorMessage);
					}
				});
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
			}
		}

		public static Result<string> AddMoney(string[] args)
		{
			if (args.Length == 0)
			{
				string text = "Amount is missing.";
				Plugin.Logger.LogError((object)text);
				return Result<string>.Err(text);
			}
			if (!int.TryParse(args[0], out var result))
			{
				string text2 = "Amount must be an integer type number.";
				Plugin.Logger.LogError((object)text2);
				return Result<string>.Err(text2);
			}
			SemiFunc.StatSetRunCurrency(SemiFunc.StatGetRunCurrency() + result);
			string text3 = $"New Total: {SemiFunc.StatGetRunCurrency()}";
			Plugin.Logger.LogInfo((object)text3);
			return Result<string>.Ok(text3);
		}

		private static Result<string> ListItems()
		{
			string text = "Items:\n";
			foreach (Item value in StatsManager.instance.itemDictionary.Values)
			{
				text = text + value.itemName + "\n";
			}
			text += "\nValuables:\n";
			string[] array = new string[7] { "01 Tiny", "02 Small", "03 Medium", "04 Big", "05 Wide", "06 Tall", "07 Very Tall" };
			GameObject[] array2;
			foreach (string text2 in array)
			{
				array2 = Resources.LoadAll<GameObject>("Valuables/" + text2);
				foreach (GameObject val in array2)
				{
					text = text + ((Object)val).name.Replace("Valuable ", string.Empty) + "\n";
				}
			}
			text += "\nRemoved Items:\n";
			array2 = Resources.LoadAll<GameObject>("Items/Removed Items");
			foreach (GameObject val2 in array2)
			{
				text = text + ((Object)val2).name + "\n";
			}
			Debug.Log((object)text);
			return Result<string>.Ok("Check Logs");
		}

		private static Result<string> SpawnItem(string[] args)
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			int result = 1;
			string text = "";
			if (args.Length != 0)
			{
				if (int.TryParse(args[^1], out result))
				{
					text = args[..^1].Aggregate((string x, string y) => x + " " + y);
				}
				else
				{
					text = args.Aggregate((string x, string y) => x + " " + y);
					result = 1;
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				Debug.LogWarning((object)"Item name is empty!");
				return Result<string>.Err("nuh uh");
			}
			text = text.Trim();
			Item val = null;
			foreach (Item value in StatsManager.instance.itemDictionary.Values)
			{
				if (string.Equals(value.itemAssetName, text, StringComparison.OrdinalIgnoreCase) || string.Equals(value.itemName.Trim(), text, StringComparison.OrdinalIgnoreCase))
				{
					val = value;
					break;
				}
			}
			Transform transform = ((Component)Camera.main).transform;
			Vector3 val2 = transform.position + transform.forward * 2f;
			Quaternion identity = Quaternion.identity;
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)val.prefab == (Object)null)
				{
					Debug.LogWarning((object)("Item prefab is null for: " + text));
					return Result<string>.Err("nuh uh");
				}
				GameObject obj = Resources.Load<GameObject>("Valuables/" + ((Object)val.prefab).name);
				string text2 = (((Object)(object)obj != (Object)null) ? "Valuables/" : "Items/");
				Debug.Log((object)(((Object)(object)obj != (Object)null) ? ("Found valuable prefab in Resources/Valuables. Using '" + text2 + "'.") : ("Valuable prefab not found in Resources/Valuables; using '" + text2 + "' folder.")));
				if (SemiFunc.IsMultiplayer())
				{
					for (int i = 0; i < result; i++)
					{
						InstantiateRoomObject(text2 + ((Object)val.prefab).name, val2 + transform.up * (float)i * 0.2f, identity, 0);
					}
				}
				else
				{
					GameObject val3 = Resources.Load<GameObject>(text2 + ((Object)val.prefab).name);
					if ((Object)(object)val3 != (Object)null)
					{
						for (int j = 0; j < result; j++)
						{
							Object.Instantiate<GameObject>(val3, val2 + transform.up * (float)j * 0.2f, identity);
						}
					}
					else
					{
						Debug.LogWarning((object)("Prefab not found for singleplayer spawn: " + text2 + ((Object)val.prefab).name));
					}
				}
				string itemName = val.itemName;
				Debug.Log((object)("Spawned item: " + itemName + " at " + ((object)(Vector3)(ref val2)).ToString()));
				return Result<string>.Ok("yippee");
			}
			Debug.Log((object)"Item not found in StatsManager; searching Resources subfolders for a valuable prefab.");
			if ((Object)(object)TryLoadValuablePrefab(text, out var foundPath) != (Object)null)
			{
				if (SemiFunc.IsMultiplayer())
				{
					for (int k = 0; k < result; k++)
					{
						InstantiateRoomObject(foundPath, val2 + transform.up * (float)k * 0.2f, identity, 0);
					}
				}
				else
				{
					GameObject val4 = Resources.Load<GameObject>(foundPath);
					if ((Object)(object)val4 != (Object)null)
					{
						for (int l = 0; l < result; l++)
						{
							Object.Instantiate<GameObject>(val4, val2 + transform.up * (float)l * 0.2f, identity);
						}
					}
					else
					{
						Debug.LogWarning((object)("Prefab not found for singleplayer spawn: " + foundPath));
					}
				}
				Debug.Log((object)("Spawned valuable from path: " + foundPath + " at " + ((object)(Vector3)(ref val2)).ToString()));
				return Result<string>.Ok("yippee");
			}
			Debug.LogWarning((object)("No item or valuable found with name: " + text));
			return Result<string>.Err("nuh uh");
		}

		private static GameObject TryLoadValuablePrefab(string searchName, out string foundPath)
		{
			foundPath = "";
			string[] array = new string[7] { "01 Tiny", "02 Small", "03 Medium", "04 Big", "05 Wide", "06 Tall", "07 Very Tall" };
			foreach (string text in array)
			{
				string text2 = "Valuables/" + text + "/";
				GameObject[] array2 = Resources.LoadAll<GameObject>("Valuables/" + text);
				foreach (GameObject val in array2)
				{
					if (string.Equals(((Object)val).name.Replace("Valuable ", string.Empty), searchName, StringComparison.OrdinalIgnoreCase))
					{
						foundPath = text2 + ((Object)val).name;
						return val;
					}
				}
			}
			string text3 = "Items/Removed Items/" + searchName;
			GameObject val2 = Resources.Load<GameObject>(text3);
			if ((Object)(object)val2 != (Object)null)
			{
				foundPath = text3;
				return val2;
			}
			return null;
		}

		public static GameObject InstantiateRoomObject(string prefabName, Vector3 position, Quaternion rotation, byte group = 0, object[] data = null)
		{
			//IL_003c: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			if (PhotonNetwork.CurrentRoom == null)
			{
				Debug.LogError((object)"Can not Instantiate before the client joined/created a room.");
				return null;
			}
			try
			{
				return (GameObject)GetMethod(typeof(PhotonNetwork), "NetworkInstantiate", typeof(InstantiateParameters)).Invoke(null, new object[3]
				{
					(object)new InstantiateParameters(prefabName, position, rotation, group, data, (byte)0, (int[])null, PhotonNetwork.LocalPlayer, PhotonNetwork.ServerTimestamp),
					true,
					false
				});
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
				return null;
			}
		}

		public static MethodInfo GetMethod(Type type, string name, Type uniqueParamType)
		{
			return (from x in type.GetRuntimeMethods()
				where x.Name.Equals(name)
				select x into r
				let p = r.GetParameters()
				where p.Any((ParameterInfo o) => uniqueParamType.IsAssignableFrom(o.ParameterType))
				select r).ToList()[0];
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar))]
	[HarmonyPatch("Awake")]
	internal class MessageSystem : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <SendMessageCoroutine>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string message;

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

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

			[DebuggerHidden]
			public <SendMessageCoroutine>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					PlayerAvatar.instance.ChatMessageSend(message, false);
					return false;
				}
			}

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

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

		public static MessageSystem Instance;

		[HarmonyPostfix]
		public static void Postfix()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = new GameObject("MessageSystem").AddComponent<MessageSystem>();
			}
			else
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
		}

		public void SendMessage(string message)
		{
			((MonoBehaviour)this).StartCoroutine(SendMessageCoroutine(message));
		}

		[IteratorStateMachine(typeof(<SendMessageCoroutine>d__3))]
		public static IEnumerator SendMessageCoroutine(string message)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendMessageCoroutine>d__3(0)
			{
				message = message
			};
		}
	}
}