using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Configgy;
using HarmonyLib;
using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Packets;
using MQTTnet.Protocol;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("WebTestMQTTVersionHost")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("WebTestMQTTVersionHost")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7eb06f5e-d765-4aa9-b273-c87ab21b0de2")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class JsonBindingMQTT
{
	public string path;

	public bool isComposite;

	public string[] compositePath;
}
public class Binding
{
	public string Action { get; set; }

	public string Id { get; set; }

	public string Path { get; set; }

	public string Interactions { get; set; }

	public string Processors { get; set; }
}
public class Root
{
	public List<Binding> Bindings { get; set; }
}
namespace WebTestMQTTVersionHost;

internal class FileHandler
{
	public static byte[] Base64ToFile(string base64String)
	{
		return Convert.FromBase64String(base64String);
	}

	public static void ProcessFile(byte[] fileData, string fileName)
	{
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Processing file...");
		string text = Path.GetExtension(fileName).ToLower();
		switch (text)
		{
		case ".png":
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"It's an image");
			HandlePNG(fileData);
			break;
		case ".wav":
		case ".ogg":
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"It's an audio file");
			HandleAudio(fileData, text);
			break;
		default:
			WebTestMQTTVersionHostPlugin.Log.LogWarning((object)("Unsupported file type: " + text));
			break;
		}
	}

	private static void HandlePNG(byte[] fileData)
	{
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Converted image to base64");
		((MonoBehaviour)MonoSingleton<OptionsMenuToManager>.Instance).StartCoroutine(LoadImage(fileData));
	}

	private static IEnumerator LoadImage(byte[] imageBytes)
	{
		yield return (object)new WaitForSeconds(0.1f);
		if (imageBytes == null || imageBytes.Length == 0)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)"Image byte array is null or empty.");
			yield break;
		}
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Attempting to decode base64 and load image...");
		Texture2D texture = new Texture2D(2, 2);
		try
		{
			if (!ImageConversion.LoadImage(texture, imageBytes))
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)"LoadImage failed to decode byte array.");
				yield break;
			}
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Image loaded successfully. Dimensions: {((Texture)texture).width}x{((Texture)texture).height}");
			Sprite sprite = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f));
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Sprite created.");
			OptionsMenuToManager manager = MonoSingleton<OptionsMenuToManager>.Instance;
			if ((Object)(object)manager != (Object)null)
			{
				GameObject go = new GameObject("Image");
				go.transform.SetParent(((Component)manager).transform, false);
				Image img = go.AddComponent<Image>();
				img.sprite = sprite;
				go.transform.localPosition = Vector3.zero;
				WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Image added to screen.");
			}
			else
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)"OptionsMenuToManager instance is null.");
			}
		}
		catch (Exception ex2)
		{
			Exception ex = ex2;
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Exception during image loading: " + ex.Message));
		}
		yield return null;
	}

	private static void HandleAudio(byte[] fileData, string fileExtension)
	{
		string tempPath = Path.Combine(Application.temporaryCachePath, Guid.NewGuid().ToString() + fileExtension);
		try
		{
			File.WriteAllBytes(tempPath, fileData);
			((MonoBehaviour)MonoSingleton<OptionsMenuToManager>.Instance).StartCoroutine(LoadAudioClip("file://" + tempPath, (AudioType)((fileExtension == ".wav") ? 20 : 14), delegate(AudioClip audioClip)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				if ((Object)(object)audioClip != (Object)null)
				{
					GameObject val = new GameObject("AudioPlayer");
					AudioSource val2 = val.AddComponent<AudioSource>();
					val2.clip = audioClip;
					val2.Play();
					WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Audio is playing!");
					((MonoBehaviour)MonoSingleton<OptionsMenuToManager>.Instance).StartCoroutine(CleanupAfterAudio(val, audioClip));
				}
				else
				{
					WebTestMQTTVersionHostPlugin.Log.LogError((object)"AudioClip is null!");
				}
				((MonoBehaviour)MonoSingleton<OptionsMenuToManager>.Instance).StartCoroutine(DeleteTempFileAfterDelay(tempPath));
			}));
		}
		catch (Exception ex)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Failed to process audio file: " + ex.Message));
		}
	}

	private static IEnumerator LoadAudioClip(string path, AudioType type, Action<AudioClip> onLoaded)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(path, type);
		try
		{
			yield return www.SendWebRequest();
			if (www.isNetworkError || www.isHttpError)
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)("Failed to load audio: " + www.error));
				onLoaded?.Invoke(null);
			}
			else
			{
				AudioClip clip = DownloadHandlerAudioClip.GetContent(www);
				onLoaded?.Invoke(clip);
			}
		}
		finally
		{
			((IDisposable)www)?.Dispose();
		}
	}

	private static IEnumerator DeleteTempFileAfterDelay(string path)
	{
		yield return (object)new WaitForSeconds(1f);
		if (File.Exists(path))
		{
			File.Delete(path);
		}
	}

	private static IEnumerator CleanupAfterAudio(GameObject audioPlayer, AudioClip audioClip)
	{
		yield return (object)new WaitUntil((Func<bool>)(() => !audioPlayer.GetComponent<AudioSource>().isPlaying));
		if ((Object)(object)audioClip != (Object)null)
		{
			Object.Destroy((Object)(object)audioClip);
		}
		if ((Object)(object)audioPlayer != (Object)null)
		{
			Object.Destroy((Object)(object)audioPlayer);
		}
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Audio cleanup completed.");
	}
}
internal class JustATestLogger : MonoBehaviour
{
	private InputManager inman;

	[HideInInspector]
	public OptionsManager opm;

	public List<ActionDisplayConfig> actionConfig;

	private void Awake()
	{
		inman = MonoSingleton<InputManager>.Instance;
		opm = MonoSingleton<OptionsManager>.Instance;
	}

	private void Start()
	{
		bool @bool = MonoSingleton<PrefsManager>.Instance.GetBool("scrollVariations", false);
		bool bool2 = MonoSingleton<PrefsManager>.Instance.GetBool("scrollWeapons", false);
	}

	public void ChangeKey(InputAction action, JsonBindingMQTT path, InputControlScheme scheme)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: 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_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: 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_0139: Unknown result type (might be due to invalid IL or missing references)
		//IL_0378: Unknown result type (might be due to invalid IL or missing references)
		//IL_037d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0382: Unknown result type (might be due to invalid IL or missing references)
		//IL_0391: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_032d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0333: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Unknown result type (might be due to invalid IL or missing references)
		//IL_033a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		if (action == null || path == null)
		{
			Debug.LogError((object)"ChangeKey: One or more required parameters is null");
			return;
		}
		Debug.Log((object)(action.name + " binding path: " + path.path));
		InputManager instance = MonoSingleton<InputManager>.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			Debug.LogError((object)"InputManager instance is null");
			return;
		}
		try
		{
			PlayerInput inputSource = instance.InputSource;
			object obj;
			if (inputSource == null)
			{
				obj = null;
			}
			else
			{
				InputActions actions = inputSource.Actions;
				if (actions == null)
				{
					obj = null;
				}
				else
				{
					InputActionAsset asset = actions.asset;
					obj = ((asset != null) ? ((IEnumerable<InputActionMap>)(object)asset.actionMaps).SelectMany((InputActionMap map) => (IEnumerable<InputAction>)(object)map.actions) : null);
				}
			}
			IEnumerable<InputAction> enumerable = (IEnumerable<InputAction>)obj;
			InputBinding val = ((IEnumerable<InputBinding>)(object)action.bindings).FirstOrDefault((Func<InputBinding, bool>)((InputBinding b) => ((InputBinding)(ref b)).groups == ((InputControlScheme)(ref scheme)).bindingGroup));
			string effectivePath = ((InputBinding)(ref val)).effectivePath;
			BindingSyntax val2;
			if (enumerable != null && effectivePath != null)
			{
				foreach (InputAction item in enumerable)
				{
					if (item == action)
					{
						continue;
					}
					Enumerator<InputBinding> enumerator2 = item.bindings.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							InputBinding current2 = enumerator2.Current;
							if (((InputBinding)(ref current2)).groups == ((InputControlScheme)(ref scheme)).bindingGroup && ((InputBinding)(ref current2)).effectivePath == path.path)
							{
								Debug.Log((object)("Conflicting binding detected: " + item.name + " -> " + path.path + ". Updating to " + effectivePath + "."));
								val2 = InputActionSetupExtensions.ChangeBinding(item, current2);
								((BindingSyntax)(ref val2)).WithPath(effectivePath);
							}
						}
					}
					finally
					{
						((IDisposable)enumerator2).Dispose();
					}
				}
			}
			PlayerInput inputSource2 = instance.InputSource;
			if (inputSource2 != null)
			{
				inputSource2.Disable();
			}
			instance.anyButtonListener?.Dispose();
			InputExtensions.WipeAction(action, ((InputControlScheme)(ref scheme)).bindingGroup);
			if (path.isComposite && path.compositePath != null && path.compositePath.Length != 0)
			{
				if (!(action.expectedControlType == "Vector2"))
				{
					Debug.LogError((object)("Attempted to create composite binding for unsupported control type: '" + action.expectedControlType + "'"));
					return;
				}
				string[] array = new string[4] { "Up", "Down", "Left", "Right" };
				CompositeSyntax val3 = InputActionSetupExtensions.AddCompositeBinding(action, "2DVector", (string)null, (string)null);
				for (int i = 0; i < Mathf.Min(path.compositePath.Length, array.Length); i++)
				{
					if (!string.IsNullOrEmpty(path.compositePath[i]))
					{
						((CompositeSyntax)(ref val3)).With(array[i], path.compositePath[i], ((InputControlScheme)(ref scheme)).bindingGroup, (string)null);
					}
				}
				val = default(InputBinding);
				val2 = InputActionSetupExtensions.AddBinding(action, val);
				((BindingSyntax)(ref val2)).Erase();
			}
			else
			{
				val2 = InputActionSetupExtensions.AddBinding(action, new InputBinding(path.path, (string)null, (string)null, (string)null, (string)null, (string)null));
				((BindingSyntax)(ref val2)).WithGroup(((InputControlScheme)(ref scheme)).bindingGroup);
			}
			PlayerInput inputSource3 = instance.InputSource;
			object obj2;
			if (inputSource3 == null)
			{
				obj2 = null;
			}
			else
			{
				InputActions actions2 = inputSource3.Actions;
				obj2 = ((actions2 != null) ? actions2.asset : null);
			}
			if ((Object)obj2 != (Object)null)
			{
				instance.SaveBindings(instance.InputSource.Actions.asset);
			}
			FileInfo savedBindingsFile = instance.savedBindingsFile;
			if (savedBindingsFile != null && savedBindingsFile.Exists)
			{
				try
				{
					JsonBindingMap val4 = JsonConvert.DeserializeObject<JsonBindingMap>(File.ReadAllText(instance.savedBindingsFile.FullName));
					if (val4 != null)
					{
						val4.ApplyTo(instance.InputSource.Actions.asset);
					}
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("Failed to deserialize or apply binding map: " + ex.Message));
				}
			}
			instance.actionModified?.Invoke(action);
		}
		catch (Exception ex2)
		{
			Debug.LogError((object)("Error in ChangeKey: " + ex2.Message));
		}
		finally
		{
			PlayerInput inputSource4 = instance.InputSource;
			if (inputSource4 != null)
			{
				inputSource4.Enable();
			}
			instance.anyButtonListener = InputManager.onAnyInput.Subscribe((IObserver<InputControl>)ButtonPressListener.Instance);
		}
	}

	private void LateUpdate()
	{
	}

	public void ScrollOn(bool stuff)
	{
		if ((Object)(object)inman == (Object)null)
		{
			inman = MonoSingleton<InputManager>.Instance;
		}
		if (stuff)
		{
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollEnabled", true);
			inman.ScrOn = true;
		}
		else
		{
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollEnabled", false);
			inman.ScrOn = false;
		}
	}

	public void ScrollVariations(int stuff)
	{
		if ((Object)(object)inman == (Object)null)
		{
			inman = MonoSingleton<InputManager>.Instance;
		}
		switch (stuff)
		{
		case 0:
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollWeapons", true);
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollVariations", false);
			inman.ScrWep = true;
			inman.ScrVar = false;
			break;
		case 1:
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollWeapons", false);
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollVariations", true);
			inman.ScrWep = false;
			inman.ScrVar = true;
			break;
		default:
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollWeapons", true);
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollVariations", true);
			inman.ScrWep = true;
			inman.ScrVar = true;
			break;
		}
	}

	public void ScrollReverse(bool stuff)
	{
		if ((Object)(object)inman == (Object)null)
		{
			inman = MonoSingleton<InputManager>.Instance;
		}
		if (stuff)
		{
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollReversed", true);
			inman.ScrRev = true;
		}
		else
		{
			MonoSingleton<PrefsManager>.Instance.SetBool("scrollReversed", false);
			inman.ScrRev = false;
		}
	}
}
internal class MessageHandler : MonoBehaviour
{
	public void HandleMessage(MessageDataJson messageData)
	{
		if (messageData.Value == "infinite")
		{
			messageData.Value = float.PositiveInfinity.ToString();
		}
		else if (messageData.Value == "-infinite")
		{
			messageData.Value = float.NegativeInfinity.ToString();
		}
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Changing shit");
		if (messageData.Type == "text")
		{
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Changing text");
			((MonoBehaviour)this).StartCoroutine(waitalil(messageData));
		}
		if (messageData.Type == "setting")
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has changed " + messageData.Message + " to " + messageData.Value, "", "", 0, false);
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Changing setting");
			HandleSettingData(messageData);
		}
		if (messageData.Type == "graphics")
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has changed " + messageData.Message + " to " + messageData.Value, "", "", 0, false);
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Changing graphics");
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)(((Object)(object)MonoSingleton<GraphicsOptions>.Instance == (Object)null) ? "fucking" : "work"));
			DebugGraphicsOptionsStatus();
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"graphicssssss");
			InvokeGraphicsOptionsMethod(messageData.Message, messageData.Value);
		}
		if (messageData.Type == "file")
		{
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"It is a file");
			HandleFileData(messageData);
		}
		if (messageData.Type == "Control")
		{
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Changing control");
			HandleControlSettingData(messageData);
		}
		if (messageData.Type == "WeaponToggle")
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has put weapon " + messageData.Message + " to " + messageData.Value, "", "", 0, false);
			ChangeWeapon(messageData);
		}
	}

	public void ChangeWeapon(MessageDataJson messageData)
	{
		bool flag = bool.Parse(messageData.Value);
		MonoSingleton<PrefsManager>.Instance.SetInt("weapon." + messageData.Message, flag ? 1 : 0);
		((MonoBehaviour)this).StartCoroutine(WaitALil());
	}

	private IEnumerator WaitALil()
	{
		yield return (object)new WaitForSeconds(0.1f);
		MonoSingleton<GunSetter>.Instance.ResetWeapons(false);
	}

	public void HandleControlSettingData(MessageDataJson controlData)
	{
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Someone set " + controlData.Message + " to " + controlData.Value, "", "", 0, false);
		InputManager instance = MonoSingleton<InputManager>.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			Debug.LogError((object)"Input Manager is null!");
			return;
		}
		PlayerInput inputSource = instance.InputSource;
		if (inputSource == null)
		{
			Debug.LogError((object)"Input Source is null!");
			return;
		}
		InputActionState jump = inputSource.Jump;
		InputAction val = ((jump != null) ? jump.Action : null);
		if (val == null)
		{
			Debug.LogError((object)"Jump Action is null!");
			return;
		}
		Debug.Log((object)"Current Jump Action Bindings:");
		Enumerator<InputBinding> enumerator = val.bindings.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				InputBinding current = enumerator.Current;
				Debug.Log((object)("Path: " + ((InputBinding)(ref current)).path + ", Groups: " + ((InputBinding)(ref current)).groups));
			}
		}
		finally
		{
			((IDisposable)enumerator).Dispose();
		}
		WebTestMQTTVersionHostPlugin.Path = JsonConvert.DeserializeObject<JsonBindingMQTT>(controlData.Value);
		WebTestMQTTVersionHostPlugin.Name = controlData.Message;
		WebTestMQTTVersionHostPlugin.LaunchLoggerthing = true;
	}

	public void HandleSettingData(MessageDataJson settingData)
	{
		try
		{
			Type type = ((object)MonoSingleton<OptionsMenuToManager>.Instance).GetType();
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("Retrieved runtime type: " + type.Name));
			OptionsMenuToManager instance = MonoSingleton<OptionsMenuToManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)"OptionsMenuToManager instance is null.");
				return;
			}
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Successfully retrieved OptionsMenuToManager instance.");
			FieldInfo field = type.GetField(settingData.Message, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo property = type.GetProperty(settingData.Message, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null && property == null)
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)("Field or Property '" + settingData.Message + "' not found in OptionsMenuToManager!"));
				return;
			}
			object obj = ((field != null) ? field.GetValue(instance) : property.GetValue(instance));
			if (obj == null)
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)("Field or Property '" + settingData.Message + "' is null!"));
				return;
			}
			try
			{
				Slider val = (Slider)((obj is Slider) ? obj : null);
				if (val != null)
				{
					if (float.TryParse(settingData.Value, out var result))
					{
						if (val.maxValue < result)
						{
							val.maxValue = result;
						}
						if (val.minValue > result)
						{
							val.minValue = result;
						}
						val.value = result;
						((UnityEvent<float>)(object)val.onValueChanged).Invoke(result);
					}
					else
					{
						WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + settingData.Value + "' for Slider '" + settingData.Message + "'"));
					}
				}
				else
				{
					TMP_Dropdown val2 = (TMP_Dropdown)((obj is TMP_Dropdown) ? obj : null);
					if (val2 != null)
					{
						if (int.TryParse(settingData.Value, out var result2))
						{
							val2.value = result2;
							((UnityEvent<int>)(object)val2.onValueChanged).Invoke(result2);
						}
						else
						{
							WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + settingData.Value + "' for TMP_Dropdown '" + settingData.Message + "'"));
						}
					}
					else
					{
						Toggle val3 = (Toggle)((obj is Toggle) ? obj : null);
						if (val3 != null)
						{
							if (bool.TryParse(settingData.Value, out var result3))
							{
								val3.isOn = result3;
								((UnityEvent<bool>)(object)val3.onValueChanged).Invoke(result3);
							}
							else
							{
								WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + settingData.Value + "' for Toggle '" + settingData.Message + "'"));
							}
						}
						else
						{
							WebTestMQTTVersionHostPlugin.Log.LogError((object)$"Unsupported type '{obj.GetType()}' for '{settingData.Message}'");
						}
					}
				}
			}
			catch (Exception ex)
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)("Error updating '" + settingData.Message + "': " + ex.Message));
			}
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("Successfully updated " + settingData.Message + " with value " + settingData.Value));
		}
		catch (Exception ex2)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Failed to handle setting data: " + ex2.Message + "\n" + ex2.StackTrace));
		}
	}

	public static object InvokeGraphicsOptionsMethod(string methodName, string value = null)
	{
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("Attempting to find and modify variable: " + methodName));
		GraphicsOptions val = MonoSingleton<GraphicsOptions>.Instance;
		if ((Object)(object)val == (Object)null)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)"GraphicsOptions Instance is NULL!");
			WebTestMQTTVersionHostPlugin.Log.LogError((object)"GraphicsOptions Instance is NULL!");
			GraphicsOptions[] array = Object.FindObjectsOfType<GraphicsOptions>();
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Total GraphicsOptions components found: {array.Length}");
			if (array.Length == 0)
			{
				return null;
			}
			val = array[0];
		}
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("GraphicsOptions Type: " + ((object)val).GetType().FullName));
		FieldInfo field = ((object)val).GetType().GetField(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		PropertyInfo property = ((object)val).GetType().GetProperty(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null && property == null)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Field or Property '" + methodName + "' not found in GraphicsOptions!"));
			return null;
		}
		object obj = ((field != null) ? field.GetValue(val) : property.GetValue(val));
		if (obj == null)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Field or Property '" + methodName + "' is null!"));
			return null;
		}
		try
		{
			Slider val2 = (Slider)((obj is Slider) ? obj : null);
			if (val2 != null)
			{
				if (float.TryParse(value, out var result))
				{
					if (val2.maxValue < result)
					{
						val2.maxValue = result;
					}
					if (val2.minValue > result)
					{
						val2.minValue = result;
					}
					val2.value = result;
					((UnityEvent<float>)(object)val2.onValueChanged).Invoke(result);
				}
				else
				{
					WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + value + "' for Slider '" + methodName + "'"));
				}
			}
			else
			{
				TMP_Dropdown val3 = (TMP_Dropdown)((obj is TMP_Dropdown) ? obj : null);
				if (val3 != null)
				{
					if (int.TryParse(value, out var result2))
					{
						val3.value = result2;
						((UnityEvent<int>)(object)val3.onValueChanged).Invoke(result2);
					}
					else
					{
						WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + value + "' for TMP_Dropdown '" + methodName + "'"));
					}
				}
				else
				{
					Toggle val4 = (Toggle)((obj is Toggle) ? obj : null);
					if (val4 != null)
					{
						if (bool.TryParse(value, out var result3))
						{
							val4.isOn = result3;
							((UnityEvent<bool>)(object)val4.onValueChanged).Invoke(result3);
						}
						else
						{
							WebTestMQTTVersionHostPlugin.Log.LogError((object)("Invalid value '" + value + "' for Toggle '" + methodName + "'"));
						}
					}
					else
					{
						WebTestMQTTVersionHostPlugin.Log.LogError((object)$"Unsupported type '{obj.GetType()}' for '{methodName}'");
					}
				}
			}
		}
		catch (Exception ex)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)("Error updating '" + methodName + "': " + ex.Message));
			return null;
		}
		return obj;
	}

	public void CheckWhichItIs(string method, object param, GraphicsOptions options)
	{
		if (method == "Dithering")
		{
			float value = (float)param;
			options.dithering.value = value;
		}
	}

	public static void DebugGraphicsOptionsStatus()
	{
		GraphicsOptions instance = MonoSingleton<GraphicsOptions>.Instance;
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"--- GraphicsOptions Debug ---");
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"MonoSingleton Instance: {(Object)(object)instance != (Object)null}");
		GraphicsOptions[] array = Object.FindObjectsOfType<GraphicsOptions>();
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Total GraphicsOptions in scene: {array.Length}");
		if (array.Length != 0)
		{
			GraphicsOptions[] array2 = array;
			foreach (GraphicsOptions val in array2)
			{
				WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("Found GraphicsOptions Component: " + ((Object)val).name));
			}
		}
	}

	public static void PrintAvailableMethods()
	{
		GraphicsOptions val = Object.FindObjectOfType<GraphicsOptions>();
		if ((Object)(object)val == (Object)null)
		{
			WebTestMQTTVersionHostPlugin.Log.LogError((object)"No GraphicsOptions component found!");
			return;
		}
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Available Methods in GraphicsOptions:");
		MethodInfo[] methods = ((object)val).GetType().GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (MethodInfo methodInfo in methods)
		{
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("- " + methodInfo.Name));
		}
	}

	public void HandleFileData(MessageDataJson messageData)
	{
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Turning Base64 into bytes");
		byte[] fileData = FileHandler.Base64ToFile(messageData.Value);
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Converted Base64 into bytes!");
		FileHandler.ProcessFile(fileData, messageData.FileName);
	}

	private IEnumerator waitalil(MessageDataJson messageData)
	{
		yield return (object)new WaitForSeconds(0.1f);
		HandleTextData(messageData);
	}

	public void HandleTextData(MessageDataJson messageData)
	{
		//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_049e: Unknown result type (might be due to invalid IL or missing references)
		//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a45: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a6b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a70: Unknown result type (might be due to invalid IL or missing references)
		//IL_096b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0991: Unknown result type (might be due to invalid IL or missing references)
		//IL_0996: Unknown result type (might be due to invalid IL or missing references)
		switch (messageData.Message)
		{
		case "DupeEnemies":
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has duped enemies", "", "", 0, false);
			EnemyIdentifier[] array2 = Object.FindObjectsOfType<EnemyIdentifier>();
			foreach (EnemyIdentifier val2 in array2)
			{
				Object.Instantiate<EnemyIdentifier>(val2, ((Component)val2).transform.position, Quaternion.identity);
			}
			break;
		}
		case "BuffEnemies":
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has buffed enemies", "", "", 0, false);
			EnemyIdentifier[] array3 = Object.FindObjectsOfType<EnemyIdentifier>();
			foreach (EnemyIdentifier val4 in array3)
			{
				val4.BuffAll();
			}
			break;
		}
		case "DupeEnemy":
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has duped a random enemy", "", "", 0, false);
			EnemyIdentifier val5 = (from x in Object.FindObjectsOfType<EnemyIdentifier>()
				where !x.dead
				select x).FirstOrDefault();
			if ((Object)(object)val5 != (Object)null)
			{
				Object.Instantiate<EnemyIdentifier>(val5, ((Component)val5).transform.position, Quaternion.identity);
			}
			break;
		}
		case "BuffEnemy":
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has buffed random enemy", "", "", 0, false);
			EnemyIdentifier val3 = (from x in Object.FindObjectsOfType<EnemyIdentifier>()
				where !x.dead
				select x).FirstOrDefault();
			if ((Object)(object)val3 != (Object)null)
			{
				val3.BuffAll();
			}
			break;
		}
		case "SendToLevel":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has send you to " + messageData.Value, "", "", 0, false);
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)("Sending player to level " + messageData.Value));
			HandleLeveling(messageData.Value);
			break;
		case "SpawnPKEY":
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)"Spawning PKEY");
			HandleSpawnPKEY(messageData.Value);
			break;
		case "Yeet":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has yeeted you with force " + messageData.Value, "", "", 0, false);
			MonoSingleton<NewMovement>.Instance.Launch(GenerateRandomVector3(-180f, -180f, -180f, 180f, 180f, 180f), float.Parse(messageData.Value), false);
			break;
		case "SetSpeed":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has put your speed to " + messageData.Value, "", "", 0, false);
			MonoSingleton<NewMovement>.Instance.walkSpeed = float.Parse(messageData.Value);
			break;
		case "SetJump":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has put your jump power to " + messageData.Value, "", "", 0, false);
			MonoSingleton<NewMovement>.Instance.jumpPower = float.Parse(messageData.Value);
			break;
		case "SetDamage":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has set your damage multiplier to " + messageData.Value, "", "", 0, false);
			WebTestMQTTVersionHostPlugin.Instance.DMGMultiPLR = float.Parse(messageData.Value);
			break;
		case "SetDamageEnemy":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has set enemy damage multiplier to " + messageData.Value, "", "", 0, false);
			WebTestMQTTVersionHostPlugin.Instance.DMGMultiENEMY = float.Parse(messageData.Value);
			break;
		case "Dmg":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has damaged you with " + messageData.Value, "", "", 0, false);
			MonoSingleton<NewMovement>.Instance.GetHurt((int)float.Parse(messageData.Value), false, 1f, false, false, 0.35f, false);
			break;
		case "Heal":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has healed you with " + messageData.Value, "", "", 0, false);
			MonoSingleton<NewMovement>.Instance.GetHealth((int)float.Parse(messageData.Value), false, false);
			break;
		case "NoFist":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has removed your fists", "", "", 0, false);
			MonoSingleton<FistControl>.Instance.NoFist();
			break;
		case "NoWeapons":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has removed your weapons", "", "", 0, false);
			MonoSingleton<GunControl>.Instance.NoWeapon();
			break;
		case "YesFist":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has readded your fists", "", "", 0, false);
			MonoSingleton<FistControl>.Instance.YesFist();
			break;
		case "YesWeapons":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has readded your weapons", "", "", 0, false);
			MonoSingleton<GunControl>.Instance.YesWeapon();
			break;
		case "Time":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has set time to " + messageData.Value, "", "", 0, false);
			Time.timeScale = float.Parse(messageData.Value);
			break;
		case "Scale":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has scaled everything by " + messageData.Value, "", "", 0, false);
			{
				foreach (GameObject item in FindAllObjectsInScene())
				{
					if (!IsDescendantOf(item.transform, ((Component)MonoSingleton<NewMovement>.instance).transform) && !((Object)(object)item.GetComponent<RectTransform>() != (Object)null))
					{
						Transform transform2 = item.transform;
						transform2.localScale += new Vector3(float.Parse(messageData.Value), float.Parse(messageData.Value), float.Parse(messageData.Value));
					}
				}
				break;
			}
		case "Move":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has moved everything by " + messageData.Value, "", "", 0, false);
			{
				foreach (GameObject item2 in FindAllObjectsInScene())
				{
					if (!IsDescendantOf(item2.transform, ((Component)MonoSingleton<NewMovement>.instance).transform) && !((Object)(object)item2.GetComponent<RectTransform>() != (Object)null))
					{
						Transform transform = item2.transform;
						transform.position += new Vector3(float.Parse(messageData.Value), float.Parse(messageData.Value), float.Parse(messageData.Value));
					}
				}
				break;
			}
		case "KillAll":
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.User + " has killed all enemies", "", "", 0, false);
			EnemyIdentifier[] array = Object.FindObjectsOfType<EnemyIdentifier>();
			foreach (EnemyIdentifier val in array)
			{
				val.InstaKill();
			}
			break;
		}
		case "SendHudMessage":
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage(messageData.Value, "", "", 0, false);
			break;
		}
	}

	public static GameObject FindObjectEvenIfDisabled(string rootName, string objPath = null, int childNum = 0, bool useChildNum = false)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
		GameObject val = Array.Find(rootGameObjects, (GameObject obj) => ((Object)obj).name == rootName);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		GameObject val2 = val;
		if (!string.IsNullOrEmpty(objPath))
		{
			Transform obj2 = val.transform.Find(objPath);
			val2 = ((obj2 != null) ? ((Component)obj2).gameObject : null);
		}
		if ((Object)(object)val2 != (Object)null && useChildNum && val2.transform.childCount > childNum)
		{
			val2 = ((Component)val2.transform.GetChild(childNum)).gameObject;
		}
		return val2;
	}

	public static List<GameObject> FindAllObjectsInScene()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		List<GameObject> list = new List<GameObject>();
		Scene activeScene = SceneManager.GetActiveScene();
		GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
		GameObject[] array = rootGameObjects;
		foreach (GameObject obj in array)
		{
			CollectAllChildren(obj, list);
		}
		return list;
	}

	private static void CollectAllChildren(GameObject obj, List<GameObject> collectedObjects)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		collectedObjects.Add(obj);
		foreach (Transform item in obj.transform)
		{
			Transform val = item;
			CollectAllChildren(((Component)val).gameObject, collectedObjects);
		}
	}

	public static bool IsDescendantOf(Transform potentialChild, Transform potentialParent)
	{
		Transform val = potentialChild;
		while ((Object)(object)val != (Object)null)
		{
			if ((Object)(object)val == (Object)(object)potentialParent)
			{
				return true;
			}
			val = val.parent;
		}
		return false;
	}

	public static Vector3 GenerateRandomVector3(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
	{
		//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)
		float num = Random.Range(minX, maxX);
		float num2 = Random.Range(minY, maxY);
		float num3 = Random.Range(minZ, maxZ);
		return new Vector3(num, num2, num3);
	}

	public void HandleSpawnPKEY(string jsonData)
	{
		PKEYValueData pKEYValueData = JsonConvert.DeserializeObject<PKEYValueData>(jsonData);
		if (pKEYValueData != null)
		{
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Spawning PKEY {pKEYValueData.PKEY} at {pKEYValueData.Vector3Pos}, relative: {pKEYValueData.Relative}, amount: {pKEYValueData.amount}, delay: {pKEYValueData.delay}");
			((MonoBehaviour)this).StartCoroutine(SpawnPKEYAddressableCoroutine(pKEYValueData));
		}
		else
		{
			WebTestMQTTVersionHostPlugin.Log.LogWarning((object)"Failed to deserialize PKEY data.");
		}
	}

	private IEnumerator SpawnPKEYAddressableCoroutine(PKEYValueData pkeyData)
	{
		Vector3 basePosition = new Vector3(pkeyData.Vector3Pos.x, pkeyData.Vector3Pos.y, pkeyData.Vector3Pos.z);
		for (int i = 0; (float)i < pkeyData.amount; i++)
		{
			SpawnAddressable(position: pkeyData.Relative ? GetRelativePosition(basePosition) : basePosition, pkey: pkeyData.PKEY);
			WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Spawned instance {i + 1}/{pkeyData.amount} of {pkeyData.PKEY}");
			yield return (object)new WaitForSeconds(pkeyData.delay);
		}
	}

	public Vector3 GetRelativePosition(Vector3 position)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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)
		position = ((Component)MonoSingleton<NewMovement>.instance).transform.position + position;
		return position;
	}

	public void SpawnAddressable(string pkey, Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Spawning addressable {pkey} at {position}");
		AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)pkey);
		val.Completed += delegate(AsyncOperationHandle<GameObject> op)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((int)op.Status == 1)
			{
				GameObject val2 = Object.Instantiate<GameObject>(op.Result, position, Quaternion.identity);
				WebTestMQTTVersionHostPlugin.Log.LogInfo((object)$"Successfully spawned {pkey} at {position}");
			}
			else
			{
				WebTestMQTTVersionHostPlugin.Log.LogError((object)("Failed to load addressable " + pkey + ". Error: " + op.OperationException?.Message));
			}
		};
	}

	public void HandleLeveling(string levelText)
	{
		SceneHelper.LoadScene(levelText, false);
	}
}
[BepInPlugin("com.michi.WebTestMQTTVersionHost", "WebTestMQTTVersionHost", "1.0.0")]
public class WebTestMQTTVersionHostPlugin : BaseUnityPlugin
{
	private const string MyGUID = "com.michi.WebTestMQTTVersionHost";

	private const string PluginName = "WebTestMQTTVersionHost";

	private const string VersionString = "1.0.0";

	private static readonly Harmony Harmony = new Harmony("com.michi.WebTestMQTTVersionHost");

	public static ManualLogSource Log = new ManualLogSource("WebTestMQTTVersionHost");

	private ConfigEntry<string> BrokerAddress;

	private ConfigEntry<int> BrokerPort;

	private ConfigEntry<string> BrokerUsername;

	private ConfigEntry<string> BrokerPassword;

	private const string Topic = "messages/actors";

	private const string EncryptionKey = "MySecureKey123!";

	private MessageHandler handler;

	public static bool LaunchLoggerthing = false;

	public static string Name = "";

	public static JsonBindingMQTT Path = null;

	private IMqttClient mqttClient;

	public static JsonBindingMap map;

	private JustATestLogger thingthatisntactualyatestanymore;

	public float DMGMultiPLR = 1f;

	public float DMGMultiENEMY = 1f;

	[Configgable("Setup", null, 4, null)]
	public static ConfigButton Connect = new ConfigButton((Action)async delegate
	{
		await Instance.InitializeMqttClientAsync();
	}, (string)null);

	public static WebTestMQTTVersionHostPlugin Instance { get; private set; }

	private async void Start()
	{
		Instance = this;
		handler = ((Component)this).gameObject.AddComponent<MessageHandler>();
		thingthatisntactualyatestanymore = ((Component)this).gameObject.AddComponent<JustATestLogger>();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Starting Host Mod...");
		BrokerAddress = ((BaseUnityPlugin)this).Config.Bind<string>("Setup", "Broker Address", "", (ConfigDescription)null);
		BrokerPort = ((BaseUnityPlugin)this).Config.Bind<int>("Setup", "Broker Port", 8883, (ConfigDescription)null);
		BrokerUsername = ((BaseUnityPlugin)this).Config.Bind<string>("Setup", "Broker Username", "", "Optional");
		BrokerPassword = ((BaseUnityPlugin)this).Config.Bind<string>("Setup", "Broker Password", "", "Optional");
		ConfigBuilder builder = new ConfigBuilder((string)null, (string)null);
		builder.BuildAll();
	}

	private async Task InitializeMqttClientAsync()
	{
		MqttFactory factory = new MqttFactory();
		mqttClient = factory.CreateMqttClient();
		MqttClientOptionsBuilder optionsBuilder = new MqttClientOptionsBuilder().WithTcpServer(BrokerAddress.Value, (int?)BrokerPort.Value, AddressFamily.Unspecified).WithTlsOptions(new MqttClientTlsOptions
		{
			UseTls = true,
			AllowUntrustedCertificates = false,
			CertificateValidationHandler = (MqttClientCertificateValidationEventArgs context) => true
		});
		if (!string.IsNullOrEmpty(BrokerUsername.Value) && !string.IsNullOrEmpty(BrokerPassword.Value))
		{
			optionsBuilder.WithCredentials(BrokerUsername.Value, BrokerPassword.Value);
		}
		MqttClientOptions options = optionsBuilder.Build();
		try
		{
			mqttClient.ConnectedAsync += async delegate
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Connected to MQTT broker at {BrokerAddress}:{BrokerPort}.");
				MonoSingleton<HudMessageReceiver>.instance.SendHudMessage("Succesfully connected to the broker!", "", "", 0, false);
				await MqttClientExtensions.SubscribeAsync(mqttClient, "messages/actors", (MqttQualityOfServiceLevel)0, default(CancellationToken));
			};
			mqttClient.DisconnectedAsync += delegate
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Disconnected from MQTT broker.");
				return Task.CompletedTask;
			};
			mqttClient.ApplicationMessageReceivedAsync += delegate(MqttApplicationMessageReceivedEventArgs e)
			{
				string @string = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
				string text = DecryptMessage(@string, "MySecureKey123!");
				MessageDataJson messageDataJson = JsonConvert.DeserializeObject<MessageDataJson>(text);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Received message: message: " + messageDataJson.Message + ", Type: " + messageDataJson.Type + ", Value: " + messageDataJson.Value));
				handler.HandleMessage(messageDataJson);
				return Task.CompletedTask;
			};
			await mqttClient.ConnectAsync(options, default(CancellationToken));
		}
		catch (Exception ex)
		{
			MonoSingleton<HudMessageReceiver>.instance.SendHudMessage("Failed to connect to broker. Check console for more info.", "", "", 0, false);
			((BaseUnityPlugin)this).Logger.LogError((object)("Failed to connect to MQTT Broker: " + ex.Message));
		}
	}

	private static string DecryptMessage(string encryptedText, string key)
	{
		using Aes aes = Aes.Create();
		aes.Key = Encoding.UTF8.GetBytes(key.PadRight(32).Substring(0, 32));
		aes.IV = new byte[16];
		ICryptoTransform cryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV);
		byte[] array = Convert.FromBase64String(encryptedText);
		byte[] bytes = cryptoTransform.TransformFinalBlock(array, 0, array.Length);
		return Encoding.UTF8.GetString(bytes);
	}

	private void OnDestroy()
	{
		IMqttClient obj = mqttClient;
		if (obj != null)
		{
			MqttClientExtensions.DisconnectAsync(obj, (MqttClientDisconnectOptionsReason)0, (string)null, 0u, (List<MqttUserProperty>)null, default(CancellationToken));
		}
	}

	private void Awake()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: WebTestMQTTVersionHost, VersionString: 1.0.0 is loading...");
		Harmony.PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: WebTestMQTTVersionHost, VersionString: 1.0.0 is loaded.");
		Log = ((BaseUnityPlugin)this).Logger;
	}

	private void Update()
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		if (LaunchLoggerthing)
		{
			LaunchLoggerthing = false;
			InputAction val = MonoSingleton<InputManager>.instance.InputSource.Actions.FindAction(Name, false);
			if (val != null && Path != null && Path.path != null)
			{
				thingthatisntactualyatestanymore.ChangeKey(val, Path, MonoSingleton<InputManager>.instance.InputSource.Actions.KeyboardMouseScheme);
			}
		}
	}
}
[Serializable]
public class SerializableVector3
{
	public float x;

	public float y;

	public float z;

	public SerializableVector3(Vector3 vector)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		x = vector.x;
		y = vector.y;
		z = vector.z;
	}

	public Vector3 ToVector3()
	{
		//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_001b: Unknown result type (might be due to invalid IL or missing references)
		return new Vector3(x, y, z);
	}
}
public class PKEYValueData
{
	public string PKEY;

	public SerializableVector3 Vector3Pos;

	public bool Relative;

	public float delay;

	public float amount;
}
public class JsonBindingMQTT
{
	public string path;

	public bool isComposite;

	public string[] compositePath;
}
public class MessageDataJson
{
	public string User { get; set; }

	public string Message { get; set; }

	public string Type { get; set; }

	public string Value { get; set; }

	public string FileName { get; set; }
}
[HarmonyPatch(typeof(Slider), "UpdateDrag")]
public class UnrestrictedSliderDragPatch
{
	private static bool Prefix(Slider __instance, PointerEventData eventData, Camera cam)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_0037: Expected I4, but got Unknown
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Expected I4, but got Unknown
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Expected I4, but got Unknown
		RectTransform val = __instance.m_HandleContainerRect ?? __instance.m_FillContainerRect;
		if ((Object)(object)val != (Object)null)
		{
			Rect rect = val.rect;
			Vector2 val2 = ((Rect)(ref rect)).size;
			if (((Vector2)(ref val2))[(int)__instance.axis] > 0f)
			{
				Vector2 zero = Vector2.zero;
				MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref zero);
				Vector2 val3 = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(val, zero, cam, ref val3);
				Vector2 val4 = val3;
				rect = val.rect;
				val3 = val4 - ((Rect)(ref rect)).position;
				rect = val.rect;
				val2 = ((Rect)(ref rect)).size;
				float num = ((Vector2)(ref val2))[(int)__instance.axis];
				val2 = val3 - __instance.m_Offset;
				float num2 = ((Vector2)(ref val2))[(int)__instance.axis] / num;
				__instance.m_Value = Mathf.Lerp(__instance.minValue, __instance.maxValue, num2);
				__instance.UpdateVisuals();
				UISystemProfilerApi.AddMarker("Slider.value", (Object)(object)__instance);
				((UnityEvent<float>)(object)__instance.m_OnValueChanged).Invoke(__instance.m_Value);
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(NewMovement), "GetHurt")]
public class PLRDAMAGE
{
	public static bool Prefix(ref int damage)
	{
		damage *= (int)WebTestMQTTVersionHostPlugin.Instance.DMGMultiPLR;
		return true;
	}
}
[HarmonyPatch(typeof(EnemyIdentifier), "DeliverDamage")]
public class EnemyDAMAGE
{
	public static bool Prefix(ref float multiplier)
	{
		multiplier *= (int)WebTestMQTTVersionHostPlugin.Instance.DMGMultiENEMY;
		return true;
	}
}
[Serializable]
public class MeshData
{
	public Vector3[] vertices;

	public Vector3[] normals;

	public Vector2[] uvs;

	public int[] triangles;
}
[Serializable]
public class MaterialData
{
	public string name;

	public string shaderName;

	public string textureName;
}
[Serializable]
public class ModelData
{
	public MeshData[] meshes;

	public MaterialData[] materials;
}