using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.BoneMenu.Elements;
using BoneLib.Notifications;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using OBSWebsocketDotNet;
using OBSWebsocketDotNet.Types;
using OBSWebsocketDotNet.Types.Events;
using UnityEngine;
using UnityEngine.Diagnostics;
using WeatherElectric.OBSControl;
using WeatherElectric.OBSControl.Handlers;
using WeatherElectric.OBSControl.Melon;
using WeatherElectric.OBSControl.Menu;
using WeatherElectric.OBSControl.OBS;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Control OBS from within BONELAB.")]
[assembly: AssemblyDescription("Control OBS from within BONELAB.")]
[assembly: AssemblyCompany("Weather Electric")]
[assembly: AssemblyProduct("OBSControl")]
[assembly: AssemblyCopyright("Developed by SoulWithMae")]
[assembly: AssemblyTrademark("Weather Electric")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: MelonInfo(typeof(Main), "OBSControl", "1.0.0", "SoulWithMae", "https://thunderstore.io/c/bonelab/p/SoulWithMae/OBSControl/")]
[assembly: MelonColor(ConsoleColor.White)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 WeatherElectric.OBSControl
{
	internal static class ControlHandler
	{
		private static bool _isFirstTap;

		private static float _doubleTapTimer;

		public static void Update()
		{
			switch (Preferences.ReplayControlHand.Value)
			{
			case ControlHand.Left:
				HandleLeft();
				break;
			case ControlHand.Right:
				HandleRight();
				break;
			case ControlHand.Both:
				HandleBoth();
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			if (_isFirstTap)
			{
				_doubleTapTimer += Time.deltaTime;
				if (_doubleTapTimer > Preferences.DoubleTapTime.Value)
				{
					_isFirstTap = false;
				}
			}
			static void HandleBoth()
			{
				if (Player.rightController._menuTap || Player.leftController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
			static void HandleLeft()
			{
				if (Player.leftController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
			static void HandleRight()
			{
				if (Player.rightController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
		}
	}
	public class Main : MelonMod
	{
		internal const string Name = "OBSControl";

		internal const string Description = "Control OBS from within BONELAB.";

		internal const string Author = "SoulWithMae";

		internal const string Company = "Weather Electric";

		internal const string Version = "1.0.0";

		internal const string DownloadLink = "https://thunderstore.io/c/bonelab/p/SoulWithMae/OBSControl/";

		private static bool _rigExists;

		public override void OnInitializeMelon()
		{
			ModConsole.Setup(((MelonBase)this).LoggerInstance);
			Preferences.Setup();
			ObsBridge.Connect();
			ObsBridge.InitHooks();
			Hooking.OnLevelInitialized += OnLevelLoaded;
			Hooking.OnLevelUnloaded += OnLevelUnloaded;
		}

		public override void OnLateInitializeMelon()
		{
			BoneMenu.SetupBaseMenu();
		}

		public override void OnApplicationQuit()
		{
			ObsBridge.Disconnect();
		}

		public override void OnUpdate()
		{
			if (_rigExists)
			{
				ControlHandler.Update();
			}
		}

		private static void OnLevelLoaded(LevelInfo levelInfo)
		{
			_rigExists = true;
		}

		private static void OnLevelUnloaded()
		{
			_rigExists = false;
		}
	}
}
namespace WeatherElectric.OBSControl.OBS
{
	public static class ObsBridge
	{
		private static readonly OBSWebsocket Obs = new OBSWebsocket();

		public static Action<object, RecordStateChangedEventArgs> OnRecordStateChanged;

		public static Action<object, ReplayBufferSavedEventArgs> OnReplayBufferSaved;

		public static Action<object, ReplayBufferStateChangedEventArgs> OnReplayBufferStateChanged;

		public static Action<object, StreamStateChangedEventArgs> OnStreamStateChanged;

		public static Action<object, ProgramSceneChangedEventArgs> OnSceneChanged;

		public static Action<object, SceneCreatedEventArgs> OnSceneCreated;

		public static Action<object, VirtualcamStateChangedEventArgs> OnVirtualCamStateChanged;

		public static Action<object, SceneRemovedEventArgs> OnSceneRemoved;

		private static void RecordStateChanged(object sender, RecordStateChangedEventArgs e)
		{
			OnRecordStateChanged?.Invoke(sender, e);
		}

		private static void ReplaySaved(object sender, ReplayBufferSavedEventArgs e)
		{
			OnReplayBufferSaved?.Invoke(sender, e);
		}

		private static void ReplayStateChanged(object sender, ReplayBufferStateChangedEventArgs e)
		{
			OnReplayBufferStateChanged?.Invoke(sender, e);
		}

		private static void StreamStateChanged(object sender, StreamStateChangedEventArgs e)
		{
			OnStreamStateChanged?.Invoke(sender, e);
		}

		private static void SceneChanged(object sender, ProgramSceneChangedEventArgs e)
		{
			OnSceneChanged?.Invoke(sender, e);
		}

		private static void VirtualCamStateChanged(object sender, VirtualcamStateChangedEventArgs e)
		{
			OnVirtualCamStateChanged?.Invoke(sender, e);
		}

		private static void SceneCreated(object sender, SceneCreatedEventArgs e)
		{
			OnSceneCreated?.Invoke(sender, e);
		}

		private static void SceneRemoved(object sender, SceneRemovedEventArgs e)
		{
		}

		internal static void Connect()
		{
			//IL_002f: Expected O, but got Unknown
			try
			{
				Obs.ConnectAsync(Preferences.WebsocketURL.Value, Preferences.WebsocketPassword.Value);
			}
			catch (AuthFailureException)
			{
				ModConsole.Error("Failed to authenticate with OBS. Check your password.");
			}
			catch (ErrorResponseException val2)
			{
				ErrorResponseException val3 = val2;
				ModConsole.Error("Failed to connect to OBS. Error: " + ((Exception)(object)val3).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to connect to OBS. Error: " + ex.Message);
			}
		}

		internal static void Disconnect()
		{
			Obs.Disconnect();
		}

		internal static void InitHooks()
		{
			Obs.RecordStateChanged += RecordStateChanged;
			Obs.ReplayBufferSaved += ReplaySaved;
			Obs.ReplayBufferStateChanged += ReplayStateChanged;
			Obs.StreamStateChanged += StreamStateChanged;
			Obs.CurrentProgramSceneChanged += SceneChanged;
			Obs.VirtualcamStateChanged += VirtualCamStateChanged;
			Obs.SceneCreated += SceneCreated;
			Obs.SceneRemoved += SceneRemoved;
		}

		public static List<SceneBasicInfo> GetScenes()
		{
			return Obs.GetSceneList().Scenes;
		}

		public static void SetScene(string sceneName)
		{
			Obs.SetCurrentProgramScene(sceneName);
		}

		public static bool IsConnected()
		{
			return Obs.IsConnected;
		}

		public static bool IsRecording()
		{
			return Obs.GetRecordStatus().IsRecording;
		}

		public static bool IsRecordingPaused()
		{
			return Obs.GetRecordStatus().IsRecordingPaused;
		}

		public static bool IsStreaming()
		{
			return Obs.GetStreamStatus().IsActive;
		}

		public static bool IsReplayBufferActive()
		{
			return Obs.GetReplayBufferStatus();
		}

		public static bool IsVirtualCamActive()
		{
			return Obs.GetVirtualCamStatus().IsActive;
		}

		public static void StartRecording()
		{
			//IL_0016: Expected O, but got Unknown
			if (IsRecording())
			{
				return;
			}
			try
			{
				Obs.StartRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start recording. Error: " + ex.Message);
			}
		}

		public static void PauseRecording()
		{
			//IL_0016: Expected O, but got Unknown
			if (IsRecordingPaused())
			{
				return;
			}
			try
			{
				Obs.PauseRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to pause recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to pause recording. Error: " + ex.Message);
			}
		}

		public static void ResumeRecording()
		{
			//IL_0016: Expected O, but got Unknown
			if (!IsRecordingPaused())
			{
				return;
			}
			try
			{
				Obs.ResumeRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to resume recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to resume recording. Error: " + ex.Message);
			}
		}

		public static void StopRecording()
		{
			//IL_0017: Expected O, but got Unknown
			if (!IsRecording())
			{
				return;
			}
			try
			{
				Obs.StopRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop recording. Error: " + ex.Message);
			}
		}

		public static void StartStreaming()
		{
			//IL_0016: Expected O, but got Unknown
			if (IsStreaming())
			{
				return;
			}
			try
			{
				Obs.StartStream();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start streaming. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start streaming. Error: " + ex.Message);
			}
		}

		public static void StopStreaming()
		{
			//IL_0016: Expected O, but got Unknown
			if (!IsStreaming())
			{
				return;
			}
			try
			{
				Obs.StopStream();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop streaming. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop streaming. Error: " + ex.Message);
			}
		}

		public static void StartReplayBuffer()
		{
			//IL_0016: Expected O, but got Unknown
			if (IsReplayBufferActive())
			{
				return;
			}
			try
			{
				Obs.StartReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start replay buffer. Error: " + ex.Message);
			}
		}

		public static void StopReplayBuffer()
		{
			//IL_0016: Expected O, but got Unknown
			if (!IsReplayBufferActive())
			{
				return;
			}
			try
			{
				Obs.StopReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop replay buffer. Error: " + ex.Message);
			}
		}

		public static void SaveReplayBuffer()
		{
			//IL_0016: Expected O, but got Unknown
			if (!IsReplayBufferActive())
			{
				return;
			}
			try
			{
				Obs.SaveReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to save replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to save replay buffer. Error: " + ex.Message);
			}
		}
	}
}
namespace WeatherElectric.OBSControl.Melon
{
	internal static class ModConsole
	{
		private static Instance _logger;

		public static void Setup(Instance loggerInstance)
		{
			_logger = loggerInstance;
		}

		public static void Msg(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text);
			}
		}

		public static void Msg(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text);
			}
		}

		public static void Msg(ConsoleColor txtcolor, object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text);
			}
		}

		public static void Msg(ConsoleColor txtcolor, string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text);
			}
		}

		public static void Msg(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text, args);
			}
		}

		public static void Msg(ConsoleColor txtcolor, string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text, args);
			}
		}

		public static void Error(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text);
			}
		}

		public static void Error(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text);
			}
		}

		public static void Error(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text, args);
			}
		}

		public static void Warning(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text);
			}
		}

		public static void Warning(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text);
			}
		}

		public static void Warning(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text, args);
			}
		}
	}
	internal static class Preferences
	{
		public static readonly MelonPreferences_Category GlobalCategory = MelonPreferences.CreateCategory("Global");

		public static readonly MelonPreferences_Category OwnCategory = MelonPreferences.CreateCategory("OBSControl");

		public static MelonPreferences_Entry<int> LoggingMode { get; set; }

		public static MelonPreferences_Entry<bool> ShowNotifications { get; set; }

		public static MelonPreferences_Entry<string> WebsocketURL { get; set; }

		public static MelonPreferences_Entry<string> WebsocketPassword { get; set; }

		public static MelonPreferences_Entry<ControlHand> ReplayControlHand { get; set; }

		public static MelonPreferences_Entry<float> DoubleTapTime { get; set; }

		public static void Setup()
		{
			LoggingMode = GlobalCategory.GetEntry<int>("LoggingMode") ?? GlobalCategory.CreateEntry<int>("LoggingMode", 0, "Logging Mode", "The level of logging to use. 0 = Important Only, 1 = All", false, false, (ValueValidator)null, (string)null);
			GlobalCategory.SetFilePath(MelonUtils.UserDataDirectory + "/WeatherElectric.cfg");
			GlobalCategory.SaveToFile(false);
			ShowNotifications = OwnCategory.CreateEntry<bool>("ShowNotifications", true, "Show Notifications", "Whether to show notifications when OBS events occur.", false, false, (ValueValidator)null, (string)null);
			WebsocketURL = OwnCategory.CreateEntry<string>("WebsocketURL", "ws://127.0.0.1:4455", "Websocket URL", "The URL to use for the websocket connection. Usually don't have to change this.", false, false, (ValueValidator)null, (string)null);
			WebsocketPassword = OwnCategory.CreateEntry<string>("WebsocketPassword", "REPLACEME", "Websocket Password", "The password to use for the websocket connection. Change this to the password you set in OBS.", false, false, (ValueValidator)null, (string)null);
			ReplayControlHand = OwnCategory.CreateEntry<ControlHand>("ReplayControlHand", ControlHand.Right, "Replay Control Hand", "The hand to use for saving replays. Left = Left hand, Right = Right hand, Both = Both hands.", false, false, (ValueValidator)null, (string)null);
			DoubleTapTime = OwnCategory.CreateEntry<float>("DoubleTapTime", 0.3f, "Double Tap Time", "The time to wait between taps to trigger saving a replay.", false, false, (ValueValidator)null, (string)null);
			OwnCategory.SetFilePath(MelonUtils.UserDataDirectory + "/WeatherElectric.cfg");
			OwnCategory.SaveToFile(false);
			ModConsole.Msg("Finished preferences setup for OBSControl", 1);
		}
	}
	internal enum ControlHand
	{
		Left,
		Right,
		Both
	}
}
namespace WeatherElectric.OBSControl.Handlers
{
	internal static class NotificationHandler
	{
		public static Notification SceneChanged { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Scene Changed"),
			Message = NotificationText.op_Implicit("Scene has been changed."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Started"),
			Message = NotificationText.op_Implicit("Recording has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Stopped"),
			Message = NotificationText.op_Implicit("Recording has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingPaused { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Paused"),
			Message = NotificationText.op_Implicit("Recording has been paused."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingResumed { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Resumed"),
			Message = NotificationText.op_Implicit("Recording has been resumed."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification StreamStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Stream Started"),
			Message = NotificationText.op_Implicit("Stream has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification StreamStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Stream Stopped"),
			Message = NotificationText.op_Implicit("Stream has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplayBufferStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Buffer Started"),
			Message = NotificationText.op_Implicit("Replay buffer has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplayBufferStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Buffer Stopped"),
			Message = NotificationText.op_Implicit("Replay buffer has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplaySaved { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Saved"),
			Message = NotificationText.op_Implicit("Replay has been saved."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static void SendNotif(Notification notification)
		{
			if (Preferences.ShowNotifications.Value)
			{
				Notifier.Send(notification);
			}
		}
	}
}
namespace WeatherElectric.OBSControl.Menu
{
	internal static class BoneMenu
	{
		private static MenuCategory _subCat;

		private static FunctionElement _recordButton;

		private static FunctionElement _pauseButton;

		private static FunctionElement _streamButton;

		private static FunctionElement _replayButton;

		private static SubPanelElement _scenesPanel;

		private static readonly List<FunctionElement> SceneButtons = new List<FunctionElement>();

		public static void SetupBaseMenu()
		{
			_subCat = MenuManager.CreateCategory("Weather Electric", "#6FBDFF").CreateCategory("OBSControl", "#284cb8");
			CheckIfConnected();
		}

		private static void CheckIfConnected()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!ObsBridge.IsConnected())
			{
				_subCat.CreateFunctionElement("OBS is not connected! Restart the game with OBS open!", Color.red, (Action)delegate
				{
					Utils.ForceCrash((ForcedCrashCategory)2);
				}, "This will crash the game intentionally to close the game!");
			}
			else
			{
				SetupObsControls();
			}
		}

		private static void SetupObsControls()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			SubPanelElement obj = _subCat.CreateSubPanel("Record", Color.green);
			_recordButton = obj.CreateFunctionElement("Record Button", Color.green, (Action)delegate
			{
				if (ObsBridge.IsRecording())
				{
					ObsBridge.StopRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingStopped);
				}
				else
				{
					ObsBridge.StartRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingStarted);
				}
			});
			SetRecordButton(ObsBridge.IsRecording());
			_pauseButton = obj.CreateFunctionElement("Pause Button", Color.yellow, (Action)delegate
			{
				if (ObsBridge.IsRecordingPaused())
				{
					ObsBridge.ResumeRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingResumed);
				}
				else
				{
					ObsBridge.PauseRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingPaused);
				}
			});
			SetPauseButton(ObsBridge.IsRecordingPaused());
			_streamButton = _subCat.CreateSubPanel("Stream", Color.blue).CreateFunctionElement("Stream Button", Color.blue, (Action)delegate
			{
				if (ObsBridge.IsStreaming())
				{
					ObsBridge.StopStreaming();
					NotificationHandler.SendNotif(NotificationHandler.StreamStopped);
				}
				else
				{
					ObsBridge.StartStreaming();
					NotificationHandler.SendNotif(NotificationHandler.StreamStarted);
				}
			});
			SetStreamButton(ObsBridge.IsStreaming());
			SubPanelElement obj2 = _subCat.CreateSubPanel("Replay", Color.yellow);
			_replayButton = obj2.CreateFunctionElement("Replay Button", Color.blue, (Action)delegate
			{
				if (ObsBridge.IsReplayBufferActive())
				{
					ObsBridge.StopReplayBuffer();
					NotificationHandler.SendNotif(NotificationHandler.ReplayBufferStopped);
				}
				else
				{
					ObsBridge.StartReplayBuffer();
					NotificationHandler.SendNotif(NotificationHandler.ReplayBufferStarted);
				}
			});
			SetReplayButton(ObsBridge.IsReplayBufferActive());
			obj2.CreateFunctionElement("Save Replay", Color.blue, (Action)delegate
			{
				ObsBridge.SaveReplayBuffer();
				NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
			});
			_scenesPanel = _subCat.CreateSubPanel("Scenes", Color.red);
			foreach (SceneBasicInfo scene in ObsBridge.GetScenes())
			{
				FunctionElement item = _scenesPanel.CreateFunctionElement(scene.Name, Color.white, (Action)delegate
				{
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					ObsBridge.SetScene(scene.Name);
					NotificationHandler.SceneChanged.Message = NotificationText.op_Implicit("Scene changed to " + scene.Name);
					NotificationHandler.SendNotif(NotificationHandler.SceneChanged);
				});
				SceneButtons.Add(item);
			}
			SubPanelElement category = _subCat.CreateSubPanel("Settings", Color.gray);
			category.CreateBoolPreference("Show Notifications", Color.white, Preferences.ShowNotifications, Preferences.OwnCategory);
			category.CreateEnumPreference<ControlHand>("Replay Control Hand", Color.white, Preferences.ReplayControlHand, Preferences.OwnCategory);
			category.CreateFloatPreference("Double Tap Time", Color.white, 0.1f, 0.1f, 1f, Preferences.DoubleTapTime, Preferences.OwnCategory);
			ConnectHooks();
		}

		private static void ConnectHooks()
		{
			ObsBridge.OnRecordStateChanged = (Action<object, RecordStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnRecordStateChanged, new Action<object, RecordStateChangedEventArgs>(RecordStatusChanged));
			ObsBridge.OnStreamStateChanged = (Action<object, StreamStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnStreamStateChanged, new Action<object, StreamStateChangedEventArgs>(StreamStatusChanged));
			ObsBridge.OnReplayBufferStateChanged = (Action<object, ReplayBufferStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnReplayBufferStateChanged, new Action<object, ReplayBufferStateChangedEventArgs>(ReplayStatusChanged));
			ObsBridge.OnSceneCreated = (Action<object, SceneCreatedEventArgs>)Delegate.Combine(ObsBridge.OnSceneCreated, new Action<object, SceneCreatedEventArgs>(SceneCreated));
			ObsBridge.OnSceneRemoved = (Action<object, SceneRemovedEventArgs>)Delegate.Combine(ObsBridge.OnSceneRemoved, new Action<object, SceneRemovedEventArgs>(SceneDeleted));
		}

		private static void RecordStatusChanged(object sender, RecordStateChangedEventArgs e)
		{
			SetRecordButton(((OutputStateChanged)e.OutputState).IsActive);
		}

		private static void StreamStatusChanged(object sender, StreamStateChangedEventArgs e)
		{
			SetStreamButton(e.OutputState.IsActive);
		}

		private static void ReplayStatusChanged(object sender, ReplayBufferStateChangedEventArgs e)
		{
			SetReplayButton(e.OutputState.IsActive);
		}

		private static void SceneCreated(object sender, SceneCreatedEventArgs e)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			FunctionElement item = _scenesPanel.CreateFunctionElement(e.SceneName, Color.white, (Action)delegate
			{
				ObsBridge.SetScene(e.SceneName);
			});
			SceneButtons.Add(item);
		}

		private static void SceneDeleted(object sender, SceneRemovedEventArgs e)
		{
			using IEnumerator<FunctionElement> enumerator = SceneButtons.Where((FunctionElement button) => ((MenuElement)button).Name == e.SceneName).GetEnumerator();
			if (enumerator.MoveNext())
			{
				FunctionElement current = enumerator.Current;
				_scenesPanel.RemoveElement((MenuElement)(object)current);
				SceneButtons.Remove(current);
			}
		}

		private static void SetRecordButton(bool isRecording)
		{
			//IL_0027: 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)
			if (isRecording)
			{
				((MenuElement)_recordButton).SetColor(Color.red);
				((MenuElement)_recordButton).SetName("Stop Recording");
			}
			else
			{
				((MenuElement)_recordButton).SetColor(Color.green);
				((MenuElement)_recordButton).SetName("Start Recording");
			}
		}

		private static void SetPauseButton(bool isPaused)
		{
			//IL_0027: 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)
			if (isPaused)
			{
				((MenuElement)_pauseButton).SetColor(Color.white);
				((MenuElement)_pauseButton).SetName("Resume Recording");
			}
			else
			{
				((MenuElement)_pauseButton).SetColor(Color.yellow);
				((MenuElement)_pauseButton).SetName("Pause Recording");
			}
		}

		private static void SetStreamButton(bool isStreaming)
		{
			//IL_0027: 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)
			if (isStreaming)
			{
				((MenuElement)_streamButton).SetColor(Color.red);
				((MenuElement)_streamButton).SetName("Stop Streaming");
			}
			else
			{
				((MenuElement)_streamButton).SetColor(Color.green);
				((MenuElement)_streamButton).SetName("Start Streaming");
			}
		}

		private static void SetReplayButton(bool isReplayActive)
		{
			//IL_0027: 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)
			if (isReplayActive)
			{
				((MenuElement)_replayButton).SetColor(Color.red);
				((MenuElement)_replayButton).SetName("Stop Replay Buffer");
			}
			else
			{
				((MenuElement)_replayButton).SetColor(Color.green);
				((MenuElement)_replayButton).SetName("Start Replay Buffer");
			}
		}
	}
	internal static class BoneMenuExtensions
	{
		public static BoolElement CreateBoolPreference(this MenuCategory category, string name, Color color, MelonPreferences_Entry<bool> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateBoolElement(name, color, pref.Value, (Action<bool>)delegate(bool v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static BoolElement CreateBoolPreference(this MenuCategory category, string name, string hexColor, MelonPreferences_Entry<bool> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateBoolElement(name, hexColor, pref.Value, (Action<bool>)delegate(bool v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static BoolElement CreateBoolPreference(this SubPanelElement category, string name, Color color, MelonPreferences_Entry<bool> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateBoolElement(name, color, pref.Value, (Action<bool>)delegate(bool v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static BoolElement CreateBoolPreference(this SubPanelElement category, string name, string hexColor, MelonPreferences_Entry<bool> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateBoolElement(name, hexColor, pref.Value, (Action<bool>)delegate(bool v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static FloatElement CreateFloatPreference(this MenuCategory category, string name, Color color, float increment, float min, float max, MelonPreferences_Entry<float> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateFloatElement(name, color, pref.Value, increment, min, max, (Action<float>)delegate(float v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static FloatElement CreateFloatPreference(this MenuCategory category, string name, string hexColor, float increment, float min, float max, MelonPreferences_Entry<float> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateFloatElement(name, hexColor, pref.Value, increment, min, max, (Action<float>)delegate(float v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static FloatElement CreateFloatPreference(this SubPanelElement category, string name, Color color, float increment, float min, float max, MelonPreferences_Entry<float> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateFloatElement(name, color, pref.Value, increment, min, max, (Action<float>)delegate(float v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static FloatElement CreateFloatPreference(this SubPanelElement category, string name, string hexColor, float increment, float min, float max, MelonPreferences_Entry<float> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateFloatElement(name, hexColor, pref.Value, increment, min, max, (Action<float>)delegate(float v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static IntElement CreateIntPreference(this MenuCategory category, string name, Color color, int increment, int min, int max, MelonPreferences_Entry<int> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateIntElement(name, color, pref.Value, increment, min, max, (Action<int>)delegate(int v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static IntElement CreateIntPreference(this MenuCategory category, string name, string hexColor, int increment, int min, int max, MelonPreferences_Entry<int> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateIntElement(name, hexColor, pref.Value, increment, min, max, (Action<int>)delegate(int v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static IntElement CreateIntPreference(this SubPanelElement category, string name, Color color, int increment, int min, int max, MelonPreferences_Entry<int> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateIntElement(name, color, pref.Value, increment, min, max, (Action<int>)delegate(int v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static IntElement CreateIntPreference(this SubPanelElement category, string name, string hexColor, int increment, int min, int max, MelonPreferences_Entry<int> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			return category.CreateIntElement(name, hexColor, pref.Value, increment, min, max, (Action<int>)delegate(int v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static EnumElement<TEnum> CreateEnumPreference<TEnum>(this MenuCategory category, string name, Color color, MelonPreferences_Entry<TEnum> pref, MelonPreferences_Category prefCategory, bool autoSave = true) where TEnum : Enum
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateEnumElement<TEnum>(name, color, pref.Value, (Action<TEnum>)delegate(TEnum v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static EnumElement<TEnum> CreateEnumPreference<TEnum>(this MenuCategory category, string name, string hexColor, MelonPreferences_Entry<TEnum> pref, MelonPreferences_Category prefCategory, bool autoSave = true) where TEnum : Enum
		{
			return category.CreateEnumElement<TEnum>(name, hexColor, pref.Value, (Action<TEnum>)delegate(TEnum v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static EnumElement<TEnum> CreateEnumPreference<TEnum>(this SubPanelElement category, string name, Color color, MelonPreferences_Entry<TEnum> pref, MelonPreferences_Category prefCategory, bool autoSave = true) where TEnum : Enum
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateEnumElement<TEnum>(name, color, pref.Value, (Action<TEnum>)delegate(TEnum v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static EnumElement<TEnum> CreateEnumPreference<TEnum>(this SubPanelElement category, string name, string hexColor, MelonPreferences_Entry<TEnum> pref, MelonPreferences_Category prefCategory, bool autoSave = true) where TEnum : Enum
		{
			return category.CreateEnumElement<TEnum>(name, hexColor, pref.Value, (Action<TEnum>)delegate(TEnum v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}
	}
}