using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using HarmonyLib;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Economy;
using Il2CppScheduleOne.Messaging;
using Il2CppScheduleOne.NPCs;
using Il2CppScheduleOne.Persistence;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Logging;
using TwitchCustomers;
using TwitchCustomers.HarmonyPatches;
using TwitchCustomers.HarmonyPatches.Customer;
using TwitchCustomers.HarmonyPatches.LoadManager;
using TwitchCustomers.HarmonyPatches.MSGConversation;
using TwitchCustomers.NPC;
using TwitchCustomers.TwitchIntegration;
using TwitchLib.Client;
using TwitchLib.Client.Enums;
using TwitchLib.Client.Events;
using TwitchLib.Client.Models;
using TwitchLib.Communication.Interfaces;
using UnityEngine;
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: HarmonyDontPatchAll]
[assembly: MelonInfo(typeof(Mod), "TwitchCustomers", "0.3.1", "ReservedKeyword", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonColor(1, 160, 32, 240)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("TwitchCustomers")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.3.1")]
[assembly: AssemblyInformationalVersion("1.0.0+40b1757cc4e8b973e747407a8f3748c238e42c9e")]
[assembly: AssemblyProduct("TwitchCustomers")]
[assembly: AssemblyTitle("TwitchCustomers")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.1.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 TwitchCustomers
{
	public class Constants
	{
		public const string ENTRY_TRANSFORM_FIND_NAME = "Name";

		public const string ENTRY_TRANSFORM_FIND_CATEGORY = "Category";

		public const float ENTRY_TRANSFORM_CATEGORY_MARGIN_RIGHT = 225f;

		public static string ToHarmonyID()
		{
			return "TwitchCustomers-MelonLoader.0.3.1";
		}
	}
	public class Mod : MelonMod
	{
		private Harmony harmony;

		public static Mod Instance { get; private set; }

		public ModConfig ModConfig { get; private set; }

		public ChatterManager ChatterManager { get; private set; }

		public CachedNPCManager CachedNPCManger { get; private set; }

		public override void OnInitializeMelon()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			Instance = this;
			ModConfig = new ModConfig();
			if (!ModConfig.IsEnabled)
			{
				((MelonBase)this).LoggerInstance.Msg("Plugin disabled in configuration file, won't proceed...");
				return;
			}
			ChatterManager = new ChatterManager(this, ModConfig);
			ChatterManager.Connect();
			CachedNPCManger = new CachedNPCManager(((MelonBase)this).LoggerInstance);
			harmony = new Harmony(Constants.ToHarmonyID());
			List<IPatchModule> list = new List<IPatchModule>(3)
			{
				new CustomerPatchModule(),
				new LoadManagerPatchModule(),
				new MSGConversationPatchModule()
			};
			foreach (IPatchModule item in list)
			{
				item.Setup(this);
			}
			harmony.PatchAll();
			((MelonBase)this).LoggerInstance.Msg("Mod has finished initialization process!");
		}
	}
	public class ModConfig
	{
		public bool IsEnabled { get; private set; }

		public bool PreserveOriginalNPCName { get; private set; }

		public string ChannelName { get; private set; }

		public List<string> BlocklistedChatters { get; private set; }

		public string MessageCommand { get; private set; }

		public double SubscriberWeight { get; private set; }

		public int QueueSize { get; private set; }

		public ModConfig()
		{
			MelonPreferences_Category val = MelonPreferences.CreateCategory("TwitchCustomers_General", "Twitch Customers - General");
			IsEnabled = val.CreateEntry<bool>("Enable Mod", true, (string)null, "If true, plugin will initialize when loaded.", false, false, (ValueValidator)null, (string)null).Value;
			PreserveOriginalNPCName = val.CreateEntry<bool>("Preserve Original NPC Name", true, (string)null, "If true, NPC names are reset once a deal has finished.", false, false, (ValueValidator)null, (string)null).Value;
			MelonPreferences_Category val2 = MelonPreferences.CreateCategory("TwitchCustomers_Integration", "Twitch Customers - Twitch Integration");
			ChannelName = val2.CreateEntry<string>("Channel Name", "reservedkeyword", (string)null, "Twitch channel to listen to messages in (no authentication needed).", false, false, (ValueValidator)null, (string)null).Value;
			BlocklistedChatters = val2.CreateEntry<string>("Blocklisted Chatters", "", (string)null, "Comma-separated list of chatter usernames to not process messages from.", false, false, (ValueValidator)null, (string)null).Value.Split(",").ToList();
			MessageCommand = val2.CreateEntry<string>("Message Command", "!iwannabeacustomer", (string)null, "Unique command that registers a Twitch chatter's intent to be a non-playable, in-game character.", false, false, (ValueValidator)null, (string)null).Value;
			SubscriberWeight = val2.CreateEntry<double>("Subscriber Weight", 1.2, (string)null, "Weight value that makes subscribers more likely to get picked. (For example, 1.2 means subscribers are 20% luckier.)", false, false, (ValueValidator)null, (string)null).Value;
			QueueSize = val2.CreateEntry<int>("Queue Size", 100, (string)null, "Limit of **unique** chatters, subscribers and non-subscribers combined, to keep in queue. Mod will refuse above limit.", false, false, (ValueValidator)null, (string)null).Value;
		}
	}
}
namespace TwitchCustomers.TwitchIntegration
{
	public class ChatterManager
	{
		private enum TargetGroup
		{
			Subscriber,
			NonSubscriber,
			None
		}

		private const double NON_SUBSCRIBER_WEIGHT = 1.0;

		private readonly string channelName = modConfig.ChannelName;

		private readonly List<string> blocklistedChatters = modConfig.BlocklistedChatters;

		private readonly string messageCommand = modConfig.MessageCommand;

		private readonly double subscriberWeight = modConfig.SubscriberWeight;

		private readonly int queueSize = modConfig.QueueSize;

		private TwitchClient client;

		private readonly Instance log = ((MelonBase)mod).LoggerInstance;

		private readonly object chattersLock = new object();

		private readonly HashSet<string> subscriberParticipants = new HashSet<string>();

		private readonly HashSet<string> nonSubscriberParticipants = new HashSet<string>();

		private readonly Random random = new Random();

		public ChatterManager(Mod mod, ModConfig modConfig)
		{
		}

		public void Connect()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			ConnectionCredentials val = new ConnectionCredentials("justinfan1234567", "", "wss://irc-ws.chat.twitch.tv:443", false, (Capabilities)null);
			client = new TwitchClient((IClient)null, (ClientProtocol)1, (ILogger<TwitchClient>)null);
			client.Initialize(val, channelName, '!', '!', true);
			client.OnConnected += Client_OnConnected;
			client.OnConnectionError += Client_OnConnectionError;
			client.OnJoinedChannel += Client_OnJoinedChannel;
			client.OnMessageReceived += Client_OnMessageReceived;
			client.Connect();
			log.Msg("Attempting to connect to Twitch IRC client...");
		}

		private void Client_OnConnected(object sender, OnConnectedArgs e)
		{
			log.Msg("Connected to Twitch IRC client.");
			client.JoinChannel(channelName, false);
			log.Msg("Attempting to join channel " + channelName + " as anonymous user...");
		}

		private void Client_OnConnectionError(object sender, OnConnectionErrorArgs e)
		{
			log.Error("Failed to connect to Twitch IRC client!");
			log.Error(e.Error.Message);
		}

		private void Client_OnJoinedChannel(object sender, OnJoinedChannelArgs e)
		{
			log.Msg("Joined " + channelName + "'s Twitch channel as anonymous user.");
		}

		private void Client_OnMessageReceived(object sender, OnMessageReceivedArgs e)
		{
			string displayName = ((TwitchLibMessage)e.ChatMessage).DisplayName;
			bool isSubscriber = e.ChatMessage.IsSubscriber;
			if (blocklistedChatters.Contains<string>(displayName, StringComparer.CurrentCultureIgnoreCase))
			{
				log.Msg("Detected blocklisted chatter " + displayName + ", will not add to queue.");
			}
			else
			{
				if (!e.ChatMessage.Message.Contains(messageCommand))
				{
					return;
				}
				lock (chattersLock)
				{
					if (GetTotalParticipants() < queueSize)
					{
						if (isSubscriber)
						{
							subscriberParticipants.Add(displayName);
							log.Msg("Twitch chatter " + displayName + " (subscriber) added as participant.");
						}
						else
						{
							nonSubscriberParticipants.Add(displayName);
							log.Msg("Twitch chatter " + displayName + " (non-subscriber) added as participant.");
						}
					}
				}
			}
		}

		private (double totalWeight, double subscriberWeightTotal) CalculateWeights()
		{
			double num = (double)subscriberParticipants.Count * subscriberWeight;
			double num2 = (double)nonSubscriberParticipants.Count * 1.0;
			return (num + num2, num);
		}

		private TargetGroup DetermineTargetGroup(double randomPick, double subscriberWeightTotal)
		{
			bool flag = randomPick < subscriberWeightTotal;
			int count = subscriberParticipants.Count;
			int count2 = nonSubscriberParticipants.Count;
			if (flag && count > 0)
			{
				return TargetGroup.Subscriber;
			}
			if (count2 > 0)
			{
				return TargetGroup.NonSubscriber;
			}
			if (count > 0)
			{
				return TargetGroup.Subscriber;
			}
			return TargetGroup.None;
		}

		public string GetRandomChatter()
		{
			lock (chattersLock)
			{
				if (GetTotalParticipants() == 0)
				{
					log.Warning("No chatters found, nothing to return.");
					return null;
				}
				var (num, subscriberWeightTotal) = CalculateWeights();
				if (num <= 0.0)
				{
					log.Error("Total weight is zero or negative. Cannot perform weighted pick.");
					return null;
				}
				double randomPick = random.NextDouble() * num;
				TargetGroup targetGroup = DetermineTargetGroup(randomPick, subscriberWeightTotal);
				string text = null;
				bool flag = false;
				switch (targetGroup)
				{
				case TargetGroup.Subscriber:
				{
					int index2 = random.Next(subscriberParticipants.Count);
					text = subscriberParticipants.ElementAt(index2);
					subscriberParticipants.Remove(text);
					log.Msg("Selected winner (subscriber): " + text);
					flag = true;
					break;
				}
				case TargetGroup.NonSubscriber:
				{
					int index = random.Next(nonSubscriberParticipants.Count);
					text = nonSubscriberParticipants.ElementAt(index);
					nonSubscriberParticipants.Remove(text);
					log.Msg("Selected winner (non-subscriber): " + text);
					flag = true;
					break;
				}
				default:
					log.Warning("No target group determined for selection.");
					flag = false;
					break;
				}
				if (!flag && GetTotalParticipants() > 0)
				{
					log.Error($"Failed to select winner event thought participants exist (Target Group: {targetGroup}).");
					return null;
				}
				log.Msg($"Returning winner: {text}. Remaining participants: {GetTotalParticipants()}.");
				return text;
			}
		}

		private int GetTotalParticipants()
		{
			return subscriberParticipants.Count + nonSubscriberParticipants.Count;
		}
	}
}
namespace TwitchCustomers.NPC
{
	public class CachedNPC
	{
		[CompilerGenerated]
		private sealed class <UpdateConversationDisplayName_Coroutine>d__22 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string newDisplayName;

			public CachedNPC <>4__this;

			private Text <nameTextComponent>5__1;

			private Exception <ex>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<nameTextComponent>5__1 = null;
				<ex>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if ((Object)(object)<>4__this.UnityRectEntry == (Object)null)
				{
					log.Warning("Can't update conversation display name, UnityRectEntry was null.");
					return false;
				}
				try
				{
					<nameTextComponent>5__1 = <>4__this.GetConversationTextComponent();
					if ((Object)(object)<nameTextComponent>5__1 == (Object)null)
					{
						log.Warning("Can't update conversation display name, nameTextComponent was null");
						return false;
					}
					<nameTextComponent>5__1.text = newDisplayName;
					<>4__this.UpdateConversationCategoryPadding();
					log.Msg($"NPC {<>4__this.NPCGUID} text component updated successfully!");
					<nameTextComponent>5__1 = null;
				}
				catch (Exception ex)
				{
					<ex>5__2 = ex;
					log.Error($"Exception while updating conversation display name: {<ex>5__2}.");
				}
				return false;
			}

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

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

		private static readonly Mod mod = Mod.Instance;

		private static readonly Instance log = ((MelonBase)mod).LoggerInstance;

		public Guid NPCGUID { get; private set; }

		public RectTransform UnityRectEntry { get; set; }

		public OriginalNPCName OriginalNPCName { get; private set; }

		public CachedNPC(NPC gameNpc)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			NPCGUID = gameNpc.GUID;
			OriginalNPCName = new OriginalNPCName(gameNpc.FirstName, gameNpc.LastName);
		}

		public CachedNPC(NPC gameNpc, RectTransform unityRectEntry)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			NPCGUID = gameNpc.GUID;
			UnityRectEntry = unityRectEntry;
			OriginalNPCName = new OriginalNPCName(gameNpc.FirstName, gameNpc.LastName);
		}

		private Text GetConversationTextComponent()
		{
			if ((Object)(object)UnityRectEntry == (Object)null)
			{
				return null;
			}
			Transform val = ((Transform)UnityRectEntry).Find("Name");
			if ((Object)(object)val == (Object)null)
			{
				log.Warning("Could not find 'Name' child transform on " + ((Object)UnityRectEntry).name + ".");
				return null;
			}
			Text component = ((Component)val).GetComponent<Text>();
			if ((Object)(object)component == (Object)null)
			{
				log.Warning("'Name' transform on " + ((Object)UnityRectEntry).name + " is missing Text component.");
				return null;
			}
			return component;
		}

		private NPC GetGameNPC()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (NPCManager.NPCRegistry == null)
			{
				log.Error("Cannot fetch Game NPC, NPCRegistry was found null.");
				return null;
			}
			Enumerator<NPC> enumerator = NPCManager.NPCRegistry.GetEnumerator();
			while (enumerator.MoveNext())
			{
				NPC current = enumerator.Current;
				if ((Object)(object)current != (Object)null && current.GUID == NPCGUID)
				{
					return current;
				}
			}
			return null;
		}

		public void ResetCharacterName()
		{
			UpdateCharacterName(OriginalNPCName.FirstName, OriginalNPCName.LastName);
		}

		public void ResetConversationDisplayName()
		{
			UpdateConversationDisplayName(OriginalNPCName.FirstName + " " + OriginalNPCName.LastName);
		}

		public void UpdateCharacterName(string firstName, string lastName = "")
		{
			NPC gameNPC = GetGameNPC();
			if ((Object)(object)gameNPC == (Object)null)
			{
				log.Error("Failed to update character name, NPC not found in game registry.");
				return;
			}
			gameNPC.FirstName = firstName;
			gameNPC.LastName = lastName;
		}

		public void UpdateConversationDisplayName(string contactName)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NetworkSingleton<MessagingManager>.instance == (Object)null)
			{
				log.Error("MessagingManager.instance is null!");
				return;
			}
			NPC gameNPC = GetGameNPC();
			if ((Object)(object)gameNPC == (Object)null)
			{
				log.Error("Failed to update conversation display name, NPC not found in game registry.");
				return;
			}
			MSGConversation conversation = NetworkSingleton<MessagingManager>.instance.GetConversation(gameNPC);
			if (conversation == null)
			{
				log.Warning($"Could not get MSGConversation for {((gameNPC != null) ? new Guid?(gameNPC.GUID) : null)}. Cannot update contactName.");
			}
			else
			{
				conversation.contactName = contactName;
				MelonCoroutines.Start(UpdateConversationDisplayName_Coroutine(contactName));
			}
		}

		[IteratorStateMachine(typeof(<UpdateConversationDisplayName_Coroutine>d__22))]
		private IEnumerator UpdateConversationDisplayName_Coroutine(string newDisplayName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateConversationDisplayName_Coroutine>d__22(0)
			{
				<>4__this = this,
				newDisplayName = newDisplayName
			};
		}

		private void UpdateConversationCategoryPadding()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			if ((Object)(object)UnityRectEntry == (Object)null)
			{
				log.Warning("Can't update conversation display name, UnityRectEntry was null.");
				return;
			}
			Text conversationTextComponent = GetConversationTextComponent();
			if ((Object)(object)conversationTextComponent == (Object)null)
			{
				log.Warning("Can't update conversation display name, nameTextComponent was null");
				return;
			}
			float preferredWidth = conversationTextComponent.preferredWidth;
			Transform obj = ((Transform)UnityRectEntry).Find("Category");
			RectTransform val = ((obj != null) ? ((Component)obj).GetComponent<RectTransform>() : null);
			if ((Object)(object)val == (Object)null)
			{
				log.Warning("Could not find 'Category' child transform (or RectTransform) on " + ((Object)UnityRectEntry).name + ".");
				return;
			}
			Vector2 anchoredPosition = val.anchoredPosition;
			anchoredPosition.x = preferredWidth + 225f;
			val.anchoredPosition = anchoredPosition;
		}
	}
	public class CachedNPCManager
	{
		private readonly Instance log;

		private readonly Dictionary<Guid, CachedNPC> cachedNpcsByGuid;

		public CachedNPCManager(Instance log)
		{
			this.log = log;
			cachedNpcsByGuid = new Dictionary<Guid, CachedNPC>();
			base..ctor();
		}

		public bool AddCachedNPC(CachedNPC npc)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (npc != null)
			{
				_ = npc.NPCGUID;
				if (0 == 0)
				{
					Guid nPCGUID = npc.NPCGUID;
					return cachedNpcsByGuid.TryAdd(nPCGUID, npc);
				}
			}
			log.Warning("Attempted to add a null CachedNPC or one with a null GameNPC.");
			return false;
		}

		public void Clear()
		{
			cachedNpcsByGuid.Clear();
		}

		public CachedNPC GetFromGameNPC(NPC gameNPC)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameNPC == (Object)null)
			{
				return null;
			}
			Guid gUID = gameNPC.GUID;
			if (cachedNpcsByGuid.TryGetValue(gUID, out var value))
			{
				return value;
			}
			return null;
		}
	}
	public class OriginalNPCName
	{
		public string FirstName { get; private set; }

		public string LastName { get; private set; }

		public OriginalNPCName(string firstName, string lastName)
		{
			FirstName = firstName;
			LastName = lastName;
			base..ctor();
		}
	}
}
namespace TwitchCustomers.HarmonyPatches
{
	public interface IPatchModule
	{
		Type StaticWrapperType { get; }

		void Setup(Mod mod);
	}
	public abstract class PatchModule<TLogic> : IPatchModule where TLogic : class
	{
		public abstract Type StaticWrapperType { get; }

		protected TLogic LogicInstance { get; private set; }

		public abstract TLogic CreateLogicInstance(Mod mod);

		public abstract void InitializeStaticWrapper(Instance log);

		public virtual void Setup(Mod mod)
		{
			Instance loggerInstance = ((MelonBase)mod).LoggerInstance;
			if (LogicInstance != null)
			{
				loggerInstance.Warning("PatchModule for " + StaticWrapperType.Name + " already initialized. Skipping...");
				return;
			}
			LogicInstance = CreateLogicInstance(mod);
			if (LogicInstance == null)
			{
				throw new InvalidOperationException("CreateLogicInstance for " + GetType().Name + " did not set the LogicInstance property.");
			}
			InitializeStaticWrapper(((MelonBase)mod).LoggerInstance);
		}
	}
}
namespace TwitchCustomers.HarmonyPatches.MSGConversation
{
	public class MSGConversationPatchLogic
	{
		private readonly CachedNPCManager cachedNpcManager = mod.CachedNPCManger;

		private readonly Instance log = ((MelonBase)mod).LoggerInstance;

		public MSGConversationPatchLogic(Mod mod)
		{
		}

		public void CreateUI_Postfix(MSGConversation __instance)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			NPC sender = __instance.sender;
			RectTransform entry = __instance.entry;
			CachedNPC fromGameNPC = cachedNpcManager.GetFromGameNPC(sender);
			if (fromGameNPC != null)
			{
				fromGameNPC.UnityRectEntry = entry;
				log.Msg($"NPC {sender.GUID} already found cached, updated Unity container.");
			}
			else
			{
				cachedNpcManager.AddCachedNPC(new CachedNPC(sender, entry));
				log.Msg($"NPC {sender.GUID} not found cached, cached for future use.");
			}
		}
	}
	public class MSGConversationPatchModule : PatchModule<MSGConversationPatchLogic>
	{
		public override Type StaticWrapperType => typeof(MSGConversationPatchWrapper);

		public override MSGConversationPatchLogic CreateLogicInstance(Mod mod)
		{
			((MelonBase)mod).LoggerInstance.Msg("LoadManagerPatchModule created & bound LoadManagerPatchLogic instance.");
			return new MSGConversationPatchLogic(mod);
		}

		public override void InitializeStaticWrapper(Instance log)
		{
			MSGConversationPatchLogic logicInstance = base.LogicInstance;
			if (logicInstance != null)
			{
				MSGConversationPatchWrapper.Initialize(logicInstance);
				return;
			}
			log.Error("LogicInstance is not type MSGConversationPatchLogic in MSGConversationPatchModule. Type is $" + (base.LogicInstance?.GetType().Name ?? "unknown") + ".");
			throw new InvalidOperationException("LogicInstance is not type MSGConversationPatchLogic for " + GetType().Name + ".");
		}
	}
	[HarmonyPatch(typeof(MSGConversation))]
	public static class MSGConversationPatchWrapper
	{
		private static MSGConversationPatchLogic patchLogic;

		public static void Initialize(MSGConversationPatchLogic patchLogic)
		{
			MSGConversationPatchWrapper.patchLogic = patchLogic;
		}

		[HarmonyPatch("CreateUI")]
		[HarmonyPostfix]
		public static void CreateUI_Postfix_Wrapper(MSGConversation __instance)
		{
			patchLogic?.CreateUI_Postfix(__instance);
		}
	}
}
namespace TwitchCustomers.HarmonyPatches.LoadManager
{
	public class LoadManagerPatchLogic
	{
		private readonly CachedNPCManager cachedNpcManager = mod.CachedNPCManger;

		private readonly Instance log = ((MelonBase)mod).LoggerInstance;

		public LoadManagerPatchLogic(Mod mod)
		{
		}

		public void ExitToMenu_Postfix()
		{
			log.Msg("Player exited to main menu, clearing NPC cache...");
			cachedNpcManager.Clear();
		}
	}
	public class LoadManagerPatchModule : PatchModule<LoadManagerPatchLogic>
	{
		public override Type StaticWrapperType => typeof(LoadManagerPatchWrapper);

		public override LoadManagerPatchLogic CreateLogicInstance(Mod mod)
		{
			((MelonBase)mod).LoggerInstance.Msg("LoadManagerPatchModule created & bound LoadManagerPatchLogic instance.");
			return new LoadManagerPatchLogic(mod);
		}

		public override void InitializeStaticWrapper(Instance log)
		{
			LoadManagerPatchLogic logicInstance = base.LogicInstance;
			if (logicInstance != null)
			{
				LoadManagerPatchWrapper.Initialize(logicInstance);
				return;
			}
			log.Error("LogicInstance is not type LoadManagerPatchLogic in LoadManagerPatchModule. Type is $" + (base.LogicInstance?.GetType().Name ?? "unknown") + ".");
			throw new InvalidOperationException("LogicInstance is not type LoadManagerPatchLogic for " + GetType().Name + ".");
		}
	}
	[HarmonyPatch(typeof(LoadManager))]
	public static class LoadManagerPatchWrapper
	{
		private static LoadManagerPatchLogic patchLogic;

		public static void Initialize(LoadManagerPatchLogic patchLogic)
		{
			LoadManagerPatchWrapper.patchLogic = patchLogic;
		}

		[HarmonyPatch("ExitToMenu")]
		[HarmonyPostfix]
		public static void ExitToMenu_Postfix_Wrapper()
		{
			patchLogic?.ExitToMenu_Postfix();
		}
	}
}
namespace TwitchCustomers.HarmonyPatches.Customer
{
	public class CustomerPatchLogic
	{
		private readonly CachedNPCManager cachedNpcManager = mod.CachedNPCManger;

		private readonly ChatterManager chatterManager = mod.ChatterManager;

		private readonly Instance log = ((MelonBase)mod).LoggerInstance;

		private readonly ModConfig modConfig = mod.ModConfig;

		public CustomerPatchLogic(Mod mod)
		{
		}

		public void ContractRejected_Postfix(Customer __instance)
		{
			ResetCustomerIfPreserveOriginalNPC(__instance);
		}

		public void CurrentContractEnded_Postfix(Customer __instance)
		{
			ResetCustomerIfPreserveOriginalNPC(__instance);
		}

		public void EvaluateCounterOffer_Postfix(Customer __instance, bool __result)
		{
			if (!__result)
			{
				ResetCustomerIfPreserveOriginalNPC(__instance);
			}
		}

		public void ExpireOffer_Prefix(Customer __instance)
		{
			ResetCustomerIfPreserveOriginalNPC(__instance);
		}

		public void NotifyPlayerOfContract_Prefix(Customer __instance)
		{
			string randomChatter = chatterManager.GetRandomChatter();
			if (string.IsNullOrEmpty(randomChatter))
			{
				log.Warning("No chatter found for contract notification, skipping name update.");
				return;
			}
			NPC val = ((__instance != null) ? __instance.NPC : null);
			CachedNPC cachedNPC = cachedNpcManager.GetFromGameNPC(val);
			if (cachedNPC == null)
			{
				cachedNPC = new CachedNPC(val);
				cachedNpcManager.AddCachedNPC(cachedNPC);
			}
			cachedNPC.UpdateCharacterName(randomChatter);
			cachedNPC.UpdateConversationDisplayName(randomChatter);
			log.Msg("Updated in-game NPC with Twitch chatter: " + randomChatter + ".");
		}

		private void ResetCustomerIfPreserveOriginalNPC(Customer customer)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (modConfig.PreserveOriginalNPCName)
			{
				NPC nPC = customer.NPC;
				CachedNPC fromGameNPC = cachedNpcManager.GetFromGameNPC(nPC);
				if (fromGameNPC == null)
				{
					log.Warning($"Failed to find cached NPC {nPC.GUID}. Unable to reset customer.");
				}
				else
				{
					fromGameNPC.ResetCharacterName();
					fromGameNPC.ResetConversationDisplayName();
				}
			}
		}
	}
	public class CustomerPatchModule : PatchModule<CustomerPatchLogic>
	{
		public override Type StaticWrapperType => typeof(CustomerPatchWrapper);

		public override CustomerPatchLogic CreateLogicInstance(Mod mod)
		{
			((MelonBase)mod).LoggerInstance.Msg("CustomerPatchModule created & bound CustomerPatchLogic instance.");
			return new CustomerPatchLogic(mod);
		}

		public override void InitializeStaticWrapper(Instance log)
		{
			CustomerPatchLogic logicInstance = base.LogicInstance;
			if (logicInstance != null)
			{
				CustomerPatchWrapper.Initialize(logicInstance);
				return;
			}
			log.Error("LogicInstance is not type CustomerPatchLogic in CustomerPatchModule. Type is $" + (base.LogicInstance?.GetType().Name ?? "unknown") + ".");
			throw new InvalidOperationException("LogicInstance is not type CustomerPatchLogic for " + GetType().Name + ".");
		}
	}
	[HarmonyPatch(typeof(Customer))]
	public static class CustomerPatchWrapper
	{
		private static CustomerPatchLogic patchLogic;

		public static void Initialize(CustomerPatchLogic patchLogic)
		{
			CustomerPatchWrapper.patchLogic = patchLogic;
		}

		[HarmonyPatch("ContractRejected")]
		[HarmonyPostfix]
		public static void ContractRejected_Postfix_Wrapper(Customer __instance)
		{
			patchLogic?.ContractRejected_Postfix(__instance);
		}

		[HarmonyPatch("CurrentContractEnded")]
		[HarmonyPostfix]
		public static void CurrentContractEnded_Postfix_Wrapper(Customer __instance)
		{
			patchLogic?.CurrentContractEnded_Postfix(__instance);
		}

		[HarmonyPatch("EvaluateCounteroffer")]
		[HarmonyPostfix]
		public static void EvaluateCounterOffer_Postfix_Wrapper(Customer __instance, bool __result)
		{
			patchLogic?.EvaluateCounterOffer_Postfix(__instance, __result);
		}

		[HarmonyPatch("ExpireOffer")]
		[HarmonyPrefix]
		public static void ExpireOffer_Prefix_Wrapper(Customer __instance)
		{
			patchLogic?.ExpireOffer_Prefix(__instance);
		}

		[HarmonyPatch("NotifyPlayerOfContract")]
		[HarmonyPrefix]
		public static void NotifyPlayerOfContract_Prefix_Wrapper(Customer __instance)
		{
			patchLogic?.NotifyPlayerOfContract_Prefix(__instance);
		}
	}
}

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Timers;
using Microsoft.Extensions.Logging;
using TwitchLib.Client.Enums;
using TwitchLib.Client.Enums.Internal;
using TwitchLib.Client.Events;
using TwitchLib.Client.Exceptions;
using TwitchLib.Client.Interfaces;
using TwitchLib.Client.Internal;
using TwitchLib.Client.Internal.Parsing;
using TwitchLib.Client.Manager;
using TwitchLib.Client.Models;
using TwitchLib.Client.Models.Internal;
using TwitchLib.Communication.Clients;
using TwitchLib.Communication.Events;
using TwitchLib.Communication.Interfaces;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("swiftyspiffy, Prom3theu5, Syzuna, LuckyNoS7evin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2022")]
[assembly: AssemblyDescription("Client component of TwitchLib. This component allows you to access Twitch chat and whispers, as well as the events that are sent over this connection.")]
[assembly: AssemblyFileVersion("3.3.1")]
[assembly: AssemblyInformationalVersion("3.3.1")]
[assembly: AssemblyProduct("TwitchLib.Client")]
[assembly: AssemblyTitle("TwitchLib.Client")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/TwitchLib/TwitchLib.Client")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("3.3.1.0")]
namespace TwitchLib.Client
{
	public class TwitchClient : ITwitchClient
	{
		private IClient _client;

		private MessageEmoteCollection _channelEmotes = new MessageEmoteCollection();

		private readonly ICollection<char> _chatCommandIdentifiers = new HashSet<char>();

		private readonly ICollection<char> _whisperCommandIdentifiers = new HashSet<char>();

		private readonly Queue<JoinedChannel> _joinChannelQueue = new Queue<JoinedChannel>();

		private readonly ILogger<TwitchClient> _logger;

		private readonly ClientProtocol _protocol;

		private bool _currentlyJoiningChannels;

		private Timer _joinTimer;

		private List<KeyValuePair<string, DateTime>> _awaitingJoins;

		private readonly IrcParser _ircParser;

		private readonly JoinedChannelManager _joinedChannelManager;

		private readonly List<string> _hasSeenJoinedChannels = new List<string>();

		private string _lastMessageSent;

		public Version Version => Assembly.GetEntryAssembly().GetName().Version;

		public bool IsInitialized => _client != null;

		public IReadOnlyList<JoinedChannel> JoinedChannels => _joinedChannelManager.GetJoinedChannels();

		public string TwitchUsername { get; private set; }

		public WhisperMessage PreviousWhisper { get; private set; }

		public bool IsConnected
		{
			get
			{
				if (!IsInitialized || _client == null)
				{
					return false;
				}
				return _client.IsConnected;
			}
		}

		public MessageEmoteCollection ChannelEmotes => _channelEmotes;

		public bool DisableAutoPong { get; set; }

		public bool WillReplaceEmotes { get; set; }

		public ConnectionCredentials ConnectionCredentials { get; private set; }

		public bool AutoReListenOnException { get; set; }

		public event EventHandler<OnAnnouncementArgs> OnAnnouncement;

		public event EventHandler<OnVIPsReceivedArgs> OnVIPsReceived;

		public event EventHandler<OnLogArgs> OnLog;

		public event EventHandler<OnConnectedArgs> OnConnected;

		public event EventHandler<OnJoinedChannelArgs> OnJoinedChannel;

		public event EventHandler<OnIncorrectLoginArgs> OnIncorrectLogin;

		public event EventHandler<OnChannelStateChangedArgs> OnChannelStateChanged;

		public event EventHandler<OnUserStateChangedArgs> OnUserStateChanged;

		public event EventHandler<OnMessageReceivedArgs> OnMessageReceived;

		public event EventHandler<OnWhisperReceivedArgs> OnWhisperReceived;

		public event EventHandler<OnMessageSentArgs> OnMessageSent;

		public event EventHandler<OnWhisperSentArgs> OnWhisperSent;

		public event EventHandler<OnChatCommandReceivedArgs> OnChatCommandReceived;

		public event EventHandler<OnWhisperCommandReceivedArgs> OnWhisperCommandReceived;

		public event EventHandler<OnUserJoinedArgs> OnUserJoined;

		public event EventHandler<OnModeratorJoinedArgs> OnModeratorJoined;

		public event EventHandler<OnModeratorLeftArgs> OnModeratorLeft;

		public event EventHandler<OnMessageClearedArgs> OnMessageCleared;

		public event EventHandler<OnNewSubscriberArgs> OnNewSubscriber;

		public event EventHandler<OnReSubscriberArgs> OnReSubscriber;

		public event EventHandler<OnPrimePaidSubscriberArgs> OnPrimePaidSubscriber;

		public event EventHandler<OnExistingUsersDetectedArgs> OnExistingUsersDetected;

		public event EventHandler<OnUserLeftArgs> OnUserLeft;

		public event EventHandler<OnDisconnectedEventArgs> OnDisconnected;

		public event EventHandler<OnConnectionErrorArgs> OnConnectionError;

		public event EventHandler<OnChatClearedArgs> OnChatCleared;

		public event EventHandler<OnUserTimedoutArgs> OnUserTimedout;

		public event EventHandler<OnLeftChannelArgs> OnLeftChannel;

		public event EventHandler<OnUserBannedArgs> OnUserBanned;

		public event EventHandler<OnModeratorsReceivedArgs> OnModeratorsReceived;

		public event EventHandler<OnChatColorChangedArgs> OnChatColorChanged;

		public event EventHandler<OnSendReceiveDataArgs> OnSendReceiveData;

		public event EventHandler<OnRaidNotificationArgs> OnRaidNotification;

		public event EventHandler<OnGiftedSubscriptionArgs> OnGiftedSubscription;

		public event EventHandler<OnCommunitySubscriptionArgs> OnCommunitySubscription;

		public event EventHandler<OnContinuedGiftedSubscriptionArgs> OnContinuedGiftedSubscription;

		public event EventHandler<OnMessageThrottledEventArgs> OnMessageThrottled;

		public event EventHandler<OnWhisperThrottledEventArgs> OnWhisperThrottled;

		public event EventHandler<OnErrorEventArgs> OnError;

		public event EventHandler<OnReconnectedEventArgs> OnReconnected;

		public event EventHandler<OnRequiresVerifiedEmailArgs> OnRequiresVerifiedEmail;

		public event EventHandler<OnRequiresVerifiedPhoneNumberArgs> OnRequiresVerifiedPhoneNumber;

		public event EventHandler<OnRateLimitArgs> OnRateLimit;

		public event EventHandler<OnDuplicateArgs> OnDuplicate;

		public event EventHandler<OnBannedEmailAliasArgs> OnBannedEmailAlias;

		public event EventHandler OnSelfRaidError;

		public event EventHandler OnNoPermissionError;

		public event EventHandler OnRaidedChannelIsMatureAudience;

		public event EventHandler<OnFailureToReceiveJoinConfirmationArgs> OnFailureToReceiveJoinConfirmation;

		public event EventHandler<OnFollowersOnlyArgs> OnFollowersOnly;

		public event EventHandler<OnSubsOnlyArgs> OnSubsOnly;

		public event EventHandler<OnEmoteOnlyArgs> OnEmoteOnly;

		public event EventHandler<OnSuspendedArgs> OnSuspended;

		public event EventHandler<OnBannedArgs> OnBanned;

		public event EventHandler<OnSlowModeArgs> OnSlowMode;

		public event EventHandler<OnR9kModeArgs> OnR9kMode;

		public event EventHandler<OnUserIntroArgs> OnUserIntro;

		public event EventHandler<OnUnaccountedForArgs> OnUnaccountedFor;

		public TwitchClient(IClient client = null, ClientProtocol protocol = 1, ILogger<TwitchClient> logger = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			_logger = logger;
			_client = client;
			_protocol = protocol;
			_joinedChannelManager = new JoinedChannelManager();
			_ircParser = new IrcParser();
		}

		public void Initialize(ConnectionCredentials credentials, string channel = null, char chatCommandIdentifier = '!', char whisperCommandIdentifier = '!', bool autoReListenOnExceptions = true)
		{
			if (channel != null && channel[0] == '#')
			{
				channel = channel.Substring(1);
			}
			initializeHelper(credentials, new List<string> { channel }, chatCommandIdentifier, whisperCommandIdentifier, autoReListenOnExceptions);
		}

		public void Initialize(ConnectionCredentials credentials, List<string> channels, char chatCommandIdentifier = '!', char whisperCommandIdentifier = '!', bool autoReListenOnExceptions = true)
		{
			channels = channels.Select((string x) => (x[0] != '#') ? x : x.Substring(1)).ToList();
			initializeHelper(credentials, channels, chatCommandIdentifier, whisperCommandIdentifier, autoReListenOnExceptions);
		}

		private void initializeHelper(ConnectionCredentials credentials, List<string> channels, char chatCommandIdentifier = '!', char whisperCommandIdentifier = '!', bool autoReListenOnExceptions = true)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			Log($"TwitchLib-TwitchClient initialized, assembly version: {Assembly.GetExecutingAssembly().GetName().Version}");
			ConnectionCredentials = credentials;
			TwitchUsername = ConnectionCredentials.TwitchUsername;
			if (chatCommandIdentifier != 0)
			{
				_chatCommandIdentifiers.Add(chatCommandIdentifier);
			}
			if (whisperCommandIdentifier != 0)
			{
				_whisperCommandIdentifiers.Add(whisperCommandIdentifier);
			}
			AutoReListenOnException = autoReListenOnExceptions;
			if (channels != null && channels.Count > 0)
			{
				int i;
				for (i = 0; i < channels.Count; i++)
				{
					if (!string.IsNullOrEmpty(channels[i]))
					{
						if (((IEnumerable<JoinedChannel>)JoinedChannels).FirstOrDefault((Func<JoinedChannel, bool>)((JoinedChannel x) => x.Channel.ToLower() == channels[i])) != null)
						{
							return;
						}
						_joinChannelQueue.Enqueue(new JoinedChannel(channels[i]));
					}
				}
			}
			InitializeClient();
		}

		private void InitializeClient()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (_client == null)
			{
				ClientProtocol protocol = _protocol;
				if ((int)protocol != 0)
				{
					if ((int)protocol == 1)
					{
						_client = (IClient)new WebSocketClient((IClientOptions)null);
					}
				}
				else
				{
					_client = (IClient)new TcpClient((IClientOptions)null);
				}
			}
			_client.OnConnected += _client_OnConnected;
			_client.OnMessage += _client_OnMessage;
			_client.OnDisconnected += _client_OnDisconnected;
			_client.OnFatality += _client_OnFatality;
			_client.OnMessageThrottled += _client_OnMessageThrottled;
			_client.OnWhisperThrottled += _client_OnWhisperThrottled;
			_client.OnReconnected += _client_OnReconnected;
		}

		internal void RaiseEvent(string eventName, object args = null)
		{
			Delegate[] invocationList = (GetType().GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this) as MulticastDelegate).GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				@delegate.Method.Invoke(@delegate.Target, (args == null) ? new object[2]
				{
					this,
					new EventArgs()
				} : new object[2] { this, args });
			}
		}

		public void SendRaw(string message)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			Log("Writing: " + message);
			_client.Send(message);
			this.OnSendReceiveData?.Invoke(this, new OnSendReceiveDataArgs
			{
				Direction = (SendReceiveDirection)0,
				Data = message
			});
		}

		private void SendTwitchMessage(JoinedChannel channel, string message, string replyToId = null, bool dryRun = false)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0062: Expected O, but got Unknown
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			if (channel == null || message == null || dryRun)
			{
				return;
			}
			if (message.Length > 500)
			{
				LogError("Message length has exceeded the maximum character count. (500)");
				return;
			}
			OutboundChatMessage val = new OutboundChatMessage
			{
				Channel = channel.Channel,
				Username = ConnectionCredentials.TwitchUsername,
				Message = message
			};
			if (replyToId != null)
			{
				val.ReplyToId = replyToId;
			}
			_lastMessageSent = message;
			_client.Send(((object)val).ToString());
		}

		public void SendMessage(JoinedChannel channel, string message, bool dryRun = false)
		{
			SendTwitchMessage(channel, message, null, dryRun);
		}

		public void SendMessage(string channel, string message, bool dryRun = false)
		{
			SendMessage(GetJoinedChannel(channel), message, dryRun);
		}

		public void SendReply(JoinedChannel channel, string replyToId, string message, bool dryRun = false)
		{
			SendTwitchMessage(channel, message, replyToId, dryRun);
		}

		public void SendReply(string channel, string replyToId, string message, bool dryRun = false)
		{
			SendReply(GetJoinedChannel(channel), replyToId, message, dryRun);
		}

		public void SendWhisper(string receiver, string message, bool dryRun = false)
		{
			//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_001d: 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)
			//IL_0036: Expected O, but got Unknown
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			if (!dryRun)
			{
				OutboundWhisperMessage val = new OutboundWhisperMessage
				{
					Receiver = receiver,
					Username = ConnectionCredentials.TwitchUsername,
					Message = message
				};
				_client.SendWhisper(((object)val).ToString());
				this.OnWhisperSent?.Invoke(this, new OnWhisperSentArgs
				{
					Receiver = receiver,
					Message = message
				});
			}
		}

		public bool Connect()
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			Log("Connecting to: " + ConnectionCredentials.TwitchWebsocketURI);
			_joinedChannelManager.Clear();
			if (_client.Open())
			{
				Log("Should be connected!");
				return true;
			}
			return false;
		}

		public void Disconnect()
		{
			Log("Disconnect Twitch Chat Client...");
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_client.Close(true);
			_joinedChannelManager.Clear();
			PreviousWhisper = null;
		}

		public void Reconnect()
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			Log("Reconnecting to Twitch");
			_client.Reconnect();
		}

		public void AddChatCommandIdentifier(char identifier)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_chatCommandIdentifiers.Add(identifier);
		}

		public void RemoveChatCommandIdentifier(char identifier)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_chatCommandIdentifiers.Remove(identifier);
		}

		public void AddWhisperCommandIdentifier(char identifier)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_whisperCommandIdentifiers.Add(identifier);
		}

		public void RemoveWhisperCommandIdentifier(char identifier)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_whisperCommandIdentifiers.Remove(identifier);
		}

		public void SetConnectionCredentials(ConnectionCredentials credentials)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			if (IsConnected)
			{
				throw new IllegalAssignmentException("While the client is connected, you are unable to change the connection credentials. Please disconnect first and then change them.");
			}
			ConnectionCredentials = credentials;
		}

		public void JoinChannel(string channel, bool overrideCheck = false)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			if (!IsConnected)
			{
				HandleNotConnected();
			}
			if (((IEnumerable<JoinedChannel>)JoinedChannels).FirstOrDefault((Func<JoinedChannel, bool>)((JoinedChannel x) => x.Channel.ToLower() == channel && !overrideCheck)) == null)
			{
				if (channel[0] == '#')
				{
					channel = channel.Substring(1);
				}
				_joinChannelQueue.Enqueue(new JoinedChannel(channel));
				if (!_currentlyJoiningChannels)
				{
					QueueingJoinCheck();
				}
			}
		}

		public JoinedChannel GetJoinedChannel(string channel)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			if (JoinedChannels.Count == 0)
			{
				throw new BadStateException("Must be connected to at least one channel.");
			}
			if (channel[0] == '#')
			{
				channel = channel.Substring(1);
			}
			return _joinedChannelManager.GetJoinedChannel(channel);
		}

		public void LeaveChannel(string channel)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			channel = channel.ToLower();
			if (channel[0] == '#')
			{
				channel = channel.Substring(1);
			}
			Log("Leaving channel: " + channel);
			if (_joinedChannelManager.GetJoinedChannel(channel) != null)
			{
				_client.Send(Rfc2812.Part("#" + channel));
			}
		}

		public void LeaveChannel(JoinedChannel channel)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			LeaveChannel(channel.Channel);
		}

		public void OnReadLineTest(string rawIrc)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			HandleIrcMessage(_ircParser.ParseIrcMessage(rawIrc));
		}

		private void _client_OnWhisperThrottled(object sender, OnWhisperThrottledEventArgs e)
		{
			this.OnWhisperThrottled?.Invoke(sender, e);
		}

		private void _client_OnMessageThrottled(object sender, OnMessageThrottledEventArgs e)
		{
			this.OnMessageThrottled?.Invoke(sender, e);
		}

		private void _client_OnFatality(object sender, OnFatalErrorEventArgs e)
		{
			//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_0034: Expected O, but got Unknown
			this.OnConnectionError?.Invoke(this, new OnConnectionErrorArgs
			{
				BotUsername = TwitchUsername,
				Error = new ErrorEvent
				{
					Message = e.Reason
				}
			});
		}

		private void _client_OnDisconnected(object sender, OnDisconnectedEventArgs e)
		{
			this.OnDisconnected?.Invoke(sender, e);
		}

		private void _client_OnReconnected(object sender, OnReconnectedEventArgs e)
		{
			foreach (JoinedChannel joinedChannel in _joinedChannelManager.GetJoinedChannels())
			{
				if (!string.Equals(joinedChannel.Channel, TwitchUsername, StringComparison.CurrentCultureIgnoreCase))
				{
					_joinChannelQueue.Enqueue(joinedChannel);
				}
			}
			_joinedChannelManager.Clear();
			this.OnReconnected?.Invoke(sender, e);
		}

		private void _client_OnMessage(object sender, OnMessageEventArgs e)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			string[] separator = new string[1] { "\r\n" };
			string[] array = e.Message.Split(separator, StringSplitOptions.None);
			foreach (string text in array)
			{
				if (text.Length > 1)
				{
					Log("Received: " + text);
					this.OnSendReceiveData?.Invoke(this, new OnSendReceiveDataArgs
					{
						Direction = (SendReceiveDirection)1,
						Data = text
					});
					HandleIrcMessage(_ircParser.ParseIrcMessage(text));
				}
			}
		}

		private void _client_OnConnected(object sender, object e)
		{
			_client.Send(Rfc2812.Pass(ConnectionCredentials.TwitchOAuth));
			_client.Send(Rfc2812.Nick(ConnectionCredentials.TwitchUsername));
			_client.Send(Rfc2812.User(ConnectionCredentials.TwitchUsername, 0, ConnectionCredentials.TwitchUsername));
			if (ConnectionCredentials.Capabilities.Membership)
			{
				_client.Send("CAP REQ twitch.tv/membership");
			}
			if (ConnectionCredentials.Capabilities.Commands)
			{
				_client.Send("CAP REQ twitch.tv/commands");
			}
			if (ConnectionCredentials.Capabilities.Tags)
			{
				_client.Send("CAP REQ twitch.tv/tags");
			}
			if (_joinChannelQueue != null && _joinChannelQueue.Count > 0)
			{
				QueueingJoinCheck();
			}
		}

		private void QueueingJoinCheck()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			if (_joinChannelQueue.Count > 0)
			{
				_currentlyJoiningChannels = true;
				JoinedChannel val = _joinChannelQueue.Dequeue();
				Log("Joining channel: " + val.Channel);
				_client.Send(Rfc2812.Join("#" + val.Channel.ToLower()));
				_joinedChannelManager.AddJoinedChannel(new JoinedChannel(val.Channel));
				StartJoinedChannelTimer(val.Channel);
			}
			else
			{
				Log("Finished channel joining queue.");
			}
		}

		private void StartJoinedChannelTimer(string channel)
		{
			if (_joinTimer == null)
			{
				_joinTimer = new Timer(1000.0);
				_joinTimer.Elapsed += JoinChannelTimeout;
				_awaitingJoins = new List<KeyValuePair<string, DateTime>>();
			}
			_awaitingJoins.Add(new KeyValuePair<string, DateTime>(channel.ToLower(), DateTime.Now));
			if (!_joinTimer.Enabled)
			{
				_joinTimer.Start();
			}
		}

		private void JoinChannelTimeout(object sender, ElapsedEventArgs e)
		{
			if (_awaitingJoins.Any())
			{
				List<KeyValuePair<string, DateTime>> list = _awaitingJoins.Where((KeyValuePair<string, DateTime> x) => (DateTime.Now - x.Value).TotalSeconds > 5.0).ToList();
				if (!list.Any())
				{
					return;
				}
				_awaitingJoins.RemoveAll((KeyValuePair<string, DateTime> x) => (DateTime.Now - x.Value).TotalSeconds > 5.0);
				{
					foreach (KeyValuePair<string, DateTime> item in list)
					{
						_joinedChannelManager.RemoveJoinedChannel(item.Key.ToLowerInvariant());
						this.OnFailureToReceiveJoinConfirmation?.Invoke(this, new OnFailureToReceiveJoinConfirmationArgs
						{
							Exception = new FailureToReceiveJoinConfirmationException(item.Key)
						});
					}
					return;
				}
			}
			_joinTimer.Stop();
			_currentlyJoiningChannels = false;
			QueueingJoinCheck();
		}

		private void HandleIrcMessage(IrcMessage ircMessage)
		{
			//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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected I4, but got Unknown
			if (ircMessage.Message.Contains("Login authentication failed"))
			{
				this.OnIncorrectLogin?.Invoke(this, new OnIncorrectLoginArgs
				{
					Exception = new ErrorLoggingInException(ircMessage.ToString(), TwitchUsername)
				});
				return;
			}
			IrcCommand command = ircMessage.Command;
			switch ((int)command)
			{
			case 1:
				HandlePrivMsg(ircMessage);
				break;
			case 2:
				HandleNotice(ircMessage);
				break;
			case 3:
				if (!DisableAutoPong)
				{
					SendRaw("PONG");
				}
				break;
			case 4:
				break;
			case 5:
				HandleJoin(ircMessage);
				break;
			case 6:
				HandlePart(ircMessage);
				break;
			case 7:
				HandleClearChat(ircMessage);
				break;
			case 8:
				HandleClearMsg(ircMessage);
				break;
			case 9:
				HandleUserState(ircMessage);
				break;
			case 17:
				Handle004();
				break;
			case 18:
				Handle353(ircMessage);
				break;
			case 19:
				Handle366();
				break;
			case 23:
				HandleWhisper(ircMessage);
				break;
			case 24:
				HandleRoomState(ircMessage);
				break;
			case 25:
				Reconnect();
				break;
			case 27:
				HandleUserNotice(ircMessage);
				break;
			case 28:
				HandleMode(ircMessage);
				break;
			case 13:
				HandleCap(ircMessage);
				break;
			default:
				this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
				{
					BotUsername = TwitchUsername,
					Channel = null,
					Location = "HandleIrcMessage",
					RawIRC = ircMessage.ToString()
				});
				UnaccountedFor(ircMessage.ToString());
				break;
			case 10:
			case 14:
			case 15:
			case 16:
			case 20:
			case 21:
			case 22:
				break;
			}
		}

		private void HandlePrivMsg(IrcMessage ircMessage)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			ChatMessage val = new ChatMessage(TwitchUsername, ircMessage, ref _channelEmotes, WillReplaceEmotes);
			foreach (JoinedChannel item in JoinedChannels.Where((JoinedChannel x) => string.Equals(x.Channel, ircMessage.Channel, StringComparison.InvariantCultureIgnoreCase)))
			{
				item.HandleMessage(val);
			}
			this.OnMessageReceived?.Invoke(this, new OnMessageReceivedArgs
			{
				ChatMessage = val
			});
			if (ircMessage.Tags.TryGetValue("msg-id", out var value) && value == "user-intro")
			{
				this.OnUserIntro?.Invoke(this, new OnUserIntroArgs
				{
					ChatMessage = val
				});
			}
			if (_chatCommandIdentifiers != null && _chatCommandIdentifiers.Count != 0 && !string.IsNullOrEmpty(val.Message) && _chatCommandIdentifiers.Contains(val.Message[0]))
			{
				ChatCommand command = new ChatCommand(val);
				this.OnChatCommandReceived?.Invoke(this, new OnChatCommandReceivedArgs
				{
					Command = command
				});
			}
		}

		private void HandleNotice(IrcMessage ircMessage)
		{
			if (ircMessage.Message.Contains("Improperly formatted auth"))
			{
				this.OnIncorrectLogin?.Invoke(this, new OnIncorrectLoginArgs
				{
					Exception = new ErrorLoggingInException(ircMessage.ToString(), TwitchUsername)
				});
				return;
			}
			if (!ircMessage.Tags.TryGetValue("msg-id", out var value))
			{
				this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel,
					Location = "NoticeHandling",
					RawIRC = ircMessage.ToString()
				});
				UnaccountedFor(ircMessage.ToString());
			}
			switch (value)
			{
			case "color_changed":
				this.OnChatColorChanged?.Invoke(this, new OnChatColorChangedArgs
				{
					Channel = ircMessage.Channel
				});
				break;
			case "room_mods":
				this.OnModeratorsReceived?.Invoke(this, new OnModeratorsReceivedArgs
				{
					Channel = ircMessage.Channel,
					Moderators = ircMessage.Message.Replace(" ", "").Split(new char[1] { ':' })[1].Split(new char[1] { ',' }).ToList()
				});
				break;
			case "no_mods":
				this.OnModeratorsReceived?.Invoke(this, new OnModeratorsReceivedArgs
				{
					Channel = ircMessage.Channel,
					Moderators = new List<string>()
				});
				break;
			case "no_permission":
				this.OnNoPermissionError?.Invoke(this, null);
				break;
			case "raid_error_self":
				this.OnSelfRaidError?.Invoke(this, null);
				break;
			case "raid_notice_mature":
				this.OnRaidedChannelIsMatureAudience?.Invoke(this, null);
				break;
			case "msg_banned_email_alias":
				this.OnBannedEmailAlias?.Invoke(this, new OnBannedEmailAliasArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_channel_suspended":
				_awaitingJoins.RemoveAll((KeyValuePair<string, DateTime> x) => x.Key.ToLower() == ircMessage.Channel);
				_joinedChannelManager.RemoveJoinedChannel(ircMessage.Channel);
				QueueingJoinCheck();
				this.OnFailureToReceiveJoinConfirmation?.Invoke(this, new OnFailureToReceiveJoinConfirmationArgs
				{
					Exception = new FailureToReceiveJoinConfirmationException(ircMessage.Channel, ircMessage.Message)
				});
				break;
			case "msg_requires_verified_phone_number":
				this.OnRequiresVerifiedPhoneNumber?.Invoke(this, new OnRequiresVerifiedPhoneNumberArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_verified_email":
				this.OnRequiresVerifiedEmail?.Invoke(this, new OnRequiresVerifiedEmailArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "no_vips":
				this.OnVIPsReceived?.Invoke(this, new OnVIPsReceivedArgs
				{
					Channel = ircMessage.Channel,
					VIPs = new List<string>()
				});
				break;
			case "vips_success":
				this.OnVIPsReceived?.Invoke(this, new OnVIPsReceivedArgs
				{
					Channel = ircMessage.Channel,
					VIPs = ircMessage.Message.Replace(" ", "").Replace(".", "").Split(new char[1] { ':' })[1].Split(new char[1] { ',' }).ToList()
				});
				break;
			case "msg_ratelimit":
				this.OnRateLimit?.Invoke(this, new OnRateLimitArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_duplicate":
				this.OnDuplicate?.Invoke(this, new OnDuplicateArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_followersonly":
				this.OnFollowersOnly?.Invoke(this, new OnFollowersOnlyArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_subsonly":
				this.OnSubsOnly?.Invoke(this, new OnSubsOnlyArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_emoteonly":
				this.OnEmoteOnly?.Invoke(this, new OnEmoteOnlyArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_suspended":
				this.OnSuspended?.Invoke(this, new OnSuspendedArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_banned":
				this.OnBanned?.Invoke(this, new OnBannedArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_slowmode":
				this.OnSlowMode?.Invoke(this, new OnSlowModeArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			case "msg_r9k":
				this.OnR9kMode?.Invoke(this, new OnR9kModeArgs
				{
					Channel = ircMessage.Channel,
					Message = ircMessage.Message
				});
				break;
			default:
				this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel,
					Location = "NoticeHandling",
					RawIRC = ircMessage.ToString()
				});
				UnaccountedFor(ircMessage.ToString());
				break;
			}
		}

		private void HandleJoin(IrcMessage ircMessage)
		{
			this.OnUserJoined?.Invoke(this, new OnUserJoinedArgs
			{
				Channel = ircMessage.Channel,
				Username = ircMessage.User
			});
		}

		private void HandlePart(IrcMessage ircMessage)
		{
			if (string.Equals(TwitchUsername, ircMessage.User, StringComparison.InvariantCultureIgnoreCase))
			{
				_joinedChannelManager.RemoveJoinedChannel(ircMessage.Channel);
				_hasSeenJoinedChannels.Remove(ircMessage.Channel);
				this.OnLeftChannel?.Invoke(this, new OnLeftChannelArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel
				});
			}
			else
			{
				this.OnUserLeft?.Invoke(this, new OnUserLeftArgs
				{
					Channel = ircMessage.Channel,
					Username = ircMessage.User
				});
			}
		}

		private void HandleClearChat(IrcMessage ircMessage)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			string value;
			if (string.IsNullOrWhiteSpace(ircMessage.Message))
			{
				this.OnChatCleared?.Invoke(this, new OnChatClearedArgs
				{
					Channel = ircMessage.Channel
				});
			}
			else if (ircMessage.Tags.TryGetValue("ban-duration", out value))
			{
				UserTimeout userTimeout = new UserTimeout(ircMessage);
				this.OnUserTimedout?.Invoke(this, new OnUserTimedoutArgs
				{
					UserTimeout = userTimeout
				});
			}
			else
			{
				UserBan userBan = new UserBan(ircMessage);
				this.OnUserBanned?.Invoke(this, new OnUserBannedArgs
				{
					UserBan = userBan
				});
			}
		}

		private void HandleClearMsg(IrcMessage ircMessage)
		{
			this.OnMessageCleared?.Invoke(this, new OnMessageClearedArgs
			{
				Channel = ircMessage.Channel,
				Message = ircMessage.Message,
				TargetMessageId = ircMessage.ToString().Split(new char[1] { '=' })[3].Split(new char[1] { ';' })[0],
				TmiSentTs = ircMessage.ToString().Split(new char[1] { '=' })[4].Split(new char[1] { ' ' })[0]
			});
		}

		private void HandleUserState(IrcMessage ircMessage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			UserState val = new UserState(ircMessage);
			if (!_hasSeenJoinedChannels.Contains(val.Channel.ToLowerInvariant()))
			{
				_hasSeenJoinedChannels.Add(val.Channel.ToLowerInvariant());
				this.OnUserStateChanged?.Invoke(this, new OnUserStateChangedArgs
				{
					UserState = val
				});
			}
			else
			{
				this.OnMessageSent?.Invoke(this, new OnMessageSentArgs
				{
					SentMessage = new SentMessage(val, _lastMessageSent)
				});
			}
		}

		private void Handle004()
		{
			this.OnConnected?.Invoke(this, new OnConnectedArgs
			{
				BotUsername = TwitchUsername
			});
		}

		private void Handle353(IrcMessage ircMessage)
		{
			this.OnExistingUsersDetected?.Invoke(this, new OnExistingUsersDetectedArgs
			{
				Channel = ircMessage.Channel,
				Users = ircMessage.Message.Split(new char[1] { ' ' }).ToList()
			});
		}

		private void Handle366()
		{
			_currentlyJoiningChannels = false;
			QueueingJoinCheck();
		}

		private void HandleWhisper(IrcMessage ircMessage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			WhisperMessage val2 = (PreviousWhisper = new WhisperMessage(ircMessage, TwitchUsername));
			this.OnWhisperReceived?.Invoke(this, new OnWhisperReceivedArgs
			{
				WhisperMessage = val2
			});
			if (_whisperCommandIdentifiers != null && _whisperCommandIdentifiers.Count != 0 && !string.IsNullOrEmpty(val2.Message) && _whisperCommandIdentifiers.Contains(val2.Message[0]))
			{
				WhisperCommand command = new WhisperCommand(val2);
				this.OnWhisperCommandReceived?.Invoke(this, new OnWhisperCommandReceivedArgs
				{
					Command = command
				});
				return;
			}
			this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
			{
				BotUsername = TwitchUsername,
				Channel = ircMessage.Channel,
				Location = "WhispergHandling",
				RawIRC = ircMessage.ToString()
			});
			UnaccountedFor(ircMessage.ToString());
		}

		private void HandleRoomState(IrcMessage ircMessage)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (ircMessage.Tags.Count > 2)
			{
				KeyValuePair<string, DateTime> item = _awaitingJoins.FirstOrDefault((KeyValuePair<string, DateTime> x) => x.Key == ircMessage.Channel);
				_awaitingJoins.Remove(item);
				this.OnJoinedChannel?.Invoke(this, new OnJoinedChannelArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel
				});
			}
			this.OnChannelStateChanged?.Invoke(this, new OnChannelStateChangedArgs
			{
				ChannelState = new ChannelState(ircMessage),
				Channel = ircMessage.Channel
			});
		}

		private void HandleUserNotice(IrcMessage ircMessage)
		{
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			if (!ircMessage.Tags.TryGetValue("msg-id", out var value))
			{
				this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel,
					Location = "UserNoticeHandling",
					RawIRC = ircMessage.ToString()
				});
				UnaccountedFor(ircMessage.ToString());
				return;
			}
			switch (value)
			{
			case "announcement":
			{
				Announcement announcement = new Announcement(ircMessage);
				this.OnAnnouncement?.Invoke(this, new OnAnnouncementArgs
				{
					Announcement = announcement,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "raid":
			{
				RaidNotification raidNotification = new RaidNotification(ircMessage);
				this.OnRaidNotification?.Invoke(this, new OnRaidNotificationArgs
				{
					Channel = ircMessage.Channel,
					RaidNotification = raidNotification
				});
				break;
			}
			case "resub":
			{
				ReSubscriber reSubscriber = new ReSubscriber(ircMessage);
				this.OnReSubscriber?.Invoke(this, new OnReSubscriberArgs
				{
					ReSubscriber = reSubscriber,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "subgift":
			{
				GiftedSubscription giftedSubscription2 = new GiftedSubscription(ircMessage);
				this.OnGiftedSubscription?.Invoke(this, new OnGiftedSubscriptionArgs
				{
					GiftedSubscription = giftedSubscription2,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "submysterygift":
			{
				CommunitySubscription giftedSubscription = new CommunitySubscription(ircMessage);
				this.OnCommunitySubscription?.Invoke(this, new OnCommunitySubscriptionArgs
				{
					GiftedSubscription = giftedSubscription,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "giftpaidupgrade":
			{
				ContinuedGiftedSubscription continuedGiftedSubscription = new ContinuedGiftedSubscription(ircMessage);
				this.OnContinuedGiftedSubscription?.Invoke(this, new OnContinuedGiftedSubscriptionArgs
				{
					ContinuedGiftedSubscription = continuedGiftedSubscription,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "sub":
			{
				Subscriber subscriber = new Subscriber(ircMessage);
				this.OnNewSubscriber?.Invoke(this, new OnNewSubscriberArgs
				{
					Subscriber = subscriber,
					Channel = ircMessage.Channel
				});
				break;
			}
			case "primepaidupgrade":
			{
				PrimePaidSubscriber primePaidSubscriber = new PrimePaidSubscriber(ircMessage);
				this.OnPrimePaidSubscriber?.Invoke(this, new OnPrimePaidSubscriberArgs
				{
					PrimePaidSubscriber = primePaidSubscriber,
					Channel = ircMessage.Channel
				});
				break;
			}
			default:
				this.OnUnaccountedFor?.Invoke(this, new OnUnaccountedForArgs
				{
					BotUsername = TwitchUsername,
					Channel = ircMessage.Channel,
					Location = "UserNoticeHandling",
					RawIRC = ircMessage.ToString()
				});
				UnaccountedFor(ircMessage.ToString());
				break;
			}
		}

		private void HandleMode(IrcMessage ircMessage)
		{
			if (ircMessage.Message.StartsWith("+o"))
			{
				this.OnModeratorJoined?.Invoke(this, new OnModeratorJoinedArgs
				{
					Channel = ircMessage.Channel,
					Username = ircMessage.Message.Split(new char[1] { ' ' })[1]
				});
			}
			else if (ircMessage.Message.StartsWith("-o"))
			{
				this.OnModeratorLeft?.Invoke(this, new OnModeratorLeftArgs
				{
					Channel = ircMessage.Channel,
					Username = ircMessage.Message.Split(new char[1] { ' ' })[1]
				});
			}
		}

		private void HandleCap(IrcMessage ircMessage)
		{
		}

		private void UnaccountedFor(string ircString)
		{
			Log("Unaccounted for: " + ircString + " (please create a TwitchLib GitHub issue :P)");
		}

		private void Log(string message, bool includeDate = false, bool includeTime = false)
		{
			string arg = ((includeDate && includeTime) ? $"{DateTime.UtcNow}" : ((!includeDate) ? (DateTime.UtcNow.ToShortTimeString() ?? "") : (DateTime.UtcNow.ToShortDateString() ?? "")));
			if (includeDate || includeTime)
			{
				_logger?.LogInformation($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version} - {arg}] {message}");
			}
			else
			{
				_logger?.LogInformation($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version}] {message}");
			}
			EventHandler<OnLogArgs> onLog = this.OnLog;
			if (onLog != null)
			{
				OnLogArgs onLogArgs = new OnLogArgs();
				ConnectionCredentials connectionCredentials = ConnectionCredentials;
				onLogArgs.BotUsername = ((connectionCredentials != null) ? connectionCredentials.TwitchUsername : null);
				onLogArgs.Data = message;
				onLogArgs.DateTime = DateTime.UtcNow;
				onLog(this, onLogArgs);
			}
		}

		private void LogError(string message, bool includeDate = false, bool includeTime = false)
		{
			string arg = ((includeDate && includeTime) ? $"{DateTime.UtcNow}" : ((!includeDate) ? (DateTime.UtcNow.ToShortTimeString() ?? "") : (DateTime.UtcNow.ToShortDateString() ?? "")));
			if (includeDate || includeTime)
			{
				_logger?.LogError($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version} - {arg}] {message}");
			}
			else
			{
				_logger?.LogError($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version}] {message}");
			}
			EventHandler<OnLogArgs> onLog = this.OnLog;
			if (onLog != null)
			{
				OnLogArgs onLogArgs = new OnLogArgs();
				ConnectionCredentials connectionCredentials = ConnectionCredentials;
				onLogArgs.BotUsername = ((connectionCredentials != null) ? connectionCredentials.TwitchUsername : null);
				onLogArgs.Data = message;
				onLogArgs.DateTime = DateTime.UtcNow;
				onLog(this, onLogArgs);
			}
		}

		public void SendQueuedItem(string message)
		{
			if (!IsInitialized)
			{
				HandleNotInitialized();
			}
			_client.Send(message);
		}

		protected static void HandleNotInitialized()
		{
			throw new ClientNotInitializedException("The twitch client has not been initialized and cannot be used. Please call Initialize();");
		}

		protected static void HandleNotConnected()
		{
			throw new ClientNotConnectedException("In order to perform this action, the client must be connected to Twitch. To confirm connection, try performing this action in or after the OnConnected event has been fired.");
		}
	}
}
namespace TwitchLib.Client.Manager
{
	internal class JoinedChannelManager
	{
		private readonly ConcurrentDictionary<string, JoinedChannel> _joinedChannels;

		public JoinedChannelManager()
		{
			_joinedChannels = new ConcurrentDictionary<string, JoinedChannel>(StringComparer.OrdinalIgnoreCase);
		}

		public void AddJoinedChannel(JoinedChannel joinedChannel)
		{
			_joinedChannels.TryAdd(joinedChannel.Channel, joinedChannel);
		}

		public JoinedChannel GetJoinedChannel(string channel)
		{
			_joinedChannels.TryGetValue(channel, out var value);
			return value;
		}

		public IReadOnlyList<JoinedChannel> GetJoinedChannels()
		{
			return _joinedChannels.Values.ToList().AsReadOnly();
		}

		public void RemoveJoinedChannel(string channel)
		{
			_joinedChannels.TryRemove(channel, out var _);
		}

		public void Clear()
		{
			_joinedChannels.Clear();
		}
	}
}
namespace TwitchLib.Client.Internal
{
	public sealed class Rfc2812
	{
		private static readonly Regex NicknameRegex = new Regex("^[A-Za-z\\[\\]\\\\`_^{|}][A-Za-z0-9\\[\\]\\\\`_\\-^{|}]+$", RegexOptions.Compiled);

		private Rfc2812()
		{
		}

		public static bool IsValidNickname(string nickname)
		{
			if (!string.IsNullOrEmpty(nickname))
			{
				return NicknameRegex.Match(nickname).Success;
			}
			return false;
		}

		public static string Pass(string password)
		{
			return "PASS " + password;
		}

		public static string Nick(string nickname)
		{
			return "NICK " + nickname;
		}

		public static string User(string username, int usermode, string realname)
		{
			return $"USER {username} {usermode} * :{realname}";
		}

		public static string Oper(string name, string password)
		{
			return "OPER " + name + " " + password;
		}

		public static string Privmsg(string destination, string message)
		{
			return "PRIVMSG " + destination + " :" + message;
		}

		public static string Notice(string destination, string message)
		{
			return "NOTICE " + destination + " :" + message;
		}

		public static string Join(string channel)
		{
			return "JOIN " + channel;
		}

		public static string Join(string[] channels)
		{
			return "JOIN " + string.Join(",", channels);
		}

		public static string Join(string channel, string key)
		{
			return "JOIN " + channel + " " + key;
		}

		public static string Join(string[] channels, string[] keys)
		{
			return "JOIN " + string.Join(",", channels) + " " + string.Join(",", keys);
		}

		public static string Part(string channel)
		{
			return "PART " + channel;
		}

		public static string Part(string[] channels)
		{
			return "PART " + string.Join(",", channels);
		}

		public static string Part(string channel, string partmessage)
		{
			return "PART " + channel + " :" + partmessage;
		}

		public static string Part(string[] channels, string partmessage)
		{
			return "PART " + string.Join(",", channels) + " :" + partmessage;
		}

		public static string Kick(string channel, string nickname)
		{
			return "KICK " + channel + " " + nickname;
		}

		public static string Kick(string channel, string nickname, string comment)
		{
			return "KICK " + channel + " " + nickname + " :" + comment;
		}

		public static string Kick(string[] channels, string nickname)
		{
			return "KICK " + string.Join(",", channels) + " " + nickname;
		}

		public static string Kick(string[] channels, string nickname, string comment)
		{
			return "KICK " + string.Join(",", channels) + " " + nickname + " :" + comment;
		}

		public static string Kick(string channel, string[] nicknames)
		{
			return "KICK " + channel + " " + string.Join(",", nicknames);
		}

		public static string Kick(string channel, string[] nicknames, string comment)
		{
			return "KICK " + channel + " " + string.Join(",", nicknames) + " :" + comment;
		}

		public static string Kick(string[] channels, string[] nicknames)
		{
			return "KICK " + string.Join(",", channels) + " " + string.Join(",", nicknames);
		}

		public static string Kick(string[] channels, string[] nicknames, string comment)
		{
			return "KICK " + string.Join(",", channels) + " " + string.Join(",", nicknames) + " :" + comment;
		}

		public static string Motd()
		{
			return "MOTD";
		}

		public static string Motd(string target)
		{
			return "MOTD " + target;
		}

		public static string Lusers()
		{
			return "LUSERS";
		}

		public static string Lusers(string mask)
		{
			return "LUSER " + mask;
		}

		public static string Lusers(string mask, string target)
		{
			return "LUSER " + mask + " " + target;
		}

		public static string Version()
		{
			return "VERSION";
		}

		public static string Version(string target)
		{
			return "VERSION " + target;
		}

		public static string Stats()
		{
			return "STATS";
		}

		public static string Stats(string query)
		{
			return "STATS " + query;
		}

		public static string Stats(string query, string target)
		{
			return "STATS " + query + " " + target;
		}

		public static string Links()
		{
			return "LINKS";
		}

		public static string Links(string servermask)
		{
			return "LINKS " + servermask;
		}

		public static string Links(string remoteserver, string servermask)
		{
			return "LINKS " + remoteserver + " " + servermask;
		}

		public static string Time()
		{
			return "TIME";
		}

		public static string Time(string target)
		{
			return "TIME " + target;
		}

		public static string Connect(string targetserver, string port)
		{
			return "CONNECT " + targetserver + " " + port;
		}

		public static string Connect(string targetserver, string port, string remoteserver)
		{
			return "CONNECT " + targetserver + " " + port + " " + remoteserver;
		}

		public static string Trace()
		{
			return "TRACE";
		}

		public static string Trace(string target)
		{
			return "TRACE " + target;
		}

		public static string Admin()
		{
			return "ADMIN";
		}

		public static string Admin(string target)
		{
			return "ADMIN " + target;
		}

		public static string Info()
		{
			return "INFO";
		}

		public static string Info(string target)
		{
			return "INFO " + target;
		}

		public static string Servlist()
		{
			return "SERVLIST";
		}

		public static string Servlist(string mask)
		{
			return "SERVLIST " + mask;
		}

		public static string Servlist(string mask, string type)
		{
			return "SERVLIST " + mask + " " + type;
		}

		public static string Squery(string servicename, string servicetext)
		{
			return "SQUERY " + servicename + " :" + servicename;
		}

		public static string List()
		{
			return "LIST";
		}

		public static string List(string channel)
		{
			return "LIST " + channel;
		}

		public static string List(string[] channels)
		{
			return "LIST " + string.Join(",", channels);
		}

		public static string List(string channel, string target)
		{
			return "LIST " + channel + " " + target;
		}

		public static string List(string[] channels, string target)
		{
			return "LIST " + string.Join(",", channels) + " " + target;
		}

		public static string Names()
		{
			return "NAMES";
		}

		public static string Names(string channel)
		{
			return "NAMES " + channel;
		}

		public static string Names(string[] channels)
		{
			return "NAMES " + string.Join(",", channels);
		}

		public static string Names(string channel, string target)
		{
			return "NAMES " + channel + " " + target;
		}

		public static string Names(string[] channels, string target)
		{
			return "NAMES " + string.Join(",", channels) + " " + target;
		}

		public static string Topic(string channel)
		{
			return "TOPIC " + channel;
		}

		public static string Topic(string channel, string newtopic)
		{
			return "TOPIC " + channel + " :" + newtopic;
		}

		public static string Mode(string target)
		{
			return "MODE " + target;
		}

		public static string Mode(string target, string newmode)
		{
			return "MODE " + target + " " + newmode + target + " " + newmode;
		}

		public static string Mode(string target, string[] newModes, string[] newModeParameters)
		{
			if (newModes == null)
			{
				throw new ArgumentNullException("newModes");
			}
			if (newModeParameters == null)
			{
				throw new ArgumentNullException("newModeParameters");
			}
			if (newModes.Length != newModeParameters.Length)
			{
				throw new ArgumentException("newModes and newModeParameters must have the same size.");
			}
			StringBuilder stringBuilder = new StringBuilder(newModes.Length);
			StringBuilder stringBuilder2 = new StringBuilder();
			if (newModes.Length > 3)
			{
				throw new ArgumentOutOfRangeException("Length", newModes.Length, $"Mode change list is too large (> {3}).");
			}
			for (int i = 0; i <= newModes.Length; i += 3)
			{
				for (int j = 0; j < 3 && i + j < newModes.Length; j++)
				{
					stringBuilder.Append(newModes[i + j]);
				}
				for (int k = 0; k < 3 && i + k < newModeParameters.Length; k++)
				{
					stringBuilder2.Append(newModeParameters[i + k]);
					stringBuilder2.Append(" ");
				}
			}
			if (stringBuilder2.Length <= 0)
			{
				return Mode(target, stringBuilder.ToString());
			}
			stringBuilder2.Length--;
			stringBuilder.Append(" ");
			stringBuilder.Append((object?)stringBuilder2);
			return Mode(target, stringBuilder.ToString());
		}

		public static string Service(string nickname, string distribution, string info)
		{
			return "SERVICE " + nickname + " * " + distribution + " * * :" + info;
		}

		public static string Invite(string nickname, string channel)
		{
			return "INVITE " + nickname + " " + channel;
		}

		public static string Who()
		{
			return "WHO";
		}

		public static string Who(string mask)
		{
			return "WHO " + mask;
		}

		public static string Who(string mask, bool ircop)
		{
			if (!ircop)
			{
				return "WHO " + mask;
			}
			return "WHO " + mask + " o";
		}

		public static string Whois(string mask)
		{
			return "WHOIS " + mask;
		}

		public static string Whois(string[] masks)
		{
			return "WHOIS " + string.Join(",", masks);
		}

		public static string Whois(string target, string mask)
		{
			return "WHOIS " + target + " " + mask;
		}

		public static string Whois(string target, string[] masks)
		{
			return "WHOIS " + target + " " + string.Join(",", masks);
		}

		public static string Whowas(string nickname)
		{
			return "WHOWAS " + nickname;
		}

		public static string Whowas(string[] nicknames)
		{
			return "WHOWAS " + string.Join(",", nicknames);
		}

		public static string Whowas(string nickname, string count)
		{
			return "WHOWAS " + nickname + " " + count + " ";
		}

		public static string Whowas(string[] nicknames, string count)
		{
			return "WHOWAS " + string.Join(",", nicknames) + " " + count + " ";
		}

		public static string Whowas(string nickname, string count, string target)
		{
			return "WHOWAS " + nickname + " " + count + " " + target;
		}

		public static string Whowas(string[] nicknames, string count, string target)
		{
			return "WHOWAS " + string.Join(",", nicknames) + " " + count + " " + target;
		}

		public static string Kill(string nickname, string comment)
		{
			return "KILL " + nickname + " :" + comment;
		}

		public static string Ping(string server)
		{
			return "PING " + server;
		}

		public static string Ping(string server, string server2)
		{
			return "PING " + server + " " + server2;
		}

		public static string Pong(string server)
		{
			return "PONG " + server;
		}

		public static string Pong(string server, string server2)
		{
			return "PONG " + server + " " + server2;
		}

		public static string Error(string errormessage)
		{
			return "ERROR :" + errormessage;
		}

		public static string Away()
		{
			return "AWAY";
		}

		public static string Away(string awaytext)
		{
			return "AWAY :" + awaytext;
		}

		public static string Rehash()
		{
			return "REHASH";
		}

		public static string Die()
		{
			return "DIE";
		}

		public static string Restart()
		{
			return "RESTART";
		}

		public static string Summon(string user)
		{
			return "SUMMON " + user;
		}

		public static string Summon(string user, string target)
		{
			return "SUMMON " + user + " " + target + user + " " + target;
		}

		public static string Summon(string user, string target, string channel)
		{
			return "SUMMON " + user + " " + target + " " + channel;
		}

		public static string Users()
		{
			return "USERS";
		}

		public static string Users(string target)
		{
			return "USERS " + target;
		}

		public static string Wallops(string wallopstext)
		{
			return "WALLOPS :" + wallopstext;
		}

		public static string Userhost(string nickname)
		{
			return "USERHOST " + nickname;
		}

		public static string Userhost(string[] nicknames)
		{
			return "USERHOST " + string.Join(" ", nicknames);
		}

		public static string Ison(string nickname)
		{
			return "ISON " + nickname;
		}

		public static string Ison(string[] nicknames)
		{
			return "ISON " + string.Join(" ", nicknames);
		}

		public static string Quit()
		{
			return "QUIT";
		}

		public static string Quit(string quitmessage)
		{
			return "QUIT :" + quitmessage;
		}

		public static string Squit(string server, string comment)
		{
			return "SQUIT " + server + " :" + comment;
		}
	}
}
namespace TwitchLib.Client.Internal.Parsing
{
	internal class IrcParser
	{
		private enum ParserState
		{
			STATE_NONE,
			STATE_V3,
			STATE_PREFIX,
			STATE_COMMAND,
			STATE_PARAM,
			STATE_TRAILING
		}

		public IrcMessage ParseIrcMessage(string raw)
		{
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0728: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Expected O, but got Unknown
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0696: Unknown result type (might be due to invalid IL or missing references)
			//IL_0667: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_069c: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			ParserState parserState = ParserState.STATE_NONE;
			int[] array = new int[6];
			int[] array2 = new int[6];
			for (int i = 0; i < raw.Length; i++)
			{
				array2[(int)parserState] = i - array[(int)parserState] - 1;
				if (parserState == ParserState.STATE_NONE && raw[i] == '@')
				{
					parserState = ParserState.STATE_V3;
					i = (array[(int)parserState] = i + 1);
					int num = i;
					string text = null;
					for (; i < raw.Length; i++)
					{
						if (raw[i] == '=')
						{
							text = raw.Substring(num, i - num);
							num = i + 1;
						}
						else if (raw[i] == ';')
						{
							if (text == null)
							{
								dictionary[raw.Substring(num, i - num)] = "1";
							}
							else
							{
								dictionary[text] = raw.Substring(num, i - num);
							}
							num = i + 1;
						}
						else if (raw[i] == ' ')
						{
							if (text == null)
							{
								dictionary[raw.Substring(num, i - num)] = "1";
							}
							else
							{
								dictionary[text] = raw.Substring(num, i - num);
							}
							break;
						}
					}
				}
				else if (parserState < ParserState.STATE_PREFIX && raw[i] == ':')
				{
					parserState = ParserState.STATE_PREFIX;
					i = (array[(int)parserState] = i + 1);
				}
				else if (parserState < ParserState.STATE_COMMAND)
				{
					parserState = ParserState.STATE_COMMAND;
					array[(int)parserState] = i;
				}
				else
				{
					if (parserState < ParserState.STATE_TRAILING && raw[i] == ':')
					{
						parserState = ParserState.STATE_TRAILING;
						i = (array[(int)parserState] = i + 1);
						break;
					}
					if ((parserState < ParserState.STATE_TRAILING && raw[i] == '+') || (parserState < ParserState.STATE_TRAILING && raw[i] == '-'))
					{
						parserState = ParserState.STATE_TRAILING;
						array[(int)parserState] = i;
						break;
					}
					if (parserState == ParserState.STATE_COMMAND)
					{
						parserState = ParserState.STATE_PARAM;
						array[(int)parserState] = i;
					}
				}
				for (; i < raw.Length && raw[i] != ' '; i++)
				{
				}
			}
			array2[(int)parserState] = raw.Length - array[(int)parserState];
			string text2 = raw.Substring(array[3], array2[3]);
			IrcCommand val = (IrcCommand)0;
			switch (text2)
			{
			case "PRIVMSG":
				val = (IrcCommand)1;
				break;
			case "NOTICE":
				val = (IrcCommand)2;
				break;
			case "PING":
				val = (IrcCommand)3;
				break;
			case "PONG":
				val = (IrcCommand)4;
				break;
			case "CLEARCHAT":
				val = (IrcCommand)7;
				break;
			case "CLEARMSG":
				val = (IrcCommand)8;
				break;
			case "USERSTATE":
				val = (IrcCommand)9;
				break;
			case "GLOBALUSERSTATE":
				val = (IrcCommand)10;
				break;
			case "NICK":
				val = (IrcCommand)11;
				break;
			case "JOIN":
				val = (IrcCommand)5;
				break;
			case "PART":
				val = (IrcCommand)6;
				break;
			case "PASS":
				val = (IrcCommand)12;
				break;
			case "CAP":
				val = (IrcCommand)13;
				break;
			case "001":
				val = (IrcCommand)14;
				break;
			case "002":
				val = (IrcCommand)15;
				break;
			case "003":
				val = (IrcCommand)16;
				break;
			case "004":
				val = (IrcCommand)17;
				break;
			case "353":
				val = (IrcCommand)18;
				break;
			case "366":
				val = (IrcCommand)19;
				break;
			case "372":
				val = (IrcCommand)20;
				break;
			case "375":
				val = (IrcCommand)21;
				break;
			case "376":
				val = (IrcCommand)22;
				break;
			case "WHISPER":
				val = (IrcCommand)23;
				break;
			case "SERVERCHANGE":
				val = (IrcCommand)26;
				break;
			case "RECONNECT":
				val = (IrcCommand)25;
				break;
			case "ROOMSTATE":
				val = (IrcCommand)24;
				break;
			case "USERNOTICE":
				val = (IrcCommand)27;
				break;
			case "MODE":
				val = (IrcCommand)28;
				break;
			}
			string text3 = raw.Substring(array[4], array2[4]);
			string text4 = raw.Substring(array[5], array2[5]);
			string text5 = raw.Substring(array[2], array2[2]);
			return new IrcMessage(val, new string[2] { text3, text4 }, text5, dictionary);
		}
	}
}
namespace TwitchLib.Client.Interfaces
{
	public interface ITwitchClient
	{
		bool AutoReListenOnException { get; set; }

		MessageEmoteCollection ChannelEmotes { get; }

		ConnectionCredentials ConnectionCredentials { get; }

		bool DisableAutoPong { get; set; }

		bool IsConnected { get; }

		bool IsInitialized { get; }

		IReadOnlyList<JoinedChannel> JoinedChannels { get; }

		WhisperMessage PreviousWhisper { get; }

		string TwitchUsername { get; }

		bool WillReplaceEmotes { get; set; }

		event EventHandler<OnChannelStateChangedArgs> OnChannelStateChanged;

		event EventHandler<OnChatClearedArgs> OnChatCleared;

		event EventHandler<OnChatColorChangedArgs> OnChatColorChanged;

		event EventHandler<OnChatCommandReceivedArgs> OnChatCommandReceived;

		event EventHandler<OnConnectedArgs> OnConnected;

		event EventHandler<OnConnectionErrorArgs> OnConnectionError;

		event EventHandler<OnDisconnectedEventArgs> OnDisconnected;

		event EventHandler<OnExistingUsersDetectedArgs> OnExistingUsersDetected;

		event EventHandler<OnGiftedSubscriptionArgs> OnGiftedSubscription;

		event EventHandler<OnIncorrectLoginArgs> OnIncorrectLogin;

		event EventHandler<OnJoinedChannelArgs> OnJoinedChannel;

		event EventHandler<OnLeftChannelArgs> OnLeftChannel;

		event EventHandler<OnLogArgs> OnLog;

		event EventHandler<OnMessageReceivedArgs> OnMessageReceived;

		event EventHandler<OnMessageSentArgs> OnMessageSent;

		event EventHandler<OnModeratorJoinedArgs> OnModeratorJoined;

		event EventHandler<OnModeratorLeftArgs> OnModeratorLeft;

		event EventHandler<OnModeratorsReceivedArgs> OnModeratorsReceived;

		event EventHandler<OnNewSubscriberArgs> OnNewSubscriber;

		event EventHandler<OnRaidNotificationArgs> OnRaidNotification;

		event EventHandler<OnReSubscriberArgs> OnReSubscriber;

		event EventHandler<OnSendReceiveDataArgs> OnSendReceiveData;

		event EventHandler<OnUserBannedArgs> OnUserBanned;

		event EventHandler<OnUserJoinedArgs> OnUserJoined;

		event EventHandler<OnUserLeftArgs> OnUserLeft;

		event EventHandler<OnUserStateChangedArgs> OnUserStateChanged;

		event EventHandler<OnUserTimedoutArgs> OnUserTimedout;

		event EventHandler<OnWhisperCommandReceivedArgs> OnWhisperCommandReceived;

		event EventHandler<OnWhisperReceivedArgs> OnWhisperReceived;

		event EventHandler<OnWhisperSentArgs> OnWhisperSent;

		event EventHandler<OnMessageThrottledEventArgs> OnMessageThrottled;

		event EventHandler<OnWhisperThrottledEventArgs> OnWhisperThrottled;

		event EventHandler<OnErrorEventArgs> OnError;

		event EventHandler<OnReconnectedEventArgs> OnReconnected;

		event EventHandler<OnVIPsReceivedArgs> OnVIPsReceived;

		event EventHandler<OnCommunitySubscriptionArgs> OnCommunitySubscription;

		event EventHandler<OnMessageClearedArgs> OnMessageCleared;

		event EventHandler<OnRequiresVerifiedEmailArgs> OnRequiresVerifiedEmail;

		event EventHandler<OnRequiresVerifiedPhoneNumberArgs> OnRequiresVerifiedPhoneNumber;

		event EventHandler<OnBannedEmailAliasArgs> OnBannedEmailAlias;

		event EventHandler<OnUserIntroArgs> OnUserIntro;

		event EventHandler<OnAnnouncementArgs> OnAnnouncement;

		void Initialize(ConnectionCredentials credentials, string channel = null, char chatCommandIdentifier = '!', char whisperCommandIdentifier = '!', bool autoReListenOnExceptions = true);

		void Initialize(ConnectionCredentials credentials, List<string> channels, char chatCommandIdentifier = '!', char whisperCommandIdentifier = '!', bool autoReListenOnExceptions = true);

		void SetConnectionCredentials(ConnectionCredentials credentials);

		void AddChatCommandIdentifier(char identifier);

		void AddWhisperCommandIdentifier(char identifier);

		void RemoveChatCommandIdentifier(char identifier);

		void RemoveWhisperCommandIdentifier(char identifier);

		bool Connect();

		void Disconnect();

		void Reconnect();

		JoinedChannel GetJoinedChannel(string channel);

		void JoinChannel(string channel, bool overrideCheck = false);

		void LeaveChannel(JoinedChannel channel);

		void LeaveChannel(string channel);

		void OnReadLineTest(string rawIrc);

		void SendMessage(JoinedChannel channel, string message, bool dryRun = false);

		void SendMessage(string channel, string message, bool dryRun = false);

		void SendReply(JoinedChannel channel, string replyToId, string message, bool dryRun = false);

		void SendReply(string channel, string replyToId, string message, bool dryRun = false);

		void SendQueuedItem(string message);

		void SendRaw(string message);

		void SendWhisper(string receiver, string message, bool dryRun = false);
	}
}
namespace TwitchLib.Client.Extensions
{
	public static class AnnoucementExt
	{
		public static void Announce(this ITwitchClient client, JoinedChannel channel, string message)
		{
			client.SendMessage(channel, ".announce " + message);
		}

		public static void Announce(this ITwitchClient client, string channel, string message)
		{
			client.SendMessage(channel, ".announce " + message);
		}
	}
	public static class BanUserExt
	{
		public static void BanUser(this ITwitchClient client, JoinedChannel channel, string viewer, string message = "", bool dryRun = false)
		{
			client.SendMessage(channel, ".ban " + viewer + " " + message);
		}

		public static void BanUser(this ITwitchClient client, string channel, string viewer, string message = "", bool dryRun = false)
		{
			JoinedChannel joinedChannel = client.GetJoinedChannel(channel);
			if (joinedChannel != null)
			{
				client.BanUser(joinedChannel, viewer, message, dryRun);
			}
		}
	}
	public static class ChangeChatColorExt
	{
		public static void ChangeChatColor(this ITwitchClient client, JoinedChannel channel, ChatColorPresets color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			client.SendMessage(channel, $".color {color}");
		}

		public static void ChangeChatColor(this ITwitchClient client, string channel, ChatColorPresets color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			client.SendMessage(channel, $".color {color}");
		}
	}
	public static class ClearChatExt
	{
		public static void ClearChat(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".clear");
		}

		public static void ClearChat(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".clear");
		}
	}
	public static class CommercialExt
	{
		public static void StartCommercial(this ITwitchClient client, JoinedChannel channel, CommercialLength length)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((int)length <= 90)
			{
				if ((int)length == 30)
				{
					client.SendMessage(channel, ".commercial 30");
					return;
				}
				if ((int)length == 60)
				{
					client.SendMessage(channel, ".commercial 60");
					return;
				}
				if ((int)length == 90)
				{
					client.SendMessage(channel, ".commercial 90");
					return;
				}
			}
			else
			{
				if ((int)length == 120)
				{
					client.SendMessage(channel, ".commercial 120");
					return;
				}
				if ((int)length == 150)
				{
					client.SendMessage(channel, ".commercial 150");
					return;
				}
				if ((int)length == 180)
				{
					client.SendMessage(channel, ".commercial 180");
					return;
				}
			}
			throw new ArgumentOutOfRangeException("length", length, null);
		}

		public static void StartCommercial(this ITwitchClient client, string channel, CommercialLength length)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((int)length <= 90)
			{
				if ((int)length == 30)
				{
					client.SendMessage(channel, ".commercial 30");
					return;
				}
				if ((int)length == 60)
				{
					client.SendMessage(channel, ".commercial 60");
					return;
				}
				if ((int)length == 90)
				{
					client.SendMessage(channel, ".commercial 90");
					return;
				}
			}
			else
			{
				if ((int)length == 120)
				{
					client.SendMessage(channel, ".commercial 120");
					return;
				}
				if ((int)length == 150)
				{
					client.SendMessage(channel, ".commercial 150");
					return;
				}
				if ((int)length == 180)
				{
					client.SendMessage(channel, ".commercial 180");
					return;
				}
			}
			throw new ArgumentOutOfRangeException("length", length, null);
		}
	}
	public static class DeleteMessageExt
	{
		public static void DeleteMessage(this ITwitchClient client, JoinedChannel channel, string messageId)
		{
			client.SendMessage(channel, ".delete " + messageId);
		}

		public static void DeleteMessage(this ITwitchClient client, string channel, string messageId)
		{
			client.SendMessage(channel, ".delete " + messageId);
		}

		public static void DeleteMessage(this ITwitchClient client, JoinedChannel channel, ChatMessage msg)
		{
			client.SendMessage(channel, ".delete " + msg.Id);
		}

		public static void DeleteMessage(this ITwitchClient client, string channel, ChatMessage msg)
		{
			client.SendMessage(channel, ".delete " + msg.Id);
		}
	}
	public static class EmoteOnlyExt
	{
		public static void EmoteOnlyOn(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".emoteonly");
		}

		public static void EmoteOnlyOn(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".emoteonly");
		}

		public static void EmoteOnlyOff(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".emoteonlyoff");
		}

		public static void EmoteOnlyOff(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".emoteonlyoff");
		}
	}
	public static class EventInvocationExt
	{
		public static void InvokeChannelStateChanged(this TwitchClient client, string channel, bool r9k, bool rituals, bool subOnly, int slowMode, bool emoteOnly, string broadcasterLanguage, TimeSpan followersOnly, bool mercury, string roomId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			ChannelState channelState = new ChannelState(r9k, rituals, subOnly, slowMode, emoteOnly, broadcasterLanguage, channel, followersOnly, mercury, roomId);
			OnChannelStateChangedArgs args = new OnChannelStateChangedArgs
			{
				Channel = channel,
				ChannelState = channelState
			};
			client.RaiseEvent("OnChannelStateChanged", args);
		}

		public static void InvokeChatCleared(this TwitchClient client, string channel)
		{
			OnChatClearedArgs args = new OnChatClearedArgs
			{
				Channel = channel
			};
			client.RaiseEvent("OnChatCleared", args);
		}

		public static void InvokeChatCommandsReceived(this TwitchClient client, string botUsername, string userId, string userName, string displayName, string colorHex, Color color, EmoteSet emoteSet, string message, UserType userType, string channel, string id, bool isSubscriber, int subscribedMonthCount, string roomId, bool isTurbo, bool isModerator, bool isMe, bool isBroadcaster, bool isVip, bool isPartner, bool isStaff, Noisy noisy, string rawIrcMessage, string emoteReplacedMessage, List<KeyValuePair<string, string>> badges, CheerBadge cheerBadge, int bits, double bitsInDollars, string commandText, string argumentsAsString, List<string> argumentsAsList, char commandIdentifier)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			ChatMessage val = new ChatMessage(botUsername, userId, userName, displayName, colorHex, color, emoteSet, message, userType, channel, id, isSubscriber, subscribedMonthCount, roomId, isTurbo, isModerator, isMe, isBroadcaster, isVip, isPartner, isStaff, noisy, rawIrcMessage, emoteReplacedMessage, badges, cheerBadge, bits, bitsInDollars);
			OnChatCommandReceivedArgs args = new OnChatCommandReceivedArgs
			{
				Command = new ChatCommand(val, commandText, argumentsAsString, argumentsAsList, commandIdentifier)
			};
			client.RaiseEvent("OnChatCommandReceived", args);
		}

		public static void InvokeConnected(this TwitchClient client, string autoJoinChannel, string botUsername)
		{
			OnConnectedArgs args = new OnConnectedArgs
			{
				AutoJoinChannel = autoJoinChannel,
				BotUsername = botUsername
			};
			client.RaiseEvent("OnConnected", args);
		}

		public static void InvokeConnectionError(this TwitchClient client, string botUsername, ErrorEvent errorEvent)
		{
			OnConnectionErrorArgs args = new OnConnectionErrorArgs
			{
				BotUsername = botUsername,
				Error = errorEvent
			};
			client.RaiseEvent("OnConnectionError", args);
		}

		public static void InvokeDisconnected(this TwitchClient client, string botUsername)
		{
			OnDisconnectedArgs args = new OnDisconnectedArgs
			{
				BotUsername = botUsername
			};
			client.RaiseEvent("OnDisconnected", args);
		}

		public static void InvokeExistingUsersDetected(this TwitchClient client, string channel, List<string> users)
		{
			OnExistingUsersDetectedArgs args = new OnExistingUsersDetectedArgs
			{
				Channel = channel,
				Users = users
			};
			client.RaiseEvent("OnExistingUsersDetected", args);
		}

		public static void InvokeGiftedSubscription(this TwitchClient client, List<KeyValuePair<string, string>> badges, List<KeyValuePair<string, string>> badgeInfo, string color, string displayName, string emotes, string id, string login, bool isModerator, string msgId, string msgParamMonths, string msgParamRecipientDisplayName, string msgParamRecipientId, string msgParamRecipientUserName, string msgParamSubPlanName, string msgMultiMonthGiftDuration, SubscriptionPlan msgParamSubPlan, string roomId, bool isSubscriber, string systemMsg, string systemMsgParsed, string tmiSentTs, bool isTurbo, UserType userType, string userId)
		{
			//IL_0021: 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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			OnGiftedSubscriptionArgs args = new OnGiftedSubscriptionArgs
			{
				GiftedSubscription = new GiftedSubscription(badges, badgeInfo, color, displayName, emotes, id, login, isModerator, msgId, msgParamMonths, msgParamRecipientDisplayName, msgParamRecipientId, msgParamRecipientUserName, msgParamSubPlanName, msgMultiMonthGiftDuration, msgParamSubPlan, roomId, isSubscriber, systemMsg, systemMsgParsed, tmiSentTs, isTurbo, userType, userId)
			};
			client.RaiseEvent("OnGiftedSubscription", args);
		}

		public static void InvokeIncorrectLogin(this TwitchClient client, ErrorLoggingInException ex)
		{
			OnIncorrectLoginArgs args = new OnIncorrectLoginArgs
			{
				Exception = ex
			};
			client.RaiseEvent("OnIncorrectLogin", args);
		}

		public static void InvokeJoinedChannel(this TwitchClient client, string botUsername, string channel)
		{
			OnJoinedChannelArgs args = new OnJoinedChannelArgs
			{
				BotUsername = botUsername,
				Channel = channel
			};
			client.RaiseEvent("OnJoinedChannel", args);
		}

		public static void InvokeLeftChannel(this TwitchClient client, string botUsername, string channel)
		{
			OnLeftChannelArgs args = new OnLeftChannelArgs
			{
				BotUsername = botUsername,
				Channel = channel
			};
			client.RaiseEvent("OnLeftChannel", args);
		}

		public static void InvokeLog(this TwitchClient client, string botUsername, string data, DateTime dateTime)
		{
			OnLogArgs args = new OnLogArgs
			{
				BotUsername = botUsername,
				Data = data,
				DateTime = dateTime
			};
			client.RaiseEvent("OnLog", args);
		}

		public static void InvokeMessageReceived(this TwitchClient client, string botUsername, string userId, string userName, string displayName, string colorHex, Color color, EmoteSet emoteSet, string message, UserType userType, string channel, string id, bool isSubscriber, int subscribedMonthCount, string roomId, bool isTurbo, bool isModerator, bool isMe, bool isBroadcaster, bool isVip, bool isPartner, bool isStaff, Noisy noisy, string rawIrcMessage, string emoteReplacedMessage, List<KeyValuePair<string, string>> badges, CheerBadge cheerBadge, int bits, double bitsInDollars)
		{
			//IL_0013: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			OnMessageReceivedArgs args = new OnMessageReceivedArgs
			{
				ChatMessage = new ChatMessage(botUsername, userId, userName, displayName, colorHex, color, emoteSet, message, userType, channel, id, isSubscriber, subscribedMonthCount, roomId, isTurbo, isModerator, isMe, isBroadcaster, isVip, isPartner, isStaff, noisy, rawIrcMessage, emoteReplacedMessage, badges, cheerBadge, bits, bitsInDollars)
			};
			client.RaiseEvent("OnMessageReceived", args);
		}

		public static void InvokeMessageSent(this TwitchClient client, List<KeyValuePair<string, string>> badges, string channel, string colorHex, string displayName, string emoteSet, bool isModerator, bool isSubscriber, UserType userType, string message)
		{
			//IL_0011: 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_001f: Expected O, but got Unknown
			OnMessageSentArgs args = new OnMessageSentArgs
			{
				SentMessage = new SentMessage(badges, channel, colorHex, displayName, emoteSet, isModerator, isSubscriber, userType, message)
			};
			client.RaiseEvent("OnMessageSent", args);
		}

		public static void InvokeModeratorJoined(this TwitchClient client, string channel, string username)
		{
			OnModeratorJoinedArgs args = new OnModeratorJoinedArgs
			{
				Channel = channel,
				Username = username
			};
			client.RaiseEvent("OnModeratorJoined", args);
		}

		public static void InvokeModeratorLeft(this TwitchClient client, string channel, string username)
		{
			OnModeratorLeftArgs args = new OnModeratorLeftArgs
			{
				Channel = channel,
				Username = username
			};
			client.RaiseEvent("OnModeratorLeft", args);
		}

		public static void InvokeModeratorsReceived(this TwitchClient client, string channel, List<string> moderators)
		{
			OnModeratorsReceivedArgs args = new OnModeratorsReceivedArgs
			{
				Channel = channel,
				Moderators = moderators
			};
			client.RaiseEvent("OnModeratorsReceived", args);
		}

		public static void InvokeNewSubscriber(this TwitchClient client, List<KeyValuePair<string, string>> badges, List<KeyValuePair<string, string>> badgeInfo, string colorHex, Color color, string displayName, string emoteSet, string id, string login, string systemMessage, string msgId, string msgParamCumulativeMonths, string msgParamStreakMonths, bool msgParamShouldShareStreak, string systemMessageParsed, string resubMessage, SubscriptionPlan subscriptionPlan, string subscriptionPlanName, string roomId, string userId, bool isModerator, bool isTurbo, bool isSubscriber, bool isPartner, string tmiSentTs, UserType userType, string rawIrc, string channel)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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)
			//IL_0043: Expected O, but got Unknown
			OnNewSubscriberArgs args = new OnNewSubscriberArgs
			{
				Subscriber = new Subscriber(badges, badgeInfo, colorHex, color, displayName, emoteSet, id, login, systemMessage, msgId, msgParamCumulativeMonths, msgParamStreakMonths, msgParamShouldShareStreak, systemMessageParsed, resubMessage, subscriptionPlan, subscriptionPlanName, roomId, userId, isModerator, isTurbo, isSubscriber, isPartner, tmiSentTs, userType, rawIrc, channel)
			};
			client.RaiseEvent("OnNewSubscriber", args);
		}

		public static void InvokeRaidNotification(this TwitchClient client, string channel, List<KeyValuePair<string, string>> badges, List<KeyValuePair<string, string>> badgeInfo, string color, string displayName, string emotes, string id, string login, bool moderator, string msgId, string msgParamDisplayName, string msgParamLogin, string msgParamViewerCount, string roomId, bool subscriber, string systemMsg, string systemMsgParsed, string tmiSentTs, bool turbo, UserType userType, string userId)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			OnRaidNotificationArgs args = new OnRaidNotificationArgs
			{
				Channel = channel,
				RaidNotification = new RaidNotification(badges, badgeInfo, color, displayName, emotes, id, login, moderator, msgId, msgParamDisplayName, msgParamLogin, msgParamViewerCount, roomId, subscriber, systemMsg, systemMsgParsed, tmiSentTs, turbo, userType, userId)
			};
			client.RaiseEvent("OnRaidNotification", args);
		}

		public static void InvokeReSubscriber(this TwitchClient client, List<KeyValuePair<string, string>> badges, List<KeyValuePair<string, string>> badgeInfo, string colorHex, Color color, string displayName, string emoteSet, string id, string login, string systemMessage, string msgId, string msgParamCumulativeMonths, string msgParamStreakMonths, bool msgParamShouldShareStreak, string systemMessageParsed, string resubMessage, SubscriptionPlan subscriptionPlan, string subscriptionPlanName, string roomId, string userId, bool isModerator, bool isTurbo, bool isSubscriber, bool isPartner, string tmiSentTs, UserType userType, string rawIrc, string channel)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			OnReSubscriberArgs args = new OnReSubscriberArgs
			{
				ReSubscriber = new ReSubscriber(badges, badgeInfo, colorHex, color, displayName, emoteSet, id, login, systemMessage, msgId, msgParamCumulativeMonths, msgParamStreakMonths, msgParamShouldShareStreak, systemMessageParsed, resubMessage, subscriptionPlan, subscriptionPlanName, roomId, userId, isModerator, isTurbo, isSubscriber, isPartner, tmiSentTs, userType, rawIrc, channel, 0)
			};
			client.RaiseEvent("OnReSubscriber", args);
		}

		public static void InvokeSendReceiveData(this TwitchClient client, string data, SendReceiveDirection direction)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			OnSendReceiveDataArgs args = new OnSendReceiveDataArgs
			{
				Data = data,
				Direction = direction
			};
			client.RaiseEvent("OnSendReceiveData", args);
		}

		public static void InvokeUserBanned(this TwitchClient client, string channel, string username, string banReason, string roomId, string targetUserId)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnUserBannedArgs args = new OnUserBannedArgs
			{
				UserBan = new UserBan(channel, username, banReason, roomId, targetUserId)
			};
			client.RaiseEvent("OnUserBanned", args);
		}

		public static void InvokeUserJoined(this TwitchClient client, string channel, string username)
		{
			OnUserJoinedArgs args = new OnUserJoinedArgs
			{
				Channel = channel,
				Username = username
			};
			client.RaiseEvent("OnUserJoined", args);
		}

		public static void InvokeUserLeft(this TwitchClient client, string channel, string username)
		{
			OnUserLeftArgs args = new OnUserLeftArgs
			{
				Channel = channel,
				Username = username
			};
			client.RaiseEvent("OnUserLeft", args);
		}

		public static void InvokeUserStateChanged(this TwitchClient client, List<KeyValuePair<string, string>> badges, List<KeyValuePair<string, string>> badgeInfo, string colorHex, string displayName, string emoteSet, string channel, string id, bool isSubscriber, bool isModerator, UserType userType)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			OnUserStateChangedArgs args = new OnUserStateChangedArgs
			{
				UserState = new UserState(badges, badgeInfo, colorHex, displayName, emoteSet, channel, id, isSubscriber, isModerator, userType)
			};
			client.RaiseEvent("OnUserStateChanged", args);
		}

		public static void InvokeUserTimedout(this TwitchClient client, string channel, string username, string targetUserId, int timeoutDuration, string timeoutReason)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			OnUserTimedoutArgs args = new OnUserTimedoutArgs
			{
				UserTimeout = new UserTimeout(channel, username, targetUserId, timeoutDuration, timeoutReason)
			};
			client.RaiseEvent("OnUserTimedout", args);
		}

		public static void InvokeWhisperCommandReceived(this TwitchClient client, List<KeyValuePair<string, string>> badges, string colorHex, Color color, string username, string displayName, EmoteSet emoteSet, string threadId, string messageId, string userId, bool isTurbo, string botUsername, string message, UserType userType, string commandText, string argumentsAsString, List<string> argumentsAsList, char commandIdentifier)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			WhisperMessage val = new WhisperMessage(badges, colorHex, color, username, displayName, emoteSet, threadId, messageId, userId, isTurbo, botUsername, message, userType);
			OnWhisperCommandReceivedArgs args = new OnWhisperCommandReceivedArgs
			{
				Command = new WhisperCommand(val, commandText, argumentsAsString, argumentsAsList, commandIdentifier)
			};
			client.RaiseEvent("OnWhisperCommandReceived", args);
		}

		public static void InvokeWhisperReceived(this TwitchClient client, List<KeyValuePair<string, string>> badges, string colorHex, Color color, string username, string displayName, EmoteSet emoteSet, string threadId, string messageId, string userId, bool isTurbo, string botUsername, string message, UserType userType)
		{
			//IL_001b: 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_0027: Expected O, but got Unknown
			OnWhisperReceivedArgs args = new OnWhisperReceivedArgs
			{
				WhisperMessage = new WhisperMessage(badges, colorHex, color, username, displayName, emoteSet, threadId, messageId, userId, isTurbo, botUsername, message, userType)
			};
			client.RaiseEvent("OnWhisperReceived", args);
		}

		public static void InvokeWhisperSent(this TwitchClient client, string username, string receiver, string message)
		{
			OnWhisperSentArgs args = new OnWhisperSentArgs
			{
				Message = message,
				Receiver = receiver,
				Username = username
			};
			client.RaiseEvent("OnWhisperSent", args);
		}
	}
	public static class FollowersOnlyExt
	{
		private const int MaximumDurationAllowedDays = 90;

		public static void FollowersOnlyOn(this ITwitchClient client, JoinedChannel channel, TimeSpan requiredFollowTime)
		{
			if (requiredFollowTime > TimeSpan.FromDays(90.0))
			{
				throw new InvalidParameterException("The amount of time required to chat exceeded the maximum allowed by Twitch, which is 3 months.", client.TwitchUsername);
			}
			string text = $"{requiredFollowTime.Days}d {requiredFollowTime.Hours}h {requiredFollowTime.Minutes}m";
			client.SendMessage(channel, ".followers " + text);
		}

		public static void FollowersOnlyOn(this ITwitchClient client, string channel, TimeSpan requiredFollowTime)
		{
			if (requiredFollowTime > TimeSpan.FromDays(90.0))
			{
				throw new InvalidParameterException("The amount of time required to chat exceeded the maximum allowed by Twitch, which is 3 months.", client.TwitchUsername);
			}
			string text = $"{requiredFollowTime.Days}d {requiredFollowTime.Hours}h {requiredFollowTime.Minutes}m";
			client.SendMessage(channel, ".followers " + text);
		}

		public static void FollowersOnlyOff(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".followersoff");
		}

		public static void FollowersOnlyOff(this TwitchClient client, string channel)
		{
			client.SendMessage(channel, ".followersoff");
		}
	}
	public static class GetChannelModeratorsExt
	{
		public static void GetChannelModerators(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".mods");
		}

		public static void GetChannelModerators(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".mods");
		}
	}
	public static class MarkerExt
	{
		public static void Marker(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".marker");
		}

		public static void Marker(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".marker");
		}
	}
	public static class ModExt
	{
		public static void Mod(this ITwitchClient client, JoinedChannel channel, string viewerToMod)
		{
			client.SendMessage(channel, ".mod " + viewerToMod);
		}

		public static void Mod(this ITwitchClient client, string channel, string viewerToMod)
		{
			client.SendMessage(channel, ".mod " + viewerToMod);
		}

		public static void Unmod(this ITwitchClient client, JoinedChannel channel, string viewerToUnmod)
		{
			client.SendMessage(channel, ".unmod " + viewerToUnmod);
		}

		public static void Unmod(this ITwitchClient client, string channel, string viewerToUnmod)
		{
			client.SendMessage(channel, ".unmod " + viewerToUnmod);
		}
	}
	public static class RaidExt
	{
		public static void Raid(this ITwitchClient client, JoinedChannel channel, string channelToRaid)
		{
			client.SendMessage(channel, ".raid " + channelToRaid);
		}

		public static void Raid(this ITwitchClient client, string channel, string channelToRaid)
		{
			client.SendMessage(channel, ".raid " + channelToRaid);
		}
	}
	public static class ReplyWhisperExt
	{
		public static void ReplyToLastWhisper(this ITwitchClient client, string message = "", bool dryRun = false)
		{
			if (client.PreviousWhisper != null)
			{
				client.SendWhisper(((TwitchLibMessage)client.PreviousWhisper).Username, message, dryRun);
			}
		}
	}
	public static class SlowModeExt
	{
		public static void SlowModeOn(this ITwitchClient client, JoinedChannel channel, TimeSpan messageCooldown)
		{
			if (messageCooldown > TimeSpan.FromDays(1.0))
			{
				throw new InvalidParameterException("The message cooldown time supplied exceeded the maximum allowed by Twitch, which is 1 day.", client.TwitchUsername);
			}
			client.SendMessage(channel, $".slow {messageCooldown.TotalSeconds}");
		}

		public static void SlowModeOn(this ITwitchClient client, string channel, TimeSpan messageCooldown)
		{
			if (messageCooldown > TimeSpan.FromDays(1.0))
			{
				throw new InvalidParameterException("The message cooldown time supplied exceeded the maximum allowed by Twitch, which is 1 day.", client.TwitchUsername);
			}
			client.SendMessage(channel, $".slow {messageCooldown.TotalSeconds}");
		}

		public static void SlowModeOff(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".slowoff");
		}

		public static void SlowModeOff(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".slowoff");
		}
	}
	public static class SubscribersOnly
	{
		public static void SubscribersOnlyOn(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".subscribers");
		}

		public static void SubscribersOnlyOn(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".subscribers");
		}

		public static void SubscribersOnlyOff(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".subscribersoff");
		}

		public static void SubscribersOnlyOff(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".subscribersoff");
		}
	}
	public static class TimeoutUserExt
	{
		public static void TimeoutUser(this ITwitchClient client, JoinedChannel channel, string viewer, TimeSpan duration, string message = "", bool dryRun = false)
		{
			client.SendMessage(channel, $".timeout {viewer} {duration.TotalSeconds} {message}", dryRun);
		}

		public static void TimeoutUser(this ITwitchClient client, string channel, string viewer, TimeSpan duration, string message = "", bool dryRun = false)
		{
			JoinedChannel joinedChannel = client.GetJoinedChannel(channel);
			if (joinedChannel != null)
			{
				client.TimeoutUser(joinedChannel, viewer, duration, message, dryRun);
			}
		}
	}
	public static class UnbanUserExt
	{
		public static void UnbanUser(this ITwitchClient client, JoinedChannel channel, string viewer, bool dryRun = false)
		{
			client.SendMessage(channel, ".unban " + viewer, dryRun);
		}

		public static void UnbanUser(this ITwitchClient client, string channel, string viewer, bool dryRun = false)
		{
			JoinedChannel joinedChannel = client.GetJoinedChannel(channel);
			if (joinedChannel != null)
			{
				client.UnbanUser(joinedChannel, viewer, dryRun);
			}
		}
	}
	public static class VIPExt
	{
		public static void VIP(this ITwitchClient client, JoinedChannel channel, string viewerToVIP)
		{
			client.SendMessage(channel, ".vip " + viewerToVIP);
		}

		public static void VIP(this ITwitchClient client, string channel, string viewerToVIP)
		{
			client.SendMessage(channel, ".vip " + viewerToVIP);
		}

		public static void UnVIP(this ITwitchClient client, JoinedChannel channel, string viewerToUnVIP)
		{
			client.SendMessage(channel, ".unvip " + viewerToUnVIP);
		}

		public static void UnVIP(this ITwitchClient client, string channel, string viewerToUnVIP)
		{
			client.SendMessage(channel, ".unvip " + viewerToUnVIP);
		}

		public static void GetVIPs(this ITwitchClient client, JoinedChannel channel)
		{
			client.SendMessage(channel, ".vips");
		}

		public static void GetVIPs(this ITwitchClient client, string channel)
		{
			client.SendMessage(channel, ".vips");
		}
	}
}
namespace TwitchLib.Client.Exceptions
{
	public class BadListenException : Exception
	{
		public BadListenException(string eventName, string additionalDetails = "")
			: base(string.IsNullOrEmpty(additionalDetails) ? ("You are listening to event '" + eventName + "', which is not currently allowed. See details: " + additionalDetails) : ("You are listening to event '" + eventName + "', which is not currently allowed."))
		{
		}
	}
	public class BadStateException : Exception
	{
		public BadStateException(string details)
			: base(details)
		{
		}
	}
	public class ClientNotConnectedException : Exception
	{
		public ClientNotConnectedException(string description)
			: base(description)
		{
		}
	}
	public class ClientNotInitializedException : Exception
	{
		public ClientNotInitializedException(string description)
			: base(description)
		{
		}
	}
	public class ErrorLoggingInException : Exception
	{
		public string Username { get; protected set; }

		public ErrorLoggingInException(string ircData, string twitchUsername)
			: base(ircData)
		{
			Username = twitchUsername;
		}
	}
	public class EventNotHandled : Exception
	{
		public EventNotHandled(string eventName, string additionalDetails = "")
			: base(string.IsNullOrEmpty(additionalDetails) ? ("To use this call, you must handle/subscribe to event: " + eventName) : ("To use this call, you must handle/subscribe to event: " + eventName + ", additional details: " + additionalDetails))
		{
		}
	}
	public class FailureToReceiveJoinConfirmationException
	{
		public string Channel { get; protected set; }

		public string Details { get; protected set; }