using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Fleck;
using InteractiveMapCompanion.Config;
using InteractiveMapCompanion.Entities;
using InteractiveMapCompanion.Protocol;
using InteractiveMapCompanion.Server;
using InteractiveMapCompanion.State;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("InteractiveMapCompanion")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e490dd69c4081469154be1c2911480c8a1564cde")]
[assembly: AssemblyProduct("InteractiveMapCompanion")]
[assembly: AssemblyTitle("InteractiveMapCompanion")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 InteractiveMapCompanion
{
	[BepInPlugin("wow-much.interactive-map-companion", "Interactive Map Companion", "2026.214.1")]
	public sealed class Plugin : BaseUnityPlugin
	{
		private ModConfig? _config;

		private IWebSocketServer? _server;

		private IBroadcastLoop? _broadcastLoop;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			_config = new ModConfig(((BaseUnityPlugin)this).Config);
			EntityFinder finder = new EntityFinder();
			EntityClassifier classifier = new EntityClassifier();
			EntityExtractor extractor = new EntityExtractor();
			EntityTrackerAdapter entityTracker = new EntityTrackerAdapter(finder, classifier, extractor, (EntityType _) => true);
			_server = new WebSocketServer(_config, Log);
			_server.Start();
			_broadcastLoop = new BroadcastLoop(entityTracker, _server, _config, delegate(string msg)
			{
				if (_config.ModLogLevel.Value == LogLevel.Debug)
				{
					Log.LogDebug((object)msg);
				}
			});
			SceneManager.sceneLoaded += OnSceneLoaded;
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			_broadcastLoop.OnSceneLoaded(name);
			Log.LogInfo((object)"Interactive Map Companion v2026.214.1 loaded");
		}

		private void Update()
		{
			_broadcastLoop?.Tick(Time.deltaTime);
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_broadcastLoop?.OnSceneLoaded(((Scene)(ref scene)).name);
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			_server?.Stop();
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "wow-much.interactive-map-companion";

		public const string Name = "Interactive Map Companion";

		public const string Version = "2026.214.1";
	}
}
namespace InteractiveMapCompanion.State
{
	public sealed class BroadcastLoop : IBroadcastLoop
	{
		private readonly IEntityTracker _entityTracker;

		private readonly IWebSocketServer _server;

		private readonly ModConfig _config;

		private readonly Action<string>? _log;

		private float _elapsed;

		private string _currentZone = "";

		public BroadcastLoop(IEntityTracker entityTracker, IWebSocketServer server, ModConfig config, Action<string>? log = null)
		{
			_entityTracker = entityTracker;
			_server = server;
			_config = config;
			_log = log;
		}

		public void Tick(float deltaTime)
		{
			_elapsed += deltaTime;
			float num = (float)_config.UpdateInterval.Value / 1000f;
			if (!(_elapsed < num))
			{
				_elapsed = 0f;
				BroadcastState();
			}
		}

		public void OnSceneLoaded(string newZone)
		{
			string currentZone = _currentZone;
			_currentZone = newZone;
			if (!string.IsNullOrEmpty(currentZone) && currentZone != newZone)
			{
				SendZoneChange(currentZone, newZone);
			}
			BroadcastState();
		}

		private void BroadcastState()
		{
			if (_server.ClientCount == 0)
			{
				return;
			}
			try
			{
				IReadOnlyList<EntityData> trackedEntities = _entityTracker.GetTrackedEntities();
				StateUpdateMessage message = StateUpdateMessage.Create(_currentZone, trackedEntities.ToArray());
				string message2 = MessageSerializer.Serialize(message);
				_server.Broadcast(message2);
			}
			catch (Exception ex)
			{
				_log?.Invoke("Error broadcasting state: " + ex.Message);
			}
		}

		private void SendZoneChange(string previousZone, string newZone)
		{
			if (_server.ClientCount == 0)
			{
				return;
			}
			try
			{
				ZoneChangeMessage message = ZoneChangeMessage.Create(previousZone, newZone);
				string message2 = MessageSerializer.Serialize(message);
				_server.Broadcast(message2);
				_log?.Invoke("Zone changed: " + previousZone + " -> " + newZone);
			}
			catch (Exception ex)
			{
				_log?.Invoke("Error sending zone change: " + ex.Message);
			}
		}
	}
	public interface IBroadcastLoop
	{
		void Tick(float deltaTime);

		void OnSceneLoaded(string newZone);
	}
}
namespace InteractiveMapCompanion.Server
{
	public interface IWebSocketServer : IDisposable
	{
		int ClientCount { get; }

		void Start();

		void Stop();

		void Broadcast(string message);
	}
	public class WebSocketServer : IWebSocketServer, IDisposable
	{
		private readonly ModConfig _config;

		private readonly ManualLogSource _logger;

		private readonly ConcurrentDictionary<Guid, IWebSocketConnection> _clients = new ConcurrentDictionary<Guid, IWebSocketConnection>();

		private WebSocketServer? _server;

		private bool _disposed;

		public int ClientCount => _clients.Count;

		public WebSocketServer(ModConfig config, ManualLogSource logger)
		{
			_config = config;
			_logger = logger;
			ConfigureFleckLogging();
		}

		public void Start()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			int value = _config.Port.Value;
			string text = $"ws://0.0.0.0:{value}";
			try
			{
				_server = new WebSocketServer(text, true);
				_server.Start((Action<IWebSocketConnection>)ConfigureSocket);
				_logger.LogInfo((object)("WebSocket server started on " + text));
			}
			catch (Exception ex)
			{
				_logger.LogError((object)$"Failed to start WebSocket server on port {value}: {ex.Message}");
				_logger.LogDebug((object)ex.ToString());
			}
		}

		public void Stop()
		{
			if (_server == null)
			{
				return;
			}
			foreach (IWebSocketConnection value in _clients.Values)
			{
				try
				{
					value.Close();
				}
				catch
				{
				}
			}
			_clients.Clear();
			_server.Dispose();
			_server = null;
			_logger.LogInfo((object)"WebSocket server stopped");
		}

		public void Broadcast(string message)
		{
			foreach (KeyValuePair<Guid, IWebSocketConnection> client in _clients)
			{
				client.Deconstruct(out var key, out var value);
				Guid guid = key;
				IWebSocketConnection val = value;
				try
				{
					if (val.IsAvailable)
					{
						val.Send(message);
					}
					else
					{
						_clients.TryRemove(guid, out value);
					}
				}
				catch (Exception ex)
				{
					_logger.LogWarning((object)$"Failed to send to client {guid}: {ex.Message}");
					_clients.TryRemove(guid, out value);
				}
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				Stop();
				_disposed = true;
			}
		}

		private void ConfigureSocket(IWebSocketConnection socket)
		{
			IWebSocketConnection socket2 = socket;
			socket2.OnOpen = delegate
			{
				OnClientConnected(socket2);
			};
			socket2.OnClose = delegate
			{
				OnClientDisconnected(socket2);
			};
			socket2.OnError = delegate(Exception ex)
			{
				OnClientError(socket2, ex);
			};
			socket2.OnMessage = delegate(string message)
			{
				OnClientMessage(socket2, message);
			};
		}

		private void OnClientConnected(IWebSocketConnection socket)
		{
			_clients[socket.ConnectionInfo.Id] = socket;
			_logger.LogInfo((object)$"Client connected: {socket.ConnectionInfo.ClientIpAddress} (total: {ClientCount})");
			SendHandshake(socket);
		}

		private void OnClientDisconnected(IWebSocketConnection socket)
		{
			_clients.TryRemove(socket.ConnectionInfo.Id, out IWebSocketConnection _);
			_logger.LogInfo((object)$"Client disconnected: {socket.ConnectionInfo.ClientIpAddress} (total: {ClientCount})");
		}

		private void OnClientError(IWebSocketConnection socket, Exception ex)
		{
			_logger.LogWarning((object)("Client error (" + socket.ConnectionInfo.ClientIpAddress + "): " + ex.Message));
			_clients.TryRemove(socket.ConnectionInfo.Id, out IWebSocketConnection _);
		}

		private void OnClientMessage(IWebSocketConnection socket, string message)
		{
			_logger.LogDebug((object)("Received message from " + socket.ConnectionInfo.ClientIpAddress + ": " + message));
		}

		private void SendHandshake(IWebSocketConnection socket)
		{
			string currentZone = GetCurrentZone();
			string[] capabilities = _config.GetCapabilities();
			HandshakeMessage message = HandshakeMessage.Create(currentZone, capabilities);
			string text = MessageSerializer.Serialize(message);
			try
			{
				socket.Send(text);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("Failed to send handshake: " + ex.Message));
			}
		}

		private static string GetCurrentZone()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				return ((Scene)(ref activeScene)).name;
			}
			catch
			{
				return "";
			}
		}

		private void ConfigureFleckLogging()
		{
			FleckLog.LogAction = delegate(LogLevel level, string message, Exception ex)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected I4, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected I4, but got Unknown
				LogLevel value = _config.WebSocketLogLevel.Value;
				if (1 == 0)
				{
				}
				bool flag = (int)level switch
				{
					0 => value == LogLevel.Debug, 
					1 => value == LogLevel.Debug || value == LogLevel.Info, 
					2 => value == LogLevel.Debug || value == LogLevel.Info || value == LogLevel.Warning, 
					3 => true, 
					_ => false, 
				};
				if (1 == 0)
				{
				}
				if (flag)
				{
					switch ((int)level)
					{
					case 0:
						_logger.LogDebug((object)("[Fleck] " + message));
						break;
					case 1:
						_logger.LogInfo((object)("[Fleck] " + message));
						break;
					case 2:
						_logger.LogWarning((object)("[Fleck] " + message));
						break;
					case 3:
						_logger.LogError((object)("[Fleck] " + message));
						if (ex != null)
						{
							_logger.LogDebug((object)ex.ToString());
						}
						break;
					}
				}
			};
		}
	}
}
namespace InteractiveMapCompanion.Protocol
{
	public sealed class HandshakeMessage
	{
		public string Type { get; }

		public string ProtocolVersion { get; }

		public string ModVersion { get; }

		public string Zone { get; }

		public string[] Capabilities { get; }

		public HandshakeMessage(string Type, string ProtocolVersion, string ModVersion, string Zone, string[] Capabilities)
		{
			this.Type = Type;
			this.ProtocolVersion = ProtocolVersion;
			this.ModVersion = ModVersion;
			this.Zone = Zone;
			this.Capabilities = Capabilities;
		}

		public static HandshakeMessage Create(string zone, string[] capabilities)
		{
			return new HandshakeMessage("handshake", "0.2.0", "2026.214.1", zone, capabilities);
		}
	}
	public sealed class StateUpdateMessage
	{
		public string Type { get; }

		public string Zone { get; }

		public long Timestamp { get; }

		public EntityData[] Entities { get; }

		public StateUpdateMessage(string Type, string Zone, long Timestamp, EntityData[] Entities)
		{
			this.Type = Type;
			this.Zone = Zone;
			this.Timestamp = Timestamp;
			this.Entities = Entities;
		}

		public static StateUpdateMessage Create(string zone, EntityData[] entities)
		{
			return new StateUpdateMessage("stateUpdate", zone, DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), entities);
		}
	}
	public sealed class ZoneChangeMessage
	{
		public string Type { get; }

		public string PreviousZone { get; }

		public string Zone { get; }

		public long Timestamp { get; }

		public ZoneChangeMessage(string Type, string PreviousZone, string Zone, long Timestamp)
		{
			this.Type = Type;
			this.PreviousZone = PreviousZone;
			this.Zone = Zone;
			this.Timestamp = Timestamp;
		}

		public static ZoneChangeMessage Create(string previousZone, string zone)
		{
			return new ZoneChangeMessage("zoneChange", previousZone, zone, DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
		}
	}
	public static class MessageSerializer
	{
		private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
		{
			ContractResolver = (IContractResolver)new DefaultContractResolver
			{
				NamingStrategy = (NamingStrategy)new CamelCaseNamingStrategy()
			},
			NullValueHandling = (NullValueHandling)1,
			Formatting = (Formatting)0
		};

		public static string Serialize<T>(T message)
		{
			return JsonConvert.SerializeObject((object)message, Settings);
		}

		public static T? Deserialize<T>(string json)
		{
			return JsonConvert.DeserializeObject<T>(json, Settings);
		}
	}
	public static class ProtocolVersion
	{
		public const string Current = "0.2.0";
	}
}
namespace InteractiveMapCompanion.Entities
{
	public sealed class EntityClassifier : IEntityClassifier
	{
		public EntityType? Classify(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			if (character.MiningNode)
			{
				return null;
			}
			NPC myNPC = character.MyNPC;
			if (myNPC != null && myNPC.TreasureChest)
			{
				return null;
			}
			if ((Object)(object)GameData.PlayerControl?.Myself == (Object)(object)character)
			{
				return EntityType.Player;
			}
			if ((Object)(object)character.Master != (Object)null)
			{
				return EntityType.Pet;
			}
			if ((Object)(object)((Component)character).GetComponent<SimPlayer>() != (Object)null)
			{
				return EntityType.SimPlayer;
			}
			if (IsHostileToPlayer(character))
			{
				return EntityType.NpcEnemy;
			}
			return EntityType.NpcFriendly;
		}

		private static bool IsHostileToPlayer(Character character)
		{
			if (character.AggressiveTowards != null && (character.AggressiveTowards.Contains((Faction)0) || character.AggressiveTowards.Contains((Faction)11)))
			{
				return true;
			}
			if ((Object)(object)character.MyWorldFaction != (Object)null && character.MyWorldFaction.FactionValue <= 0f)
			{
				return true;
			}
			return false;
		}
	}
	public sealed class EntityData
	{
		public int Id { get; }

		public string EntityType { get; }

		public string Name { get; }

		public float[] Position { get; }

		public float Rotation { get; }

		public int? Level { get; }

		public string? Rarity { get; }

		public string? CharacterClass { get; }

		public string? Owner { get; }

		public EntityData(int Id, string EntityType, string Name, float[] Position, float Rotation, int? Level = null, string? Rarity = null, string? CharacterClass = null, string? Owner = null)
		{
			this.Id = Id;
			this.EntityType = EntityType;
			this.Name = Name;
			this.Position = Position;
			this.Rotation = Rotation;
			this.Level = Level;
			this.Rarity = Rarity;
			this.CharacterClass = CharacterClass;
			this.Owner = Owner;
		}
	}
	public sealed class EntityExtractor : IEntityExtractor
	{
		public EntityData Extract(Character character, EntityType entityType)
		{
			//IL_003a: 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)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)character).transform;
			Stats myStats = character.MyStats;
			return new EntityData(((Object)character).GetInstanceID(), EntityTypeToString(entityType), myStats?.MyName ?? ((Object)character).name, new float[3]
			{
				transform.position.x,
				transform.position.y,
				transform.position.z
			}, NormalizeRotation(transform.eulerAngles.y), GetLevel(myStats, entityType), GetRarity(character, entityType), GetCharacterClass(myStats, entityType), GetOwner(character, entityType));
		}

		private static string EntityTypeToString(EntityType type)
		{
			if (1 == 0)
			{
			}
			string result = type switch
			{
				EntityType.Player => "player", 
				EntityType.SimPlayer => "simplayer", 
				EntityType.Pet => "pet", 
				EntityType.NpcFriendly => "npc_friendly", 
				EntityType.NpcEnemy => "npc_enemy", 
				_ => "unknown", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static float NormalizeRotation(float degrees)
		{
			degrees %= 360f;
			if (degrees < 0f)
			{
				degrees += 360f;
			}
			return degrees;
		}

		private static int? GetLevel(Stats? stats, EntityType type)
		{
			return stats?.Level;
		}

		private static string? GetRarity(Character character, EntityType type)
		{
			if (type != EntityType.NpcEnemy)
			{
				return null;
			}
			if (character.BossXp > 1f)
			{
				return "boss";
			}
			return "common";
		}

		private static string? GetCharacterClass(Stats? stats, EntityType type)
		{
			if ((uint)type > 1u)
			{
				return null;
			}
			return stats?.CharacterClass?.DisplayName;
		}

		private static string? GetOwner(Character character, EntityType type)
		{
			if (type != EntityType.Pet)
			{
				return null;
			}
			return character.Master?.MyStats?.MyName ?? "Unknown";
		}
	}
	public sealed class EntityFinder : IEntityFinder
	{
		public IEnumerable<Character> FindAll()
		{
			return Object.FindObjectsOfType<Character>();
		}
	}
	public sealed class EntityTracker<TCharacter> where TCharacter : class
	{
		private readonly Func<IEnumerable<TCharacter>> _findEntities;

		private readonly Func<TCharacter, EntityType?> _classify;

		private readonly Func<TCharacter, EntityType, EntityData> _extract;

		private readonly Func<EntityType, bool> _shouldTrack;

		public EntityTracker(Func<IEnumerable<TCharacter>> findEntities, Func<TCharacter, EntityType?> classify, Func<TCharacter, EntityType, EntityData> extract, Func<EntityType, bool> shouldTrack)
		{
			_findEntities = findEntities;
			_classify = classify;
			_extract = extract;
			_shouldTrack = shouldTrack;
		}

		public IReadOnlyList<EntityData> GetTrackedEntities()
		{
			List<EntityData> list = new List<EntityData>();
			foreach (TCharacter item2 in _findEntities())
			{
				EntityType? entityType = _classify(item2);
				if (entityType.HasValue && _shouldTrack(entityType.Value))
				{
					EntityData item = _extract(item2, entityType.Value);
					list.Add(item);
				}
			}
			return list;
		}
	}
	public sealed class EntityTrackerAdapter : IEntityTracker
	{
		private readonly EntityTracker<Character> _inner;

		public EntityTrackerAdapter(IEntityFinder finder, IEntityClassifier classifier, IEntityExtractor extractor, Func<EntityType, bool> entityFilter)
		{
			_inner = new EntityTracker<Character>(finder.FindAll, classifier.Classify, extractor.Extract, entityFilter);
		}

		public IReadOnlyList<EntityData> GetTrackedEntities()
		{
			return _inner.GetTrackedEntities();
		}
	}
	public enum EntityType
	{
		Player,
		SimPlayer,
		Pet,
		NpcFriendly,
		NpcEnemy
	}
	public interface IEntityClassifier
	{
		EntityType? Classify(Character character);
	}
	public interface IEntityExtractor
	{
		EntityData Extract(Character character, EntityType entityType);
	}
	public interface IEntityFinder
	{
		IEnumerable<Character> FindAll();
	}
	public interface IEntityTracker
	{
		IReadOnlyList<EntityData> GetTrackedEntities();
	}
}
namespace InteractiveMapCompanion.Config
{
	public enum LogLevel
	{
		Debug,
		Info,
		Warning,
		Error
	}
	public class ModConfig
	{
		public ConfigEntry<int> Port { get; }

		public ConfigEntry<int> UpdateInterval { get; }

		public ConfigEntry<bool> EnableSpawnTracking { get; }

		public ConfigEntry<bool> EnableThirdPartyMarkers { get; }

		public ConfigEntry<bool> EnableBidirectional { get; }

		public ConfigEntry<LogLevel> WebSocketLogLevel { get; }

		public ConfigEntry<LogLevel> ModLogLevel { get; }

		public ModConfig(ConfigFile config)
		{
			Port = config.Bind<int>("Server", "Port", 18585, "WebSocket server port. Clients connect to ws://localhost:{port}");
			UpdateInterval = config.Bind<int>("Server", "UpdateInterval", 100, "Interval in milliseconds between state broadcasts to clients");
			EnableSpawnTracking = config.Bind<bool>("Features", "EnableSpawnTracking", true, "Track enemy deaths and broadcast respawn timers");
			EnableThirdPartyMarkers = config.Bind<bool>("Features", "EnableThirdPartyMarkers", true, "Allow other mods to register custom markers via the API");
			EnableBidirectional = config.Bind<bool>("Features", "EnableBidirectional", true, "Accept messages from clients (waypoints, pings, commands)");
			WebSocketLogLevel = config.Bind<LogLevel>("Logging", "WebSocketLogLevel", LogLevel.Warning, "Log level for WebSocket library. Debug shows all messages (verbose), Warning shows only issues (recommended).");
			ModLogLevel = config.Bind<LogLevel>("Logging", "ModLogLevel", LogLevel.Info, "Log level for the mod itself. Debug shows detailed diagnostics, Info shows important events (recommended).");
		}

		public string[] GetCapabilities()
		{
			List<string> list = new List<string> { "entities" };
			if (EnableSpawnTracking.Value)
			{
				list.Add("spawns");
			}
			if (EnableThirdPartyMarkers.Value)
			{
				list.Add("markers");
			}
			if (EnableBidirectional.Value)
			{
				list.Add("bidirectional");
			}
			return list.ToArray();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Fleck.Handlers;
using Fleck.Helpers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("statenjason")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright Jason Staten 2010-2018. All rights reserved.")]
[assembly: AssemblyDescription("C# WebSocket Implementation")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("Fleck")]
[assembly: AssemblyTitle("Fleck")]
[assembly: AssemblyVersion("1.2.0.0")]
namespace Fleck
{
	public class ConnectionNotAvailableException : Exception
	{
		public ConnectionNotAvailableException()
		{
		}

		public ConnectionNotAvailableException(string message)
			: base(message)
		{
		}

		public ConnectionNotAvailableException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public enum LogLevel
	{
		Debug,
		Info,
		Warn,
		Error
	}
	public class FleckLog
	{
		public static LogLevel Level = LogLevel.Info;

		public static Action<LogLevel, string, Exception> LogAction = delegate(LogLevel level, string message, Exception ex)
		{
			if (level >= Level)
			{
				Console.WriteLine("{0} [{1}] {2} {3}", DateTime.Now, level, message, ex);
			}
		};

		public static void Warn(string message, Exception ex = null)
		{
			LogAction(LogLevel.Warn, message, ex);
		}

		public static void Error(string message, Exception ex = null)
		{
			LogAction(LogLevel.Error, message, ex);
		}

		public static void Debug(string message, Exception ex = null)
		{
			LogAction(LogLevel.Debug, message, ex);
		}

		public static void Info(string message, Exception ex = null)
		{
			LogAction(LogLevel.Info, message, ex);
		}
	}
	public enum FrameType : byte
	{
		Continuation = 0,
		Text = 1,
		Binary = 2,
		Close = 8,
		Ping = 9,
		Pong = 10
	}
	public class HandlerFactory
	{
		public static IHandler BuildHandler(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
		{
			switch (GetVersion(request))
			{
			case "76":
				return Draft76Handler.Create(request, onMessage);
			case "7":
			case "8":
			case "13":
				return Hybi13Handler.Create(request, onMessage, onClose, onBinary, onPing, onPong);
			case "policy-file-request":
				return FlashSocketPolicyRequestHandler.Create(request);
			default:
				throw new WebSocketException(1003);
			}
		}

		public static string GetVersion(WebSocketHttpRequest request)
		{
			if (request.Headers.TryGetValue("Sec-WebSocket-Version", out var value))
			{
				return value;
			}
			if (request.Headers.TryGetValue("Sec-WebSocket-Draft", out value))
			{
				return value;
			}
			if (request.Headers.ContainsKey("Sec-WebSocket-Key1"))
			{
				return "76";
			}
			if (request.Body != null && request.Body.ToLower().Contains("policy-file-request"))
			{
				return "policy-file-request";
			}
			return "75";
		}
	}
	public interface IHandler
	{
		byte[] CreateHandshake(string subProtocol = null);

		void Receive(IEnumerable<byte> data);

		byte[] FrameText(string text);

		byte[] FrameBinary(byte[] bytes);

		byte[] FramePing(byte[] bytes);

		byte[] FramePong(byte[] bytes);

		byte[] FrameClose(int code);
	}
	public interface ISocket
	{
		bool Connected { get; }

		string RemoteIpAddress { get; }

		int RemotePort { get; }

		Stream Stream { get; }

		bool NoDelay { get; set; }

		EndPoint LocalEndPoint { get; }

		Task<ISocket> Accept(Action<ISocket> callback, Action<Exception> error);

		Task Send(byte[] buffer, Action callback, Action<Exception> error);

		Task<int> Receive(byte[] buffer, Action<int> callback, Action<Exception> error, int offset = 0);

		Task Authenticate(X509Certificate2 certificate, SslProtocols enabledSslProtocols, Action callback, Action<Exception> error);

		void Dispose();

		void Close();

		void Bind(EndPoint ipLocal);

		void Listen(int backlog);
	}
	public interface IWebSocketConnection
	{
		Action OnOpen { get; set; }

		Action OnClose { get; set; }

		Action<string> OnMessage { get; set; }

		Action<byte[]> OnBinary { get; set; }

		Action<byte[]> OnPing { get; set; }

		Action<byte[]> OnPong { get; set; }

		Action<Exception> OnError { get; set; }

		IWebSocketConnectionInfo ConnectionInfo { get; }

		bool IsAvailable { get; }

		Task Send(string message);

		Task Send(byte[] message);

		Task SendPing(byte[] message);

		Task SendPong(byte[] message);

		void Close();

		void Close(int code);
	}
	public interface IWebSocketConnectionInfo
	{
		string SubProtocol { get; }

		string Origin { get; }

		string Host { get; }

		string Path { get; }

		string ClientIpAddress { get; }

		int ClientPort { get; }

		IDictionary<string, string> Cookies { get; }

		IDictionary<string, string> Headers { get; }

		Guid Id { get; }

		string NegotiatedSubProtocol { get; }
	}
	public interface IWebSocketServer : IDisposable
	{
		void Start(Action<IWebSocketConnection> config);
	}
	public static class IntExtensions
	{
		public static byte[] ToBigEndianBytes<T>(this int source)
		{
			Type typeFromHandle = typeof(T);
			byte[] bytes;
			if (typeFromHandle == typeof(ushort))
			{
				bytes = BitConverter.GetBytes((ushort)source);
			}
			else if (typeFromHandle == typeof(ulong))
			{
				bytes = BitConverter.GetBytes((ulong)source);
			}
			else
			{
				if (!(typeFromHandle == typeof(int)))
				{
					throw new InvalidCastException("Cannot be cast to T");
				}
				bytes = BitConverter.GetBytes(source);
			}
			if (BitConverter.IsLittleEndian)
			{
				Array.Reverse((Array)bytes);
			}
			return bytes;
		}

		public static int ToLittleEndianInt(this byte[] source)
		{
			if (BitConverter.IsLittleEndian)
			{
				Array.Reverse((Array)source);
			}
			if (source.Length == 2)
			{
				return BitConverter.ToUInt16(source, 0);
			}
			if (source.Length == 8)
			{
				return (int)BitConverter.ToUInt64(source, 0);
			}
			throw new ArgumentException("Unsupported Size");
		}
	}
	public class QueuedStream : Stream
	{
		private class WriteData
		{
			public readonly byte[] Buffer;

			public readonly int Offset;

			public readonly int Count;

			public readonly AsyncCallback Callback;

			public readonly object State;

			public readonly QueuedWriteResult AsyncResult;

			public WriteData(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
			{
				Buffer = buffer;
				Offset = offset;
				Count = count;
				Callback = callback;
				State = state;
				AsyncResult = new QueuedWriteResult(state);
			}
		}

		private class QueuedWriteResult : IAsyncResult
		{
			private readonly object _state;

			public Exception Exception { get; set; }

			public IAsyncResult ActualResult { get; set; }

			public object AsyncState => _state;

			public WaitHandle AsyncWaitHandle
			{
				get
				{
					throw new NotSupportedException("Queued write operations do not support wait handle.");
				}
			}

			public bool CompletedSynchronously => false;

			public bool IsCompleted
			{
				get
				{
					if (ActualResult != null)
					{
						return ActualResult.IsCompleted;
					}
					return false;
				}
			}

			public QueuedWriteResult(object state)
			{
				_state = state;
			}
		}

		private readonly Stream _stream;

		private readonly Queue<WriteData> _queue = new Queue<WriteData>();

		private int _pendingWrite;

		private bool _disposed;

		public override bool CanRead => _stream.CanRead;

		public override bool CanSeek => _stream.CanSeek;

		public override bool CanWrite => _stream.CanWrite;

		public override long Length => _stream.Length;

		public override long Position
		{
			get
			{
				return _stream.Position;
			}
			set
			{
				_stream.Position = value;
			}
		}

		public QueuedStream(Stream stream)
		{
			_stream = stream;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return _stream.Read(buffer, offset, count);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return _stream.Seek(offset, origin);
		}

		public override void SetLength(long value)
		{
			_stream.SetLength(value);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException("QueuedStream does not support synchronous write operations yet.");
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return _stream.BeginRead(buffer, offset, count, callback, state);
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			lock (_queue)
			{
				WriteData writeData = new WriteData(buffer, offset, count, callback, state);
				if (_pendingWrite > 0)
				{
					_queue.Enqueue(writeData);
					return writeData.AsyncResult;
				}
				return BeginWriteInternal(buffer, offset, count, callback, state, writeData);
			}
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			return _stream.EndRead(asyncResult);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			if (asyncResult is QueuedWriteResult)
			{
				QueuedWriteResult queuedWriteResult = asyncResult as QueuedWriteResult;
				if (queuedWriteResult.Exception != null)
				{
					throw queuedWriteResult.Exception;
				}
				if (queuedWriteResult.ActualResult == null)
				{
					throw new NotSupportedException("QueuedStream does not support synchronous write operations. Please wait for callback to be invoked before calling EndWrite.");
				}
				return;
			}
			throw new ArgumentException();
		}

		public override void Flush()
		{
			_stream.Flush();
		}

		public override void Close()
		{
			_stream.Close();
		}

		protected override void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				if (disposing)
				{
					_stream.Dispose();
				}
				_disposed = true;
			}
			base.Dispose(disposing);
		}

		private IAsyncResult BeginWriteInternal(byte[] buffer, int offset, int count, AsyncCallback callback, object state, WriteData queued)
		{
			_pendingWrite++;
			IAsyncResult actualResult = _stream.BeginWrite(buffer, offset, count, delegate(IAsyncResult ar)
			{
				queued.AsyncResult.ActualResult = ar;
				try
				{
					_stream.EndWrite(ar);
				}
				catch (Exception exception)
				{
					queued.AsyncResult.Exception = exception;
				}
				lock (_queue)
				{
					_pendingWrite--;
					while (_queue.Count > 0)
					{
						WriteData writeData = _queue.Dequeue();
						try
						{
							writeData.AsyncResult.ActualResult = BeginWriteInternal(writeData.Buffer, writeData.Offset, writeData.Count, writeData.Callback, writeData.State, writeData);
						}
						catch (Exception exception2)
						{
							_pendingWrite--;
							writeData.AsyncResult.Exception = exception2;
							writeData.Callback(writeData.AsyncResult);
							continue;
						}
						break;
					}
					callback(queued.AsyncResult);
				}
			}, state);
			queued.AsyncResult.ActualResult = actualResult;
			return queued.AsyncResult;
		}
	}
	public class ReadState
	{
		public List<byte> Data { get; private set; }

		public FrameType? FrameType { get; set; }

		public ReadState()
		{
			Data = new List<byte>();
		}

		public void Clear()
		{
			Data.Clear();
			FrameType = null;
		}
	}
	public class RequestParser
	{
		private const string pattern = "^(?<method>[^\\s]+)\\s(?<path>[^\\s]+)\\sHTTP\\/1\\.1\\r\\n((?<field_name>[^:\\r\\n]+):(?([^\\r\\n])\\s)*(?<field_value>[^\\r\\n]*)\\r\\n)+\\r\\n(?<body>.+)?";

		private const string FlashSocketPolicyRequestPattern = "^[<]policy-file-request\\s*[/][>]";

		private static readonly Regex _regex = new Regex("^(?<method>[^\\s]+)\\s(?<path>[^\\s]+)\\sHTTP\\/1\\.1\\r\\n((?<field_name>[^:\\r\\n]+):(?([^\\r\\n])\\s)*(?<field_value>[^\\r\\n]*)\\r\\n)+\\r\\n(?<body>.+)?", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex _FlashSocketPolicyRequestRegex = new Regex("^[<]policy-file-request\\s*[/][>]", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		public static WebSocketHttpRequest Parse(byte[] bytes)
		{
			return Parse(bytes, "ws");
		}

		public static WebSocketHttpRequest Parse(byte[] bytes, string scheme)
		{
			string @string = Encoding.UTF8.GetString(bytes);
			Match match = _regex.Match(@string);
			if (!match.Success)
			{
				match = _FlashSocketPolicyRequestRegex.Match(@string);
				if (match.Success)
				{
					return new WebSocketHttpRequest
					{
						Body = @string,
						Bytes = bytes
					};
				}
				return null;
			}
			WebSocketHttpRequest webSocketHttpRequest = new WebSocketHttpRequest
			{
				Method = match.Groups["method"].Value,
				Path = match.Groups["path"].Value,
				Body = match.Groups["body"].Value,
				Bytes = bytes,
				Scheme = scheme
			};
			CaptureCollection captures = match.Groups["field_name"].Captures;
			CaptureCollection captures2 = match.Groups["field_value"].Captures;
			for (int i = 0; i < captures.Count; i++)
			{
				string key = captures[i].ToString();
				string value = captures2[i].ToString();
				webSocketHttpRequest.Headers[key] = value;
			}
			return webSocketHttpRequest;
		}
	}
	public class SocketWrapper : ISocket
	{
		public const uint KeepAliveInterval = 60000u;

		public const uint RetryInterval = 10000u;

		private readonly Socket _socket;

		private Stream _stream;

		private CancellationTokenSource _tokenSource;

		private TaskFactory _taskFactory;

		public string RemoteIpAddress
		{
			get
			{
				if (!(_socket.RemoteEndPoint is IPEndPoint iPEndPoint))
				{
					return null;
				}
				return iPEndPoint.Address.ToString();
			}
		}

		public int RemotePort
		{
			get
			{
				if (!(_socket.RemoteEndPoint is IPEndPoint iPEndPoint))
				{
					return -1;
				}
				return iPEndPoint.Port;
			}
		}

		public bool Connected => _socket.Connected;

		public Stream Stream => _stream;

		public bool NoDelay
		{
			get
			{
				return _socket.NoDelay;
			}
			set
			{
				_socket.NoDelay = value;
			}
		}

		public EndPoint LocalEndPoint => _socket.LocalEndPoint;

		public void SetKeepAlive(Socket socket, uint keepAliveInterval, uint retryInterval)
		{
			int num = 4;
			byte[] array = new byte[num * 3];
			Array.Copy(BitConverter.GetBytes(1u), 0, array, 0, num);
			Array.Copy(BitConverter.GetBytes(keepAliveInterval), 0, array, num, num);
			Array.Copy(BitConverter.GetBytes(retryInterval), 0, array, num * 2, num);
			socket.IOControl(IOControlCode.KeepAliveValues, array, null);
		}

		public SocketWrapper(Socket socket)
		{
			_tokenSource = new CancellationTokenSource();
			_taskFactory = new TaskFactory(_tokenSource.Token);
			_socket = socket;
			if (_socket.Connected)
			{
				_stream = new NetworkStream(_socket);
			}
			if (FleckRuntime.IsRunningOnWindows())
			{
				SetKeepAlive(socket, 60000u, 10000u);
			}
		}

		public Task Authenticate(X509Certificate2 certificate, SslProtocols enabledSslProtocols, Action callback, Action<Exception> error)
		{
			SslStream ssl = new SslStream(_stream, leaveInnerStreamOpen: false);
			_stream = new QueuedStream(ssl);
			Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => ssl.BeginAuthenticateAsServer(certificate, clientCertificateRequired: false, enabledSslProtocols, checkCertificateRevocation: false, cb, s);
			Task task = Task.Factory.FromAsync(beginMethod, ssl.EndAuthenticateAsServer, null);
			task.ContinueWith(delegate
			{
				callback();
			}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
			{
				error(t.Exception);
			}, TaskContinuationOptions.OnlyOnFaulted);
			task.ContinueWith(delegate(Task t)
			{
				error(t.Exception);
			}, TaskContinuationOptions.OnlyOnFaulted);
			return task;
		}

		public void Listen(int backlog)
		{
			_socket.Listen(backlog);
		}

		public void Bind(EndPoint endPoint)
		{
			_socket.Bind(endPoint);
		}

		public Task<int> Receive(byte[] buffer, Action<int> callback, Action<Exception> error, int offset)
		{
			try
			{
				Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => _stream.BeginRead(buffer, offset, buffer.Length, cb, s);
				Task<int> task = Task.Factory.FromAsync(beginMethod, (Func<IAsyncResult, int>)_stream.EndRead, (object?)null);
				task.ContinueWith(delegate(Task<int> t)
				{
					callback(t.Result);
				}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
				{
					error(t.Exception);
				}, TaskContinuationOptions.OnlyOnFaulted);
				task.ContinueWith(delegate(Task<int> t)
				{
					error(t.Exception);
				}, TaskContinuationOptions.OnlyOnFaulted);
				return task;
			}
			catch (Exception obj)
			{
				error(obj);
				return null;
			}
		}

		public Task<ISocket> Accept(Action<ISocket> callback, Action<Exception> error)
		{
			Func<IAsyncResult, ISocket> endMethod = (IAsyncResult r) => (!_tokenSource.Token.IsCancellationRequested) ? new SocketWrapper(_socket.EndAccept(r)) : null;
			Task<ISocket> task = _taskFactory.FromAsync(_socket.BeginAccept, endMethod, null);
			task.ContinueWith(delegate(Task<ISocket> t)
			{
				callback(t.Result);
			}, TaskContinuationOptions.OnlyOnRanToCompletion).ContinueWith(delegate(Task t)
			{
				error(t.Exception);
			}, TaskContinuationOptions.OnlyOnFaulted);
			task.ContinueWith(delegate(Task<ISocket> t)
			{
				error(t.Exception);
			}, TaskContinuationOptions.OnlyOnFaulted);
			return task;
		}

		public void Dispose()
		{
			_tokenSource.Cancel();
			if (_stream != null)
			{
				_stream.Dispose();
			}
			if (_socket != null)
			{
				_socket.Dispose();
			}
		}

		public void Close()
		{
			_tokenSource.Cancel();
			if (_stream != null)
			{
				_stream.Close();
			}
			if (_socket != null)
			{
				_socket.Close();
			}
		}

		public int EndSend(IAsyncResult asyncResult)
		{
			_stream.EndWrite(asyncResult);
			return 0;
		}

		public Task Send(byte[] buffer, Action callback, Action<Exception> error)
		{
			if (_tokenSource.IsCancellationRequested)
			{
				return null;
			}
			try
			{
				Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => _stream.BeginWrite(buffer, 0, buffer.Length, cb, s);
				Task task = Task.Factory.FromAsync(beginMethod, _stream.EndWrite, null);
				task.ContinueWith(delegate
				{
					callback();
				}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
				{
					error(t.Exception);
				}, TaskContinuationOptions.OnlyOnFaulted);
				task.ContinueWith(delegate(Task t)
				{
					error(t.Exception);
				}, TaskContinuationOptions.OnlyOnFaulted);
				return task;
			}
			catch (Exception obj)
			{
				error(obj);
				return null;
			}
		}
	}
	public class SubProtocolNegotiationFailureException : Exception
	{
		public SubProtocolNegotiationFailureException()
		{
		}

		public SubProtocolNegotiationFailureException(string message)
			: base(message)
		{
		}

		public SubProtocolNegotiationFailureException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public static class SubProtocolNegotiator
	{
		public static string Negotiate(IEnumerable<string> server, IEnumerable<string> client)
		{
			if (!server.Any() || !client.Any())
			{
				return null;
			}
			IEnumerable<string> source = client.Intersect(server);
			if (!source.Any())
			{
				throw new SubProtocolNegotiationFailureException("Unable to negotiate a subprotocol");
			}
			return source.First();
		}
	}
	public class WebSocketConnection : IWebSocketConnection
	{
		private readonly Action<IWebSocketConnection> _initialize;

		private readonly Func<WebSocketHttpRequest, IHandler> _handlerFactory;

		private readonly Func<IEnumerable<string>, string> _negotiateSubProtocol;

		private readonly Func<byte[], WebSocketHttpRequest> _parseRequest;

		private bool _closing;

		private bool _closed;

		private const int ReadSize = 4096;

		public ISocket Socket { get; set; }

		public IHandler Handler { get; set; }

		public Action OnOpen { get; set; }

		public Action OnClose { get; set; }

		public Action<string> OnMessage { get; set; }

		public Action<byte[]> OnBinary { get; set; }

		public Action<byte[]> OnPing { get; set; }

		public Action<byte[]> OnPong { get; set; }

		public Action<Exception> OnError { get; set; }

		public IWebSocketConnectionInfo ConnectionInfo { get; private set; }

		public bool IsAvailable
		{
			get
			{
				if (!_closing && !_closed)
				{
					return Socket.Connected;
				}
				return false;
			}
		}

		public WebSocketConnection(ISocket socket, Action<IWebSocketConnection> initialize, Func<byte[], WebSocketHttpRequest> parseRequest, Func<WebSocketHttpRequest, IHandler> handlerFactory, Func<IEnumerable<string>, string> negotiateSubProtocol)
		{
			Socket = socket;
			OnOpen = delegate
			{
			};
			OnClose = delegate
			{
			};
			OnMessage = delegate
			{
			};
			OnBinary = delegate
			{
			};
			OnPing = delegate(byte[] x)
			{
				SendPong(x);
			};
			OnPong = delegate
			{
			};
			OnError = delegate
			{
			};
			_initialize = initialize;
			_handlerFactory = handlerFactory;
			_parseRequest = parseRequest;
			_negotiateSubProtocol = negotiateSubProtocol;
		}

		public Task Send(string message)
		{
			return Send(message, Handler.FrameText);
		}

		public Task Send(byte[] message)
		{
			return Send(message, Handler.FrameBinary);
		}

		public Task SendPing(byte[] message)
		{
			return Send(message, Handler.FramePing);
		}

		public Task SendPong(byte[] message)
		{
			return Send(message, Handler.FramePong);
		}

		private Task Send<T>(T message, Func<T, byte[]> createFrame)
		{
			if (Handler == null)
			{
				throw new InvalidOperationException("Cannot send before handshake");
			}
			if (!IsAvailable)
			{
				FleckLog.Warn("Data sent while closing or after close. Ignoring.");
				TaskCompletionSource<object> taskCompletionSource = new TaskCompletionSource<object>();
				taskCompletionSource.SetException(new ConnectionNotAvailableException("Data sent while closing or after close. Ignoring."));
				return taskCompletionSource.Task;
			}
			byte[] bytes = createFrame(message);
			return SendBytes(bytes);
		}

		public void StartReceiving()
		{
			List<byte> data = new List<byte>(4096);
			byte[] buffer = new byte[4096];
			Read(data, buffer);
		}

		public void Close()
		{
			Close(1000);
		}

		public void Close(int code)
		{
			if (!IsAvailable)
			{
				return;
			}
			_closing = true;
			if (Handler == null)
			{
				CloseSocket();
				return;
			}
			byte[] array = Handler.FrameClose(code);
			if (array.Length == 0)
			{
				CloseSocket();
			}
			else
			{
				SendBytes(array, CloseSocket);
			}
		}

		public void CreateHandler(IEnumerable<byte> data)
		{
			WebSocketHttpRequest webSocketHttpRequest = _parseRequest(data.ToArray());
			if (webSocketHttpRequest != null)
			{
				Handler = _handlerFactory(webSocketHttpRequest);
				if (Handler != null)
				{
					string text = _negotiateSubProtocol(webSocketHttpRequest.SubProtocols);
					ConnectionInfo = WebSocketConnectionInfo.Create(webSocketHttpRequest, Socket.RemoteIpAddress, Socket.RemotePort, text);
					_initialize(this);
					byte[] bytes = Handler.CreateHandshake(text);
					SendBytes(bytes, OnOpen);
				}
			}
		}

		private void Read(List<byte> data, byte[] buffer)
		{
			if (!IsAvailable)
			{
				return;
			}
			Socket.Receive(buffer, delegate(int r)
			{
				if (r <= 0)
				{
					FleckLog.Debug("0 bytes read. Closing.");
					CloseSocket();
				}
				else
				{
					FleckLog.Debug(r + " bytes read");
					IEnumerable<byte> enumerable = buffer.Take(r);
					if (Handler != null)
					{
						Handler.Receive(enumerable);
					}
					else
					{
						data.AddRange(enumerable);
						CreateHandler(data);
					}
					Read(data, buffer);
				}
			}, HandleReadError);
		}

		private void HandleReadError(Exception e)
		{
			if (e is AggregateException)
			{
				AggregateException ex = e as AggregateException;
				HandleReadError(ex.InnerException);
				return;
			}
			if (e is ObjectDisposedException)
			{
				FleckLog.Debug("Swallowing ObjectDisposedException", e);
				return;
			}
			OnError(e);
			if (e is WebSocketException)
			{
				FleckLog.Debug("Error while reading", e);
				Close(((WebSocketException)e).StatusCode);
			}
			else if (e is SubProtocolNegotiationFailureException)
			{
				FleckLog.Debug(e.Message);
				Close(1002);
			}
			else if (e is IOException)
			{
				FleckLog.Debug("Error while reading", e);
				Close(1006);
			}
			else
			{
				FleckLog.Error("Application Error", e);
				Close(1011);
			}
		}

		private Task SendBytes(byte[] bytes, Action callback = null)
		{
			return Socket.Send(bytes, delegate
			{
				FleckLog.Debug("Sent " + bytes.Length + " bytes");
				if (callback != null)
				{
					callback();
				}
			}, delegate(Exception e)
			{
				if (e is IOException)
				{
					FleckLog.Debug("Failed to send. Disconnecting.", e);
				}
				else
				{
					FleckLog.Info("Failed to send. Disconnecting.", e);
				}
				CloseSocket();
			});
		}

		private void CloseSocket()
		{
			_closing = true;
			OnClose();
			_closed = true;
			Socket.Close();
			Socket.Dispose();
			_closing = false;
		}
	}
	public class WebSocketConnectionInfo : IWebSocketConnectionInfo
	{
		private const string CookiePattern = "((;)*(\\s)*(?<cookie_name>[^=]+)=(?<cookie_value>[^\\;]+))+";

		private static readonly Regex CookieRegex = new Regex("((;)*(\\s)*(?<cookie_name>[^=]+)=(?<cookie_value>[^\\;]+))+", RegexOptions.Compiled);

		public string NegotiatedSubProtocol { get; private set; }

		public string SubProtocol { get; private set; }

		public string Origin { get; private set; }

		public string Host { get; private set; }

		public string Path { get; private set; }

		public string ClientIpAddress { get; set; }

		public int ClientPort { get; set; }

		public Guid Id { get; set; }

		public IDictionary<string, string> Cookies { get; private set; }

		public IDictionary<string, string> Headers { get; private set; }

		public static WebSocketConnectionInfo Create(WebSocketHttpRequest request, string clientIp, int clientPort, string negotiatedSubprotocol)
		{
			WebSocketConnectionInfo webSocketConnectionInfo = new WebSocketConnectionInfo
			{
				Origin = (request["Origin"] ?? request["Sec-WebSocket-Origin"]),
				Host = request["Host"],
				SubProtocol = request["Sec-WebSocket-Protocol"],
				Path = request.Path,
				ClientIpAddress = clientIp,
				ClientPort = clientPort,
				NegotiatedSubProtocol = negotiatedSubprotocol,
				Headers = new Dictionary<string, string>(request.Headers, StringComparer.InvariantCultureIgnoreCase)
			};
			string text = request["Cookie"];
			if (text != null)
			{
				Match match = CookieRegex.Match(text);
				CaptureCollection captures = match.Groups["cookie_name"].Captures;
				CaptureCollection captures2 = match.Groups["cookie_value"].Captures;
				for (int i = 0; i < captures.Count; i++)
				{
					string key = captures[i].ToString();
					string value = captures2[i].ToString();
					webSocketConnectionInfo.Cookies[key] = value;
				}
			}
			return webSocketConnectionInfo;
		}

		private WebSocketConnectionInfo()
		{
			Cookies = new Dictionary<string, string>();
			Id = Guid.NewGuid();
		}
	}
	public class WebSocketException : Exception
	{
		public ushort StatusCode { get; private set; }

		public WebSocketException(ushort statusCode)
		{
			StatusCode = statusCode;
		}

		public WebSocketException(ushort statusCode, string message)
			: base(message)
		{
			StatusCode = statusCode;
		}

		public WebSocketException(ushort statusCode, string message, Exception innerException)
			: base(message, innerException)
		{
			StatusCode = statusCode;
		}
	}
	public class WebSocketHttpRequest
	{
		private readonly IDictionary<string, string> _headers = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);

		public string Method { get; set; }

		public string Path { get; set; }

		public string Body { get; set; }

		public string Scheme { get; set; }

		public byte[] Bytes { get; set; }

		public string this[string name]
		{
			get
			{
				if (!_headers.TryGetValue(name, out var value))
				{
					return null;
				}
				return value;
			}
		}

		public IDictionary<string, string> Headers => _headers;

		public string[] SubProtocols
		{
			get
			{
				if (!_headers.TryGetValue("Sec-WebSocket-Protocol", out var value))
				{
					return new string[0];
				}
				return value.Split(new char[2] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
			}
		}
	}
	public class WebSocketServer : IWebSocketServer, IDisposable
	{
		private readonly string _scheme;

		private readonly IPAddress _locationIP;

		private Action<IWebSocketConnection> _config;

		public ISocket ListenerSocket { get; set; }

		public string Location { get; private set; }

		public bool SupportDualStack { get; }

		public int Port { get; private set; }

		public X509Certificate2 Certificate { get; set; }

		public SslProtocols EnabledSslProtocols { get; set; }

		public IEnumerable<string> SupportedSubProtocols { get; set; }

		public bool RestartAfterListenError { get; set; }

		public bool IsSecure
		{
			get
			{
				if (_scheme == "wss")
				{
					return Certificate != null;
				}
				return false;
			}
		}

		public WebSocketServer(string location, bool supportDualStack = true)
		{
			Uri uri = new Uri(location);
			Port = uri.Port;
			Location = location;
			SupportDualStack = supportDualStack;
			_locationIP = ParseIPAddress(uri);
			_scheme = uri.Scheme;
			Socket socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
			socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
			if (SupportDualStack && !FleckRuntime.IsRunningOnMono() && FleckRuntime.IsRunningOnWindows())
			{
				socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, optionValue: false);
			}
			ListenerSocket = new SocketWrapper(socket);
			SupportedSubProtocols = new string[0];
		}

		public void Dispose()
		{
			ListenerSocket.Dispose();
		}

		private IPAddress ParseIPAddress(Uri uri)
		{
			string host = uri.Host;
			if (host == "0.0.0.0")
			{
				return IPAddress.Any;
			}
			if (host == "[0000:0000:0000:0000:0000:0000:0000:0000]")
			{
				return IPAddress.IPv6Any;
			}
			try
			{
				return IPAddress.Parse(host);
			}
			catch (Exception innerException)
			{
				throw new FormatException("Failed to parse the IP address part of the location. Please make sure you specify a valid IP address. Use 0.0.0.0 or [::] to listen on all interfaces.", innerException);
			}
		}

		public void Start(Action<IWebSocketConnection> config)
		{
			IPEndPoint ipLocal = new IPEndPoint(_locationIP, Port);
			ListenerSocket.Bind(ipLocal);
			ListenerSocket.Listen(100);
			Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
			FleckLog.Info($"Server started at {Location} (actual port {Port})");
			if (_scheme == "wss")
			{
				if (Certificate == null)
				{
					FleckLog.Error("Scheme cannot be 'wss' without a Certificate");
					return;
				}
				if (EnabledSslProtocols == SslProtocols.None)
				{
					EnabledSslProtocols = SslProtocols.Tls;
					FleckLog.Debug("Using default TLS 1.0 security protocol.");
				}
			}
			ListenForClients();
			_config = config;
		}

		private void ListenForClients()
		{
			ListenerSocket.Accept(OnClientConnect, delegate(Exception e)
			{
				FleckLog.Error("Listener socket is closed", e);
				if (RestartAfterListenError)
				{
					FleckLog.Info("Listener socket restarting");
					try
					{
						ListenerSocket.Dispose();
						Socket socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
						ListenerSocket = new SocketWrapper(socket);
						Start(_config);
						FleckLog.Info("Listener socket restarted");
					}
					catch (Exception ex)
					{
						FleckLog.Error("Listener could not be restarted", ex);
					}
				}
			});
		}

		private void OnClientConnect(ISocket clientSocket)
		{
			if (clientSocket == null)
			{
				return;
			}
			FleckLog.Debug($"Client connected from {clientSocket.RemoteIpAddress}:{clientSocket.RemotePort.ToString()}");
			ListenForClients();
			WebSocketConnection connection = null;
			connection = new WebSocketConnection(clientSocket, _config, (byte[] bytes) => RequestParser.Parse(bytes, _scheme), (WebSocketHttpRequest r) => HandlerFactory.BuildHandler(r, delegate(string s)
			{
				connection.OnMessage(s);
			}, connection.Close, delegate(byte[] b)
			{
				connection.OnBinary(b);
			}, delegate(byte[] b)
			{
				connection.OnPing(b);
			}, delegate(byte[] b)
			{
				connection.OnPong(b);
			}), (IEnumerable<string> s) => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
			if (IsSecure)
			{
				FleckLog.Debug("Authenticating Secure Connection");
				clientSocket.Authenticate(Certificate, EnabledSslProtocols, connection.StartReceiving, delegate(Exception e)
				{
					FleckLog.Warn("Failed to Authenticate", e);
				});
			}
			else
			{
				connection.StartReceiving();
			}
		}
	}
	public static class WebSocketStatusCodes
	{
		public const ushort NormalClosure = 1000;

		public const ushort GoingAway = 1001;

		public const ushort ProtocolError = 1002;

		public const ushort UnsupportedDataType = 1003;

		public const ushort NoStatusReceived = 1005;

		public const ushort AbnormalClosure = 1006;

		public const ushort InvalidFramePayloadData = 1007;

		public const ushort PolicyViolation = 1008;

		public const ushort MessageTooBig = 1009;

		public const ushort MandatoryExt = 1010;

		public const ushort InternalServerError = 1011;

		public const ushort TLSHandshake = 1015;

		public const ushort ApplicationError = 3000;

		public static ushort[] ValidCloseCodes = new ushort[9] { 1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011 };
	}
}
namespace Fleck.Helpers
{
	internal static class FleckRuntime
	{
		public static bool IsRunningOnMono()
		{
			return Type.GetType("Mono.Runtime") != null;
		}

		public static bool IsRunningOnWindows()
		{
			return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
		}
	}
}
namespace Fleck.Handlers
{
	public class ComposableHandler : IHandler
	{
		public Func<string, byte[]> Handshake = (string s) => new byte[0];

		public Func<string, byte[]> TextFrame = (string x) => new byte[0];

		public Func<byte[], byte[]> BinaryFrame = (byte[] x) => new byte[0];

		public Action<List<byte>> ReceiveData = delegate
		{
		};

		public Func<byte[], byte[]> PingFrame = (byte[] i) => new byte[0];

		public Func<byte[], byte[]> PongFrame = (byte[] i) => new byte[0];

		public Func<int, byte[]> CloseFrame = (int i) => new byte[0];

		private readonly List<byte> _data = new List<byte>();

		public byte[] CreateHandshake(string subProtocol = null)
		{
			return Handshake(subProtocol);
		}

		public void Receive(IEnumerable<byte> data)
		{
			_data.AddRange(data);
			ReceiveData(_data);
		}

		public byte[] FrameText(string text)
		{
			return TextFrame(text);
		}

		public byte[] FrameBinary(byte[] bytes)
		{
			return BinaryFrame(bytes);
		}

		public byte[] FramePing(byte[] bytes)
		{
			return PingFrame(bytes);
		}

		public byte[] FramePong(byte[] bytes)
		{
			return PongFrame(bytes);
		}

		public byte[] FrameClose(int code)
		{
			return CloseFrame(code);
		}
	}
	public static class Draft76Handler
	{
		private const byte End = byte.MaxValue;

		private const byte Start = 0;

		private const int MaxSize = 5242880;

		public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage)
		{
			return new ComposableHandler
			{
				TextFrame = FrameText,
				Handshake = (string sub) => Handshake(request, sub),
				ReceiveData = delegate(List<byte> data)
				{
					ReceiveData(onMessage, data);
				}
			};
		}

		public static void ReceiveData(Action<string> onMessage, List<byte> data)
		{
			while (data.Count > 0)
			{
				if (data[0] != 0)
				{
					throw new WebSocketException(1007);
				}
				int num = data.IndexOf(byte.MaxValue);
				if (num < 0)
				{
					break;
				}
				if (num > 5242880)
				{
					throw new WebSocketException(1009);
				}
				byte[] bytes = data.Skip(1).Take(num - 1).ToArray();
				data.RemoveRange(0, num + 1);
				string @string = Encoding.UTF8.GetString(bytes);
				onMessage(@string);
			}
		}

		public static byte[] FrameText(string data)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(data);
			byte[] array = new byte[bytes.Length + 2];
			array[0] = 0;
			array[^1] = byte.MaxValue;
			Array.Copy(bytes, 0, array, 1, bytes.Length);
			return array;
		}

		public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
		{
			FleckLog.Debug("Building Draft76 Response");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
			stringBuilder.Append("Upgrade: WebSocket\r\n");
			stringBuilder.Append("Connection: Upgrade\r\n");
			stringBuilder.AppendFormat("Sec-WebSocket-Origin: {0}\r\n", request["Origin"]);
			stringBuilder.AppendFormat("Sec-WebSocket-Location: {0}://{1}{2}\r\n", request.Scheme, request["Host"], request.Path);
			if (subProtocol != null)
			{
				stringBuilder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
			}
			stringBuilder.Append("\r\n");
			string key = request["Sec-WebSocket-Key1"];
			string key2 = request["Sec-WebSocket-Key2"];
			ArraySegment<byte> challenge = new ArraySegment<byte>(request.Bytes, request.Bytes.Length - 8, 8);
			byte[] array = CalculateAnswerBytes(key, key2, challenge);
			byte[] array2 = Encoding.ASCII.GetBytes(stringBuilder.ToString());
			int num = array2.Length;
			Array.Resize(ref array2, num + array.Length);
			Array.Copy(array, 0, array2, num, array.Length);
			return array2;
		}

		public static byte[] CalculateAnswerBytes(string key1, string key2, ArraySegment<byte> challenge)
		{
			byte[] sourceArray = ParseKey(key1);
			byte[] sourceArray2 = ParseKey(key2);
			byte[] array = new byte[16];
			Array.Copy(sourceArray, 0, array, 0, 4);
			Array.Copy(sourceArray2, 0, array, 4, 4);
			Array.Copy(challenge.Array, challenge.Offset, array, 8, 8);
			return MD5.Create().ComputeHash(array);
		}

		private static byte[] ParseKey(string key)
		{
			int num = key.Count((char x) => x == ' ');
			byte[] bytes = BitConverter.GetBytes((int)(long.Parse(new string(key.Where(char.IsDigit).ToArray())) / num));
			if (BitConverter.IsLittleEndian)
			{
				Array.Reverse((Array)bytes);
			}
			return bytes;
		}
	}
	public class FlashSocketPolicyRequestHandler
	{
		public static string PolicyResponse = "<?xml version=\"1.0\"?>\n<cross-domain-policy>\n   <allow-access-from domain=\"*\" to-ports=\"*\"/>\n   <site-control permitted-cross-domain-policies=\"all\"/>\n</cross-domain-policy>\n\0";

		public static IHandler Create(WebSocketHttpRequest request)
		{
			return new ComposableHandler
			{
				Handshake = (string sub) => Handshake(request, sub)
			};
		}

		public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
		{
			FleckLog.Debug("Building Flash Socket Policy Response");
			return Encoding.UTF8.GetBytes(PolicyResponse);
		}
	}
	public static class Hybi13Handler
	{
		private const string WebSocketResponseGuid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

		public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
		{
			ReadState readState = new ReadState();
			return new ComposableHandler
			{
				Handshake = (string sub) => BuildHandshake(request, sub),
				TextFrame = (string s) => FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
				BinaryFrame = (byte[] s) => FrameData(s, FrameType.Binary),
				PingFrame = (byte[] s) => FrameData(s, FrameType.Ping),
				PongFrame = (byte[] s) => FrameData(s, FrameType.Pong),
				CloseFrame = (int i) => FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
				ReceiveData = delegate(List<byte> d)
				{
					ReceiveData(d, readState, delegate(FrameType op, byte[] data)
					{
						ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong);
					});
				}
			};
		}

		public static byte[] FrameData(byte[] payload, FrameType frameType)
		{
			MemoryStream memoryStream = new MemoryStream();
			byte value = (byte)(frameType + 128);
			memoryStream.WriteByte(value);
			if (payload.Length > 65535)
			{
				memoryStream.WriteByte(127);
				byte[] array = payload.Length.ToBigEndianBytes<ulong>();
				memoryStream.Write(array, 0, array.Length);
			}
			else if (payload.Length > 125)
			{
				memoryStream.WriteByte(126);
				byte[] array2 = payload.Length.ToBigEndianBytes<ushort>();
				memoryStream.Write(array2, 0, array2.Length);
			}
			else
			{
				memoryStream.WriteByte((byte)payload.Length);
			}
			memoryStream.Write(payload, 0, payload.Length);
			return memoryStream.ToArray();
		}

		public static void ReceiveData(List<byte> data, ReadState readState, Action<FrameType, byte[]> processFrame)
		{
			while (data.Count >= 2)
			{
				bool flag = (data[0] & 0x80) != 0;
				int num = data[0] & 0x70;
				FrameType frameType = (FrameType)(data[0] & 0xFu);
				bool num2 = (data[1] & 0x80) != 0;
				int num3 = data[1] & 0x7F;
				if (!num2 || !Enum.IsDefined(typeof(FrameType), frameType) || num != 0 || (frameType == FrameType.Continuation && !readState.FrameType.HasValue))
				{
					throw new WebSocketException(1002);
				}
				int num4 = 2;
				int num5;
				switch (num3)
				{
				case 127:
					if (data.Count < num4 + 8)
					{
						return;
					}
					num5 = data.Skip(num4).Take(8).ToArray()
						.ToLittleEndianInt();
					num4 += 8;
					break;
				case 126:
					if (data.Count < num4 + 2)
					{
						return;
					}
					num5 = data.Skip(num4).Take(2).ToArray()
						.ToLittleEndianInt();
					num4 += 2;
					break;
				default:
					num5 = num3;
					break;
				}
				if (data.Count < num4 + 4)
				{
					break;
				}
				byte[] array = data.Skip(num4).Take(4).ToArray();
				num4 += 4;
				if (data.Count < num4 + num5)
				{
					break;
				}
				byte[] array2 = new byte[num5];
				for (int i = 0; i < num5; i++)
				{
					array2[i] = (byte)(data[num4 + i] ^ array[i % 4]);
				}
				readState.Data.AddRange(array2);
				data.RemoveRange(0, num4 + num5);
				if (frameType != 0)
				{
					readState.FrameType = frameType;
				}
				if (flag && readState.FrameType.HasValue)
				{
					byte[] arg = readState.Data.ToArray();
					FrameType? frameType2 = readState.FrameType;
					readState.Clear();
					processFrame(frameType2.Value, arg);
				}
			}
		}

		public static void ProcessFrame(FrameType frameType, byte[] data, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
		{
			switch (frameType)
			{
			case FrameType.Close:
				if (data.Length == 1 || data.Length > 125)
				{
					throw new WebSocketException(1002);
				}
				if (data.Length >= 2)
				{
					ushort num = (ushort)data.Take(2).ToArray().ToLittleEndianInt();
					if (!WebSocketStatusCodes.ValidCloseCodes.Contains(num) && (num < 3000 || num > 4999))
					{
						throw new WebSocketException(1002);
					}
				}
				if (data.Length > 2)
				{
					ReadUTF8PayloadData(data.Skip(2).ToArray());
				}
				onClose();
				break;
			case FrameType.Binary:
				onBinary(data);
				break;
			case FrameType.Ping:
				onPing(data);
				break;
			case FrameType.Pong:
				onPong(data);
				break;
			case FrameType.Text:
				onMessage(ReadUTF8PayloadData(data));
				break;
			default:
				FleckLog.Debug("Received unhandled " + frameType);
				break;
			}
		}

		public static byte[] BuildHandshake(WebSocketHttpRequest request, string subProtocol)
		{
			FleckLog.Debug("Building Hybi-14 Response");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("HTTP/1.1 101 Switching Protocols\r\n");
			stringBuilder.Append("Upgrade: websocket\r\n");
			stringBuilder.Append("Connection: Upgrade\r\n");
			if (subProtocol != null)
			{
				stringBuilder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
			}
			string arg = CreateResponseKey(request["Sec-WebSocket-Key"]);
			stringBuilder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", arg);
			stringBuilder.Append("\r\n");
			return Encoding.ASCII.GetBytes(stringBuilder.ToString());
		}

		public static string CreateResponseKey(string requestKey)
		{
			string s = requestKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
			return Convert.ToBase64String(SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(s)));
		}

		private static string ReadUTF8PayloadData(byte[] bytes)
		{
			UTF8Encoding uTF8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
			try
			{
				return uTF8Encoding.GetString(bytes);
			}
			catch (ArgumentException)
			{
				throw new WebSocketException(1007);
			}
		}
	}
}