using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BaboonAPI.Hooks.Initializer;
using BaboonAPI.Hooks.Tracks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Logging;
using Microsoft.FSharp.Collections;
using Microsoft.FSharp.Core;
using Newtonsoft.Json;
using TMPro;
using TootTallyAccounts;
using TootTallyCore;
using TootTallyCore.APIServices;
using TootTallyCore.Graphics;
using TootTallyCore.Graphics.Animations;
using TootTallyCore.Utils.Assets;
using TootTallyCore.Utils.Helpers;
using TootTallyCore.Utils.TootTallyModules;
using TootTallyCore.Utils.TootTallyNotifs;
using TootTallySettings;
using TrombLoader.CustomTracks;
using TwitchLib.Client;
using TwitchLib.Client.Enums;
using TwitchLib.Client.Events;
using TwitchLib.Client.Models;
using TwitchLib.Communication.Clients;
using TwitchLib.Communication.Events;
using TwitchLib.Communication.Interfaces;
using TwitchLib.Communication.Models;
using UnityEngine;
using UnityEngine.Events;
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: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("TootTallyTwitchIntegration")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Twitch integration with song requests and more")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2")]
[assembly: AssemblyProduct("TootTallyTwitchIntegration")]
[assembly: AssemblyTitle("TootTallyTwitchIntegration")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TootTallyTwitchIntegration
{
	public static class FileManager
	{
		public const string requestFileName = "TwitchRequests.json";

		public const string blockFileName = "BlockedRequests.json";

		public static void SaveRequestsQueueToFile(List<Plugin.Request> requests)
		{
			string path = Path.Combine(Paths.ConfigPath, "TwitchRequests.json");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			File.WriteAllText(path, JsonConvert.SerializeObject((object)requests));
		}

		public static List<Plugin.Request> GetRequestsFromFile()
		{
			string path = Path.Combine(Paths.ConfigPath, "TwitchRequests.json");
			if (File.Exists(path))
			{
				try
				{
					return JsonConvert.DeserializeObject<List<Plugin.Request>>(File.ReadAllText(path));
				}
				catch (Exception ex)
				{
					Plugin.LogError("Couldn't parse request queue file.");
					Plugin.LogError(ex.Message);
					Plugin.LogError(ex.StackTrace);
				}
			}
			return new List<Plugin.Request>();
		}

		public static void SaveBlockedRequestsToFile(List<Plugin.BlockedRequests> requests)
		{
			string path = Path.Combine(Paths.ConfigPath, "BlockedRequests.json");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			File.WriteAllText(path, JsonConvert.SerializeObject((object)requests));
		}

		public static List<Plugin.BlockedRequests> GetBlockedRequestsFromFile()
		{
			string path = Path.Combine(Paths.ConfigPath, "BlockedRequests.json");
			if (File.Exists(path))
			{
				try
				{
					return JsonConvert.DeserializeObject<List<Plugin.BlockedRequests>>(File.ReadAllText(path));
				}
				catch (Exception ex)
				{
					Plugin.LogError("Couldn't parse block list file.");
					Plugin.LogError(ex.Message);
					Plugin.LogError(ex.StackTrace);
				}
			}
			return new List<Plugin.BlockedRequests>();
		}
	}
	[BepInPlugin("TootTallyTwitchIntegration", "TootTallyTwitchIntegration", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin, ITootTallyModule
	{
		public static class TwitchPatches
		{
			private static string _selectedSongTrackRef;

			[HarmonyPatch(typeof(GameObjectFactory), "OnHomeControllerInitialize")]
			[HarmonyPostfix]
			public static void InitializeRequestPanel()
			{
				RequestPanelManager.Initialize();
			}

			[HarmonyPatch(typeof(HomeController), "Start")]
			[HarmonyPostfix]
			public static void DeInitialize()
			{
				RequestPanelManager.songSelectInstance = null;
			}

			[HarmonyPatch(typeof(TootTallyUser), "OnUserLogin")]
			[HarmonyPostfix]
			public static void OnUserLoginInitializeBot()
			{
				Instance.StartBotCoroutine();
			}

			[HarmonyPatch(typeof(HomeController), "tryToSaveSettings")]
			[HarmonyPostfix]
			public static void InitializeRequestPanelOnSaveConfig()
			{
				Instance.StartBotCoroutine();
			}

			[HarmonyPatch(typeof(GameController), "Start")]
			[HarmonyPostfix]
			public static void SetCurrentSong()
			{
				RequestPanelManager.songSelectInstance = null;
				RequestPanelManager.isPlaying = true;
				TromboneTrack val = TrackLookup.lookup(GlobalVariables.chosen_track_data.trackref);
				string songHash = SongDataHelper.GetSongHash(val);
				((MonoBehaviour)Instance).StartCoroutine((IEnumerator)TootTallyAPIService.GetHashInDB(songHash, val is CustomTrack, (Action<int>)delegate(int id)
				{
					RequestPanelManager.currentSongID = id;
				}));
			}

			[HarmonyPatch(typeof(PointSceneController), "Start")]
			[HarmonyPostfix]
			public static void ResetCurrentSong()
			{
				RequestPanelManager.isPlaying = false;
				RequestPanelManager.Remove(GlobalVariables.chosen_track_data.trackref);
			}

			[HarmonyPatch(typeof(LevelSelectController), "Start")]
			[HarmonyPostfix]
			public static void StartBot(LevelSelectController __instance, int ___songindex)
			{
				RequestPanelManager.songSelectInstance = __instance;
				RequestPanelManager.songIndex = ___songindex;
				RequestPanelManager.isPlaying = false;
			}

			[HarmonyPatch(typeof(LevelSelectController), "advanceSongs")]
			[HarmonyPostfix]
			public static void UpdateInstance(LevelSelectController __instance, int ___songindex)
			{
				RequestPanelManager.songSelectInstance = __instance;
				RequestPanelManager.songIndex = ___songindex;
			}

			[HarmonyPatch(typeof(LevelSelectController), "clickBack")]
			[HarmonyPrefix]
			private static bool OnClickBackSkipIfPanelActive()
			{
				return ShouldScrollSongs();
			}

			[HarmonyPatch(typeof(LevelSelectController), "clickNext")]
			[HarmonyPrefix]
			private static bool OnClickNextSkipIfScrollWheelUsed()
			{
				return ShouldScrollSongs();
			}

			[HarmonyPatch(typeof(LevelSelectController), "clickPrev")]
			[HarmonyPrefix]
			private static bool OnClickBackSkipIfScrollWheelUsed()
			{
				return ShouldScrollSongs();
			}

			private static bool ShouldScrollSongs()
			{
				return RequestPanelManager.ShouldScrollSongs();
			}
		}

		[Serializable]
		public class Request
		{
			public string requester;

			public SongDataFromDB songData;

			public int song_id;

			public string date;
		}

		[Serializable]
		public class BlockedRequests
		{
			public int song_id;
		}

		public class UnprocessedRequest
		{
			public string requester;

			public int song_id;
		}

		public class Notif
		{
			public string message;
		}

		public static Plugin Instance;

		private const string CONFIG_NAME = "TwitchIntegration.cfg";

		private const string CONFIG_FIELD = "Twitch";

		private Harmony _harmony;

		public static TootTallySettingPage settingPage;

		public TwitchBot Bot = null;

		public RequestController requestController;

		public ConfigEntry<bool> ModuleConfigEnabled { get; set; }

		public bool IsConfigInitialized { get; set; }

		public string Name
		{
			get
			{
				return "Twitch Integration";
			}
			set
			{
				Name = value;
			}
		}

		public ConfigEntry<bool> EnableRequestsCommand { get; set; }

		public ConfigEntry<bool> EnableProfileCommand { get; set; }

		public ConfigEntry<bool> EnableCurrentSongCommand { get; set; }

		public ConfigEntry<bool> SubOnlyMode { get; set; }

		public ConfigEntry<string> TwitchUsername { get; set; }

		public ConfigEntry<string> TwitchAccessToken { get; set; }

		public ConfigEntry<float> MaxRequestCount { get; set; }

		public static void LogInfo(string msg)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)msg);
		}

		public static void LogError(string msg)
		{
			((BaseUnityPlugin)Instance).Logger.LogError((object)msg);
		}

		public static void LogDebug(string msg)
		{
			((BaseUnityPlugin)Instance).Logger.LogDebug((object)msg);
		}

		private void Awake()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				_harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				GameInitializationEvent.Register(((BaseUnityPlugin)this).Info, (Action)TryInitialize);
			}
		}

		private void Update()
		{
			RequestPanelManager.Update();
		}

		private void TryInitialize()
		{
			ModuleConfigEnabled = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Modules", "Twitch", true, "Twitch integration with song requests and more.");
			TootTallyModuleManager.AddModule((ITootTallyModule)(object)this);
			Plugin.Instance.AddModuleToSettingPage((ITootTallyModule)(object)this);
		}

		public void LoadModule()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			AssetManager.LoadAssets(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Instance).Info.Location), "Assets"));
			string text = Path.Combine(Paths.BepInExRootPath, "config/");
			string toottallyTwitchLink = "https://toottally.com/twitch/";
			ConfigFile val = new ConfigFile(text + "TwitchIntegration.cfg", true)
			{
				SaveOnConfigSet = true
			};
			EnableRequestsCommand = val.Bind<bool>("Twitch", "Enable requests command", true, "Allow people to requests songs using !ttr [songID]");
			EnableCurrentSongCommand = val.Bind<bool>("Twitch", "Enable current song command", true, "!song command that sends a link to the current song into the chat");
			EnableProfileCommand = val.Bind<bool>("Twitch", "Enable profile command", true, "!profile command that links your toottally profile into the chat");
			SubOnlyMode = val.Bind<bool>("Twitch", "Sub-only requests", false, "Only allow subscribers to send requests");
			TwitchUsername = val.Bind<string>("Twitch", "Twitch channel to attach to", "", "Paste your twitch username here");
			TwitchAccessToken = val.Bind<string>("Twitch", "Twitch Access Token", "", "Paste the access token from the website here");
			MaxRequestCount = val.Bind<float>("Twitch", "Max Request Count", 50f, "Maximum request count allowed in queue");
			settingPage = TootTallySettingsManager.AddNewPage("Twitch", "Twitch Integration Settings", 40f, new Color(0.1f, 0.1f, 0.1f, 0.1f));
			if (settingPage != null)
			{
				settingPage.AddToggle("Enable Requests Command", EnableRequestsCommand, (UnityAction<bool>)null);
				settingPage.AddToggle("Enable Current Songs Command", EnableCurrentSongCommand, (UnityAction<bool>)null);
				settingPage.AddToggle("Enable Profile Command", EnableProfileCommand, (UnityAction<bool>)null);
				settingPage.AddSlider("Max Request Count", 0f, 200f, MaxRequestCount, true);
				settingPage.AddLabel("TwitchSpecificSettingsLabel", "Twitch Integration", 24f, (FontStyles)0, (TextAlignmentOptions)4097);
				settingPage.AddLabel("TwitchSpecificUsernameLabel", "Username", 16f, (FontStyles)0, (TextAlignmentOptions)1025);
				settingPage.AddTextField("Twitch Username", new Vector2(350f, 50f), 20f, TwitchUsername.Value, ((ConfigEntryBase)TwitchUsername).Description.Description, false, (Action<string>)SetTwitchUsername);
				settingPage.AddLabel("TwitchSpecificAccessTokenLabel", "AccessToken", 16f, (FontStyles)0, (TextAlignmentOptions)1025);
				settingPage.AddTextField("Twitch Access Token", new Vector2(350f, 50f), 20f, TwitchAccessToken.Value, ((ConfigEntryBase)TwitchAccessToken).Description.Description, true, (Action<string>)SetTwitchAccessToken);
				settingPage.AddButton("AuthorizeTwitchButton", new Vector2(450f, 50f), "Authorize TootTally on Twitch", "Opens a page to get your auth token", (Action)delegate
				{
					Application.OpenURL(toottallyTwitchLink);
				});
				settingPage.AddLabel("TwitchBotButtons", "Twitch Bot Settings", 24f, (FontStyles)0, (TextAlignmentOptions)4097);
				settingPage.AddButton("ConnectDisconnectBot", new Vector2(350f, 50f), "Connect/Disconnect Bot", "Rarely useful if the bot fails to connect after setting the auth token", (Action)delegate
				{
					if (Bot == null)
					{
						StartBotCoroutine();
					}
					else
					{
						Bot.Disconnect();
						Bot = null;
					}
				});
				settingPage.AddLabel("TwitchBotInstruction", "Twitch bot will also automatically start when you enter the song select menu.", 16f, (FontStyles)0, (TextAlignmentOptions)4097);
			}
			requestController = ((Component)this).gameObject.AddComponent<RequestController>();
			Plugin.TryAddThunderstoreIconToPageButton(((BaseUnityPlugin)Instance).Info.Location, Name, settingPage);
			ThemeManager.OnThemeRefreshEvents = (Action)Delegate.Combine(ThemeManager.OnThemeRefreshEvents, new Action(RequestPanelManager.UpdateTheme));
			_harmony.PatchAll(typeof(TwitchPatches));
			LogInfo("Module loaded!");
		}

		public void UnloadModule()
		{
			ThemeManager.OnThemeRefreshEvents = (Action)Delegate.Remove(ThemeManager.OnThemeRefreshEvents, new Action(RequestPanelManager.UpdateTheme));
			RequestPanelManager.Dispose();
			Bot?.Disconnect();
			Bot = null;
			requestController?.Dispose();
			Object.DestroyImmediate((Object)(object)requestController);
			((MonoBehaviour)this).StopAllCoroutines();
			_harmony.UnpatchSelf();
			settingPage.Remove();
			LogInfo("Module unloaded!");
		}

		private void SetTwitchUsername(string text)
		{
			Instance.TwitchUsername.Value = text;
			TootTallyNotifManager.DisplayNotif("Twitch username is set to '" + text + "'", 6f);
		}

		public void StartBotCoroutine()
		{
			if (Bot == null)
			{
				Bot = new TwitchBot();
			}
		}

		private void SetTwitchAccessToken(string text)
		{
			Instance.TwitchAccessToken.Value = text;
		}
	}
	public class RequestController : MonoBehaviour
	{
		private ConcurrentQueue<Plugin.Notif> NotifQueue;

		private ConcurrentQueue<Plugin.UnprocessedRequest> RequestQueue;

		public List<string> RequesterBlacklist { get; set; }

		public void Awake()
		{
			NotifQueue = new ConcurrentQueue<Plugin.Notif>();
			RequestQueue = new ConcurrentQueue<Plugin.UnprocessedRequest>();
			RequesterBlacklist = new List<string>();
		}

		public void Update()
		{
			if (RequestPanelManager.isPlaying)
			{
				return;
			}
			if (RequestQueue.TryDequeue(out var request))
			{
				Plugin.LogInfo($"Attempting to get song data for ID {request.song_id}");
				((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)TootTallyAPIService.GetSongDataFromDB(request.song_id, (Action<SongDataFromDB>)delegate(SongDataFromDB songdata)
				{
					Plugin.LogInfo("Obtained request by " + request.requester + " for song " + songdata.author + " - " + songdata.name);
					TootTallyNotifManager.DisplayNotif("Requested song by " + request.requester + ": " + songdata.author + " - " + songdata.name, 6f);
					Plugin.Request request2 = new Plugin.Request
					{
						requester = request.requester,
						songData = songdata,
						song_id = request.song_id,
						date = DateTime.Now.ToString()
					};
					RequestPanelManager.AddRow(request2);
				}));
			}
			if (NotifQueue.TryDequeue(out var result))
			{
				Plugin.LogInfo("Attempting to generate notification...");
				TootTallyNotifManager.DisplayNotif(result.message, 6f);
			}
		}

		public void RequestSong(int song_id, string requester, bool isSubscriber = false)
		{
			if (!RequesterBlacklist.Contains(requester))
			{
				if (RequestPanelManager.IsBlocked(song_id))
				{
					Plugin.Instance.Bot.client.SendMessage(Plugin.Instance.Bot.CHANNEL, $"!Song #{song_id} is blocked.", false);
				}
				else if (RequestPanelManager.IsDuplicate(song_id) && !RequestQueue.Any((Plugin.UnprocessedRequest x) => x.song_id == song_id))
				{
					Plugin.Instance.Bot.client.SendMessage(Plugin.Instance.Bot.CHANNEL, $"!Song #{song_id} already requested.", false);
				}
				else if ((float)RequestPanelManager.RequestCount >= Plugin.Instance.MaxRequestCount.Value)
				{
					Plugin.Instance.Bot.client.SendMessage(Plugin.Instance.Bot.CHANNEL, "!Request cap reached.", false);
				}
				else if (!Plugin.Instance.SubOnlyMode.Value || isSubscriber)
				{
					Plugin.UnprocessedRequest unprocessedRequest = new Plugin.UnprocessedRequest();
					unprocessedRequest.song_id = song_id;
					unprocessedRequest.requester = requester;
					Plugin.LogInfo($"Accepted request {song_id} by {requester}.");
					Plugin.Instance.Bot.client.SendMessage(Plugin.Instance.Bot.CHANNEL, $"!Song #{song_id} successfully requested.", false);
					RequestQueue.Enqueue(unprocessedRequest);
				}
			}
		}

		public void Dispose()
		{
			NotifQueue?.Clear();
			NotifQueue = null;
			RequestQueue?.Clear();
			RequestQueue = null;
			RequesterBlacklist?.Clear();
			RequesterBlacklist = null;
		}
	}
	public static class RequestPanelManager
	{
		private const float MIN_POS_Y = -40f;

		public static GameObject requestRowPrefab;

		public static LevelSelectController songSelectInstance;

		public static int songIndex;

		public static bool isPlaying;

		private static List<RequestPanelRow> _requestRowList;

		private static List<Plugin.Request> _requestList;

		private static List<Plugin.BlockedRequests> _blockedList;

		private static List<int> _songIDHistory;

		public static int currentSongID;

		private static ScrollableSliderHandler _scrollableHandler;

		private static Slider _slider;

		private static RectTransform _containerRect;

		private static TootTallyAnimation _panelAnimationFG;

		private static TootTallyAnimation _panelAnimationBG;

		private static GameObject _overlayPanel;

		private static GameObject _overlayCanvas;

		private static GameObject _overlayPanelContainer;

		private static bool _isPanelActive;

		private static bool _isInitialized;

		private static bool _isAnimating;

		public static int RequestCount => _requestList.Count;

		public static void Initialize()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			if (!_isInitialized)
			{
				_overlayCanvas = new GameObject("TwitchOverlayCanvas");
				Canvas val = _overlayCanvas.AddComponent<Canvas>();
				val.renderMode = (RenderMode)0;
				val.overrideSorting = true;
				val.sortingOrder = 1;
				CanvasScaler val2 = _overlayCanvas.AddComponent<CanvasScaler>();
				val2.referenceResolution = new Vector2(1920f, 1080f);
				val2.uiScaleMode = (ScaleMode)1;
				_requestRowList = new List<RequestPanelRow>();
				_requestList = new List<Plugin.Request>();
				_blockedList = new List<Plugin.BlockedRequests>();
				_songIDHistory = new List<int>();
				Object.DontDestroyOnLoad((Object)(object)_overlayCanvas);
				_overlayPanel = GameObjectFactory.CreateOverlayPanel(_overlayCanvas.transform, Vector2.zero, new Vector2(1700f, 900f), 20f, "TwitchOverlayPanel");
				_overlayPanelContainer = ((Component)_overlayPanel.transform.Find("FSLatencyPanel/LatencyFG/MainPage")).gameObject;
				_slider = new GameObject("TwitchPanelSlider", new Type[1] { typeof(Slider) }).GetComponent<Slider>();
				((Component)_slider).transform.SetParent(_overlayPanel.transform);
				((UnityEvent<float>)(object)_slider.onValueChanged).AddListener((UnityAction<float>)OnScrolling);
				_scrollableHandler = ((Component)_slider).gameObject.AddComponent<ScrollableSliderHandler>();
				_overlayPanel.transform.Find("FSLatencyPanel/LatencyFG").localScale = Vector2.op_Implicit(Vector2.zero);
				_overlayPanel.transform.Find("FSLatencyPanel/LatencyBG").localScale = Vector2.op_Implicit(Vector2.zero);
				((Graphic)((Component)_overlayPanel.transform.Find("FSLatencyPanel/LatencyFG")).GetComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f);
				_containerRect = _overlayPanelContainer.GetComponent<RectTransform>();
				_containerRect.anchoredPosition = new Vector2(0f, -40f);
				_containerRect.sizeDelta = new Vector2(1700f, 900f);
				VerticalLayoutGroup component = _overlayPanelContainer.GetComponent<VerticalLayoutGroup>();
				((LayoutGroup)component).padding = new RectOffset(20, 20, 20, 20);
				((HorizontalOrVerticalLayoutGroup)component).spacing = 120f;
				((LayoutGroup)component).childAlignment = (TextAnchor)1;
				bool childControlHeight = (((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true);
				((HorizontalOrVerticalLayoutGroup)component).childControlHeight = childControlHeight;
				((Component)_overlayPanelContainer.transform.parent).gameObject.AddComponent<Mask>();
				GameObjectFactory.DestroyFromParent(((Component)_overlayPanelContainer.transform.parent).gameObject, "subtitle");
				GameObjectFactory.DestroyFromParent(((Component)_overlayPanelContainer.transform.parent).gameObject, "title");
				TMP_Text val3 = GameObjectFactory.CreateSingleText(_overlayPanelContainer.transform, "title", "Twitch Requests", (TextFont)0);
				val3.fontSize = 60f;
				_overlayPanel.SetActive(false);
				SetRequestRowPrefab();
				_requestList = FileManager.GetRequestsFromFile();
				_requestList.ForEach(AddRowFromFile);
				_blockedList = FileManager.GetBlockedRequestsFromFile();
				_isPanelActive = false;
				_isInitialized = true;
				isPlaying = false;
			}
		}

		public static void Update()
		{
			if (_isInitialized)
			{
				if (Input.GetKeyDown((KeyCode)289))
				{
					TogglePanel();
				}
				if (Input.GetKeyDown((KeyCode)27) && _isPanelActive)
				{
					TogglePanel();
				}
			}
		}

		private static void OnScrolling(float value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_containerRect.anchoredPosition = new Vector2(_containerRect.anchoredPosition.x, value * (65f * (float)_requestList.Count) - 40f);
		}

		public static void TogglePanel()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			_isPanelActive = !_isPanelActive;
			((Behaviour)_scrollableHandler).enabled = _isPanelActive && _requestRowList.Count > 6;
			_isAnimating = true;
			if (!((Object)(object)_overlayPanel != (Object)null))
			{
				return;
			}
			TootTallyAnimation panelAnimationBG = _panelAnimationBG;
			if (panelAnimationBG != null)
			{
				panelAnimationBG.Dispose();
			}
			TootTallyAnimation panelAnimationFG = _panelAnimationFG;
			if (panelAnimationFG != null)
			{
				panelAnimationFG.Dispose();
			}
			Vector2 val = (_isPanelActive ? Vector2.one : Vector2.zero);
			float num = (_isPanelActive ? 1f : 0.45f);
			SecondDegreeDynamicsAnimation val2 = (_isPanelActive ? new SecondDegreeDynamicsAnimation(1.75f, 1f, 0f) : new SecondDegreeDynamicsAnimation(3.2f, 1f, 0.25f));
			SecondDegreeDynamicsAnimation val3 = (_isPanelActive ? new SecondDegreeDynamicsAnimation(1.75f, 1f, 0f) : new SecondDegreeDynamicsAnimation(3.2f, 1f, 0.25f));
			_panelAnimationFG = TootTallyAnimationManager.AddNewScaleAnimation(((Component)_overlayPanel.transform.Find("FSLatencyPanel/LatencyFG")).gameObject, val, num, val2, (Action<GameObject>)null);
			_panelAnimationBG = TootTallyAnimationManager.AddNewScaleAnimation(((Component)_overlayPanel.transform.Find("FSLatencyPanel/LatencyBG")).gameObject, val, num, val3, (Action<GameObject>)delegate
			{
				_isAnimating = false;
				if (!_isPanelActive)
				{
					_overlayPanel.SetActive(_isPanelActive);
				}
			});
			if (_isPanelActive)
			{
				_overlayPanel.SetActive(_isPanelActive);
			}
		}

		public static void AddRow(Plugin.Request request)
		{
			_requestList.Add(request);
			UpdateSaveRequestFile();
			_requestRowList.Add(new RequestPanelRow(_overlayPanelContainer.transform, request));
			_scrollableHandler.accelerationMult = 6f / (float)_requestRowList.Count;
			((Behaviour)_scrollableHandler).enabled = _requestRowList.Count > 6;
		}

		public static void AddToBlockList(int id)
		{
			_blockedList.Add(new Plugin.BlockedRequests
			{
				song_id = id
			});
			TootTallyNotifManager.DisplayNotif($"Song #{id} blocked.", 6f);
			FileManager.SaveBlockedRequestsToFile(_blockedList);
		}

		public static void AddRowFromFile(Plugin.Request request)
		{
			_requestRowList.Add(new RequestPanelRow(_overlayPanelContainer.transform, request));
		}

		public static void Dispose()
		{
			if (_isInitialized)
			{
				Object.DestroyImmediate((Object)(object)_overlayCanvas);
				_isInitialized = false;
			}
		}

		public static void Remove(RequestPanelRow row)
		{
			_requestList.Remove(row.request);
			UpdateSaveRequestFile();
			_requestRowList.Remove(row);
			_slider.value = 0f;
		}

		public static void Remove(string trackref)
		{
			RequestPanelRow requestPanelRow = _requestRowList.Find((RequestPanelRow r) => r.request.songData.track_ref == trackref);
			if (requestPanelRow != null)
			{
				requestPanelRow.RemoveFromPanel();
				AddSongIDToHistory(requestPanelRow.request.song_id);
				TootTallyNotifManager.DisplayNotif("Fulfilled request from " + requestPanelRow.request.requester, 6f);
			}
		}

		public static void SetRequestRowPrefab()
		{
			//IL_000b: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			GameObject gameObject = ((Component)GameObjectFactory.CreateOverlayPanel(_overlayCanvas.transform, Vector2.zero, new Vector2(1200f, 84f), 5f, "TwitchRequestRowTemp").transform.Find("FSLatencyPanel")).gameObject;
			requestRowPrefab = Object.Instantiate<GameObject>(gameObject);
			Object.DestroyImmediate((Object)(object)gameObject.gameObject);
			((Object)requestRowPrefab).name = "RequestRowPrefab";
			requestRowPrefab.transform.localScale = Vector3.one;
			((MaskableGraphic)requestRowPrefab.GetComponent<Image>()).maskable = true;
			GameObject gameObject2 = ((Component)requestRowPrefab.transform.Find("LatencyFG/MainPage")).gameObject;
			gameObject2.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
			gameObject2.GetComponent<RectTransform>().sizeDelta = new Vector2(1200f, 100f);
			Object.DestroyImmediate((Object)(object)((Component)gameObject2.transform.parent.Find("subtitle")).gameObject);
			Object.DestroyImmediate((Object)(object)((Component)gameObject2.transform.parent.Find("title")).gameObject);
			Object.DestroyImmediate((Object)(object)gameObject2.GetComponent<VerticalLayoutGroup>());
			HorizontalLayoutGroup val = gameObject2.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)val).padding = new RectOffset(20, 20, 20, 20);
			((HorizontalOrVerticalLayoutGroup)val).spacing = 20f;
			((LayoutGroup)val).childAlignment = (TextAnchor)3;
			bool childControlHeight = (((HorizontalOrVerticalLayoutGroup)val).childControlWidth = false);
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = childControlHeight;
			childControlHeight = (((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false);
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = childControlHeight;
			((MaskableGraphic)((Component)requestRowPrefab.transform.Find("LatencyFG")).GetComponent<Image>()).maskable = true;
			((MaskableGraphic)((Component)requestRowPrefab.transform.Find("LatencyBG")).GetComponent<Image>()).maskable = true;
			Object.DontDestroyOnLoad((Object)(object)requestRowPrefab);
			requestRowPrefab.SetActive(false);
		}

		public static void SetTrackToTrackref(string trackref)
		{
			if ((Object)(object)songSelectInstance == (Object)null)
			{
				return;
			}
			for (int i = 0; i < songSelectInstance.alltrackslist.Count; i++)
			{
				if (songSelectInstance.alltrackslist[i].trackref == trackref)
				{
					int num = 0;
					while (i - songIndex != 0 && songSelectInstance.songindex != i && num <= 3)
					{
						songSelectInstance.advanceSongs(i - songIndex, true);
						num++;
					}
					break;
				}
			}
		}

		public static void AddSongIDToHistory(int id)
		{
			_songIDHistory.Add(id);
		}

		public static string GetSongIDHistoryString()
		{
			return (_songIDHistory.Count > 0) ? string.Join(", ", _songIDHistory) : "No songs history recorded";
		}

		public static string GetSongQueueIDString()
		{
			return (_requestList.Count > 0) ? string.Join(", ", _requestList.Select((Plugin.Request x) => x.song_id)) : "No songs requested";
		}

		public static string GetLastSongPlayed()
		{
			return (_songIDHistory.Count > 0) ? $"https://toottally.com/song/{_songIDHistory.Last()}" : "No song played";
		}

		public static bool IsDuplicate(int song_id)
		{
			return _requestRowList.Any((RequestPanelRow x) => x.request.song_id == song_id);
		}

		public static bool IsBlocked(int song_id)
		{
			return _blockedList.Any((Plugin.BlockedRequests x) => x.song_id == song_id);
		}

		public static bool ShouldScrollSongs()
		{
			return !_isPanelActive && !_isAnimating;
		}

		public static void UpdateTheme()
		{
			if (_isInitialized)
			{
				Dispose();
				Initialize();
			}
		}

		public static void UpdateSaveRequestFile()
		{
			FileManager.SaveRequestsQueueToFile(_requestList);
		}
	}
	public class RequestPanelRow
	{
		public class TracksLoaderListener : Listener
		{
			private RequestPanelRow _row;

			public TracksLoaderListener(RequestPanelRow row)
			{
				_row = row;
			}

			public void OnTracksLoaded(FSharpList<TromboneTrack> value)
			{
				_row.PlayChart();
				_row.UnsubscribeLoaderEvent();
			}
		}

		private string _downloadLink;

		private GameObject _requestRowContainer;

		private GameObject _requestRow;

		private GameObject _downloadButton;

		private ProgressBar _progressBar;

		private TracksLoaderListener _reloadListener;

		private SongDataFromDB _chart;

		public Plugin.Request request { get; private set; }

		public RequestPanelRow(Transform canvasTransform, Plugin.Request request)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			_chart = request.songData;
			this.request = request;
			_requestRow = Object.Instantiate<GameObject>(RequestPanelManager.requestRowPrefab, canvasTransform);
			((Object)_requestRow).name = "Request" + _chart.name;
			_requestRowContainer = ((Component)_requestRow.transform.Find("LatencyFG/MainPage")).gameObject;
			((Graphic)((Component)_requestRow.transform.Find("LatencyFG")).GetComponent<Image>()).color = new Color(0.05f, 0.05f, 0.05f);
			TMP_Text val = GameObjectFactory.CreateSingleText(_requestRowContainer.transform, "SongName", _chart.name, (TextFont)0);
			TMP_Text val2 = GameObjectFactory.CreateSingleText(_requestRowContainer.transform, "Charter", _chart.charter ?? "Unknown", (TextFont)0);
			TMP_Text val3 = GameObjectFactory.CreateSingleText(_requestRowContainer.transform, "RequestedByName", request.requester, (TextFont)0);
			TMP_Text val4 = GameObjectFactory.CreateSingleText(_requestRowContainer.transform, "Time", request.date, (TextFont)0);
			((Component)val).GetComponent<RectTransform>().sizeDelta = new Vector2(250f, 64f);
			RectTransform component = ((Component)val2).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
			Vector2 sizeDelta = default(Vector2);
			((Vector2)(ref sizeDelta))..ctor(200f, 64f);
			component2.sizeDelta = sizeDelta;
			component.sizeDelta = sizeDelta;
			((Component)val4).GetComponent<RectTransform>().sizeDelta = new Vector2(150f, 64f);
			TextOverflowModes val5 = (TextOverflowModes)1;
			val4.overflowMode = (TextOverflowModes)1;
			val.overflowMode = (val2.overflowMode = (val3.overflowMode = val5));
			if (FSharpOption<TromboneTrack>[TrackLookup.tryLookup(_chart.track_ref)])
			{
				_downloadLink = FileHelper.GetDownloadLinkFromSongData(_chart);
				if (_downloadLink != null)
				{
					_downloadButton = ((Component)GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("Download64.png"), "DownloadButton", (Action)DownloadChart)).gameObject;
					_progressBar = GameObjectFactory.CreateProgressBar(_requestRow.transform.Find("LatencyFG"), Vector2.zero, new Vector2(900f, 20f), false, "ProgressBar");
				}
				else
				{
					_downloadButton = ((Component)GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("global64.png"), "OpenLeaderboardButton", (Action)delegate
					{
						Application.OpenURL($"https://toottally.com/song/{request.songData.id}/");
					})).gameObject;
				}
			}
			else
			{
				GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("Check64.png"), "PlayButton", (Action)PlayChart);
			}
			GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("Close64.png"), "SkipButton", (Action)RemoveFromPanel);
			GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("Block64.png"), "BlockButton", (Action)BlockChart);
			_requestRow.SetActive(true);
		}

		public void PlayChart()
		{
			RequestPanelManager.currentSongID = request.song_id;
			RequestPanelManager.SetTrackToTrackref(_chart.track_ref);
		}

		public void DownloadChart()
		{
			_downloadButton.SetActive(false);
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)TootTallyAPIService.DownloadZipFromServer(_downloadLink, _progressBar, (Action<byte[]>)delegate(byte[] data)
			{
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				if (data != null)
				{
					string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), "Downloads/");
					if (!Directory.Exists(text))
					{
						Directory.CreateDirectory(text);
					}
					string text2 = $"{_chart.id}.zip";
					FileHelper.WriteBytesToFile(text, text2, data);
					string text3 = Path.Combine(text, text2);
					string text4 = Path.Combine(Paths.BepInExRootPath, "CustomSongs/");
					FileHelper.ExtractZipToDirectory(text3, text4);
					FileHelper.DeleteFile(text, text2);
					_reloadListener = new TracksLoaderListener(this);
					TracksLoadedEvent.EVENT.Register((Listener)(object)_reloadListener);
					TootTallyNotifManager.DisplayNotif("Reloading Songs...", 6f);
					((MonoBehaviour)Plugin.Instance).Invoke("ReloadTracks", 0.5f);
					CustomButton val = GameObjectFactory.CreateCustomButton(_requestRowContainer.transform, Vector2.zero, new Vector2(68f, 68f), AssetManager.GetSprite("Check64.png"), "PlayButton", (Action)PlayChart);
					((Component)val).transform.SetSiblingIndex(4);
				}
				else
				{
					TootTallyNotifManager.DisplayNotif("Download not available.", 6f);
					_downloadButton.SetActive(true);
				}
			}));
		}

		public void UnsubscribeLoaderEvent()
		{
			if (_reloadListener != null)
			{
				TracksLoadedEvent.EVENT.Unregister((Listener)(object)_reloadListener);
			}
			_reloadListener = null;
		}

		public void RemoveFromPanel()
		{
			RequestPanelManager.Remove(this);
			Object.DestroyImmediate((Object)(object)_requestRow);
		}

		public void BlockChart()
		{
			RequestPanelManager.AddToBlockList(_chart.id);
			RemoveFromPanel();
		}
	}
	public class TwitchBot
	{
		internal TwitchClient client;

		public string CHANNEL { get; set; }

		public Stack<string> MessageStack { get; set; }

		public TwitchBot()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_007d: 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_008f: Expected O, but got Unknown
			//IL_0091: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			if (Initialize())
			{
				Plugin.LogInfo("Attempting connection with channel " + CHANNEL + "...");
				ConnectionCredentials val = new ConnectionCredentials(CHANNEL, Plugin.Instance.TwitchAccessToken.Value, "wss://irc-ws.chat.twitch.tv:443", false, (Capabilities)null);
				ClientOptions val2 = new ClientOptions
				{
					MessagesAllowedInPeriod = 750,
					ThrottlingPeriod = TimeSpan.FromSeconds(30.0),
					ReconnectionPolicy = new ReconnectionPolicy(5, (int?)3)
				};
				WebSocketClient val3 = new WebSocketClient((IClientOptions)(object)val2);
				client = new TwitchClient((IClient)(object)val3, (ClientProtocol)1, (ILogger<TwitchClient>)null);
				client.Initialize(val, CHANNEL, '!', '!', true);
				client.OnLog += Client_OnLog;
				client.OnJoinedChannel += Client_OnJoinedChannel;
				client.OnConnected += Client_OnConnected;
				client.OnChatCommandReceived += Client_HandleChatCommand;
				client.OnIncorrectLogin += Client_OnIncorrectLogin;
				client.OnError += Client_OnError;
				MessageStack = new Stack<string>();
				client.Connect();
			}
		}

		public void Disconnect()
		{
			if (client != null && client.IsConnected)
			{
				client.Disconnect();
			}
			MessageStack?.Clear();
			MessageStack = null;
		}

		private bool Initialize()
		{
			if (Plugin.Instance.TwitchAccessToken.Value == null || Plugin.Instance.TwitchAccessToken.Value == "")
			{
				TootTallyNotifManager.DisplayError("Twitch Access Token is empty. Please fill it in.", 6f);
				return false;
			}
			if (Plugin.Instance.TwitchUsername.Value == null || Plugin.Instance.TwitchUsername.Value == "")
			{
				TootTallyNotifManager.DisplayError("Twitch Username is empty. Please fill it in.", 6f);
				return false;
			}
			CHANNEL = Plugin.Instance.TwitchUsername.Value.ToLower();
			return true;
		}

		private void Client_OnError(object sender, OnErrorEventArgs args)
		{
			Plugin.LogError($"{args.Exception}\n{args.Exception.StackTrace}");
		}

		private void Client_OnIncorrectLogin(object sender, OnIncorrectLoginArgs args)
		{
			TootTallyNotifManager.DisplayError("Login credentials incorrect. Please re-authorize or refresh your access token, and re-check your Twitch username.", 6f);
			client.Disconnect();
		}

		private void Client_HandleChatCommand(object sender, OnChatCommandReceivedArgs args)
		{
			string commandText = args.Command.CommandText;
			string argumentsAsString = args.Command.ArgumentsAsString;
			switch (commandText)
			{
			case "ttr":
				if (!Plugin.Instance.EnableRequestsCommand.Value)
				{
					break;
				}
				if (args.Command.ArgumentsAsList.Count == 1)
				{
					if (int.TryParse(argumentsAsString, out var result))
					{
						Plugin.LogInfo($"Successfully parsed request for {result}, submitting to stack.");
						Plugin.Instance.requestController.RequestSong(result, ((TwitchLibMessage)args.Command.ChatMessage).Username, args.Command.ChatMessage.IsSubscriber);
					}
					else
					{
						Plugin.LogInfo("Could not parse request input, ignoring.");
						client.SendMessage(CHANNEL, "!Invalid song ID. Please try again.", false);
					}
				}
				else
				{
					client.SendMessage(CHANNEL, "!Use !ttr to request a chart use its TootTally Song ID! To get a song ID, search for the song in https://toottally.com (Example: !ttr 3781)", false);
				}
				break;
			case "profile":
				if (Plugin.Instance.EnableProfileCommand.Value && TootTallyUser.userInfo.id > 0)
				{
					client.SendMessage(CHANNEL, $"!TootTally Profile: https://toottally.com/profile/{TootTallyUser.userInfo.id}", false);
				}
				break;
			case "song":
				if (Plugin.Instance.EnableCurrentSongCommand.Value && RequestPanelManager.currentSongID != 0)
				{
					client.SendMessage(CHANNEL, $"!Current Song: https://toottally.com/song/{RequestPanelManager.currentSongID}", false);
				}
				break;
			case "ttrhelp":
				if (Plugin.Instance.EnableCurrentSongCommand.Value)
				{
					client.SendMessage(CHANNEL, "!Use !ttr to request a chart use its TootTally Song ID! To get a song ID, search for the song in https://toottally.com (Example: !ttr 3781)", false);
				}
				break;
			case "queue":
				if (Plugin.Instance.EnableCurrentSongCommand.Value)
				{
					client.SendMessage(CHANNEL, "!Song Queue: " + RequestPanelManager.GetSongQueueIDString(), false);
				}
				break;
			case "last":
				if (Plugin.Instance.EnableCurrentSongCommand.Value)
				{
					client.SendMessage(CHANNEL, "!Last song played: " + RequestPanelManager.GetLastSongPlayed(), false);
				}
				break;
			case "history":
				if (Plugin.Instance.EnableCurrentSongCommand.Value)
				{
					client.SendMessage(CHANNEL, "!Songs played: " + RequestPanelManager.GetSongIDHistoryString(), false);
				}
				break;
			}
		}

		private void Client_OnLog(object sender, OnLogArgs e)
		{
			Plugin.LogDebug($"{e.DateTime}: {e.BotUsername} - {e.Data}");
		}

		private void Client_OnConnected(object sender, OnConnectedArgs e)
		{
			Plugin.LogInfo("Connected to " + e.AutoJoinChannel);
		}

		private void Client_OnJoinedChannel(object sender, OnJoinedChannelArgs e)
		{
			client.SendMessage(e.Channel, "! TootTally Twitch Integration ready!", false);
			TootTallyNotifManager.DisplayNotif("Twitch Integration successful!", 6f);
			Plugin.LogInfo("Twitch integration successfully attached to chat!");
			CHANNEL = e.Channel;
		}

		private void Client_OnDisconnected(object sender, OnDisconnectedArgs e)
		{
			Plugin.LogInfo("TwitchBot successfully disconnected from Twitch!");
			TootTallyNotifManager.DisplayNotif("Twitch bot disconnected!", 6f);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "TootTallyTwitchIntegration";

		public const string PLUGIN_NAME = "TootTallyTwitchIntegration";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}