using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Buttplug.Core;
using Buttplug.Core.Messages;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Buttplug.Test")]
[assembly: InternalsVisibleTo("Buttplug.Client.Test")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Nonpolynomial Labs, LLC")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright Nonpolynomial Labs, LLC")]
[assembly: AssemblyDescription("Buttplug Sex Toy Control Library. Contains Core (messages, errors, etc), Client, and Websocket Connector components")]
[assembly: AssemblyFileVersion("5.0.1.0")]
[assembly: AssemblyInformationalVersion("5.0.1+08b292884fa1a73f5cdd64cfa4aa956a2b22d14b")]
[assembly: AssemblyProduct("Buttplug")]
[assembly: AssemblyTitle("Buttplug")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/buttplugio/buttplug-csharp")]
[assembly: AssemblyVersion("5.0.1.0")]
namespace Buttplug.Core
{
	public static class ButtplugConsts
	{
		public const uint SystemMsgId = 0u;

		public const uint DefaultMsgId = 1u;

		public const uint MaxId = uint.MaxValue;

		public const uint ProtocolVersionMajor = 4u;

		public const uint ProtocolVersionMinor = 0u;

		public const uint CurrentSpecVersion = 4u;
	}
	public class ButtplugDeviceException : ButtplugException
	{
		public ButtplugDeviceException(string message, uint id = 0u, Exception inner = null)
			: base(message, Error.ErrorClass.ERROR_DEVICE, id, inner)
		{
		}
	}
	public class ButtplugException : Exception
	{
		public Error ButtplugErrorMessage { get; }

		public static ButtplugException FromError(Error msg)
		{
			return msg.ErrorCode switch
			{
				Error.ErrorClass.ERROR_DEVICE => new ButtplugDeviceException(msg.ErrorMessage, msg.Id), 
				Error.ErrorClass.ERROR_INIT => new ButtplugHandshakeException(msg.ErrorMessage, msg.Id), 
				Error.ErrorClass.ERROR_MSG => new ButtplugMessageException(msg.ErrorMessage, msg.Id), 
				Error.ErrorClass.ERROR_PING => new ButtplugPingException(msg.ErrorMessage, msg.Id), 
				Error.ErrorClass.ERROR_UNKNOWN => new ButtplugException(msg.ErrorMessage, msg.Id), 
				_ => new ButtplugException(msg.ErrorMessage, msg.Id), 
			};
		}

		public ButtplugException(string message, uint id = 0u, Exception inner = null)
			: this(message, Error.ErrorClass.ERROR_UNKNOWN, id, inner)
		{
		}

		public ButtplugException(string message, Error.ErrorClass err = Error.ErrorClass.ERROR_UNKNOWN, uint id = 0u, Exception inner = null)
			: base(message, inner)
		{
			ButtplugErrorMessage = new Error(message, err, id);
		}
	}
	public class ButtplugExceptionEventArgs : EventArgs
	{
		public ButtplugException Exception { get; }

		public ButtplugExceptionEventArgs(ButtplugException ex)
		{
			Exception = ex;
		}
	}
	public class ButtplugHandshakeException : ButtplugException
	{
		public ButtplugHandshakeException(string message, uint id = 0u, Exception inner = null)
			: base(message, Error.ErrorClass.ERROR_INIT, id, inner)
		{
		}
	}
	public class ButtplugJsonMessageParser
	{
		private readonly Dictionary<string, Type> _messageTypes;

		private readonly JsonSerializer _serializer;

		public ButtplugJsonMessageParser()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			_serializer = new JsonSerializer
			{
				MissingMemberHandling = (MissingMemberHandling)0
			};
			_messageTypes = new Dictionary<string, Type>();
			foreach (Type allMessageType in ButtplugUtils.GetAllMessageTypes())
			{
				_messageTypes.Add(allMessageType.Name, allMessageType);
			}
			if (!_messageTypes.Any())
			{
				throw new ButtplugMessageException("No message types available.");
			}
		}

		public IEnumerable<ButtplugMessage> Deserialize(string jsonMsg)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0031: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			JsonTextReader val = new JsonTextReader((TextReader)new StringReader(jsonMsg))
			{
				CloseInput = false,
				SupportMultipleContent = true
			};
			List<ButtplugMessage> list = new List<ButtplugMessage>();
			while (true)
			{
				try
				{
					if (!((JsonReader)val).Read())
					{
						return list;
					}
				}
				catch (JsonReaderException ex)
				{
					JsonReaderException ex2 = ex;
					throw new ButtplugMessageException("Not valid JSON: " + jsonMsg + " - " + ((Exception)(object)ex2).Message);
				}
				JArray val2;
				try
				{
					val2 = JArray.Load((JsonReader)(object)val);
				}
				catch (JsonReaderException ex3)
				{
					JsonReaderException ex4 = ex3;
					throw new ButtplugMessageException("Not valid JSON: " + jsonMsg + " - " + ((Exception)(object)ex4).Message);
				}
				foreach (JObject item in ((JToken)val2).Children<JObject>())
				{
					string name = item.Properties().First().Name;
					if (!_messageTypes.ContainsKey(name))
					{
						throw new ButtplugMessageException(name + " is not a valid message class");
					}
					list.Add(DeserializeAs(item, _messageTypes[name]));
				}
			}
		}

		private ButtplugMessage DeserializeAs(JObject obj, Type msgType)
		{
			//IL_00c0: Expected O, but got Unknown
			if (!msgType.IsSubclassOf(typeof(ButtplugMessage)))
			{
				throw new ButtplugMessageException("Type " + msgType.Name + " is not a subclass of ButtplugMessage");
			}
			if (msgType.Namespace != "Buttplug.Core.Messages")
			{
				throw new ButtplugMessageException("Type " + msgType.Name + " (" + msgType.Namespace + ") is not in the namespace of Buttplug.Core.Messages");
			}
			string name = ButtplugMessage.GetName(msgType);
			try
			{
				return (ButtplugMessage)((JToken)Extensions.Value<JObject>((IEnumerable<JToken>)obj[name])).ToObject(msgType, _serializer);
			}
			catch (InvalidCastException ex)
			{
				throw new ButtplugMessageException($"Could not create message for JSON {obj}: {ex.Message}");
			}
			catch (JsonSerializationException ex2)
			{
				JsonSerializationException ex3 = ex2;
				throw new ButtplugMessageException($"Could not create message for JSON {obj}: {((Exception)(object)ex3).Message}");
			}
		}

		public string Serialize(ButtplugMessage msg)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (msg.GetType().Namespace != "Buttplug.Core.Messages")
			{
				throw new ButtplugMessageException("Type " + msg.GetType().Name + " (" + msg.GetType().Namespace + ") is not in the namespace of Buttplug.Core.Messages");
			}
			JObject val = ButtplugMessageToJObject(msg);
			if (val == null)
			{
				throw new ButtplugMessageException("Message cannot be converted to JSON.", msg.Id);
			}
			JArray val2 = new JArray();
			val2.Add((JToken)(object)val);
			return ((JToken)val2).ToString((Formatting)0, Array.Empty<JsonConverter>());
		}

		public string Serialize(IEnumerable<ButtplugMessage> msgs)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			JArray val = new JArray();
			foreach (ButtplugMessage msg in msgs)
			{
				JObject val2 = ButtplugMessageToJObject(msg);
				if (val2 != null)
				{
					val.Add((JToken)(object)val2);
				}
			}
			if (!((IEnumerable<JToken>)val).Any())
			{
				throw new ButtplugMessageException("No messages serialized.");
			}
			return ((JToken)val).ToString((Formatting)0, Array.Empty<JsonConverter>());
		}

		private JObject ButtplugMessageToJObject(ButtplugMessage msg)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return new JObject((object)new JProperty(msg.Name, (object)JObject.FromObject((object)msg)));
		}
	}
	public class ButtplugMessageException : ButtplugException
	{
		public ButtplugMessageException(string message, uint id = 0u, Exception inner = null)
			: base(message, Error.ErrorClass.ERROR_MSG, id, inner)
		{
		}
	}
	public class ButtplugPingException : ButtplugException
	{
		public ButtplugPingException(string message, uint id = 0u, Exception inner = null)
			: base(message, Error.ErrorClass.ERROR_PING, id, inner)
		{
		}
	}
	public static class ButtplugUtils
	{
		public static IEnumerable<Type> GetAllMessageTypes()
		{
			IEnumerable<Type> enumerable;
			try
			{
				enumerable = Assembly.GetAssembly(typeof(ButtplugMessage))?.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				enumerable = ex.Types;
			}
			return (enumerable ?? throw new InvalidOperationException()).Where((Type type) => type != null && type.IsClass && type.IsSubclassOf(typeof(ButtplugMessage)) && type != typeof(ButtplugDeviceMessage));
		}

		[DebuggerStepThrough]
		public static void ArgumentNotNull(object argument, string argumentName)
		{
			if (argument == null)
			{
				throw new ArgumentNullException(argumentName);
			}
		}

		public static Type GetMessageType(string messageName)
		{
			return Type.GetType("Buttplug.Core.Messages." + messageName);
		}
	}
}
namespace Buttplug.Core.Messages
{
	public class ButtplugDeviceMessage : ButtplugMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint DeviceIndex { get; set; }

		public ButtplugDeviceMessage(uint id = 1u, uint deviceIndex = uint.MaxValue)
			: base(id)
		{
			DeviceIndex = deviceIndex;
		}
	}
	public abstract class ButtplugMessage
	{
		private static readonly Dictionary<Type, ButtplugMessageMetadata> _metadataCache = new Dictionary<Type, ButtplugMessageMetadata>();

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint Id { get; set; }

		[JsonIgnore]
		public string Name => GetName(GetType());

		protected ButtplugMessage(uint id)
		{
			Id = id;
		}

		private static T GetMessageAttribute<T>(Type msgType, Func<ButtplugMessageMetadata, T> func)
		{
			ButtplugUtils.ArgumentNotNull(msgType, "msgType");
			ButtplugUtils.ArgumentNotNull(func, "func");
			if (!msgType.IsSubclassOf(typeof(ButtplugMessage)))
			{
				throw new ArgumentException("Argument " + msgType.Name + " must be a subclass of ButtplugMessage");
			}
			if (_metadataCache.ContainsKey(msgType))
			{
				return func(_metadataCache[msgType]);
			}
			Attribute[] customAttributes = Attribute.GetCustomAttributes(msgType);
			for (int i = 0; i < customAttributes.Length; i++)
			{
				if (customAttributes[i] is ButtplugMessageMetadata buttplugMessageMetadata)
				{
					_metadataCache[msgType] = buttplugMessageMetadata;
					return func(buttplugMessageMetadata);
				}
			}
			throw new ArgumentException($"Type {msgType} does not have ButtplugMessageMetadata Attributes");
		}

		public static string GetName(Type msgType)
		{
			return GetMessageAttribute(msgType, (ButtplugMessageMetadata md) => md.Name);
		}
	}
	public interface IButtplugMessageOutgoingOnly
	{
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class ButtplugMessageMetadata : Attribute
	{
		public string Name { get; }

		public ButtplugMessageMetadata(string name)
		{
			Name = name;
		}
	}
	public interface IButtplugDeviceInfoMessage
	{
		string DeviceName { get; }

		uint DeviceIndex { get; }

		string DeviceDisplayName { get; }

		uint DeviceMessageTimingGap { get; }

		Dictionary<string, DeviceFeature> DeviceFeatures { get; }
	}
	public class MessageReceivedEventArgs : EventArgs
	{
		public ButtplugMessage Message { get; }

		public MessageReceivedEventArgs(ButtplugMessage message)
		{
			Message = message;
		}
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum OutputType
	{
		[EnumMember(Value = "Unknown")]
		Unknown,
		[EnumMember(Value = "Vibrate")]
		Vibrate,
		[EnumMember(Value = "Oscillate")]
		Oscillate,
		[EnumMember(Value = "Rotate")]
		Rotate,
		[EnumMember(Value = "Position")]
		Position,
		[EnumMember(Value = "HwPositionWithDuration")]
		HwPositionWithDuration,
		[EnumMember(Value = "Led")]
		Led,
		[EnumMember(Value = "Temperature")]
		Temperature,
		[EnumMember(Value = "Constrict")]
		Constrict,
		[EnumMember(Value = "Spray")]
		Spray
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum InputType
	{
		[EnumMember(Value = "Unknown")]
		Unknown,
		[EnumMember(Value = "Battery")]
		Battery,
		[EnumMember(Value = "RSSI")]
		RSSI,
		[EnumMember(Value = "Button")]
		Button,
		[EnumMember(Value = "Pressure")]
		Pressure,
		[EnumMember(Value = "Depth")]
		Depth,
		[EnumMember(Value = "Position")]
		Position
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum InputCommandType
	{
		[EnumMember(Value = "Read")]
		Read,
		[EnumMember(Value = "Subscribe")]
		Subscribe,
		[EnumMember(Value = "Unsubscribe")]
		Unsubscribe
	}
	[ButtplugMessageMetadata("Ok")]
	public class Ok : ButtplugMessage, IButtplugMessageOutgoingOnly
	{
		public Ok(uint id)
			: base(id)
		{
		}
	}
	[ButtplugMessageMetadata("Error")]
	public class Error : ButtplugMessage, IButtplugMessageOutgoingOnly
	{
		public enum ErrorClass
		{
			ERROR_UNKNOWN,
			ERROR_INIT,
			ERROR_PING,
			ERROR_MSG,
			ERROR_DEVICE
		}

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public ErrorClass ErrorCode;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string ErrorMessage;

		public Error(string errorMessage, ErrorClass errorCode, uint id)
			: base(id)
		{
			ErrorMessage = errorMessage;
			ErrorCode = errorCode;
		}
	}
	public class DeviceFeatureOutput
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int[] Value;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int[] Duration;
	}
	public class DeviceFeatureInput
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int[][] Value;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public InputCommandType[] Command;
	}
	public class DeviceFeature
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string FeatureDescription;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint FeatureIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, DeviceFeatureOutput> Output;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, DeviceFeatureInput> Input;

		public bool HasOutput(OutputType type)
		{
			if (Output != null)
			{
				return Output.ContainsKey(type.ToString());
			}
			return false;
		}

		public bool HasInput(InputType type)
		{
			if (Input != null)
			{
				return Input.ContainsKey(type.ToString());
			}
			return false;
		}

		public DeviceFeatureOutput GetOutput(OutputType type)
		{
			if (Output == null || !Output.ContainsKey(type.ToString()))
			{
				return null;
			}
			return Output[type.ToString()];
		}

		public DeviceFeatureInput GetInput(InputType type)
		{
			if (Input == null || !Input.ContainsKey(type.ToString()))
			{
				return null;
			}
			return Input[type.ToString()];
		}
	}
	public class DeviceInfo : IButtplugDeviceInfoMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string DeviceName;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint DeviceIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string DeviceDisplayName;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint DeviceMessageTimingGap;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, DeviceFeature> DeviceFeatures;

		string IButtplugDeviceInfoMessage.DeviceName => DeviceName;

		uint IButtplugDeviceInfoMessage.DeviceIndex => DeviceIndex;

		string IButtplugDeviceInfoMessage.DeviceDisplayName => DeviceDisplayName;

		uint IButtplugDeviceInfoMessage.DeviceMessageTimingGap => DeviceMessageTimingGap;

		Dictionary<string, DeviceFeature> IButtplugDeviceInfoMessage.DeviceFeatures => DeviceFeatures;

		public DeviceFeature GetFeature(uint index)
		{
			string key = index.ToString();
			if (DeviceFeatures != null && DeviceFeatures.ContainsKey(key))
			{
				return DeviceFeatures[key];
			}
			return null;
		}

		public IEnumerable<DeviceFeature> GetAllFeatures()
		{
			if (DeviceFeatures == null)
			{
				return Enumerable.Empty<DeviceFeature>();
			}
			return DeviceFeatures.Values;
		}

		public IEnumerable<DeviceFeature> GetFeaturesWithOutput(OutputType type)
		{
			return from f in GetAllFeatures()
				where f.HasOutput(type)
				select f;
		}

		public IEnumerable<DeviceFeature> GetFeaturesWithInput(InputType type)
		{
			return from f in GetAllFeatures()
				where f.HasInput(type)
				select f;
		}
	}
	public class DeviceListConverter : JsonConverter<DeviceList>
	{
		public override DeviceList ReadJson(JsonReader reader, Type objectType, DeviceList existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			JObject val = JObject.Load(reader);
			DeviceList deviceList = new DeviceList();
			if (val["Id"] != null)
			{
				deviceList.Id = Extensions.Value<uint>((IEnumerable<JToken>)val["Id"]);
			}
			deviceList.Devices = new Dictionary<uint, DeviceInfo>();
			if (val["Devices"] != null)
			{
				JToken obj = val["Devices"];
				JObject val2 = (JObject)(object)((obj is JObject) ? obj : null);
				if (val2 != null)
				{
					foreach (JProperty item in val2.Properties())
					{
						DeviceInfo value = item.Value.ToObject<DeviceInfo>(serializer);
						deviceList.Devices[uint.Parse(item.Name)] = value;
					}
				}
			}
			return deviceList;
		}

		public override void WriteJson(JsonWriter writer, DeviceList value, JsonSerializer serializer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			JObject val = new JObject();
			val["Id"] = JToken.op_Implicit(value.Id);
			JObject val2 = new JObject();
			if (value.Devices != null)
			{
				foreach (KeyValuePair<uint, DeviceInfo> device in value.Devices)
				{
					((JToken)val2)[(object)device.Key] = (JToken)(object)JObject.FromObject((object)device.Value, serializer);
				}
			}
			val["Devices"] = (JToken)(object)val2;
			((JToken)val).WriteTo(writer, Array.Empty<JsonConverter>());
		}
	}
	[ButtplugMessageMetadata("DeviceList")]
	[JsonConverter(typeof(DeviceListConverter))]
	public class DeviceList : ButtplugMessage, IButtplugMessageOutgoingOnly
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<uint, DeviceInfo> Devices;

		public DeviceList(Dictionary<uint, DeviceInfo> devices, uint id)
			: base(id)
		{
			Devices = devices ?? new Dictionary<uint, DeviceInfo>();
		}

		internal DeviceList()
			: base(0u)
		{
			Devices = new Dictionary<uint, DeviceInfo>();
		}

		public IEnumerable<DeviceInfo> GetAllDevices()
		{
			IEnumerable<DeviceInfo> enumerable = Devices?.Values;
			return enumerable ?? Enumerable.Empty<DeviceInfo>();
		}

		public DeviceInfo GetDevice(uint index)
		{
			if (Devices != null && Devices.ContainsKey(index))
			{
				return Devices[index];
			}
			return null;
		}
	}
	[ButtplugMessageMetadata("RequestDeviceList")]
	public class RequestDeviceList : ButtplugMessage
	{
		public RequestDeviceList(uint id = 1u)
			: base(id)
		{
		}
	}
	[ButtplugMessageMetadata("StartScanning")]
	public class StartScanning : ButtplugMessage
	{
		public StartScanning(uint id = 1u)
			: base(id)
		{
		}
	}
	[ButtplugMessageMetadata("StopScanning")]
	public class StopScanning : ButtplugMessage
	{
		public StopScanning(uint id = 1u)
			: base(id)
		{
		}
	}
	[ButtplugMessageMetadata("ScanningFinished")]
	public class ScanningFinished : ButtplugMessage, IButtplugMessageOutgoingOnly
	{
		public ScanningFinished()
			: base(0u)
		{
		}
	}
	[ButtplugMessageMetadata("RequestServerInfo")]
	public class RequestServerInfo : ButtplugMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string ClientName;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint ProtocolVersionMajor;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint ProtocolVersionMinor;

		public RequestServerInfo(string clientName, uint id = 1u, uint protocolVersionMajor = 4u, uint protocolVersionMinor = 0u)
			: base(id)
		{
			ClientName = clientName;
			ProtocolVersionMajor = protocolVersionMajor;
			ProtocolVersionMinor = protocolVersionMinor;
		}
	}
	[ButtplugMessageMetadata("ServerInfo")]
	public class ServerInfo : ButtplugMessage, IButtplugMessageOutgoingOnly
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint ProtocolVersionMajor;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint ProtocolVersionMinor;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint MaxPingTime;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string ServerName;

		[JsonIgnore]
		public uint MessageVersion => ProtocolVersionMajor;

		public ServerInfo(string serverName, uint protocolVersionMajor, uint protocolVersionMinor, uint maxPingTime, uint id = 1u)
			: base(id)
		{
			ServerName = serverName;
			ProtocolVersionMajor = protocolVersionMajor;
			ProtocolVersionMinor = protocolVersionMinor;
			MaxPingTime = maxPingTime;
		}
	}
	[ButtplugMessageMetadata("Ping")]
	public class Ping : ButtplugMessage
	{
		public Ping(uint id = 1u)
			: base(id)
		{
		}
	}
	[ButtplugMessageMetadata("StopCmd")]
	public class StopCmd : ButtplugMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint? DeviceIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint? FeatureIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Inputs;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Outputs;

		public StopCmd(uint id = 1u, uint? deviceIndex = null, uint? featureIndex = null, bool? inputs = null, bool? outputs = null)
			: base(id)
		{
			DeviceIndex = deviceIndex;
			FeatureIndex = featureIndex;
			Inputs = inputs;
			Outputs = outputs;
		}
	}
	[ButtplugMessageMetadata("StopDeviceCmd")]
	public class StopDeviceCmd : ButtplugDeviceMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Inputs;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Outputs;

		public StopDeviceCmd(uint deviceIndex = uint.MaxValue, uint id = 1u, bool? inputs = null, bool? outputs = null)
			: base(id, deviceIndex)
		{
			Inputs = inputs;
			Outputs = outputs;
		}
	}
	[ButtplugMessageMetadata("StopAllDevices")]
	public class StopAllDevices : ButtplugMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Inputs;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool? Outputs;

		public StopAllDevices(uint id = 1u, bool? inputs = null, bool? outputs = null)
			: base(id)
		{
			Inputs = inputs;
			Outputs = outputs;
		}
	}
	public class OutputCommandValue
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int Value;

		public OutputCommandValue()
		{
		}

		public OutputCommandValue(int value)
		{
			Value = value;
		}
	}
	public class OutputCommandValueWithDuration
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int Value;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint Duration;

		public OutputCommandValueWithDuration()
		{
		}

		public OutputCommandValueWithDuration(int value, uint duration)
		{
			Value = value;
			Duration = duration;
		}
	}
	public class OutputCmdConverter : JsonConverter<OutputCmd>
	{
		public override OutputCmd ReadJson(JsonReader reader, Type objectType, OutputCmd existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			JObject val = JObject.Load(reader);
			OutputCmd outputCmd = new OutputCmd();
			if (val["Id"] != null)
			{
				outputCmd.Id = Extensions.Value<uint>((IEnumerable<JToken>)val["Id"]);
			}
			if (val["DeviceIndex"] != null)
			{
				outputCmd.DeviceIndex = Extensions.Value<uint>((IEnumerable<JToken>)val["DeviceIndex"]);
			}
			if (val["FeatureIndex"] != null)
			{
				outputCmd.FeatureIndex = Extensions.Value<uint>((IEnumerable<JToken>)val["FeatureIndex"]);
			}
			outputCmd.Command = new Dictionary<string, object>();
			if (val["Command"] != null)
			{
				JToken obj = val["Command"];
				JObject val2 = (JObject)(object)((obj is JObject) ? obj : null);
				if (val2 != null)
				{
					foreach (JProperty item in val2.Properties())
					{
						if (item.Name == "HwPositionWithDuration")
						{
							outputCmd.Command[item.Name] = item.Value.ToObject<OutputCommandValueWithDuration>(serializer);
						}
						else
						{
							outputCmd.Command[item.Name] = item.Value.ToObject<OutputCommandValue>(serializer);
						}
					}
				}
			}
			return outputCmd;
		}

		public override void WriteJson(JsonWriter writer, OutputCmd value, JsonSerializer serializer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			JObject val = new JObject();
			val["Id"] = JToken.op_Implicit(value.Id);
			val["DeviceIndex"] = JToken.op_Implicit(value.DeviceIndex);
			val["FeatureIndex"] = JToken.op_Implicit(value.FeatureIndex);
			JObject val2 = new JObject();
			if (value.Command != null)
			{
				foreach (KeyValuePair<string, object> item in value.Command)
				{
					val2[item.Key] = (JToken)(object)JObject.FromObject(item.Value, serializer);
				}
			}
			val["Command"] = (JToken)(object)val2;
			((JToken)val).WriteTo(writer, Array.Empty<JsonConverter>());
		}
	}
	[ButtplugMessageMetadata("OutputCmd")]
	[JsonConverter(typeof(OutputCmdConverter))]
	public class OutputCmd : ButtplugDeviceMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint FeatureIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, object> Command;

		public OutputCmd()
		{
			Command = new Dictionary<string, object>();
		}

		public OutputCmd(uint deviceIndex, uint featureIndex, uint id = 1u)
			: base(id, deviceIndex)
		{
			FeatureIndex = featureIndex;
			Command = new Dictionary<string, object>();
		}

		public static OutputCmd Create(uint deviceIndex, uint featureIndex, OutputType outputType, int value, uint id = 1u)
		{
			return new OutputCmd(deviceIndex, featureIndex, id)
			{
				Command = { [outputType.ToString()] = new OutputCommandValue(value) }
			};
		}

		public static OutputCmd CreatePositionWithDuration(uint deviceIndex, uint featureIndex, int position, uint duration, uint id = 1u)
		{
			return new OutputCmd(deviceIndex, featureIndex, id)
			{
				Command = { [OutputType.HwPositionWithDuration.ToString()] = new OutputCommandValueWithDuration(position, duration) }
			};
		}

		public OutputCmd WithValue(OutputType outputType, int value)
		{
			Command[outputType.ToString()] = new OutputCommandValue(value);
			return this;
		}

		public OutputCmd WithPositionAndDuration(int position, uint duration)
		{
			Command[OutputType.HwPositionWithDuration.ToString()] = new OutputCommandValueWithDuration(position, duration);
			return this;
		}
	}
	[ButtplugMessageMetadata("InputCmd")]
	public class InputCmd : ButtplugDeviceMessage
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint FeatureIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public InputType Type;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public InputCommandType Command;

		public InputCmd()
		{
		}

		public InputCmd(uint deviceIndex, uint featureIndex, InputType type, InputCommandType command, uint id = 1u)
			: base(id, deviceIndex)
		{
			FeatureIndex = featureIndex;
			Type = type;
			Command = command;
		}

		public static InputCmd Read(uint deviceIndex, uint featureIndex, InputType type, uint id = 1u)
		{
			return new InputCmd(deviceIndex, featureIndex, type, InputCommandType.Read, id);
		}

		public static InputCmd Subscribe(uint deviceIndex, uint featureIndex, InputType type, uint id = 1u)
		{
			return new InputCmd(deviceIndex, featureIndex, type, InputCommandType.Subscribe, id);
		}

		public static InputCmd Unsubscribe(uint deviceIndex, uint featureIndex, InputType type, uint id = 1u)
		{
			return new InputCmd(deviceIndex, featureIndex, type, InputCommandType.Unsubscribe, id);
		}
	}
	public class InputReadingValue
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public double Value;

		public InputReadingValue()
		{
		}

		public InputReadingValue(double value)
		{
			Value = value;
		}
	}
	public class InputReadingConverter : JsonConverter<InputReading>
	{
		public override InputReading ReadJson(JsonReader reader, Type objectType, InputReading existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			JObject val = JObject.Load(reader);
			InputReading inputReading = new InputReading();
			if (val["Id"] != null)
			{
				inputReading.Id = Extensions.Value<uint>((IEnumerable<JToken>)val["Id"]);
			}
			if (val["DeviceIndex"] != null)
			{
				inputReading.DeviceIndex = Extensions.Value<uint>((IEnumerable<JToken>)val["DeviceIndex"]);
			}
			if (val["FeatureIndex"] != null)
			{
				inputReading.FeatureIndex = Extensions.Value<uint>((IEnumerable<JToken>)val["FeatureIndex"]);
			}
			inputReading.Reading = new Dictionary<string, InputReadingValue>();
			if (val["Reading"] != null)
			{
				JToken obj = val["Reading"];
				JObject val2 = (JObject)(object)((obj is JObject) ? obj : null);
				if (val2 != null)
				{
					foreach (JProperty item in val2.Properties())
					{
						inputReading.Reading[item.Name] = item.Value.ToObject<InputReadingValue>(serializer);
					}
				}
			}
			return inputReading;
		}

		public override void WriteJson(JsonWriter writer, InputReading value, JsonSerializer serializer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			JObject val = new JObject();
			val["Id"] = JToken.op_Implicit(value.Id);
			val["DeviceIndex"] = JToken.op_Implicit(value.DeviceIndex);
			val["FeatureIndex"] = JToken.op_Implicit(value.FeatureIndex);
			JObject val2 = new JObject();
			if (value.Reading != null)
			{
				foreach (KeyValuePair<string, InputReadingValue> item in value.Reading)
				{
					val2[item.Key] = (JToken)(object)JObject.FromObject((object)item.Value, serializer);
				}
			}
			val["Reading"] = (JToken)(object)val2;
			((JToken)val).WriteTo(writer, Array.Empty<JsonConverter>());
		}
	}
	[ButtplugMessageMetadata("InputReading")]
	[JsonConverter(typeof(InputReadingConverter))]
	public class InputReading : ButtplugDeviceMessage, IButtplugMessageOutgoingOnly
	{
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public uint FeatureIndex;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, InputReadingValue> Reading;

		public double? BatteryLevel => GetValue(InputType.Battery);

		public double? RSSILevel => GetValue(InputType.RSSI);

		public InputReading()
			: base(0u)
		{
			Reading = new Dictionary<string, InputReadingValue>();
		}

		public InputReading(uint deviceIndex, uint featureIndex, uint id = 0u)
			: base(id, deviceIndex)
		{
			FeatureIndex = featureIndex;
			Reading = new Dictionary<string, InputReadingValue>();
		}

		public double? GetValue(InputType type)
		{
			string key = type.ToString();
			if (Reading != null && Reading.ContainsKey(key))
			{
				return Reading[key].Value;
			}
			return null;
		}
	}
}
namespace Buttplug.Client
{
	public class ButtplugClient : IDisposable, IAsyncDisposable
	{
		protected Timer _pingTimer;

		internal ButtplugClientMessageHandler _handler;

		private readonly ConcurrentDictionary<uint, ButtplugClientDevice> _devices = new ConcurrentDictionary<uint, ButtplugClientDevice>();

		private IButtplugClientConnector _connector;

		private int _serverDisconnectRaised;

		public string Name { get; }

		public ButtplugClientDevice[] Devices => _devices.Values.ToArray();

		public bool Connected => _connector?.Connected ?? false;

		public event EventHandler<DeviceAddedEventArgs> DeviceAdded;

		public event EventHandler<DeviceRemovedEventArgs> DeviceRemoved;

		public event EventHandler<ButtplugExceptionEventArgs> ErrorReceived;

		public event EventHandler ScanningFinished;

		public event EventHandler PingTimeout;

		public event EventHandler ServerDisconnect;

		public event EventHandler<InputReadingEventArgs> InputReadingReceived;

		public ButtplugClient(string clientName)
		{
			Name = clientName;
		}

		public async Task ConnectAsync(IButtplugClientConnector connector, CancellationToken token = default(CancellationToken))
		{
			if (Connected)
			{
				throw new ButtplugHandshakeException("Client already connected to a server.");
			}
			ButtplugUtils.ArgumentNotNull(connector, "connector");
			_connector = connector;
			_serverDisconnectRaised = 0;
			_connector.Disconnected += ConnectorDisconnectedHandler;
			_connector.InvalidMessageReceived += ConnectorErrorHandler;
			_connector.MessageReceived += MessageReceivedHandler;
			_devices.Clear();
			_handler = new ButtplugClientMessageHandler(connector);
			await _connector.ConnectAsync(token).ConfigureAwait(continueOnCapturedContext: false);
			ButtplugMessage res = await _handler.SendMessageAsync(new RequestServerInfo(Name), token).ConfigureAwait(continueOnCapturedContext: false);
			if (!(res is ServerInfo si))
			{
				if (res is Error e)
				{
					await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
					throw ButtplugException.FromError(e);
				}
				await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
				throw new ButtplugHandshakeException("Unrecognized message " + res.Name + " during handshake", res.Id);
			}
			if (si.MaxPingTime != 0)
			{
				_pingTimer?.Dispose();
				_pingTimer = new Timer(OnPingTimer, null, 0, Convert.ToInt32(Math.Round((double)si.MaxPingTime / 2.0, 0)));
			}
			if (si.ProtocolVersionMajor < 4)
			{
				await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
				throw new ButtplugHandshakeException($"Buttplug Server's protocol version ({si.ProtocolVersionMajor}.{si.ProtocolVersionMinor}) is less than the client's ({4u}.{0u}). A newer server is required.", res.Id);
			}
			try
			{
				await RequestDeviceListAsync(token).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch
			{
				await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
				throw;
			}
		}

		public async Task DisconnectAsync()
		{
			if (Connected)
			{
				_connector.MessageReceived -= MessageReceivedHandler;
				_connector.InvalidMessageReceived -= ConnectorErrorHandler;
				await _connector.DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
				_connector.Disconnected -= ConnectorDisconnectedHandler;
				SignalServerDisconnect(this, EventArgs.Empty);
			}
		}

		private async Task RequestDeviceListAsync(CancellationToken token = default(CancellationToken))
		{
			ButtplugMessage buttplugMessage = await _handler.SendMessageAsync(new RequestDeviceList(), token).ConfigureAwait(continueOnCapturedContext: false);
			if (buttplugMessage is DeviceList list)
			{
				ProcessDeviceList(list);
				return;
			}
			if (buttplugMessage is Error msg)
			{
				throw ButtplugException.FromError(msg);
			}
			throw new ButtplugMessageException("Received unknown response to DeviceList query");
		}

		private void ProcessDeviceList(DeviceList list)
		{
			HashSet<uint> incomingDeviceIndices = new HashSet<uint>();
			foreach (DeviceInfo allDevice in list.GetAllDevices())
			{
				incomingDeviceIndices.Add(allDevice.DeviceIndex);
				if (!_devices.ContainsKey(allDevice.DeviceIndex))
				{
					ButtplugClientDevice buttplugClientDevice = new ButtplugClientDevice(_handler, allDevice);
					_devices[allDevice.DeviceIndex] = buttplugClientDevice;
					this.DeviceAdded?.Invoke(this, new DeviceAddedEventArgs(buttplugClientDevice));
				}
			}
			foreach (uint item in _devices.Keys.Where((uint idx) => !incomingDeviceIndices.Contains(idx)).ToList())
			{
				if (_devices.TryRemove(item, out var value))
				{
					this.DeviceRemoved?.Invoke(this, new DeviceRemovedEventArgs(value));
				}
			}
		}

		public async Task StartScanningAsync(CancellationToken token = default(CancellationToken))
		{
			EnsureConnected();
			await _handler.SendMessageExpectOk(new StartScanning(), token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task StopScanningAsync(CancellationToken token = default(CancellationToken))
		{
			EnsureConnected();
			await _handler.SendMessageExpectOk(new StopScanning(), token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task StopAllDevicesAsync(CancellationToken token = default(CancellationToken))
		{
			EnsureConnected();
			await _handler.SendMessageExpectOk(new StopCmd(), token).ConfigureAwait(continueOnCapturedContext: false);
		}

		private void EnsureConnected()
		{
			if (!Connected)
			{
				throw new ButtplugClientConnectorException("Client not connected.");
			}
		}

		private void ConnectorErrorHandler(object sender, ButtplugExceptionEventArgs exception)
		{
			this.ErrorReceived?.Invoke(this, exception);
		}

		private void ConnectorDisconnectedHandler(object sender, EventArgs eventArgs)
		{
			SignalServerDisconnect(sender, eventArgs);
		}

		private void SignalServerDisconnect(object sender, EventArgs eventArgs)
		{
			if (Interlocked.Exchange(ref _serverDisconnectRaised, 1) == 0)
			{
				this.ServerDisconnect?.Invoke(sender, eventArgs);
			}
		}

		private async void MessageReceivedHandler(object sender, MessageReceivedEventArgs args)
		{
			ButtplugMessage message = args.Message;
			if (!(message is DeviceList list))
			{
				if (!(message is ScanningFinished))
				{
					if (!(message is InputReading reading))
					{
						if (message is Error error)
						{
							this.ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(ButtplugException.FromError(error)));
							if (error.ErrorCode == Error.ErrorClass.ERROR_PING)
							{
								this.PingTimeout?.Invoke(this, EventArgs.Empty);
								await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
							}
						}
						else
						{
							this.ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugMessageException($"Got unhandled message: {message}", message.Id)));
						}
					}
					else
					{
						this.InputReadingReceived?.Invoke(this, new InputReadingEventArgs(reading));
					}
				}
				else
				{
					try
					{
						await RequestDeviceListAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
					catch (Exception ex)
					{
						this.ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugMessageException("Failed to get device list after scanning: " + ex.Message)));
					}
					this.ScanningFinished?.Invoke(this, EventArgs.Empty);
				}
			}
			else
			{
				ProcessDeviceList(list);
			}
		}

		private async void OnPingTimer(object state)
		{
			try
			{
				await _handler.SendMessageExpectOk(new Ping()).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (Exception inner)
			{
				this.ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugPingException("Exception thrown during ping update", 0u, inner)));
				await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			_pingTimer?.Dispose();
			DisconnectAsync().GetAwaiter().GetResult();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public async ValueTask DisposeAsync()
		{
			_pingTimer?.Dispose();
			await DisconnectAsync().ConfigureAwait(continueOnCapturedContext: false);
			GC.SuppressFinalize(this);
		}
	}
	public class DeviceAddedEventArgs : EventArgs
	{
		public ButtplugClientDevice Device { get; }

		public DeviceAddedEventArgs(ButtplugClientDevice device)
		{
			Device = device;
		}
	}
	public class DeviceRemovedEventArgs : EventArgs
	{
		public ButtplugClientDevice Device { get; }

		public DeviceRemovedEventArgs(ButtplugClientDevice device)
		{
			Device = device;
		}
	}
	public class InputReadingEventArgs : EventArgs
	{
		public InputReading Reading { get; }

		public uint DeviceIndex => Reading.DeviceIndex;

		public uint FeatureIndex => Reading.FeatureIndex;

		public InputReadingEventArgs(InputReading reading)
		{
			Reading = reading;
		}
	}
	public class ButtplugClientConnectorException : ButtplugException
	{
		public ButtplugClientConnectorException(string message, Exception inner = null)
			: base(message, Error.ErrorClass.ERROR_UNKNOWN, 0u, inner)
		{
		}
	}
	public class ButtplugClientDevice
	{
		private readonly Dictionary<uint, ButtplugClientDeviceFeature> _features;

		private readonly ButtplugClientMessageHandler _handler;

		public uint Index { get; }

		public string Name { get; }

		public string DisplayName { get; }

		public uint MessageTimingGap { get; }

		public IReadOnlyDictionary<uint, ButtplugClientDeviceFeature> Features => _features;

		internal ButtplugClientDevice(ButtplugClientMessageHandler handler, IButtplugDeviceInfoMessage devInfo)
			: this(handler, devInfo.DeviceIndex, devInfo.DeviceName, devInfo.DeviceFeatures, devInfo.DeviceDisplayName, devInfo.DeviceMessageTimingGap)
		{
			ButtplugUtils.ArgumentNotNull(devInfo, "devInfo");
		}

		internal ButtplugClientDevice(ButtplugClientMessageHandler handler, uint index, string name, Dictionary<string, DeviceFeature> deviceFeatures, string displayName, uint messageTimingGap)
		{
			ButtplugUtils.ArgumentNotNull(handler, "handler");
			_handler = handler;
			Index = index;
			Name = name;
			DisplayName = displayName;
			MessageTimingGap = messageTimingGap;
			_features = new Dictionary<uint, ButtplugClientDeviceFeature>();
			if (deviceFeatures == null)
			{
				return;
			}
			foreach (KeyValuePair<string, DeviceFeature> deviceFeature in deviceFeatures)
			{
				if (uint.TryParse(deviceFeature.Key, out var result))
				{
					_features[result] = new ButtplugClientDeviceFeature(this, deviceFeature.Value, _handler);
				}
			}
		}

		public IEnumerable<ButtplugClientDeviceFeature> GetFeaturesWithOutput(OutputType outputType)
		{
			return _features.Values.Where((ButtplugClientDeviceFeature f) => f.HasOutput(outputType));
		}

		public IEnumerable<ButtplugClientDeviceFeature> GetFeaturesWithInput(InputType inputType)
		{
			return _features.Values.Where((ButtplugClientDeviceFeature f) => f.HasInput(inputType));
		}

		public ButtplugClientDeviceFeature GetFeature(uint featureIndex)
		{
			if (!_features.TryGetValue(featureIndex, out var value))
			{
				return null;
			}
			return value;
		}

		public bool HasOutput(OutputType outputType)
		{
			return _features.Values.Any((ButtplugClientDeviceFeature f) => f.HasOutput(outputType));
		}

		public bool HasInput(InputType inputType)
		{
			return _features.Values.Any((ButtplugClientDeviceFeature f) => f.HasInput(inputType));
		}

		public async Task RunOutputAsync(DeviceOutputCommand command, CancellationToken token = default(CancellationToken))
		{
			List<ButtplugClientDeviceFeature> source = GetFeaturesWithOutput(command.OutputType).ToList();
			if (!source.Any())
			{
				throw new ButtplugDeviceException($"Device {Name} has no features with output type {command.OutputType}");
			}
			await Task.WhenAll(source.Select((ButtplugClientDeviceFeature f) => f.RunOutputAsync(command, token))).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task RunOutputAsync(uint featureIndex, DeviceOutputCommand command, CancellationToken token = default(CancellationToken))
		{
			await (GetFeature(featureIndex) ?? throw new ButtplugDeviceException($"Device {Name} does not have feature index {featureIndex}")).RunOutputAsync(command, token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task<InputReading> RunInputAsync(DeviceInputCommand command, CancellationToken token = default(CancellationToken))
		{
			List<ButtplugClientDeviceFeature> source = GetFeaturesWithInput(command.InputType).ToList();
			if (!source.Any())
			{
				throw new ButtplugDeviceException($"Device {Name} has no features with input type {command.InputType}");
			}
			return await source.First().RunInputAsync(command, token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task<InputReading> RunInputAsync(uint featureIndex, DeviceInputCommand command, CancellationToken token = default(CancellationToken))
		{
			return await (GetFeature(featureIndex) ?? throw new ButtplugDeviceException($"Device {Name} does not have feature index {featureIndex}")).RunInputAsync(command, token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task<double> BatteryAsync(TimeSpan? timeout = null, CancellationToken token = default(CancellationToken))
		{
			CancellationTokenSource linkedCts = null;
			try
			{
				CancellationToken token2 = token;
				if (timeout.HasValue)
				{
					linkedCts = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { token });
					linkedCts.CancelAfter(timeout.Value);
					token2 = linkedCts.Token;
				}
				double? num = (await RunInputAsync(DeviceInput.Battery.Read(), token2).ConfigureAwait(continueOnCapturedContext: false))?.GetValue(InputType.Battery);
				if (!num.HasValue)
				{
					throw new ButtplugMessageException("Battery reading from device '" + Name + "' did not contain a battery value.");
				}
				return num.Value / 100.0;
			}
			finally
			{
				linkedCts?.Dispose();
			}
		}

		public async Task StopAsync(CancellationToken token = default(CancellationToken))
		{
			await _handler.SendMessageExpectOk(new StopCmd(1u, Index), token).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	public class PercentOrSteps
	{
		private readonly double? _percent;

		private readonly int? _steps;

		public double? Percent => _percent;

		public int? Steps => _steps;

		private PercentOrSteps(double? percent, int? steps)
		{
			_percent = percent;
			_steps = steps;
		}

		public static PercentOrSteps FromSteps(int steps)
		{
			return new PercentOrSteps(null, steps);
		}

		public static PercentOrSteps FromPercent(double percent, double minPercent = 0.0, double maxPercent = 1.0)
		{
			if (percent < minPercent || percent > maxPercent)
			{
				throw new ButtplugDeviceException($"Percent value {percent} is not in the range {minPercent} <= x <= {maxPercent}");
			}
			return new PercentOrSteps(percent, null);
		}

		public int ToStepValue(int maxSteps)
		{
			if (_steps.HasValue)
			{
				return _steps.Value;
			}
			return (int)Math.Ceiling(_percent.Value * (double)maxSteps);
		}
	}
	public class DeviceOutputCommand
	{
		public OutputType OutputType { get; }

		public PercentOrSteps Value { get; }

		public uint? Duration { get; }

		public DeviceOutputCommand(OutputType outputType, PercentOrSteps value, uint? duration = null)
		{
			OutputType = outputType;
			Value = value;
			Duration = duration;
		}
	}
	public class DeviceOutputValueBuilder
	{
		private readonly OutputType _outputType;

		internal DeviceOutputValueBuilder(OutputType outputType)
		{
			_outputType = outputType;
		}

		public DeviceOutputCommand Steps(int steps)
		{
			return new DeviceOutputCommand(_outputType, PercentOrSteps.FromSteps(steps));
		}

		public DeviceOutputCommand Percent(double percent)
		{
			double minPercent = ((_outputType == OutputType.Rotate) ? (-1.0) : 0.0);
			return new DeviceOutputCommand(_outputType, PercentOrSteps.FromPercent(percent, minPercent));
		}
	}
	public class DeviceOutputPositionWithDurationBuilder
	{
		internal DeviceOutputPositionWithDurationBuilder()
		{
		}

		public DeviceOutputCommand Steps(int steps, uint durationMs)
		{
			return new DeviceOutputCommand(OutputType.HwPositionWithDuration, PercentOrSteps.FromSteps(steps), durationMs);
		}

		public DeviceOutputCommand Percent(double percent, uint durationMs)
		{
			return new DeviceOutputCommand(OutputType.HwPositionWithDuration, PercentOrSteps.FromPercent(percent), durationMs);
		}
	}
	public static class DeviceOutput
	{
		public static DeviceOutputValueBuilder Vibrate => new DeviceOutputValueBuilder(OutputType.Vibrate);

		public static DeviceOutputValueBuilder Rotate => new DeviceOutputValueBuilder(OutputType.Rotate);

		public static DeviceOutputValueBuilder Oscillate => new DeviceOutputValueBuilder(OutputType.Oscillate);

		public static DeviceOutputValueBuilder Constrict => new DeviceOutputValueBuilder(OutputType.Constrict);

		public static DeviceOutputValueBuilder Temperature => new DeviceOutputValueBuilder(OutputType.Temperature);

		public static DeviceOutputValueBuilder Led => new DeviceOutputValueBuilder(OutputType.Led);

		public static DeviceOutputValueBuilder Spray => new DeviceOutputValueBuilder(OutputType.Spray);

		public static DeviceOutputValueBuilder Position => new DeviceOutputValueBuilder(OutputType.Position);

		public static DeviceOutputPositionWithDurationBuilder PositionWithDuration => new DeviceOutputPositionWithDurationBuilder();
	}
	public class DeviceInputCommand
	{
		public InputType InputType { get; }

		public InputCommandType CommandType { get; }

		public DeviceInputCommand(InputType inputType, InputCommandType commandType)
		{
			InputType = inputType;
			CommandType = commandType;
		}
	}
	public class DeviceInputBuilder
	{
		private readonly InputType _inputType;

		internal DeviceInputBuilder(InputType inputType)
		{
			_inputType = inputType;
		}

		public DeviceInputCommand Read()
		{
			return new DeviceInputCommand(_inputType, InputCommandType.Read);
		}

		public DeviceInputCommand Subscribe()
		{
			return new DeviceInputCommand(_inputType, InputCommandType.Subscribe);
		}

		public DeviceInputCommand Unsubscribe()
		{
			return new DeviceInputCommand(_inputType, InputCommandType.Unsubscribe);
		}
	}
	public static class DeviceInput
	{
		public static DeviceInputBuilder Battery => new DeviceInputBuilder(InputType.Battery);

		public static DeviceInputBuilder RSSI => new DeviceInputBuilder(InputType.RSSI);

		public static DeviceInputBuilder Button => new DeviceInputBuilder(InputType.Button);

		public static DeviceInputBuilder Pressure => new DeviceInputBuilder(InputType.Pressure);

		public static DeviceInputBuilder Depth => new DeviceInputBuilder(InputType.Depth);

		public static DeviceInputBuilder Position => new DeviceInputBuilder(InputType.Position);
	}
	public class ButtplugClientDeviceFeature
	{
		private readonly ButtplugClientMessageHandler _handler;

		public ButtplugClientDevice Device { get; }

		public uint FeatureIndex { get; }

		public string FeatureDescription { get; }

		public DeviceFeature FeatureDefinition { get; }

		internal ButtplugClientDeviceFeature(ButtplugClientDevice device, DeviceFeature feature, ButtplugClientMessageHandler handler)
		{
			Device = device;
			FeatureIndex = feature.FeatureIndex;
			FeatureDescription = feature.FeatureDescription;
			FeatureDefinition = feature;
			_handler = handler;
		}

		public bool HasOutput(OutputType outputType)
		{
			return FeatureDefinition.HasOutput(outputType);
		}

		public bool HasInput(InputType inputType)
		{
			return FeatureDefinition.HasInput(inputType);
		}

		public bool TryGetOutputRange(OutputType outputType, out int min, out int max)
		{
			DeviceFeatureOutput output = FeatureDefinition.GetOutput(outputType);
			if (output?.Value != null && output.Value.Length >= 2)
			{
				min = output.Value[0];
				max = output.Value[1];
				return true;
			}
			min = 0;
			max = 0;
			return false;
		}

		public async Task RunOutputAsync(DeviceOutputCommand command, CancellationToken token = default(CancellationToken))
		{
			if (!HasOutput(command.OutputType))
			{
				IEnumerable<string> enumerable = FeatureDefinition.Output?.Keys;
				IEnumerable<string> enumerable2 = enumerable ?? Enumerable.Empty<string>();
				string text = (enumerable2.Any() ? string.Join(", ", enumerable2) : "none");
				throw new ButtplugDeviceException($"Feature {FeatureIndex} ({FeatureDescription}) on device '{Device.Name}' does not support output type '{command.OutputType}'. " + "Supported outputs: " + text + ".");
			}
			DeviceFeatureOutput output = FeatureDefinition.GetOutput(command.OutputType);
			int maxSteps = 100;
			if (output?.Value != null && output.Value.Length >= 2)
			{
				maxSteps = output.Value[1];
			}
			int num = command.Value.ToStepValue(maxSteps);
			OutputCmd msg;
			if (command.OutputType == OutputType.HwPositionWithDuration)
			{
				if (!command.Duration.HasValue)
				{
					throw new ButtplugDeviceException($"HwPositionWithDuration command for feature {FeatureIndex} ({FeatureDescription}) on device '{Device.Name}' requires a duration value. " + "Use DeviceOutput.PositionWithDuration.Percent(position, durationMs) or DeviceOutput.PositionWithDuration.Steps(steps, durationMs).");
				}
				msg = OutputCmd.CreatePositionWithDuration(Device.Index, FeatureIndex, num, command.Duration.Value);
			}
			else
			{
				msg = OutputCmd.Create(Device.Index, FeatureIndex, command.OutputType, num);
			}
			await _handler.SendMessageExpectOk(msg, token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task<InputReading> RunInputAsync(DeviceInputCommand command, CancellationToken token = default(CancellationToken))
		{
			if (!HasInput(command.InputType))
			{
				IEnumerable<string> enumerable = FeatureDefinition.Input?.Keys;
				IEnumerable<string> enumerable2 = enumerable ?? Enumerable.Empty<string>();
				string text = (enumerable2.Any() ? string.Join(", ", enumerable2) : "none");
				throw new ButtplugDeviceException($"Feature {FeatureIndex} ({FeatureDescription}) on device '{Device.Name}' does not support input type '{command.InputType}'. " + "Supported inputs: " + text + ".");
			}
			InputCmd msg = new InputCmd(Device.Index, FeatureIndex, command.InputType, command.CommandType);
			if (command.CommandType == InputCommandType.Read)
			{
				ButtplugMessage buttplugMessage = await _handler.SendMessageAsync(msg, token).ConfigureAwait(continueOnCapturedContext: false);
				if (!(buttplugMessage is InputReading result))
				{
					if (buttplugMessage is Error msg2)
					{
						throw ButtplugException.FromError(msg2);
					}
					throw new ButtplugMessageException("Message type " + buttplugMessage.Name + " not handled by RunInputAsync", buttplugMessage.Id);
				}
				return result;
			}
			await _handler.SendMessageExpectOk(msg, token).ConfigureAwait(continueOnCapturedContext: false);
			return null;
		}
	}
	public static class ButtplugClientExtensions
	{
		public static Task ConnectAsync(this ButtplugClient client, string uri, CancellationToken token = default(CancellationToken))
		{
			return client.ConnectAsync(new Uri(uri), token);
		}

		public static Task ConnectAsync(this ButtplugClient client, Uri uri, CancellationToken token = default(CancellationToken))
		{
			return client.ConnectAsync(new ButtplugWebsocketConnector(uri), token);
		}

		public static ButtplugClientDevice GetDevice(this ButtplugClient client, uint index)
		{
			return client.Devices.FirstOrDefault((ButtplugClientDevice d) => d.Index == index);
		}

		public static IEnumerable<ButtplugClientDevice> GetDevicesWithOutput(this ButtplugClient client, OutputType outputType)
		{
			return client.Devices.Where((ButtplugClientDevice d) => d.HasOutput(outputType));
		}

		public static IEnumerable<ButtplugClientDevice> GetDevicesWithInput(this ButtplugClient client, InputType inputType)
		{
			return client.Devices.Where((ButtplugClientDevice d) => d.HasInput(inputType));
		}
	}
	internal class ButtplugClientMessageHandler
	{
		private IButtplugClientConnector _connector;

		internal ButtplugClientMessageHandler(IButtplugClientConnector connector)
		{
			_connector = connector;
		}

		public async Task<ButtplugMessage> SendMessageAsync(ButtplugMessage msg, CancellationToken token = default(CancellationToken))
		{
			if (!_connector.Connected)
			{
				throw new ButtplugClientConnectorException("Client not connected.");
			}
			return await _connector.SendAsync(msg, token).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task SendMessageExpectOk(ButtplugMessage msg, CancellationToken token = default(CancellationToken))
		{
			ButtplugMessage buttplugMessage = await SendMessageAsync(msg, token).ConfigureAwait(continueOnCapturedContext: false);
			if (!(buttplugMessage is Ok))
			{
				if (buttplugMessage is Error msg2)
				{
					throw ButtplugException.FromError(msg2);
				}
				throw new ButtplugMessageException("Message type " + msg.Name + " not handled by SendMessageExpectOk", msg.Id);
			}
		}
	}
	public class ButtplugConnectorJSONParser
	{
		private readonly ButtplugJsonMessageParser _parser = new ButtplugJsonMessageParser();

		public string Serialize(ButtplugMessage msg)
		{
			return _parser.Serialize(msg);
		}

		public string Serialize(ButtplugMessage[] msgs)
		{
			return _parser.Serialize(msgs);
		}

		public IEnumerable<ButtplugMessage> Deserialize(string msg)
		{
			return _parser.Deserialize(msg);
		}
	}
	public class ButtplugConnectorMessageSorter : IDisposable
	{
		private class WaitingMessage : IDisposable
		{
			public TaskCompletionSource<ButtplugMessage> Promise { get; }

			public CancellationTokenRegistration Cancellation { get; set; }

			public WaitingMessage(TaskCompletionSource<ButtplugMessage> promise)
			{
				Promise = promise;
			}

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

		private int _counter;

		private readonly ConcurrentDictionary<uint, WaitingMessage> _waitingMsgs = new ConcurrentDictionary<uint, WaitingMessage>();

		public uint NextMsgId => Convert.ToUInt32(Interlocked.Increment(ref _counter));

		public Task<ButtplugMessage> PrepareMessage(ButtplugMessage msg, CancellationToken token = default(CancellationToken))
		{
			msg.Id = NextMsgId;
			WaitingMessage waitingMessage = new WaitingMessage(new TaskCompletionSource<ButtplugMessage>());
			_waitingMsgs.TryAdd(msg.Id, waitingMessage);
			if (token.CanBeCanceled)
			{
				waitingMessage.Cancellation = token.Register(delegate
				{
					if (_waitingMsgs.TryRemove(msg.Id, out var value))
					{
						value.Promise.TrySetCanceled();
					}
				});
			}
			return waitingMessage.Promise.Task;
		}

		public void CheckMessage(ButtplugMessage msg)
		{
			if (msg.Id == 0)
			{
				throw new ButtplugMessageException("Cannot sort message with System ID", msg.Id);
			}
			if (!_waitingMsgs.TryRemove(msg.Id, out var value))
			{
				throw new ButtplugMessageException("Message with non-matching ID received.", msg.Id);
			}
			value.Dispose();
			if (msg is Error msg2)
			{
				value.Promise.SetException(ButtplugException.FromError(msg2));
			}
			else
			{
				value.Promise.SetResult(msg);
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			foreach (KeyValuePair<uint, WaitingMessage> waitingMsg in _waitingMsgs)
			{
				if (_waitingMsgs.TryRemove(waitingMsg.Key, out var value))
				{
					value.Dispose();
					value.Promise.TrySetException(new Exception("Sorter has been destroyed with live tasks still in queue."));
				}
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class ReturnMessage
	{
		public readonly string Message;

		public readonly Task<ButtplugMessage> Promise;

		public ReturnMessage(string message, Task<ButtplugMessage> promise)
		{
			Message = message;
			Promise = promise;
		}
	}
	public class ButtplugRemoteJSONConnector : IDisposable
	{
		private readonly ButtplugConnectorJSONParser _jsonSerializer = new ButtplugConnectorJSONParser();

		private readonly ButtplugConnectorMessageSorter _msgSorter = new ButtplugConnectorMessageSorter();

		public event EventHandler<MessageReceivedEventArgs> MessageReceived;

		public event EventHandler<ButtplugExceptionEventArgs> InvalidMessageReceived;

		public ReturnMessage PrepareMessage(ButtplugMessage msg, CancellationToken token = default(CancellationToken))
		{
			Task<ButtplugMessage> promise = _msgSorter.PrepareMessage(msg, token);
			return new ReturnMessage(_jsonSerializer.Serialize(msg), promise);
		}

		protected void ReceiveMessages(string jSONMsg)
		{
			IEnumerable<ButtplugMessage> enumerable;
			try
			{
				enumerable = _jsonSerializer.Deserialize(jSONMsg);
			}
			catch (ButtplugMessageException ex)
			{
				this.InvalidMessageReceived?.Invoke(this, new ButtplugExceptionEventArgs(ex));
				return;
			}
			foreach (ButtplugMessage item in enumerable)
			{
				if (item.Id == 0)
				{
					this.MessageReceived?.Invoke(this, new MessageReceivedEventArgs(item));
					continue;
				}
				try
				{
					_msgSorter.CheckMessage(item);
				}
				catch (ButtplugMessageException ex2)
				{
					this.InvalidMessageReceived?.Invoke(this, new ButtplugExceptionEventArgs(ex2));
				}
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			_msgSorter.Dispose();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class ButtplugWebsocketConnector : ButtplugRemoteJSONConnector, IButtplugClientConnector
	{
		private ClientWebSocket _wsClient;

		private readonly SynchronizationContext _owningDispatcher = SynchronizationContext.Current ?? new SynchronizationContext();

		private readonly Uri _uri;

		private Task _readTask;

		private CancellationTokenSource _readLoopCancellationToken;

		public bool Connected
		{
			get
			{
				ClientWebSocket wsClient = _wsClient;
				if (wsClient == null)
				{
					return false;
				}
				return wsClient.State == WebSocketState.Open;
			}
		}

		public event EventHandler Disconnected;

		public ButtplugWebsocketConnector(Uri uri)
		{
			_uri = uri;
		}

		public async Task ConnectAsync(CancellationToken token = default(CancellationToken))
		{
			if (_wsClient != null)
			{
				throw new ButtplugHandshakeException("Websocket connector is already connected.");
			}
			try
			{
				_wsClient = new ClientWebSocket();
				await _wsClient.ConnectAsync(_uri, token).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (Exception inner)
			{
				throw new ButtplugClientConnectorException("Websocket Connection Exception! See Inner Exception", inner);
			}
			_readLoopCancellationToken?.Dispose();
			_readLoopCancellationToken = new CancellationTokenSource();
			_readTask = Task.Run(async delegate
			{
				await RunClientLoop(_readLoopCancellationToken.Token).ConfigureAwait(continueOnCapturedContext: false);
			});
		}

		public async Task DisconnectAsync(CancellationToken token = default(CancellationToken))
		{
			_readLoopCancellationToken?.Cancel();
			if (_wsClient != null && (_wsClient.State == WebSocketState.Connecting || _wsClient.State == WebSocketState.Open))
			{
				await _wsClient.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
			}
			_wsClient?.Dispose();
			_wsClient = null;
			if (_readTask != null)
			{
				await _readTask.ConfigureAwait(continueOnCapturedContext: false);
			}
			_readLoopCancellationToken?.Dispose();
			_readLoopCancellationToken = null;
		}

		public async Task<ButtplugMessage> SendAsync(ButtplugMessage msg, CancellationToken cancellationToken)
		{
			if (_wsClient == null)
			{
				throw new ButtplugException("Cannot send messages while disconnected", Error.ErrorClass.ERROR_MSG);
			}
			ReturnMessage returnMsg = PrepareMessage(msg, cancellationToken);
			await _wsClient.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(returnMsg.Message)), WebSocketMessageType.Text, endOfMessage: true, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			return await returnMsg.Promise.ConfigureAwait(continueOnCapturedContext: false);
		}

		private async Task RunClientLoop(CancellationToken token)
		{
			try
			{
				new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false);
				byte[] buff = new byte[2048];
				while (Connected && !token.IsCancellationRequested)
				{
					WebSocketReceiveResult webSocketReceiveResult = await _wsClient.ReceiveAsync(new ArraySegment<byte>(buff), token).ConfigureAwait(continueOnCapturedContext: false);
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
					{
						string jSONMsg = Encoding.Default.GetString(buff, 0, webSocketReceiveResult.Count);
						ReceiveMessages(jSONMsg);
					}
				}
			}
			catch (Exception)
			{
			}
			finally
			{
				if (_wsClient != null)
				{
					_wsClient.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None).Dispose();
					_wsClient = null;
				}
				_owningDispatcher.Send(delegate
				{
					Dispose();
				}, null);
				_owningDispatcher.Send(delegate
				{
					this.Disconnected?.Invoke(this, EventArgs.Empty);
				}, null);
			}
		}
	}
	public interface IButtplugClientConnector
	{
		bool Connected { get; }

		event EventHandler<MessageReceivedEventArgs> MessageReceived;

		event EventHandler<ButtplugExceptionEventArgs> InvalidMessageReceived;

		event EventHandler Disconnected;

		Task ConnectAsync(CancellationToken token = default(CancellationToken));

		Task DisconnectAsync(CancellationToken token = default(CancellationToken));

		Task<ButtplugMessage> SendAsync(ButtplugMessage msg, CancellationToken token = default(CancellationToken));
	}
}