using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BingoSyncAPI.NetworkHandler;
using Json.Net;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BingoSyncAPI")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BingoSyncAPI")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: Guid("e17f78c3-4a6b-4c43-b1ef-a454f8ae2f36")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BingoSyncAPI
{
	public class BingoSync
	{
		public delegate void MessageReceived(BingoSyncTypes.SocketMessage socketMessage);

		public enum ConnectionStatus
		{
			Connected,
			Connecting,
			Disconnecting,
			Disconnected
		}

		private const string URL_BingoSync = "https://bingosync.com/";

		private const string URL_BignoSyncBoard = "https://bingosync.com/room/{0}/board";

		private const string URL_BignoSyncFeed = "https://bingosync.com/room/{0}/feed";

		private const string URL_BignoSyncDisconnect = "https://bingosync.com/room/{0}/disconnect";

		private const string URL_BignoSyncSettings = "https://bingosync.com/room/{0}/room-settings";

		private const string URL_API_Select = "https://bingosync.com/api/select";

		private const string URL_API_Chat = "https://bingosync.com/api/chat";

		private const string URL_API_Color = "https://bingosync.com/api/color";

		private const string URL_API_Reveal = "https://bingosync.com/api/revealed";

		private const string URL_API_NewCard = "https://bingosync.com/api/new-card";

		private const string URL_API_JoinRoom = "https://bingosync.com/api/join-room";

		private readonly Uri WSS_BingoSync = new Uri("wss://sockets.bingosync.com/broadcast");

		private WebSocketHandler socketHandler;

		public static bool DebugMode;

		private bool _boardUpdating;

		private bool _boardAwaiting;

		private string _board;

		private BingoSyncTypes.SlotInfo[] _boardSlots;

		private BingoSyncTypes.RoomSettings _roomSettings;

		private bool _waitForColor;

		public CookieContainer SessionCookies { get; private set; }

		public ConnectionStatus Status { get; private set; } = ConnectionStatus.Disconnected;


		public bool HasAnyConnection
		{
			get
			{
				if (Status != 0 && Status != ConnectionStatus.Connecting)
				{
					return Status == ConnectionStatus.Disconnecting;
				}
				return true;
			}
		}

		public BingoSyncTypes.RoomInfo CurrentRoomInfo { get; private set; }

		public event MessageReceived OnMessageReceived;

		private void MessagePassthrough(string message)
		{
			if (Status == ConnectionStatus.Disconnected)
			{
				return;
			}
			if (message == "Socket Closed")
			{
				LeaveRoom();
				return;
			}
			BingoSyncTypes.SocketMessage socketMessage = new BingoSyncTypes.SocketMessage();
			try
			{
				socketMessage = JsonNet.Deserialize<BingoSyncTypes.SocketMessage>(message);
				socketMessage.originalMsg = message;
			}
			catch
			{
				return;
			}
			if (socketMessage.type == "new-card")
			{
				_boardUpdating = true;
				UpdateBoard();
			}
			else if (socketMessage.type == "goal" && socketMessage.square?.slot != null)
			{
				UpdateBoardSlot(socketMessage.square);
			}
			this.OnMessageReceived?.Invoke(socketMessage);
		}

		public async Task<string> GetResponse(string URL, bool returnResponse, string post = null)
		{
			if (SessionCookies == null)
			{
				return string.Empty;
			}
			return await HttpWebHandler.TryGetResponse(URL, returnResponse, SessionCookies, post);
		}

		public async Task<BingoSyncTypes.CardIDs> GetCardIDs(string gameTitle, string variantTitle = "Normal", string suppliedHTML = null)
		{
			int result = 0;
			int result2 = 0;
			string text = suppliedHTML;
			if (suppliedHTML == null)
			{
				text = await GetResponse("https://bingosync.com/", returnResponse: true);
			}
			if (text == null || text == string.Empty)
			{
				return null;
			}
			try
			{
				Match match = Regex.Match(text, "value=\"(?<=)(.*?)(?=)\".?>" + Regex.Escape(gameTitle).Trim() + "</option>", RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
				if (match.Groups.Count < 2 || !int.TryParse(match.Groups[1].Value, out result))
				{
					return null;
				}
				Match match2 = Regex.Match(text, $"value=\"(?<=)(.*?)(?=)\".?data-group=\"(?<=){result}(?=)\".*?>{Regex.Escape(variantTitle).Trim()}</option>", RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
				if (match2.Groups.Count < 2 || !int.TryParse(match2.Groups[1].Value, out result2))
				{
					return null;
				}
				return new BingoSyncTypes.CardIDs(result, result2);
			}
			catch
			{
				return null;
			}
		}

		public async Task<ConnectionStatus> JoinRoom(BingoSyncTypes.RoomInfo roomInfo)
		{
			if (HasAnyConnection)
			{
				return Status;
			}
			Status = ConnectionStatus.Connecting;
			CurrentRoomInfo = null;
			SessionCookies = await HttpWebHandler.TryGetCookies(HttpWebHandler.TryGetRequest("https://bingosync.com/"));
			if (SessionCookies == null)
			{
				return Status = ConnectionStatus.Disconnected;
			}
			string text = await GetResponse("https://bingosync.com/api/join-room", returnResponse: true, BingoSyncPost.JoinRoom(roomInfo.RoomID, roomInfo.PlayerName, roomInfo.RoomPassword, roomInfo.Spectator));
			if (text == string.Empty)
			{
				return Status = ConnectionStatus.Disconnected;
			}
			socketHandler = new WebSocketHandler(WSS_BingoSync, text, MessagePassthrough);
			if (await socketHandler.StartSocket() == WebSocketHandler.ConnectionStatus.Connected)
			{
				CurrentRoomInfo = roomInfo;
				_boardUpdating = true;
				await UpdateBoardAwait();
				_waitForColor = true;
				await SetPlayerColor(CurrentRoomInfo.PlayerColor);
				Status = ConnectionStatus.Connected;
			}
			else
			{
				Status = ConnectionStatus.Disconnected;
			}
			return Status;
		}

		public async Task SetPlayerColor(BingoSyncTypes.PlayerColors playerColor)
		{
			if (Status == ConnectionStatus.Connected || _waitForColor)
			{
				if (await GetResponse("https://bingosync.com/api/color", returnResponse: true, BingoSyncPost.SetColor(CurrentRoomInfo.RoomID, playerColor.ToString().ToLower())) != string.Empty)
				{
					CurrentRoomInfo.PlayerColor = playerColor;
				}
				_waitForColor = false;
			}
		}

		public async Task SendChatMessage(string message)
		{
			if (Status == ConnectionStatus.Connected)
			{
				await GetResponse("https://bingosync.com/api/chat", returnResponse: false, BingoSyncPost.SendChat(CurrentRoomInfo.RoomID, message));
			}
		}

		public async Task RevealBoard()
		{
			if (Status == ConnectionStatus.Connected)
			{
				await GetResponse("https://bingosync.com/api/revealed", returnResponse: false, BingoSyncPost.RevealBoard(CurrentRoomInfo.RoomID));
			}
		}

		public async Task SelectSlot(int slot, bool markState = true, BingoSyncTypes.PlayerColors? color = null)
		{
			if (Status != 0)
			{
				return;
			}
			BingoSyncTypes.RoomSettings settings = await GetRoomSettings();
			if (settings != null)
			{
				BingoSyncTypes.PlayerColors colorToUse = ((!color.HasValue) ? CurrentRoomInfo.PlayerColor : color.Value);
				BingoSyncTypes.SlotInfo slotInfo = await GetBoardSlot(slot);
				bool flag = slotInfo != null && slotInfo != null && slotInfo.Colors.Contains(null);
				if ((!markState) ? (!flag && slotInfo.Colors.Contains(colorToUse)) : ((settings.lockout_mode != "Lockout" && !slotInfo.Colors.Contains(colorToUse)) || (settings.lockout_mode == "Lockout" && flag)))
				{
					await GetResponse("https://bingosync.com/api/select", returnResponse: false, BingoSyncPost.Select(CurrentRoomInfo.RoomID, slot.ToString(), colorToUse.ToString().ToLower(), !markState));
				}
			}
		}

		public async Task CreateNewCard(bool lockout_mode, bool hide_card, BingoSyncTypes.CardIDs cardIDs, int seed = -1, string custom_json = "")
		{
			if (cardIDs != null && Status == ConnectionStatus.Connected)
			{
				await GetResponse("https://bingosync.com/api/new-card", returnResponse: false, BingoSyncPost.NewCard(CurrentRoomInfo.RoomID, lockout_mode ? "2" : "1", hide_card, (seed <= -1) ? "" : Math.Abs(seed).ToString(), custom_json, cardIDs.GameID.ToString(), cardIDs.VariantID.ToString()));
			}
		}

		public async Task<BingoSyncTypes.SlotInfo[]> GetBoardSlots()
		{
			if (Status == ConnectionStatus.Connected)
			{
				while (_boardUpdating)
				{
					await Task.Yield();
				}
				return _boardSlots;
			}
			return Array.Empty<BingoSyncTypes.SlotInfo>();
		}

		public async Task<BingoSyncTypes.SlotInfo> GetBoardSlot(int slot)
		{
			if (Status == ConnectionStatus.Connected)
			{
				while (_boardUpdating)
				{
					await Task.Yield();
				}
				return _boardSlots?.FirstOrDefault((BingoSyncTypes.SlotInfo x) => x.ID == slot);
			}
			return null;
		}

		public async Task<BingoSyncTypes.RoomSettings> GetRoomSettings()
		{
			if (Status == ConnectionStatus.Connected)
			{
				while (_boardUpdating)
				{
					await Task.Yield();
				}
				return _roomSettings;
			}
			return null;
		}

		public async Task<string> GetFeed(bool full = false)
		{
			if (Status == ConnectionStatus.Connected)
			{
				return await GetFromURL(string.Format("{0}?full={1}", "https://bingosync.com/room/{0}/feed", full));
			}
			return string.Empty;
		}

		public async Task Disconnect()
		{
			if (Status == ConnectionStatus.Connected)
			{
				Status = ConnectionStatus.Disconnecting;
				await GetFromURL("https://bingosync.com/room/{0}/room-settings", response: false);
				if (socketHandler != null && socketHandler.Status == WebSocketHandler.ConnectionStatus.Connected)
				{
					await socketHandler.CloseSocket();
				}
				Status = ConnectionStatus.Disconnected;
			}
		}

		private async void UpdateBoard()
		{
			await UpdateBoardAwait();
		}

		private async Task UpdateBoardAwait()
		{
			while (_boardAwaiting)
			{
				await Task.Yield();
			}
			_boardAwaiting = true;
			_roomSettings = await UpdateRoomSettings();
			_boardSlots = await UpdateBoardSlots();
			_boardUpdating = false;
			_boardAwaiting = false;
		}

		private async Task<BingoSyncTypes.RoomSettings> UpdateRoomSettings()
		{
			string text = await GetFromURL("https://bingosync.com/room/{0}/room-settings", response: true, force: true);
			if (text == string.Empty)
			{
				return null;
			}
			string text2 = "\"settings\":";
			text = text.Substring(text.LastIndexOf(text2));
			text = text.Substring(text2.Length, text.Length - text2.Length - 1);
			try
			{
				return JsonNet.Deserialize<BingoSyncTypes.RoomSettings>(text);
			}
			catch
			{
				return null;
			}
		}

		private async Task<BingoSyncTypes.SlotInfo[]> UpdateBoardSlots()
		{
			_board = await GetFromURL("https://bingosync.com/room/{0}/board", response: true, force: true);
			if (_board == string.Empty)
			{
				return Array.Empty<BingoSyncTypes.SlotInfo>();
			}
			try
			{
				return (from x in JsonNet.Deserialize<BingoSyncTypes.Slot[]>(_board)
					select new BingoSyncTypes.SlotInfo(x)).Cast<BingoSyncTypes.SlotInfo>().ToArray();
			}
			catch
			{
				return Array.Empty<BingoSyncTypes.SlotInfo>();
			}
		}

		private async void UpdateBoardSlot(BingoSyncTypes.SocketSlot socketSlot)
		{
			string slot = socketSlot.slot;
			if (slot.Contains("slot") && int.TryParse(slot.Replace("slot", ""), out var result))
			{
				BingoSyncTypes.SlotInfo slotInfo = await GetBoardSlot(result);
				if (slotInfo != null && slotInfo.slot != null)
				{
					slotInfo.slot.name = socketSlot.name;
					slotInfo.slot.colors = socketSlot.colors;
				}
			}
		}

		private async void LeaveRoom()
		{
			await Disconnect();
		}

		private async Task<string> GetFromURL(string URL, bool response = true, bool force = false)
		{
			if (Status == ConnectionStatus.Connected || force)
			{
				return await GetResponse(string.Format(URL, CurrentRoomInfo.RoomID), response);
			}
			return string.Empty;
		}
	}
	public class BingoSyncTypes
	{
		[Serializable]
		public class CardIDs
		{
			public int GameID;

			public int VariantID;

			public CardIDs(int GameID, int VariantID)
			{
				this.GameID = GameID;
				this.VariantID = VariantID;
			}
		}

		[Serializable]
		internal class Slot
		{
			public string name;

			public string slot;

			public string colors;
		}

		[Serializable]
		public class SlotInfo
		{
			internal Slot slot;

			public string Info => slot.name;

			public int ID => int.Parse(slot.slot.Replace("slot", ""));

			public PlayerColors?[] Colors
			{
				get
				{
					if (slot.colors.Equals("blank"))
					{
						return new PlayerColors?[1];
					}
					string[] source = new string[1] { slot.colors };
					if (Enumerable.Contains(slot.colors, ' '))
					{
						source = slot.colors.Split(new char[1] { ' ' });
					}
					PlayerColors result;
					return source.Select((string x) => (!Enum.TryParse<PlayerColors>(x.Substring(0, 1).ToUpper() + x.Substring(1, x.Length - 1).ToLower(), out result)) ? null : new PlayerColors?(result)).Cast<PlayerColors?>().ToArray();
				}
			}

			internal SlotInfo(Slot slot)
			{
				this.slot = slot;
			}
		}

		[Serializable]
		public class RoomSettings
		{
			public bool hide_card { get; internal set; }

			public string lockout_mode { get; internal set; }

			public string game { get; internal set; }

			public int game_id { get; internal set; }

			public string variant { get; internal set; }

			public int variant_id { get; internal set; }

			public int seed { get; internal set; }
		}

		[Serializable]
		public class SocketMessage
		{
			public string originalMsg { get; internal set; }

			public string game { get; internal set; }

			public bool hide_card { get; internal set; }

			public bool is_current { get; internal set; }

			public string seed { get; internal set; }

			public string type { get; internal set; }

			public string event_type { get; internal set; }

			public SocketPlayer player { get; internal set; }

			public SocketSlot square { get; internal set; }

			public string player_color { get; internal set; }

			public string color { get; internal set; }

			public bool remove { get; internal set; }

			public double timestamp { get; internal set; }

			public string room { get; internal set; }

			public string text { get; internal set; }

			public string socket_key { get; internal set; }
		}

		[Serializable]
		public class SocketPlayer
		{
			public string uuid { get; internal set; }

			public string name { get; internal set; }

			public string color { get; internal set; }

			public bool is_spectator { get; internal set; }
		}

		[Serializable]
		public class SocketSlot
		{
			public string name { get; internal set; }

			public string slot { get; internal set; }

			public string colors { get; internal set; }
		}

		[Serializable]
		public class RoomInfo
		{
			public string RoomID { get; private set; }

			public string RoomPassword { get; private set; }

			public string PlayerName { get; private set; }

			public PlayerColors PlayerColor { get; internal set; }

			public bool Spectator { get; private set; }

			public RoomInfo(string RoomID, string RoomPassword, string PlayerName, PlayerColors PlayerColor, bool Spectator)
			{
				this.RoomID = RoomID;
				this.RoomPassword = RoomPassword;
				this.PlayerName = PlayerName;
				this.PlayerColor = PlayerColor;
				this.Spectator = Spectator;
			}
		}

		[Serializable]
		public enum PlayerColors
		{
			Orange,
			Red,
			Blue,
			Green,
			Purple,
			Navy,
			Teal,
			Brown,
			Pink,
			Yellow
		}
	}
	internal static class BingoSyncPost
	{
		public static string JoinRoom(string room, string nickname, string password, bool is_spectator = false)
		{
			return JsonNet.Serialize(new
			{
				room = room,
				nickname = nickname,
				password = password,
				is_specator = is_spectator
			});
		}

		public static string SetColor(string room, string color)
		{
			return JsonNet.Serialize(new { room, color });
		}

		public static string SendChat(string room, string text)
		{
			return JsonNet.Serialize(new { room, text });
		}

		public static string RevealBoard(string room)
		{
			return JsonNet.Serialize(new { room });
		}

		public static string Select(string room, string slot, string color, bool remove_color)
		{
			return JsonNet.Serialize(new { room, slot, color, remove_color });
		}

		public static string NewCard(string room, string lockout_mode, bool hide_card, string seed, string custom_json, string game_type, string variant_type)
		{
			return JsonNet.Serialize(new { hide_card, game_type, variant_type, custom_json, lockout_mode, seed, room });
		}
	}
	internal static class DebugModeOutput
	{
		public static void WriteLine(string message)
		{
			if (BingoSync.DebugMode)
			{
				Console.WriteLine(message);
			}
		}
	}
}
namespace BingoSyncAPI.NetworkHandler
{
	internal static class HttpWebHandler
	{
		private const int MaxAttempts = 3;

		public static async Task<CookieContainer> TryGetCookies(HttpWebRequest request)
		{
			string text = await GetHeader(request, HttpResponseHeader.SetCookie);
			try
			{
				if (text != string.Empty)
				{
					CookieContainer cookieContainer = new CookieContainer();
					cookieContainer.SetCookies(request.Address, text);
					return cookieContainer;
				}
				return null;
			}
			catch
			{
				return null;
			}
		}

		public static async Task<string> GetHeader(HttpWebRequest request, HttpResponseHeader header)
		{
			return await TryResponse(request, null, returnResponse: true, header);
		}

		public static async Task<string> TryGetResponse(string URL, bool returnResponse = true, CookieContainer cookies = null, string data = null)
		{
			HttpWebRequest request = TryGetRequest(URL);
			if (cookies != null)
			{
				request.CookieContainer = cookies;
			}
			DebugModeOutput.WriteLine($"Cookies: {request?.CookieContainer}");
			if (request == null)
			{
				return string.Empty;
			}
			if (data != null)
			{
				await TryPost(request, data);
			}
			DebugModeOutput.WriteLine("Post: " + data);
			return await TryResponse(request, cookies, returnResponse);
		}

		public static HttpWebRequest TryGetRequest(string URL)
		{
			if (URL == string.Empty)
			{
				return null;
			}
			try
			{
				return (HttpWebRequest)WebRequest.Create(new Uri(URL));
			}
			catch
			{
				return null;
			}
		}

		public static async Task<bool> TryPost(HttpWebRequest request, string data)
		{
			if (request == null)
			{
				return false;
			}
			int attempt = 0;
			while (attempt < 3)
			{
				attempt++;
				try
				{
					request.Method = "POST";
					request.ContentType = "application/json; charset=UTF-8";
					request.Accept = "application/json";
					using (StreamWriter stream = new StreamWriter(await request.GetRequestStreamAsync()))
					{
						await stream.WriteAsync(data);
						stream.Dispose();
					}
					return true;
				}
				catch
				{
					if (attempt >= 3)
					{
						return false;
					}
					await Task.Delay(TimeSpan.FromSeconds(1.0));
				}
			}
			return false;
		}

		public static async Task<string> TryResponse(HttpWebRequest request, CookieContainer cookies, bool returnResponse = true, HttpResponseHeader? header = null)
		{
			if (request == null)
			{
				return string.Empty;
			}
			int attempt = 0;
			string responseString = string.Empty;
			while (attempt < 3)
			{
				attempt++;
				try
				{
					using HttpWebResponse response = (HttpWebResponse)(await request.GetResponseAsync());
					if (!returnResponse)
					{
						break;
					}
					if (header.HasValue)
					{
						responseString = response.Headers[header.Value];
						response.Dispose();
					}
					else
					{
						using StreamReader reader = new StreamReader(response.GetResponseStream());
						responseString = await reader.ReadToEndAsync();
						response.Dispose();
						reader.Dispose();
					}
					response.Close();
				}
				catch
				{
					DebugModeOutput.WriteLine($"Failed Response Attempt: {attempt}");
					DebugModeOutput.WriteLine("(" + request?.Address?.ToString() + ") Did not like request...");
					if (attempt >= 3)
					{
						return string.Empty;
					}
					if (cookies != null)
					{
						request = TryGetRequest(request.RequestUri.AbsoluteUri);
						if (request != null)
						{
							request.CookieContainer = cookies;
						}
					}
					await Task.Delay(TimeSpan.FromSeconds(1.0));
					continue;
				}
				break;
			}
			return responseString ?? string.Empty;
		}
	}
	internal class WebSocketHandler
	{
		public delegate void MessageReceived(string message);

		public enum ConnectionStatus
		{
			Connected,
			Connecting,
			Disconnected,
			Disconnecting
		}

		private MessageReceived messageReceiver;

		private const int MaxAttempts = 3;

		private ClientWebSocket socket;

		public Uri URI { get; private set; }

		public string SocketKey { get; private set; }

		public ConnectionStatus Status { get; private set; } = ConnectionStatus.Disconnected;


		public event MessageReceived OnMessageReceived;

		public WebSocketHandler(Uri URI, string socketKey, MessageReceived messageReceiver)
		{
			this.URI = URI;
			SocketKey = socketKey;
			this.messageReceiver = messageReceiver;
			OnMessageReceived += messageReceiver;
		}

		public async Task<ConnectionStatus> StartSocket()
		{
			if (Status != 0 && Status != ConnectionStatus.Connecting && Status != ConnectionStatus.Disconnecting)
			{
				Status = ConnectionStatus.Connecting;
				OpenSocket();
				return await WaitForConnection();
			}
			return Status;
		}

		private async Task<ConnectionStatus> WaitForConnection()
		{
			while (Status == ConnectionStatus.Connecting)
			{
				await Task.Yield();
			}
			return Status;
		}

		private async void OpenSocket()
		{
			byte[] socketData = Encoding.ASCII.GetBytes(SocketKey);
			using (ClientWebSocket socket = new ClientWebSocket())
			{
				await socket.ConnectAsync(URI, CancellationToken.None);
				if (socket.State == WebSocketState.Open)
				{
					try
					{
						await socket.SendAsync(new ArraySegment<byte>(socketData), WebSocketMessageType.Text, endOfMessage: true, CancellationToken.None);
					}
					catch
					{
						Status = ConnectionStatus.Disconnected;
					}
					if (Status == ConnectionStatus.Connecting)
					{
						this.socket = socket;
						await StartListeningToSocket();
					}
				}
			}
			OnMessageReceived -= messageReceiver;
			Status = ConnectionStatus.Disconnected;
		}

		private async Task StartListeningToSocket()
		{
			Status = ConnectionStatus.Connected;
			await ReceiveMessages();
		}

		private async Task ReceiveMessages()
		{
			byte[] buffer = new byte[1024];
			int attempt = 0;
			while (socket.State == WebSocketState.Open && Status == ConnectionStatus.Connected && attempt < 3)
			{
				attempt++;
				WebSocketReceiveResult result;
				try
				{
					result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
					attempt = 0;
				}
				catch
				{
					if (attempt >= 3)
					{
						await CloseSocket();
						break;
					}
					await Task.Delay(TimeSpan.FromSeconds(1.0));
					continue;
				}
				if (result.MessageType == WebSocketMessageType.Close && Status == ConnectionStatus.Connected)
				{
					await CloseSocket();
					break;
				}
				if (result != null)
				{
					string @string = Encoding.UTF8.GetString(buffer, 0, result.Count);
					if (@string != null && @string != string.Empty)
					{
						this.OnMessageReceived?.Invoke(@string);
					}
				}
			}
		}

		public async Task CloseSocket()
		{
			if (socket != null && socket.State == WebSocketState.Open && Status == ConnectionStatus.Connected)
			{
				Status = ConnectionStatus.Disconnecting;
				WebSocketCloseStatus closeStatus = socket.CloseStatus.GetValueOrDefault(WebSocketCloseStatus.NormalClosure);
				string closeReason = socket.CloseStatusDescription;
				try
				{
					await socket.CloseOutputAsync(closeStatus, closeReason, CancellationToken.None);
					await socket.CloseAsync(closeStatus, closeReason, CancellationToken.None);
				}
				catch
				{
				}
				Status = ConnectionStatus.Disconnected;
				socket = null;
				this.OnMessageReceived?.Invoke("Socket Closed");
			}
		}
	}
}
namespace Json.Net
{
	[ComVisible(true)]
	public interface IJsonConverter
	{
		Type GetConvertingType();

		string Serializer(object obj);

		object Deserializer(string txt);
	}
	[ComVisible(true)]
	public interface IPropertyNameTransform
	{
		string Transform(string propertyName);
	}
	[ComVisible(true)]
	public class JsonConverter<T> : IJsonConverter
	{
		public Func<T, string> Serializer;

		public Func<string, T> Deserializer;

		public JsonConverter(Func<T, string> serializer, Func<string, T> deserializer)
		{
			Serializer = serializer;
			Deserializer = deserializer;
		}

		Type IJsonConverter.GetConvertingType()
		{
			return typeof(T);
		}

		string IJsonConverter.Serializer(object obj)
		{
			return Serializer((T)obj);
		}

		object IJsonConverter.Deserializer(string txt)
		{
			return Deserializer(txt);
		}
	}
	[ComVisible(true)]
	public static class JsonNet
	{
		public static T Deserialize<T>(string json, SerializationOptions options = null)
		{
			return (T)JsonParser.Instance.Initialize(json, options).FromJson(typeof(T));
		}

		public static T Deserialize<T>(Stream stream, SerializationOptions options = null)
		{
			return (T)JsonParser.Instance.Initialize(new StreamReader(stream), options).FromJson(typeof(T));
		}

		public static T Deserialize<T>(TextReader reader, SerializationOptions options = null)
		{
			return (T)JsonParser.Instance.Initialize(reader, options).FromJson(typeof(T));
		}

		public static string Serialize(object obj, SerializationOptions options = null)
		{
			JsonSerializer jsonSerializer = JsonSerializer.Instance.Initialize();
			jsonSerializer.Serialize(obj, options);
			return jsonSerializer.Builder.ToString();
		}

		public static void Serialize(object obj, Stream stream, SerializationOptions options = null)
		{
			using StreamWriter writer = new StreamWriter(stream, Encoding.UTF8, 1024, leaveOpen: true);
			Serialize(obj, writer, options);
		}

		public static void Serialize(object obj, TextWriter writer, SerializationOptions options = null)
		{
			JsonSerializer.Instance.Initialize(writer).Serialize(obj, options);
			writer.Flush();
		}

		public static T Deserialize<T>(string json, params IJsonConverter[] converters)
		{
			return Deserialize<T>(json, new SerializationOptions
			{
				Converters = converters
			});
		}

		public static T Deserialize<T>(Stream stream, params IJsonConverter[] converters)
		{
			return Deserialize<T>(new StreamReader(stream), new SerializationOptions
			{
				Converters = converters
			});
		}

		public static T Deserialize<T>(TextReader reader, params IJsonConverter[] converters)
		{
			return Deserialize<T>(reader, new SerializationOptions
			{
				Converters = converters
			});
		}

		public static string Serialize(object obj, params IJsonConverter[] converters)
		{
			return Serialize(obj, new SerializationOptions
			{
				Converters = converters
			});
		}

		public static void Serialize(object obj, Stream stream, params IJsonConverter[] converters)
		{
			Serialize(obj, stream, new SerializationOptions
			{
				Converters = converters
			});
		}

		public static void Serialize(object obj, TextWriter writer, params IJsonConverter[] converters)
		{
			Serialize(obj, new SerializationOptions
			{
				Converters = converters
			});
		}

		public static T Deserialize<T>(string json, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			return Deserialize<T>(json, new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}

		public static T Deserialize<T>(Stream stream, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			return Deserialize<T>(new StreamReader(stream), new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}

		public static T Deserialize<T>(TextReader reader, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			return Deserialize<T>(reader, new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}

		public static string Serialize(object obj, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			return Serialize(obj, new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}

		public static void Serialize(object obj, Stream stream, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			Serialize(obj, stream, new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}

		public static void Serialize(object obj, TextWriter writer, IPropertyNameTransform propertyNameTransform, params IJsonConverter[] converters)
		{
			Serialize(obj, new SerializationOptions
			{
				PropertyNameTransform = propertyNameTransform,
				Converters = converters
			});
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false, AllowMultiple = true)]
	[ComVisible(true)]
	public sealed class JsonNetIgnoreAttribute : Attribute
	{
	}
	[ComVisible(true)]
	public class JsonParser : ParserBase
	{
		private IJsonConverter[] Converters;

		private IPropertyNameTransform PropertyNameTransform;

		private static Dictionary<char, char> EscapeMap = new Dictionary<char, char>
		{
			{ 'b', '\b' },
			{ 't', '\t' },
			{ 'n', '\n' },
			{ 'f', '\f' },
			{ 'r', '\r' }
		};

		[ThreadStatic]
		private static JsonParser _Instance;

		private StringBuilder text = new StringBuilder();

		public static JsonParser Instance => _Instance ?? (_Instance = new JsonParser());

		public JsonParser Initialize(string json, SerializationOptions options)
		{
			Initialize(json);
			Converters = options?.Converters;
			PropertyNameTransform = options?.PropertyNameTransform;
			return this;
		}

		public JsonParser Initialize(TextReader jsonReader, SerializationOptions options)
		{
			Initialize(jsonReader);
			Converters = options?.Converters;
			PropertyNameTransform = options.PropertyNameTransform;
			return this;
		}

		public object FromJson(Type type)
		{
			SkipWhite();
			if (NextChar == '{')
			{
				if (type == null || type == typeof(object) || type == typeof(ExpandoObject))
				{
					type = typeof(ExpandoObject);
				}
				ReadNext();
				SkipWhite();
				if (type.IsValueType)
				{
					throw new FormatException("Unexpected type!");
				}
				object obj = Activator.CreateInstance(type);
				Type type2 = ((obj is IDictionary) ? type.GenericTypeArguments[0] : typeof(string));
				Type type3 = ((obj is IDictionary) ? type.GenericTypeArguments[1] : null);
				int num = 0;
				while (NextChar != '}')
				{
					object obj2 = FromJson(type2);
					SkipWhite();
					Match(":");
					SerializerMap serializerMap = SerializerMap.GetSerializerMap(type);
					MemberAccessor memberAccessor = null;
					if (type3 == null)
					{
						if (serializerMap.Members.Length == 0)
						{
							memberAccessor = GetFieldAccessorFor(obj2.ToString());
						}
						else
						{
							for (int i = num; i < serializerMap.Members.Length; i++)
							{
								string text = serializerMap.Members[i].Name;
								if (PropertyNameTransform != null)
								{
									text = PropertyNameTransform.Transform(text);
								}
								string text2 = obj2.ToString();
								if (text == text2 || text.Equals(text2, StringComparison.InvariantCultureIgnoreCase))
								{
									memberAccessor = serializerMap.Members[i];
									break;
								}
							}
						}
					}
					Type type4 = ((memberAccessor == null) ? type3 : memberAccessor.ValueType);
					if (type4 == null)
					{
						FromJson(type4);
					}
					else
					{
						object obj3 = FromJson(type4);
						if (memberAccessor != null)
						{
							try
							{
								memberAccessor.SetValue(obj, obj3);
							}
							catch
							{
							}
						}
						else
						{
							((IDictionary)obj).Add(obj2, obj3);
						}
					}
					SkipWhite();
					if (NextChar != ',')
					{
						break;
					}
					ReadNext();
					SkipWhite();
				}
				Match("}");
				return obj;
			}
			if (NextChar == '[')
			{
				if (type == null || type == typeof(object) || type == typeof(ExpandoObject))
				{
					type = typeof(object[]);
				}
				ReadNext();
				SkipWhite();
				Type type5 = (type.IsArray ? type.GetElementType() : (type.IsGenericType ? type.GenericTypeArguments[0] : typeof(object)));
				IList list = (type.IsArray ? new ArrayList() : ((!(type == typeof(IEnumerable))) ? ((IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(type5))) : new List<object>()));
				while (NextChar != ']')
				{
					object value = FromJson(type5);
					list.Add(value);
					SkipWhite();
					if (NextChar != ',')
					{
						break;
					}
					ReadNext();
					SkipWhite();
				}
				Match("]");
				if (list is ArrayList)
				{
					return ((ArrayList)list).ToArray(type5);
				}
				return list;
			}
			if (NextChar == '"')
			{
				if (type == null || type == typeof(object) || type == typeof(ExpandoObject))
				{
					type = typeof(string);
				}
				ReadNext();
				while (!EndOfStream && NextChar != '"')
				{
					if (NextChar == '\\')
					{
						ReadNext();
						switch (NextChar)
						{
						case 'b':
						case 'f':
						case 'n':
						case 'r':
						case 't':
							this.text.Append(EscapeMap[NextChar]);
							break;
						case 'u':
						{
							ReadNext();
							string text3 = "";
							while (text3.Length < 4 && base.IsHexDigit)
							{
								text3 += NextChar;
								ReadNext();
							}
							this.text.Append(char.ConvertFromUtf32(int.Parse("0x" + text3)));
							continue;
						}
						default:
							this.text.Append(NextChar);
							break;
						}
					}
					else
					{
						this.text.Append(NextChar);
					}
					ReadNext();
				}
				SkipWhite();
				Match("\"");
				object obj = this.text.ToString();
				this.text.Clear();
				IJsonConverter jsonConverter = Converters?.FirstOrDefault((IJsonConverter c) => c.GetConvertingType() == type);
				if (jsonConverter != null)
				{
					return jsonConverter.Deserializer((string)obj);
				}
				if (type == typeof(DateTime) || type == typeof(DateTime?))
				{
					return DateTime.Parse((string)obj, CultureInfo.InvariantCulture);
				}
				if (type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?))
				{
					return DateTimeOffset.Parse((string)obj, CultureInfo.InvariantCulture);
				}
				if (type == typeof(TimeSpan) || type == typeof(TimeSpan?))
				{
					return TimeSpan.Parse((string)obj, CultureInfo.InvariantCulture);
				}
				if (type == typeof(Guid) || type == typeof(Guid?))
				{
					return Guid.Parse((string)obj);
				}
				try
				{
					return Convert.ChangeType(obj, type);
				}
				catch
				{
					throw new FormatException($"'{obj}' cannot be converted to {type.Name}");
				}
			}
			if (NextChar == 't')
			{
				Match("true");
				return true;
			}
			if (NextChar == 'f')
			{
				Match("false");
				return false;
			}
			if (NextChar == 'n')
			{
				Match("null");
				if (type == null)
				{
					type = typeof(object);
				}
				if (!type.IsClass && !type.IsInterface && !(Nullable.GetUnderlyingType(type) != null))
				{
					throw new InvalidDataException("Type " + type.Name + "'s value cannot be null!");
				}
				return null;
			}
			if (NextChar == '-' || base.IsDigit)
			{
				if (type == null || type == typeof(object))
				{
					type = typeof(double);
				}
				if (NextChar == '-')
				{
					this.text.Append('-');
					ReadNext();
				}
				if (NextChar == '0')
				{
					this.text.Append('0');
					ReadNext();
				}
				else
				{
					if (!base.IsDigit)
					{
						throw new FormatException("Digit expected!");
					}
					do
					{
						this.text.Append(NextChar);
						ReadNext();
					}
					while (base.IsDigit);
				}
				if (NextChar == '.')
				{
					this.text.Append('.');
					ReadNext();
					while (base.IsDigit)
					{
						this.text.Append(NextChar);
						ReadNext();
					}
				}
				if (NextChar == 'e' || NextChar == 'E')
				{
					this.text.Append('e');
					ReadNext();
					if (NextChar == '+' || NextChar == '-')
					{
						this.text.Append(NextChar);
						ReadNext();
					}
					while (base.IsDigit)
					{
						this.text.Append(NextChar);
						ReadNext();
					}
				}
				string text4 = this.text.ToString();
				this.text.Clear();
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				if (type.IsGenericType && type.IsValueType && Nullable.GetUnderlyingType(type).IsEnum)
				{
					type = Nullable.GetUnderlyingType(type);
				}
				if (type.IsEnum)
				{
					return Enum.Parse(type, text4);
				}
				if (type == typeof(int) || type == typeof(int?))
				{
					return int.Parse(text4, invariantCulture);
				}
				if (type == typeof(long) || type == typeof(long?))
				{
					return long.Parse(text4, invariantCulture);
				}
				return double.Parse(text4, invariantCulture);
			}
			throw new FormatException("Unexpected character! " + NextChar);
		}

		private MemberAccessor GetFieldAccessorFor(string fieldName)
		{
			string tName = fieldName.ToString();
			if (PropertyNameTransform != null)
			{
				tName = PropertyNameTransform.Transform(tName);
			}
			return new MemberAccessor
			{
				Name = tName,
				ValueType = typeof(ExpandoObject),
				GetValue = (object o) => ((IDictionary<string, object>)(ExpandoObject)o)[tName],
				SetValue = delegate(object o, object v)
				{
					((IDictionary<string, object>)(ExpandoObject)o)[tName] = v;
				}
			};
		}
	}
	[ComVisible(true)]
	public class JsonSerializer
	{
		private TextWriter Writer;

		public StringBuilder Builder = new StringBuilder(1024);

		protected Action<string> Write;

		[ThreadStatic]
		private static JsonSerializer _Instance;

		private static Dictionary<Type, Func<object, string>> SerializerCache = new Dictionary<Type, Func<object, string>>();

		public static JsonSerializer Instance => _Instance ?? (_Instance = new JsonSerializer());

		public JsonSerializer Initialize()
		{
			Writer = null;
			Builder.Clear();
			Write = delegate(string s)
			{
				Builder.Append(s);
			};
			return this;
		}

		public JsonSerializer Initialize(TextWriter writer)
		{
			Writer = writer;
			Write = delegate(string s)
			{
				Writer.Write(s);
			};
			return this;
		}

		public void Serialize(object obj, SerializationOptions options)
		{
			if (obj == null)
			{
				Write("null");
				return;
			}
			Type objectType = obj.GetType();
			IJsonConverter jsonConverter = options?.Converters?.FirstOrDefault((IJsonConverter c) => c.GetConvertingType() == objectType);
			if (jsonConverter != null)
			{
				Serialize(jsonConverter.Serializer(obj), options);
				return;
			}
			if (!SerializerCache.TryGetValue(objectType, out var value))
			{
				Func<object, string> strConverter = delegate(object s)
				{
					string text = (string)s;
					string text2 = "\"";
					for (int j = 0; j < text.Length; j++)
					{
						char c2 = text[j];
						text2 += c2 switch
						{
							'\f' => "\\f", 
							'\b' => "\\b", 
							'/' => "\\/", 
							'\\' => "\\\\", 
							'"' => "\\\"", 
							'\t' => "\\t", 
							'\n' => "\\n", 
							'\r' => "\\r", 
							_ => c2.ToString(), 
						};
					}
					return text2 + "\"";
				};
				if (obj is string)
				{
					value = strConverter;
				}
				else
				{
					if (obj is IEnumerable && !(obj is ExpandoObject))
					{
						Write((obj is IDictionary) ? "{" : "[");
						bool flag = true;
						foreach (object item in (IEnumerable)obj)
						{
							if (flag)
							{
								flag = false;
							}
							else
							{
								Write(",");
							}
							Serialize(item, options);
						}
						Write((obj is IDictionary) ? "}" : "]");
						return;
					}
					if (obj is bool || obj is bool?)
					{
						value = (object b) => (!(bool)b) ? "false" : "true";
					}
					else if (obj is Guid || obj is Guid?)
					{
						value = (object g) => strConverter(((Guid)g).ToString());
					}
					else if (obj is int || obj is int? || obj is short || obj is short? || obj is long || obj is long? || obj is uint || obj is uint? || obj is ushort || obj is ushort? || obj is ulong || obj is ulong? || obj is float || obj is float? || obj is double || obj is double? || obj is decimal || obj is decimal? || obj is float || obj is uint? || obj is ushort || obj is ushort? || obj is ulong || obj is ulong?)
					{
						value = (object n) => string.Format(CultureInfo.InvariantCulture, "{0}", n);
					}
					else if (obj is DateTime || obj is DateTime?)
					{
						value = (object d) => strConverter(((DateTime)d).ToString(CultureInfo.InvariantCulture));
					}
					else if (obj is DateTimeOffset || obj is DateTimeOffset?)
					{
						value = (object d) => strConverter(((DateTimeOffset)d).ToString(CultureInfo.InvariantCulture));
					}
					else if (obj is TimeSpan || obj is TimeSpan?)
					{
						value = (object d) => strConverter(((TimeSpan)d).ToString("c"));
					}
					else if (obj is Enum)
					{
						value = (object e) => ((int)e).ToString(CultureInfo.InvariantCulture);
					}
					else
					{
						Type type;
						if (objectType.IsGenericType && objectType.GenericTypeArguments.Length == 2 && objectType == (type = typeof(KeyValuePair<, >).MakeGenericType(objectType.GenericTypeArguments)))
						{
							string arg = type.GetProperty("Key").GetValue(obj).ToString();
							object value2 = type.GetProperty("Value").GetValue(obj);
							Write(strConverter(arg));
							Write(":");
							Serialize(value2, options);
							return;
						}
						if (!objectType.IsPrimitive)
						{
							Write("{");
							bool flag2 = true;
							MemberAccessor[] array = SerializerMap.GetSerializerMap(objectType).Members;
							if (array.Length == 0)
							{
								array = ((IDictionary<string, object>)(ExpandoObject)obj).Keys.Select((string m) => GetFieldAccessorFor(m)).ToArray();
							}
							MemberAccessor[] array2 = array;
							foreach (MemberAccessor memberAccessor in array2)
							{
								if (flag2)
								{
									flag2 = false;
								}
								else
								{
									Write(",");
								}
								if (objectType == typeof(DictionaryEntry))
								{
									DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
									Write(strConverter(dictionaryEntry.Key.ToString()));
									Write(":");
									Serialize(dictionaryEntry.Value, options);
									continue;
								}
								string arg2 = memberAccessor.Name;
								if (options?.PropertyNameTransform != null)
								{
									arg2 = options?.PropertyNameTransform.Transform(memberAccessor.Name);
								}
								Write(strConverter(arg2));
								Write(":");
								try
								{
									Serialize(memberAccessor.GetValue(obj), options);
								}
								catch (TargetInvocationException)
								{
									Serialize(null, options);
								}
							}
							Write("}");
							return;
						}
					}
				}
				SerializerCache[objectType] = value ?? throw new InvalidOperationException("Unknown object type! " + objectType.FullName);
			}
			Write(value(obj));
		}

		private MemberAccessor GetFieldAccessorFor(string fieldName)
		{
			return new MemberAccessor
			{
				Name = fieldName,
				ValueType = typeof(ExpandoObject),
				GetValue = (object o) => ((IDictionary<string, object>)(ExpandoObject)o)[fieldName],
				SetValue = delegate(object o, object v)
				{
					((IDictionary<string, object>)(ExpandoObject)o)[fieldName] = v;
				}
			};
		}
	}
	[ComVisible(true)]
	public class ParserBase
	{
		private TextReader Reader;

		private char[] ReaderBuffer;

		private string Buffer;

		private int BufferIndex;

		protected char NextChar;

		private const char EOF = '\u001b';

		protected bool EndOfStream;

		protected static string WhiteSpace = " \t\r\n";

		protected static string Digits = "0123456789";

		protected static string HexDigits = "0123456789ABCDEFabcdef";

		protected static string Alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

		protected static string AlphaNumeric = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

		private IEnumerator<char> _Stream;

		protected bool IsWhite => WhiteSpace.IndexOf(NextChar) >= 0;

		protected bool IsAlpha => Alpha.IndexOf(NextChar) >= 0;

		protected bool IsAlphaNumeric => AlphaNumeric.IndexOf(NextChar) >= 0;

		protected bool IsDigit => Digits.IndexOf(NextChar) >= 0;

		protected bool IsHexDigit => HexDigits.IndexOf(NextChar) >= 0;

		public ParserBase(int bufferSize = 1024)
		{
			ReaderBuffer = new char[bufferSize];
		}

		private ParserBase _Initialize()
		{
			EndOfStream = false;
			BufferIndex = -1;
			_Stream = _ReadNext().GetEnumerator();
			ReadNext();
			return this;
		}

		public ParserBase Initialize(string json)
		{
			Reader = null;
			Buffer = json;
			return _Initialize();
		}

		public ParserBase Initialize(TextReader textReader)
		{
			Reader = textReader;
			Buffer = "";
			return _Initialize();
		}

		protected char ReadNext()
		{
			_Stream.MoveNext();
			return NextChar = _Stream.Current;
		}

		private IEnumerable<char> _ReadNext()
		{
			if (EndOfStream)
			{
				yield break;
			}
			if (Reader == null)
			{
				while (++BufferIndex < Buffer.Length)
				{
					yield return Buffer[BufferIndex];
				}
				Buffer = "";
				BufferIndex = 0;
				EndOfStream = true;
				yield return '\u001b';
				yield break;
			}
			while (true)
			{
				int read = Reader.ReadBlock(ReaderBuffer, 0, ReaderBuffer.Length);
				Buffer = new string(ReaderBuffer, 0, read);
				BufferIndex = -1;
				while (read-- > 0)
				{
					yield return Buffer[++BufferIndex];
				}
			}
		}

		protected void SkipWhite()
		{
			while (IsWhite)
			{
				ReadNext();
			}
		}

		protected void Match(string s)
		{
			foreach (char c in s)
			{
				if (NextChar == c)
				{
					ReadNext();
					continue;
				}
				throw new FormatException(s + " expected, but " + NextChar + " found!");
			}
		}
	}
	[ComVisible(true)]
	public enum Gender
	{
		None,
		Female,
		Male,
		Other
	}
	[DataContract]
	[ComVisible(true)]
	public class Pet
	{
		public static string OriginalPetJson = "{\"id\":1,\"name\":\"gucci\",\"birth\":\"08/30/2012 13:41:59\",\"alive\":true,\"gender\":1,\"dictType\":{\"Key1\":\"Value1\",\"Key2\":\"Value2\"},\"intArray\":[1,2,3]}";

		public static Pet OriginalPet = new Pet
		{
			id = 1,
			name = "gucci",
			birth = new DateTime(2012, 8, 30, 13, 41, 59),
			alive = true,
			gender = Gender.Male,
			dictType = new Dictionary<string, string>
			{
				{ "Key1", "Value1" },
				{ "Key2", "Value2" }
			},
			intArray = new int[3] { 1, 2, 3 }
		};

		[DataMember]
		public int id { get; set; }

		[DataMember]
		public string name { get; set; }

		[DataMember]
		public DateTime birth { get; set; }

		[DataMember]
		public bool alive { get; set; }

		[DataMember]
		public Gender gender { get; set; }

		[DataMember]
		public Dictionary<string, string> dictType { get; set; }

		[DataMember]
		public int[] intArray { get; set; }
	}
	[ComVisible(true)]
	public static class PropertyNameTransforms
	{
		public static IPropertyNameTransform TitleToCamelCase { get; } = new TitleToCamelCase();

	}
	[ComVisible(true)]
	public class SerializationOptions
	{
		public IJsonConverter[] Converters { get; set; }

		public IPropertyNameTransform PropertyNameTransform { get; set; }
	}
	[ComVisible(true)]
	public class MemberAccessor
	{
		public string Name;

		public Type ValueType;

		public Func<object, object> GetValue;

		public Action<object, object> SetValue;
	}
	[ComVisible(true)]
	public class SerializerMap
	{
		public readonly Type ObjectType;

		public readonly MemberAccessor[] Members;

		[ThreadStatic]
		private static SerializerMap[] _GlobalMaps;

		private string[] IgnoredAttributes = new string[4] { "JsonIgnoreAttribute", "JsonNetIgnoreAttribute", "NonSerializedAttribute", "XmlIgnoreAttribute" };

		private static SerializerMap[] GlobalMaps => _GlobalMaps ?? (_GlobalMaps = new SerializerMap[0]);

		public SerializerMap(Type type)
		{
			SerializerMap serializerMap = this;
			ObjectType = type;
			if (type == typeof(object) || type == typeof(ExpandoObject))
			{
				Members = new MemberAccessor[0];
				return;
			}
			Members = (from m in type.GetMembers(BindingFlags.Instance | BindingFlags.Public)
				where m.MemberType == MemberTypes.Field || (m.MemberType == MemberTypes.Property && type.GetProperty(m.Name).CanRead && !(from a in m.GetCustomAttributes()
					select a.GetType().Name).Intersect(serializerMap.IgnoredAttributes).Any())
				select (m.MemberType != MemberTypes.Property) ? new MemberAccessor
				{
					Name = m.Name,
					ValueType = ((FieldInfo)m).FieldType,
					GetValue = ((FieldInfo)m).GetValue,
					SetValue = ((FieldInfo)m).SetValue
				} : new MemberAccessor
				{
					Name = m.Name,
					ValueType = ((PropertyInfo)m).PropertyType,
					GetValue = ((PropertyInfo)m).GetValue,
					SetValue = ((PropertyInfo)m).SetValue
				}).ToArray();
		}

		public static SerializerMap GetSerializerMap(Type type)
		{
			SerializerMap serializerMap;
			if ((serializerMap = GlobalMaps.FirstOrDefault((SerializerMap m) => m.ObjectType == type)) == null)
			{
				lock (_GlobalMaps)
				{
					if ((serializerMap = _GlobalMaps.FirstOrDefault((SerializerMap m) => m.ObjectType == type)) == null)
					{
						int num = _GlobalMaps.Length;
						Array.Resize(ref _GlobalMaps, num + 1);
						serializerMap = (_GlobalMaps[num] = new SerializerMap(type));
						foreach (Type item in (from v in serializerMap.Members
							select v.ValueType into t
							where t != typeof(string) && (t.IsClass || (t.IsValueType && !t.IsPrimitive))
							select t).Except(GlobalMaps.Select((SerializerMap m) => m.ObjectType)).Distinct())
						{
							GetSerializerMap(item);
						}
					}
				}
			}
			return serializerMap;
		}
	}
	[ComVisible(true)]
	public class TitleToCamelCase : IPropertyNameTransform
	{
		public string Transform(string propertyName)
		{
			return char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1);
		}
	}
}