using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using TwitchLib.Api.Core.Common;
using TwitchLib.Api.Core.Enums;
using TwitchLib.Api.Core.Exceptions;
using TwitchLib.Api.Core.Extensions.RateLimiter;
using TwitchLib.Api.Core.Interfaces;
using TwitchLib.Api.Core.Internal;
using TwitchLib.Api.Core.Models;
using TwitchLib.Api.Core.Models.Undocumented.Chatters;
using TwitchLib.Api.Core.RateLimiter;

[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("Project containing the core of TwitchLib.Api")]
[assembly: AssemblyFileVersion("3.8.0")]
[assembly: AssemblyInformationalVersion("3.8.0")]
[assembly: AssemblyProduct("TwitchLib.Api.Core")]
[assembly: AssemblyTitle("TwitchLib.Api.Core")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/swiftyspiffy/TwitchLib")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("3.8.0.0")]
namespace TwitchLib.Api.Core
{
	public class ApiBase
	{
		private class TwitchLibJsonSerializer
		{
			private class LowercaseContractResolver : DefaultContractResolver
			{
				protected override string ResolvePropertyName(string propertyName)
				{
					return propertyName.ToLower();
				}
			}

			private readonly JsonSerializerSettings _settings = new JsonSerializerSettings
			{
				ContractResolver = (IContractResolver)(object)new LowercaseContractResolver(),
				NullValueHandling = (NullValueHandling)1
			};

			public string SerializeObject(object o)
			{
				return JsonConvert.SerializeObject(o, (Formatting)1, _settings);
			}
		}

		private readonly TwitchLibJsonSerializer _jsonSerializer;

		protected readonly IApiSettings Settings;

		private readonly IRateLimiter _rateLimiter;

		private readonly IHttpCallHandler _http;

		internal const string BaseHelix = "https://api.twitch.tv/helix";

		internal const string BaseAuth = "https://id.twitch.tv/oauth2";

		private DateTime? _serverBasedAccessTokenExpiry;

		private string _serverBasedAccessToken;

		private readonly JsonSerializerSettings _twitchLibJsonDeserializer = new JsonSerializerSettings
		{
			NullValueHandling = (NullValueHandling)1,
			MissingMemberHandling = (MissingMemberHandling)0
		};

		public ApiBase(IApiSettings settings, IRateLimiter rateLimiter, IHttpCallHandler http)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			Settings = settings;
			_rateLimiter = rateLimiter;
			_http = http;
			_jsonSerializer = new TwitchLibJsonSerializer();
		}

		public async ValueTask<string> GetAccessTokenAsync(string accessToken = null)
		{
			if (!string.IsNullOrWhiteSpace(accessToken))
			{
				return accessToken;
			}
			if (!string.IsNullOrWhiteSpace(Settings.AccessToken))
			{
				return Settings.AccessToken;
			}
			if (!string.IsNullOrWhiteSpace(Settings.Secret) && !string.IsNullOrWhiteSpace(Settings.ClientId) && !Settings.SkipAutoServerTokenGeneration)
			{
				if (!_serverBasedAccessTokenExpiry.HasValue || _serverBasedAccessTokenExpiry - TimeSpan.FromMinutes(1.0) < DateTime.Now)
				{
					return await GenerateServerBasedAccessToken().ConfigureAwait(continueOnCapturedContext: false);
				}
				return _serverBasedAccessToken;
			}
			return null;
		}

		internal async Task<string> GenerateServerBasedAccessToken()
		{
			KeyValuePair<int, string> keyValuePair = await _http.GeneralRequestAsync("https://id.twitch.tv/oauth2/token?client_id=" + Settings.ClientId + "&client_secret=" + Settings.Secret + "&grant_type=client_credentials", "POST", (string)null, (ApiVersion)1, Settings.ClientId, (string)null).ConfigureAwait(continueOnCapturedContext: false);
			if (keyValuePair.Key == 200)
			{
				JObject val = JObject.Parse(keyValuePair.Value);
				int num = int.Parse(((object)((JToken)val).SelectToken("expires_in"))?.ToString() ?? string.Empty);
				_serverBasedAccessTokenExpiry = DateTime.Now + TimeSpan.FromSeconds(num);
				_serverBasedAccessToken = ((object)((JToken)val).SelectToken("access_token"))?.ToString();
				return _serverBasedAccessToken;
			}
			return null;
		}

		internal void ForceAccessTokenAndClientIdForHelix(string clientId, string accessToken, ApiVersion api)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)api != 6 || (!string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(accessToken)))
			{
				return;
			}
			throw new ClientIdAndOAuthTokenRequired("As of May 1, all calls to Twitch's Helix API require Client-ID and OAuth access token be set. Example: api.Settings.AccessToken = \"twitch-oauth-access-token-here\"; api.Settings.ClientId = \"twitch-client-id-here\";");
		}

		protected async Task<string> TwitchGetAsync(string resource, ApiVersion api, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<string>((Func<Task<string>>)(async () => (await _http.GeneralRequestAsync(url, "GET", (string)null, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value)).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchGetGenericAsync<T>(string resource, ApiVersion api, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "GET", (string)null, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchPatchGenericAsync<T>(string resource, ApiVersion api, string payload, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "PATCH", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<string> TwitchPatchAsync(string resource, ApiVersion api, string payload, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<string>((Func<Task<string>>)(async () => (await _http.GeneralRequestAsync(url, "PATCH", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value)).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<KeyValuePair<int, string>> TwitchDeleteAsync(string resource, ApiVersion api, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<KeyValuePair<int, string>>((Func<Task<KeyValuePair<int, string>>>)(async () => await _http.GeneralRequestAsync(url, "DELETE", (string)null, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchPostGenericAsync<T>(string resource, ApiVersion api, string payload, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "POST", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchPostGenericModelAsync<T>(string resource, ApiVersion api, RequestModel model, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, null, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "POST", (model != null) ? _jsonSerializer.SerializeObject(model) : "", api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchDeleteGenericAsync<T>(string resource, ApiVersion api, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "DELETE", (string)null, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<T> TwitchPutGenericAsync<T>(string resource, ApiVersion api, string payload = null, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "PUT", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<string> TwitchPutAsync(string resource, ApiVersion api, string payload, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<string>((Func<Task<string>>)(async () => (await _http.GeneralRequestAsync(url, "PUT", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value)).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected async Task<KeyValuePair<int, string>> TwitchPostAsync(string resource, ApiVersion api, string payload, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, string clientId = null, string customBase = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string url = ConstructResourceUrl(resource, getParams, api, customBase);
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<KeyValuePair<int, string>>((Func<Task<KeyValuePair<int, string>>>)(async () => await _http.GeneralRequestAsync(url, "POST", payload, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false))).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected Task PutBytesAsync(string url, byte[] payload)
		{
			return _http.PutBytesAsync(url, payload);
		}

		internal Task<int> RequestReturnResponseCode(string url, string method, List<KeyValuePair<string, string>> getParams = null)
		{
			return _http.RequestReturnResponseCodeAsync(url, method, getParams);
		}

		protected async Task<T> GetGenericAsync<T>(string url, List<KeyValuePair<string, string>> getParams = null, string accessToken = null, ApiVersion api = 6, string clientId = null)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (getParams != null)
			{
				for (int i = 0; i < getParams.Count; i++)
				{
					if (i == 0)
					{
						url = url + "?" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
					}
					else
					{
						url = url + "&" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
					}
				}
			}
			if (string.IsNullOrWhiteSpace(clientId) && !string.IsNullOrWhiteSpace(Settings.ClientId))
			{
				clientId = Settings.ClientId;
			}
			accessToken = await GetAccessTokenAsync(accessToken).ConfigureAwait(continueOnCapturedContext: false);
			ForceAccessTokenAndClientIdForHelix(clientId, accessToken, api);
			return await _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>((await _http.GeneralRequestAsync(url, "GET", (string)null, api, clientId, accessToken).ConfigureAwait(continueOnCapturedContext: false)).Value, _twitchLibJsonDeserializer))).ConfigureAwait(continueOnCapturedContext: false);
		}

		internal Task<T> GetSimpleGenericAsync<T>(string url, List<KeyValuePair<string, string>> getParams = null)
		{
			if (getParams != null)
			{
				for (int i = 0; i < getParams.Count; i++)
				{
					if (i == 0)
					{
						url = url + "?" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
					}
					else
					{
						url = url + "&" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
					}
				}
			}
			return _rateLimiter.Perform<T>((Func<Task<T>>)(async () => JsonConvert.DeserializeObject<T>(await SimpleRequestAsync(url).ConfigureAwait(continueOnCapturedContext: false), _twitchLibJsonDeserializer)));
		}

		private Task<string> SimpleRequestAsync(string url)
		{
			TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
			WebClient client = new WebClient();
			client.DownloadStringCompleted += DownloadStringCompletedEventHandler;
			client.DownloadString(new Uri(url));
			return tcs.Task;
			void DownloadStringCompletedEventHandler(object sender, DownloadStringCompletedEventArgs args)
			{
				if (args.Cancelled)
				{
					tcs.SetCanceled();
				}
				else if (args.Error != null)
				{
					tcs.SetException(args.Error);
				}
				else
				{
					tcs.SetResult(args.Result);
				}
				client.DownloadStringCompleted -= DownloadStringCompletedEventHandler;
			}
		}

		private string ConstructResourceUrl(string resource = null, List<KeyValuePair<string, string>> getParams = null, ApiVersion api = 6, string overrideUrl = null)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			string text = "";
			if (overrideUrl == null)
			{
				if (resource == null)
				{
					throw new Exception("Cannot pass null resource with null override url");
				}
				if ((int)api != 1)
				{
					if ((int)api == 6)
					{
						text = "https://api.twitch.tv/helix" + resource;
					}
				}
				else
				{
					text = "https://id.twitch.tv/oauth2" + resource;
				}
			}
			else
			{
				text = ((resource == null) ? overrideUrl : (overrideUrl + resource));
			}
			if (getParams != null)
			{
				for (int i = 0; i < getParams.Count; i++)
				{
					text = ((i != 0) ? (text + "&" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value)) : (text + "?" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value)));
				}
			}
			return text;
		}
	}
	public class ApiSettings : IApiSettings, INotifyPropertyChanged
	{
		private string _clientId;

		private string _secret;

		private string _accessToken;

		private bool _skipDynamicScopeValidation;

		private bool _skipAutoServerTokenGeneration;

		private List<AuthScopes> _scopes;

		public string ClientId
		{
			get
			{
				return _clientId;
			}
			set
			{
				if (value != _clientId)
				{
					_clientId = value;
					NotifyPropertyChanged("ClientId");
				}
			}
		}

		public string Secret
		{
			get
			{
				return _secret;
			}
			set
			{
				if (value != _secret)
				{
					_secret = value;
					NotifyPropertyChanged("Secret");
				}
			}
		}

		public string AccessToken
		{
			get
			{
				return _accessToken;
			}
			set
			{
				if (value != _accessToken)
				{
					_accessToken = value;
					NotifyPropertyChanged("AccessToken");
				}
			}
		}

		public bool SkipDynamicScopeValidation
		{
			get
			{
				return _skipDynamicScopeValidation;
			}
			set
			{
				if (value != _skipDynamicScopeValidation)
				{
					_skipDynamicScopeValidation = value;
					NotifyPropertyChanged("SkipDynamicScopeValidation");
				}
			}
		}

		public bool SkipAutoServerTokenGeneration
		{
			get
			{
				return _skipAutoServerTokenGeneration;
			}
			set
			{
				if (value != _skipAutoServerTokenGeneration)
				{
					_skipAutoServerTokenGeneration = value;
					NotifyPropertyChanged("SkipAutoServerTokenGeneration");
				}
			}
		}

		public List<AuthScopes> Scopes
		{
			get
			{
				return _scopes;
			}
			set
			{
				if (value != _scopes)
				{
					_scopes = value;
					NotifyPropertyChanged("Scopes");
				}
			}
		}

		public event PropertyChangedEventHandler PropertyChanged;

		private void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
		{
			this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
		}
	}
}
namespace TwitchLib.Api.Core.Undocumented
{
	public class Undocumented : ApiBase
	{
		public Undocumented(IApiSettings settings, IRateLimiter rateLimiter, IHttpCallHandler http)
			: base(settings, rateLimiter, http)
		{
		}

		[Obsolete("Please use the new official Helix GetChatters Endpoint (api.Helix.Chat.GetChattersAsync) instead of this undocumented and unsupported endpoint.")]
		public async Task<List<ChatterFormatted>> GetChattersAsync(string channelName)
		{
			ChattersResponse val = await GetGenericAsync<ChattersResponse>("https://tmi.twitch.tv/group/user/" + channelName.ToLower() + "/chatters", null, null, (ApiVersion)6);
			List<ChatterFormatted> list = ((IEnumerable<string>)val.Chatters.Staff).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)6))).ToList();
			list.AddRange(((IEnumerable<string>)val.Chatters.Admins).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)5))));
			list.AddRange(((IEnumerable<string>)val.Chatters.GlobalMods).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)3))));
			list.AddRange(((IEnumerable<string>)val.Chatters.Moderators).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)2))));
			list.AddRange(((IEnumerable<string>)val.Chatters.Viewers).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)0))));
			list.AddRange(((IEnumerable<string>)val.Chatters.VIP).Select((Func<string, ChatterFormatted>)((string chatter) => new ChatterFormatted(chatter, (UserType)1))));
			foreach (ChatterFormatted item in list.Where((ChatterFormatted chatter) => string.Equals(chatter.Username, channelName, StringComparison.InvariantCultureIgnoreCase)))
			{
				item.UserType = (UserType)4;
			}
			return list;
		}

		public async Task<bool> IsUsernameAvailableAsync(string username)
		{
			List<KeyValuePair<string, string>> getParams = new List<KeyValuePair<string, string>>
			{
				new KeyValuePair<string, string>("users_service", "true")
			};
			int num = await RequestReturnResponseCode("https://passport.twitch.tv/usernames/" + username, "HEAD", getParams).ConfigureAwait(continueOnCapturedContext: false);
			return num switch
			{
				200 => false, 
				204 => true, 
				_ => throw new BadResourceException("Unexpected response from resource. Expecting response code 200 or 204, received: " + num), 
			};
		}
	}
}
namespace TwitchLib.Api.Core.RateLimiter
{
	public class BypassLimiter : IRateLimiter
	{
		public Task Perform(Func<Task> perform)
		{
			return Perform(perform, CancellationToken.None);
		}

		public Task<T> Perform<T>(Func<Task<T>> perform)
		{
			return Perform(perform, CancellationToken.None);
		}

		public Task Perform(Func<Task> perform, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			return perform();
		}

		public Task<T> Perform<T>(Func<Task<T>> perform, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			return perform();
		}

		private static Func<Task> Transform(Action act)
		{
			return delegate
			{
				act();
				return Task.FromResult(0);
			};
		}

		private static Func<Task<T>> Transform<T>(Func<T> compute)
		{
			return () => Task.FromResult(compute());
		}

		public Task Perform(Action perform, CancellationToken cancellationToken)
		{
			Func<Task> perform2 = Transform(perform);
			return Perform(perform2, cancellationToken);
		}

		public Task Perform(Action perform)
		{
			Func<Task> perform2 = Transform(perform);
			return Perform(perform2);
		}

		public Task<T> Perform<T>(Func<T> perform)
		{
			Func<Task<T>> perform2 = Transform(perform);
			return Perform(perform2);
		}

		public Task<T> Perform<T>(Func<T> perform, CancellationToken cancellationToken)
		{
			Func<Task<T>> perform2 = Transform(perform);
			return Perform(perform2, cancellationToken);
		}

		public static BypassLimiter CreateLimiterBypassInstance()
		{
			return new BypassLimiter();
		}
	}
	public class ComposedAwaitableConstraint : IAwaitableConstraint
	{
		private IAwaitableConstraint _ac1;

		private IAwaitableConstraint _ac2;

		private readonly SemaphoreSlim _semafore = new SemaphoreSlim(1, 1);

		internal ComposedAwaitableConstraint(IAwaitableConstraint ac1, IAwaitableConstraint ac2)
		{
			_ac1 = ac1;
			_ac2 = ac2;
		}

		public async Task<IDisposable> WaitForReadiness(CancellationToken cancellationToken)
		{
			await _semafore.WaitAsync(cancellationToken);
			IDisposable[] diposables;
			try
			{
				diposables = await Task.WhenAll<IDisposable>(_ac1.WaitForReadiness(cancellationToken), _ac2.WaitForReadiness(cancellationToken));
			}
			catch (Exception)
			{
				_semafore.Release();
				throw;
			}
			return new DisposeAction(delegate
			{
				IDisposable[] array = diposables;
				for (int i = 0; i < array.Length; i++)
				{
					array[i].Dispose();
				}
				_semafore.Release();
			});
		}
	}
	public class CountByIntervalAwaitableConstraint : IAwaitableConstraint
	{
		public IReadOnlyList<DateTime> TimeStamps => _timeStamps.ToList();

		protected LimitedSizeStack<DateTime> _timeStamps { get; }

		private int _count { get; }

		private TimeSpan _timeSpan { get; }

		private SemaphoreSlim _semafore { get; } = new SemaphoreSlim(1, 1);


		private ITime _time { get; }

		public CountByIntervalAwaitableConstraint(int count, TimeSpan timeSpan, ITime time = null)
		{
			if (count <= 0)
			{
				throw new ArgumentException("count should be strictly positive", "count");
			}
			if (timeSpan.TotalMilliseconds <= 0.0)
			{
				throw new ArgumentException("timeSpan should be strictly positive", "timeSpan");
			}
			_count = count;
			_timeSpan = timeSpan;
			_timeStamps = new LimitedSizeStack<DateTime>(_count);
			_time = time ?? TimeSystem.StandardTime;
		}

		public async Task<IDisposable> WaitForReadiness(CancellationToken cancellationToken)
		{
			await _semafore.WaitAsync(cancellationToken);
			int num = 0;
			DateTime timeNow = _time.GetTimeNow();
			DateTime dateTime = timeNow - _timeSpan;
			LinkedListNode<DateTime> linkedListNode = _timeStamps.First;
			LinkedListNode<DateTime> linkedListNode2 = null;
			while (linkedListNode != null && linkedListNode.Value > dateTime)
			{
				linkedListNode2 = linkedListNode;
				linkedListNode = linkedListNode.Next;
				num++;
			}
			if (num < _count)
			{
				return new DisposeAction(OnEnded);
			}
			TimeSpan timeSpan = linkedListNode2.Value.Add(_timeSpan) - timeNow;
			try
			{
				await _time.GetDelay(timeSpan, cancellationToken);
			}
			catch (Exception)
			{
				_semafore.Release();
				throw;
			}
			return new DisposeAction(OnEnded);
		}

		private void OnEnded()
		{
			DateTime timeNow = _time.GetTimeNow();
			_timeStamps.Push(timeNow);
			OnEnded(timeNow);
			_semafore.Release();
		}

		protected virtual void OnEnded(DateTime now)
		{
		}
	}
	public class DisposeAction : IDisposable
	{
		private Action _act;

		public DisposeAction(Action act)
		{
			_act = act;
		}

		public void Dispose()
		{
			_act?.Invoke();
			_act = null;
		}
	}
	public class LimitedSizeStack<T> : LinkedList<T>
	{
		private readonly int _maxSize;

		public LimitedSizeStack(int maxSize)
		{
			_maxSize = maxSize;
		}

		public void Push(T item)
		{
			AddFirst(item);
			if (base.Count > _maxSize)
			{
				RemoveLast();
			}
		}
	}
	public class PersistentCountByIntervalAwaitableConstraint : CountByIntervalAwaitableConstraint
	{
		private readonly Action<DateTime> _saveStateAction;

		public PersistentCountByIntervalAwaitableConstraint(int count, TimeSpan timeSpan, Action<DateTime> saveStateAction, IEnumerable<DateTime> initialTimeStamps, ITime time = null)
			: base(count, timeSpan, time)
		{
			_saveStateAction = saveStateAction;
			if (initialTimeStamps == null)
			{
				return;
			}
			foreach (DateTime initialTimeStamp in initialTimeStamps)
			{
				base._timeStamps.Push(initialTimeStamp);
			}
		}

		protected override void OnEnded(DateTime now)
		{
			_saveStateAction(now);
		}
	}
	public class TimeLimiter : IRateLimiter
	{
		private readonly IAwaitableConstraint _ac;

		internal TimeLimiter(IAwaitableConstraint ac)
		{
			_ac = ac;
		}

		public Task Perform(Func<Task> perform)
		{
			return Perform(perform, CancellationToken.None);
		}

		public Task<T> Perform<T>(Func<Task<T>> perform)
		{
			return Perform(perform, CancellationToken.None);
		}

		public async Task Perform(Func<Task> perform, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (await _ac.WaitForReadiness(cancellationToken))
			{
				await perform();
			}
		}

		public async Task<T> Perform<T>(Func<Task<T>> perform, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (await _ac.WaitForReadiness(cancellationToken))
			{
				return await perform();
			}
		}

		private static Func<Task> Transform(Action act)
		{
			return delegate
			{
				act();
				return Task.FromResult(0);
			};
		}

		private static Func<Task<T>> Transform<T>(Func<T> compute)
		{
			return () => Task.FromResult(compute());
		}

		public Task Perform(Action perform, CancellationToken cancellationToken)
		{
			Func<Task> perform2 = Transform(perform);
			return Perform(perform2, cancellationToken);
		}

		public Task Perform(Action perform)
		{
			Func<Task> perform2 = Transform(perform);
			return Perform(perform2);
		}

		public Task<T> Perform<T>(Func<T> perform)
		{
			Func<Task<T>> perform2 = Transform(perform);
			return Perform(perform2);
		}

		public Task<T> Perform<T>(Func<T> perform, CancellationToken cancellationToken)
		{
			Func<Task<T>> perform2 = Transform(perform);
			return Perform(perform2, cancellationToken);
		}

		public static TimeLimiter GetFromMaxCountByInterval(int maxCount, TimeSpan timeSpan)
		{
			return new TimeLimiter((IAwaitableConstraint)(object)new CountByIntervalAwaitableConstraint(maxCount, timeSpan));
		}

		public static TimeLimiter GetPersistentTimeLimiter(int maxCount, TimeSpan timeSpan, Action<DateTime> saveStateAction)
		{
			return GetPersistentTimeLimiter(maxCount, timeSpan, saveStateAction, null);
		}

		public static TimeLimiter GetPersistentTimeLimiter(int maxCount, TimeSpan timeSpan, Action<DateTime> saveStateAction, IEnumerable<DateTime> initialTimeStamps)
		{
			return new TimeLimiter((IAwaitableConstraint)(object)new PersistentCountByIntervalAwaitableConstraint(maxCount, timeSpan, saveStateAction, initialTimeStamps));
		}

		public static TimeLimiter Compose(params IAwaitableConstraint[] constraints)
		{
			IAwaitableConstraint val = null;
			foreach (IAwaitableConstraint val2 in constraints)
			{
				val = ((val == null) ? val2 : val.Compose(val2));
			}
			return new TimeLimiter(val);
		}
	}
	public class TimeSystem : ITime
	{
		public static ITime StandardTime { get; }

		static TimeSystem()
		{
			StandardTime = (ITime)(object)new TimeSystem();
		}

		private TimeSystem()
		{
		}

		DateTime ITime.GetTimeNow()
		{
			return DateTime.Now;
		}

		Task ITime.GetDelay(TimeSpan timespan, CancellationToken cancellationToken)
		{
			return Task.Delay(timespan, cancellationToken);
		}
	}
}
namespace TwitchLib.Api.Core.Internal
{
	public class TwitchHttpClientHandler : DelegatingHandler
	{
		private readonly ILogger<IHttpCallHandler> _logger;

		public TwitchHttpClientHandler(ILogger<IHttpCallHandler> logger)
			: base(new HttpClientHandler())
		{
			_logger = logger;
		}

		protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
		{
			if (request.Content != null)
			{
				ILogger<IHttpCallHandler> logger = _logger;
				if (logger != null)
				{
					ILogger logger2 = logger;
					object obj = DateTime.Now;
					object obj2 = "Request";
					object obj3 = request.Method.ToString();
					object obj4 = request.RequestUri.ToString();
					string text = await request.Content.ReadAsStringAsync();
					logger2.LogInformation("Timestamp: {timestamp} Type: {type} Method: {method} Resource: {url} Content: {content}", obj, obj2, obj3, obj4, text);
				}
			}
			else
			{
				_logger?.LogInformation("Timestamp: {timestamp} Type: {type} Method: {method} Resource: {url}", DateTime.Now, "Request", request.Method.ToString(), request.RequestUri.ToString());
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			stopwatch.Stop();
			if (response.IsSuccessStatusCode)
			{
				if (response.Content != null)
				{
					ILogger<IHttpCallHandler> logger = _logger;
					if (logger != null)
					{
						ILogger logger2 = logger;
						object obj4 = DateTime.Now;
						object obj3 = "Response";
						object obj2 = response.RequestMessage.RequestUri;
						object obj = (int)response.StatusCode;
						object obj5 = stopwatch.ElapsedMilliseconds;
						string text = await response.Content.ReadAsStringAsync();
						logger2.LogInformation("Timestamp: {timestamp} Type: {type} Resource: {url} Statuscode: {statuscode} Elapsed: {elapsed} ms Content: {content}", obj4, obj3, obj2, obj, obj5, text);
					}
				}
				else
				{
					_logger?.LogInformation("Timestamp: {timestamp} Type: {type} Resource: {url} Statuscode: {statuscode} Elapsed: {elapsed} ms", DateTime.Now, "Response", response.RequestMessage.RequestUri, (int)response.StatusCode, stopwatch.ElapsedMilliseconds);
				}
			}
			else if (response.Content != null)
			{
				ILogger<IHttpCallHandler> logger = _logger;
				if (logger != null)
				{
					ILogger logger2 = logger;
					object obj5 = DateTime.Now;
					object obj = "Response";
					object obj2 = response.RequestMessage.RequestUri;
					object obj3 = (int)response.StatusCode;
					object obj4 = stopwatch.ElapsedMilliseconds;
					string text = await response.Content.ReadAsStringAsync();
					logger2.LogError("Timestamp: {timestamp} Type: {type} Resource: {url} Statuscode: {statuscode} Elapsed: {elapsed} ms Content: {content}", obj5, obj, obj2, obj3, obj4, text);
				}
			}
			else
			{
				_logger?.LogError("Timestamp: {timestamp} Type: {type} Resource: {url} Statuscode: {statuscode} Elapsed: {elapsed} ms", DateTime.Now, "Response", response.RequestMessage.RequestUri, (int)response.StatusCode, stopwatch.ElapsedMilliseconds);
			}
			return response;
		}
	}
}
namespace TwitchLib.Api.Core.HttpCallHandlers
{
	public class TwitchHttpClient : IHttpCallHandler
	{
		private readonly ILogger<TwitchHttpClient> _logger;

		private readonly HttpClient _http;

		public TwitchHttpClient(ILogger<TwitchHttpClient> logger = null)
		{
			_logger = logger;
			_http = new HttpClient(new TwitchHttpClientHandler((ILogger<IHttpCallHandler>)_logger));
		}

		public async Task PutBytesAsync(string url, byte[] payload)
		{
			HttpResponseMessage httpResponseMessage = await _http.PutAsync(new Uri(url), new ByteArrayContent(payload)).ConfigureAwait(continueOnCapturedContext: false);
			if (!httpResponseMessage.IsSuccessStatusCode)
			{
				HandleWebException(httpResponseMessage);
			}
		}

		public async Task<KeyValuePair<int, string>> GeneralRequestAsync(string url, string method, string payload = null, ApiVersion api = 6, string clientId = null, string accessToken = null)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			HttpRequestMessage httpRequestMessage = new HttpRequestMessage
			{
				RequestUri = new Uri(url),
				Method = new HttpMethod(method)
			};
			if ((int)api == 6)
			{
				if (string.IsNullOrWhiteSpace(clientId) || string.IsNullOrWhiteSpace(accessToken))
				{
					throw new InvalidCredentialException("A Client-Id and OAuth token is required to use the Twitch API.");
				}
				httpRequestMessage.Headers.Add("Client-ID", clientId);
			}
			string text = "OAuth";
			if ((int)api == 6 || (int)api == 1)
			{
				httpRequestMessage.Headers.Add(HttpRequestHeader.Accept.ToString(), "application/json");
				text = "Bearer";
			}
			if (!string.IsNullOrWhiteSpace(accessToken))
			{
				httpRequestMessage.Headers.Add(HttpRequestHeader.Authorization.ToString(), text + " " + Helpers.FormatOAuth(accessToken));
			}
			if (payload != null)
			{
				httpRequestMessage.Content = new StringContent(payload, Encoding.UTF8, "application/json");
			}
			HttpResponseMessage response = await _http.SendAsync(httpRequestMessage).ConfigureAwait(continueOnCapturedContext: false);
			if (response.IsSuccessStatusCode)
			{
				string value = await response.Content.ReadAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
				return new KeyValuePair<int, string>((int)response.StatusCode, value);
			}
			HandleWebException(response);
			return new KeyValuePair<int, string>(0, null);
		}

		public async Task<int> RequestReturnResponseCodeAsync(string url, string method, List<KeyValuePair<string, string>> getParams = null)
		{
			if (getParams != null)
			{
				for (int i = 0; i < getParams.Count; i++)
				{
					url = ((i != 0) ? (url + "&" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value)) : (url + "?" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value)));
				}
			}
			HttpRequestMessage request = new HttpRequestMessage
			{
				RequestUri = new Uri(url),
				Method = new HttpMethod(method)
			};
			return (int)(await _http.SendAsync(request).ConfigureAwait(continueOnCapturedContext: false)).StatusCode;
		}

		private void HandleWebException(HttpResponseMessage errorResp)
		{
			switch (errorResp.StatusCode)
			{
			case HttpStatusCode.BadRequest:
				throw new BadRequestException("Your request failed because either: \n 1. Your ClientID was invalid/not set. \n 2. Your refresh token was invalid. \n 3. You requested a username when the server was expecting a user ID.");
			case HttpStatusCode.Unauthorized:
			{
				HttpHeaderValueCollection<AuthenticationHeaderValue> wwwAuthenticate = errorResp.Headers.WwwAuthenticate;
				if (wwwAuthenticate == null || wwwAuthenticate.Count <= 0)
				{
					throw new BadScopeException("Your request was blocked due to bad credentials (Do you have the right scope for your access token?).");
				}
				throw new TokenExpiredException("Your request was blocked due to an expired Token. Please refresh your token and update your API instance settings.");
			}
			case HttpStatusCode.NotFound:
				throw new BadResourceException("The resource you tried to access was not valid.");
			case HttpStatusCode.TooManyRequests:
			{
				errorResp.Headers.TryGetValues("Ratelimit-Reset", out IEnumerable<string> values);
				throw new TooManyRequestsException("You have reached your rate limit. Too many requests were made", values.FirstOrDefault());
			}
			case HttpStatusCode.BadGateway:
				throw new BadGatewayException("The API answered with a 502 Bad Gateway. Please retry your request");
			case HttpStatusCode.GatewayTimeout:
				throw new GatewayTimeoutException("The API answered with a 504 Gateway Timeout. Please retry your request");
			case HttpStatusCode.InternalServerError:
				throw new InternalServerErrorException("The API answered with a 500 Internal Server Error. Please retry your request");
			case HttpStatusCode.Forbidden:
				throw new BadTokenException("The token provided in the request did not match the associated user. Make sure the token you're using is from the resource owner (streamer? viewer?)");
			default:
				throw new HttpRequestException("Something went wrong during the request! Please try again later");
			}
		}
	}
	[Obsolete("The WebRequest handler is deprecated and is not updated to be working with Helix correctly")]
	public class TwitchWebRequest : IHttpCallHandler
	{
		private readonly ILogger<TwitchWebRequest> _logger;

		public TwitchWebRequest(ILogger<TwitchWebRequest> logger = null)
		{
			_logger = logger;
		}

		public Task PutBytesAsync(string url, byte[] payload)
		{
			return Task.Factory.StartNew(delegate
			{
				try
				{
					using WebClient webClient = new WebClient();
					webClient.UploadData(new Uri(url), "PUT", payload);
				}
				catch (WebException e)
				{
					HandleWebException(e);
				}
			});
		}

		public async Task<KeyValuePair<int, string>> GeneralRequestAsync(string url, string method, string payload = null, ApiVersion api = 6, string clientId = null, string accessToken = null)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			HttpWebRequest request = WebRequest.CreateHttp(url);
			if (string.IsNullOrEmpty(clientId) && string.IsNullOrEmpty(accessToken))
			{
				throw new InvalidCredentialException("A Client-Id or OAuth token is required to use the Twitch API. If you previously set them in InitializeAsync, please be sure to await the method.");
			}
			if (!string.IsNullOrEmpty(clientId))
			{
				request.Headers["Client-ID"] = clientId;
			}
			request.Method = method;
			request.ContentType = "application/json";
			string text = "OAuth";
			if ((int)api == 6)
			{
				request.Accept = "application/json";
				text = "Bearer";
			}
			else if ((int)api != 0)
			{
				request.Accept = $"application/vnd.twitchtv.v{(int)api}+json";
			}
			if (!string.IsNullOrEmpty(accessToken))
			{
				request.Headers["Authorization"] = text + " " + Helpers.FormatOAuth(accessToken);
			}
			if (payload != null)
			{
				using StreamWriter writer = new StreamWriter(await request.GetRequestStreamAsync().ConfigureAwait(continueOnCapturedContext: false));
				await writer.WriteAsync(payload).ConfigureAwait(continueOnCapturedContext: false);
			}
			try
			{
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				using StreamReader reader = new StreamReader(response.GetResponseStream() ?? throw new InvalidOperationException());
				string value = await reader.ReadToEndAsync().ConfigureAwait(continueOnCapturedContext: false);
				return new KeyValuePair<int, string>((int)response.StatusCode, value);
			}
			catch (WebException e)
			{
				HandleWebException(e);
			}
			return new KeyValuePair<int, string>(0, null);
		}

		public Task<int> RequestReturnResponseCodeAsync(string url, string method, List<KeyValuePair<string, string>> getParams = null)
		{
			return Task.Factory.StartNew(delegate
			{
				if (getParams != null)
				{
					for (int i = 0; i < getParams.Count; i++)
					{
						if (i == 0)
						{
							url = url + "?" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
						}
						else
						{
							url = url + "&" + getParams[i].Key + "=" + Uri.EscapeDataString(getParams[i].Value);
						}
					}
				}
				HttpWebRequest obj = (HttpWebRequest)WebRequest.Create(url);
				obj.Method = method;
				return (int)((HttpWebResponse)obj.GetResponse()).StatusCode;
			});
		}

		private void HandleWebException(WebException e)
		{
			if (!(e.Response is HttpWebResponse httpWebResponse))
			{
				throw e;
			}
			switch (httpWebResponse.StatusCode)
			{
			case HttpStatusCode.BadRequest:
				throw new BadRequestException("Your request failed because either: \n 1. Your ClientID was invalid/not set. \n 2. Your refresh token was invalid. \n 3. You requested a username when the server was expecting a user ID.");
			case HttpStatusCode.Unauthorized:
			{
				string[] values = httpWebResponse.Headers.GetValues("WWW-Authenticate");
				if ((values != null && values.Length == 0) || string.IsNullOrEmpty((values != null) ? values[0] : null))
				{
					throw new BadScopeException("Your request was blocked due to bad credentials (do you have the right scope for your access token?).");
				}
				if (values[0].Contains("error='invalid_token'"))
				{
					throw new TokenExpiredException("Your request was blocked du to an expired Token. Please refresh your token and update your API instance settings.");
				}
				break;
			}
			case HttpStatusCode.NotFound:
				throw new BadResourceException("The resource you tried to access was not valid.");
			case HttpStatusCode.TooManyRequests:
			{
				string resetTime = httpWebResponse.Headers.Get("Ratelimit-Reset");
				throw new TooManyRequestsException("You have reached your rate limit. Too many requests were made", resetTime);
			}
			default:
				throw e;
			}
		}
	}
}
namespace TwitchLib.Api.Core.Extensions.System
{
	public static class DateTimeExtensions
	{
		public static string ToRfc3339String(this DateTime dateTime)
		{
			return dateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo);
		}
	}
	public static class IEnumerableExtensions
	{
		public static void AddTo<T>(this IEnumerable<T> source, List<T> destination)
		{
			if (source != null)
			{
				destination.AddRange(source);
			}
		}
	}
}
namespace TwitchLib.Api.Core.Extensions.RateLimiter
{
	public static class IAwaitableConstraintExtension
	{
		public static IAwaitableConstraint Compose(this IAwaitableConstraint ac1, IAwaitableConstraint ac2)
		{
			if (ac1 != ac2)
			{
				return (IAwaitableConstraint)(object)new ComposedAwaitableConstraint(ac1, ac2);
			}
			return ac1;
		}
	}
}
namespace TwitchLib.Api.Core.Exceptions
{
	public class BadGatewayException : Exception
	{
		public BadGatewayException(string data)
			: base(data)
		{
		}
	}
	public class BadParameterException : Exception
	{
		public BadParameterException(string badParamData)
			: base(badParamData)
		{
		}
	}
	public class BadRequestException : Exception
	{
		public BadRequestException(string apiData)
			: base(apiData)
		{
		}
	}
	public class BadResourceException : Exception
	{
		public BadResourceException(string apiData)
			: base(apiData)
		{
		}
	}
	public class BadScopeException : Exception
	{
		public BadScopeException(string data)
			: base(data)
		{
		}
	}
	public class BadTokenException : Exception
	{
		public BadTokenException(string data)
			: base(data)
		{
		}
	}
	public class ClientIdAndOAuthTokenRequired : Exception
	{
		public ClientIdAndOAuthTokenRequired(string explanation)
			: base(explanation)
		{
		}
	}
	public class GatewayTimeoutException : Exception
	{
		public GatewayTimeoutException(string data)
			: base(data)
		{
		}
	}
	public class InternalServerErrorException : Exception
	{
		public InternalServerErrorException(string data)
			: base(data)
		{
		}
	}
	public class InvalidCredentialException : Exception
	{
		public InvalidCredentialException(string data)
			: base(data)
		{
		}
	}
	public class TokenExpiredException : Exception
	{
		public TokenExpiredException(string data)
			: base(data)
		{
		}
	}
	public sealed class TooManyRequestsException : Exception
	{
		public TooManyRequestsException(string data, string resetTime)
			: base(data)
		{
			if (double.TryParse(resetTime, out var result))
			{
				Data.Add("Ratelimit-Reset", result);
			}
		}
	}
	public class UnexpectedResponseException : Exception
	{
		public UnexpectedResponseException(string data)
			: base(data)
		{
		}
	}
}
namespace TwitchLib.Api.Core.Common
{
	public static class Helpers
	{
		public static string FormatOAuth(string token)
		{
			if (!token.Contains(" "))
			{
				return token;
			}
			return token.Split(new char[1] { ' ' })[1];
		}

		public static string AuthScopesToString(AuthScopes scope)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected I4, but got Unknown
			return (int)scope switch
			{
				1 => "channel_check_subscription", 
				2 => "channel_commercial", 
				3 => "channel_editor", 
				4 => "channel_feed_edit", 
				5 => "channel_feed_read", 
				9 => "chat:read", 
				11 => "chat:moderate", 
				10 => "chat:edit", 
				6 => "channel_read", 
				7 => "channel_stream", 
				8 => "channel_subscriptions", 
				12 => "collections_edit", 
				13 => "communities_edit", 
				14 => "communities_moderate", 
				21 => "openid", 
				15 => "user_blocks_edit", 
				16 => "user_blocks_read", 
				17 => "user_follows_edit", 
				18 => "user_read", 
				19 => "user_subscriptions", 
				20 => "viewing_activity_read", 
				22 => "analytics:read:extensions", 
				23 => "analytics:read:games", 
				24 => "bits:read", 
				25 => "channel:edit:commercial", 
				26 => "channel:manage:broadcast", 
				27 => "channel:manage:extensions", 
				28 => "channel:manage:moderators", 
				31 => "channel:manage:redemptions", 
				29 => "channel:manage:polls", 
				30 => "channel:manage:predictions", 
				32 => "channel:manage:schedule", 
				33 => "channel:manage:videos", 
				34 => "channel:manage:vips", 
				35 => "channel:read:charity", 
				36 => "channel:read:editors", 
				37 => "channel:read:goals", 
				38 => "channel:read:hype_train", 
				39 => "channel:read:polls", 
				40 => "channel:read:predictions", 
				41 => "channel:read:redemptions", 
				42 => "channel:read:stream_key", 
				43 => "channel:read:subscriptions", 
				44 => "channel:read:vips", 
				45 => "clips:edit", 
				46 => "moderation:read", 
				58 => "user:edit", 
				59 => "user:edit:broadcast", 
				60 => "user:edit:follows", 
				64 => "user:read:blocked_users", 
				65 => "user:read:broadcast", 
				66 => "user:read:email", 
				67 => "user:read:follows", 
				68 => "user:read:subscriptions", 
				61 => "user:manage:blocked_users", 
				62 => "user:manage:chat_color", 
				63 => "user:manage:whispers", 
				49 => "moderator:manage:announcements", 
				50 => "moderator:manage:automod", 
				51 => "moderator:manage:automod_settings", 
				47 => "moderator:manage:banned_users", 
				48 => "moderator:manage:blocked_terms", 
				52 => "moderator:manage:chat_messages", 
				53 => "moderator:manage:chat_settings", 
				55 => "moderator:read:automod_settings", 
				54 => "moderator:read:blocked_terms", 
				56 => "moderator:read:chat_settings", 
				57 => "moderator:read:chatters", 
				_ => "", 
			};
		}

		public static string Base64Encode(string plainText)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(plainText));
		}
	}
}