#include "universal_ble_plugin.h"
#include <windows.h>

#include <flutter/plugin_registrar_windows.h>

#include <map>
#include <memory>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <thread>
#include "UniversalBle.g.h"
#include "Utils.h"
#include "universal_enum.h"
#include <regex>

#define WM_AVAILABILITY_CHANGE WM_USER + 101
#define WM_PAIR_CHANGE WM_USER + 102
#define WM_SCAN_RESULT WM_USER + 103
#define WM_VALUE_CHANGE WM_USER + 104
#define WM_CONNECTION_CHANGE WM_USER + 105

namespace universal_ble
{
  using universal_ble::ErrorOr;
  using universal_ble::UniversalBleCallbackChannel;
  using universal_ble::UniversalBlePlatformChannel;
  using universal_ble::UniversalBleScanResult;

  std::unique_ptr<UniversalBleCallbackChannel> callbackChannel;
  std::map<std::string, winrt::event_token> characteristicsTokens{};

  union uint16_t_union
  {
    uint16_t uint16;
    byte bytes[sizeof(uint16_t)];
  };

  void UniversalBlePlugin::RegisterWithRegistrar(flutter::PluginRegistrarWindows *registrar)
  {
    auto plugin = std::make_unique<UniversalBlePlugin>(registrar);
    UniversalBlePlatformChannel::SetUp(registrar->messenger(), plugin.get());
    callbackChannel = std::make_unique<UniversalBleCallbackChannel>(registrar->messenger());
    registrar->AddPlugin(std::move(plugin));
  }

  UniversalBlePlugin::UniversalBlePlugin(flutter::PluginRegistrarWindows *registrar) : registrar_(registrar)
  {
    if (window_proc_delegate_id_ == -1)
    {
      window_proc_delegate_id_ = registrar_->RegisterTopLevelWindowProcDelegate(
          std::bind(
              &UniversalBlePlugin::WindowProcDelegate, this,
              std::placeholders::_1, std::placeholders::_2,
              std::placeholders::_3, std::placeholders::_4)

      );
    }
    InitializeAsync();
  }

  UniversalBlePlugin::~UniversalBlePlugin()
  {
    if (window_proc_delegate_id_ != -1)
    {
      registrar_->UnregisterTopLevelWindowProcDelegate(
          static_cast<int32_t>(window_proc_delegate_id_));
    }
  }

  HWND UniversalBlePlugin::GetWindow()
  {
    return ::GetAncestor(registrar_->GetView()->GetNativeWindow(), GA_ROOT);
  }

  /// Background Messages Handler
  std::optional<LRESULT> UniversalBlePlugin::WindowProcDelegate(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
  {
    switch (message)
    {
    case WM_SCAN_RESULT:
    {
      UniversalBleScanResult *scanResult = reinterpret_cast<UniversalBleScanResult *>(wp);
      callbackChannel->OnScanResult(*scanResult, SuccessCallback, ErrorCallback);
      delete scanResult;
      return 0;
    }
    case WM_AVAILABILITY_CHANGE:
    {
      callbackChannel->OnAvailabilityChanged(static_cast<int>(wp), SuccessCallback, ErrorCallback);
      return 0;
    }
    case WM_CONNECTION_CHANGE:
    {
      ConnectionStateStruct *connectionStateStruct = reinterpret_cast<ConnectionStateStruct *>(wp);
      callbackChannel->OnConnectionChanged(connectionStateStruct->deviceId, connectionStateStruct->connectionState, SuccessCallback, ErrorCallback);
      delete connectionStateStruct;
      return 0;
    }
    case WM_VALUE_CHANGE:
    {
      ValueChangeStruct *valueChangeStruct = reinterpret_cast<ValueChangeStruct *>(wp);
      callbackChannel->OnValueChanged(valueChangeStruct->deviceId, valueChangeStruct->characteristicId, valueChangeStruct->value, SuccessCallback, ErrorCallback);
      delete valueChangeStruct;
      return 0;
    }
    case WM_PAIR_CHANGE:
    {
      PairStateStruct *pairStateStruct = reinterpret_cast<PairStateStruct *>(wp);
      callbackChannel->OnPairStateChange(pairStateStruct->deviceId, pairStateStruct->isPaired, &pairStateStruct->errorMessage, SuccessCallback, ErrorCallback);
      delete pairStateStruct;
      return 0;
    }
    }
    return std::nullopt;
  }

  void UniversalBlePlugin::PostConnectionUpdate(uint64_t bluetoothAddress, ConnectionState connectionState)
  {
    ConnectionStateStruct *connectionStateStruct = new ConnectionStateStruct(_mac_address_to_str(bluetoothAddress), static_cast<int>(connectionState));
    ::PostMessage(GetWindow(), WM_CONNECTION_CHANGE, reinterpret_cast<WPARAM>(connectionStateStruct), 0);
  }

  // UniversalBlePlatformChannel implementation.
  void UniversalBlePlugin::GetBluetoothAvailabilityState(std::function<void(ErrorOr<int64_t> reply)> result)
  {
    if (!bluetoothRadio)
      result(static_cast<int>(AvailabilityState::unsupported));
    else
      result(static_cast<int>(getAvailabilityStateFromRadio(bluetoothRadio.State())));
  };

  void UniversalBlePlugin::EnableBluetooth(std::function<void(ErrorOr<bool> reply)> result)
  {
    if (!bluetoothRadio)
    {
      result(FlutterError("Bluetooth is not available"));
      return;
    }
    if (bluetoothRadio.State() == RadioState::On)
    {
      result(true);
      return;
    }
    auto async_c = bluetoothRadio.SetStateAsync(RadioState::On);
    async_c.Completed([&, result](IAsyncOperation<RadioAccessStatus> const &sender, AsyncStatus const args)
                      {
                        auto radioAccessStatus = sender.GetResults();
                        if (radioAccessStatus == RadioAccessStatus::Allowed)
                        {
                          result(true);
                        }
                        else
                        {
                          result(FlutterError("Failed to enable bluetooth"));
                        } });
  }

  std::optional<FlutterError> UniversalBlePlugin::StartScan()
  {
    if (bluetoothRadio && bluetoothRadio.State() == RadioState::On)
    {
      if (!bluetoothLEWatcher)
      {
        bluetoothLEWatcher = BluetoothLEAdvertisementWatcher();
        bluetoothLEWatcherReceivedToken = bluetoothLEWatcher.Received({this, &UniversalBlePlugin::BluetoothLEWatcher_Received});
      }
      bluetoothLEWatcher.Start();
      return std::nullopt;
    }
    else
    {
      return FlutterError("Bluetooth is not available");
    }
  };

  std::optional<FlutterError> UniversalBlePlugin::StopScan()
  {
    if (bluetoothRadio && bluetoothRadio.State() == RadioState::On)
    {
      if (bluetoothLEWatcher)
      {
        bluetoothLEWatcher.Stop();
        bluetoothLEWatcher.Received(bluetoothLEWatcherReceivedToken);
      }
      bluetoothLEWatcher = nullptr;
      return std::nullopt;
    }
    else
    {
      return FlutterError("Bluetooth is not available");
    }
  };

  std::optional<FlutterError> UniversalBlePlugin::Connect(const std::string &device_id)
  {
    auto isConnectable = deviceConnectableStatus[_str_to_mac_address(device_id)];
    if (isConnectable == false)
    {
      return FlutterError("Device is not connectable");
    }

    ConnectAsync(_str_to_mac_address(device_id));
    return std::nullopt;
  };

  std::optional<FlutterError> UniversalBlePlugin::Disconnect(const std::string &device_id)
  {
    auto deviceAddress = _str_to_mac_address(device_id);
    CleanConnection(deviceAddress);
    PostConnectionUpdate(deviceAddress, ConnectionState::disconnected);
    return std::nullopt;
  };

  void UniversalBlePlugin::DiscoverServices(
      const std::string &device_id,
      std::function<void(ErrorOr<flutter::EncodableList> reply)> result)
  {
    try
    {
      auto it = connectedDevices.find(_str_to_mac_address(device_id));
      if (it == connectedDevices.end())
      {
        result(FlutterError("IllegalArgument", "Unknown devicesId:" + device_id));
        return;
      }
      auto deviceAgent = *it->second;
      DiscoverServicesAsync(deviceAgent, result);
    }
    catch (const FlutterError &err)
    {
      return result(err);
    }
    catch (...)
    {
      return result(FlutterError("Unknown error"));
    }
  }

  std::optional<FlutterError> UniversalBlePlugin::SetNotifiable(
      const std::string &device_id,
      const std::string &service,
      const std::string &characteristic,
      int64_t ble_input_property)
  {
    try
    {
      auto it = connectedDevices.find(_str_to_mac_address(device_id));
      if (it == connectedDevices.end())
        return FlutterError("IllegalArgument", "Unknown devicesId:" + device_id);
      auto bluetoothAgent = *it->second;
      gatt_characteristic_t &gatt_characteristic_holder = bluetoothAgent._fetch_characteristic(service, characteristic);
      GattCharacteristic gattCharacteristic = gatt_characteristic_holder.obj;
      auto descriptorValue = GattClientCharacteristicConfigurationDescriptorValue::None;
      auto properties = gattCharacteristic.CharacteristicProperties();

      if (ble_input_property == static_cast<int>(BleInputProperty::notification))
      {
        descriptorValue = GattClientCharacteristicConfigurationDescriptorValue::Notify;
        if ((properties & GattCharacteristicProperties::Notify) == GattCharacteristicProperties::None)
        {
          return FlutterError("Characteristic does not support notify");
        }
      }
      else if (ble_input_property == static_cast<int>(BleInputProperty::indication))
      {
        descriptorValue = GattClientCharacteristicConfigurationDescriptorValue::Indicate;
        if ((properties & GattCharacteristicProperties::Indicate) == GattCharacteristicProperties::None)
        {
          return FlutterError("Characteristic does not support indicate");
        }
      }

      SetNotifiableAsync(bluetoothAgent, service, characteristic, descriptorValue);
      return std::nullopt;
    }
    catch (const FlutterError &err)
    {
      return err;
    }
    catch (...)
    {
      return FlutterError("Unknown error");
    }
  };

  void UniversalBlePlugin::ReadValue(
      const std::string &device_id,
      const std::string &service,
      const std::string &characteristic,
      std::function<void(ErrorOr<std::vector<uint8_t>> reply)> result)
  {
    try
    {
      auto it = connectedDevices.find(_str_to_mac_address(device_id));
      if (it == connectedDevices.end())
      {
        result(FlutterError("IllegalArgument", "Unknown devicesId:" + device_id));
        return;
      }
      auto bluetoothAgent = *it->second;
      gatt_characteristic_t &gatt_characteristic_holder = bluetoothAgent._fetch_characteristic(service, characteristic);
      GattCharacteristic gattCharacteristic = gatt_characteristic_holder.obj;
      auto properties = gattCharacteristic.CharacteristicProperties();
      if ((properties & GattCharacteristicProperties::Read) == GattCharacteristicProperties::None)
      {
        result(FlutterError("Characteristic does not support read"));
        return;
      }
      auto async_c = gattCharacteristic.ReadValueAsync(Devices::Bluetooth::BluetoothCacheMode::Uncached);
      async_c.Completed([&, result](IAsyncOperation<GattReadResult> const &sender, AsyncStatus const args)
                        {
                          auto readValueResult = sender.GetResults();
                          switch (readValueResult.Status())
                          {
                          case GenericAttributeProfile::GattCommunicationStatus::Success:
                            result(to_bytevc(readValueResult.Value()));
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::Unreachable:
                            result(FlutterError("Unreachable","Failed to read value"));
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::ProtocolError:
                            result(FlutterError("ProtocolError","Failed to read value"));
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::AccessDenied:
                            result(FlutterError("AccessDenied","Failed to read value"));
                            return;
                          default:
                            result(FlutterError("Failed","Failed to read value"));
                            return;
                          } });
    }
    catch (const FlutterError &err)
    {
      return result(err);
    }
    catch (...)
    {
      return result(FlutterError("Unknown error"));
    }
  }

  void UniversalBlePlugin::WriteValue(
      const std::string &device_id,
      const std::string &service,
      const std::string &characteristic,
      const std::vector<uint8_t> &value,
      int64_t ble_output_property,
      std::function<void(std::optional<FlutterError> reply)> result)
  {
    try
    {
      auto it = connectedDevices.find(_str_to_mac_address(device_id));
      if (it == connectedDevices.end())
      {
        result(FlutterError("IllegalArgument", "Unknown devicesId:" + device_id));
        return;
      }
      auto bluetoothAgent = *it->second;
      gatt_characteristic_t &gatt_characteristic_holder = bluetoothAgent._fetch_characteristic(service, characteristic);
      GattCharacteristic gattCharacteristic = gatt_characteristic_holder.obj;
      auto properties = gattCharacteristic.CharacteristicProperties();
      auto writeOption = GattWriteOption::WriteWithResponse;
      if (ble_output_property == static_cast<int>(BleOutputProperty::withoutResponse))
      {
        writeOption = GattWriteOption::WriteWithoutResponse;
        if ((properties & GattCharacteristicProperties::WriteWithoutResponse) == GattCharacteristicProperties::None)
        {
          result(FlutterError("Characteristic does not support WriteWithoutResponse"));
          return;
        }
      }
      else
      {
        if ((properties & GattCharacteristicProperties::Write) == GattCharacteristicProperties::None)
        {
          result(FlutterError("Characteristic does not support Write"));
          return;
        }
      }
      auto async_c = gatt_characteristic_holder.obj.WriteValueAsync(from_bytevc(value), writeOption);
      async_c.Completed([&, result](IAsyncOperation<GattCommunicationStatus> const &sender, AsyncStatus const args)
                        {
                          auto writeResult = sender.GetResults();
                          switch (writeResult)
                          {
                          case GenericAttributeProfile::GattCommunicationStatus::Success:
                            result(std::nullopt);
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::Unreachable:
                            result(FlutterError("Unreachable", "Failed to write value"));
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::ProtocolError:
                            result(FlutterError("ProtocolError", "Failed to write value"));
                            return;
                          case GenericAttributeProfile::GattCommunicationStatus::AccessDenied:
                            result(FlutterError("AccessDenied", "Failed to write value"));
                            return;
                          default:
                            result(FlutterError("Failed", "Failed to write value"));
                            return;
                          } });
    }
    catch (const FlutterError &err)
    {
      result(err);
    }
    catch (...)
    {
      result(FlutterError("Unknown error"));
    }
  }

  void UniversalBlePlugin::RequestMtu(
      const std::string &device_id,
      int64_t expected_mtu,
      std::function<void(ErrorOr<int64_t> reply)> result)
  {
    try
    {
      auto it = connectedDevices.find(_str_to_mac_address(device_id));
      if (it == connectedDevices.end())
      {
        result(FlutterError("IllegalArgument", "Unknown devicesId:" + device_id));
        return;
      }
      auto bluetoothAgent = *it->second;
      auto async_c = GattSession::FromDeviceIdAsync(bluetoothAgent.device.BluetoothDeviceId());
      async_c.Completed([&, result](IAsyncOperation<GattSession> const &sender, AsyncStatus const args)
                        {
                          auto gattSession = sender.GetResults();
                           result((int64_t)gattSession.MaxPduSize()); });
    }
    catch (const FlutterError &err)
    {
      result(err);
    }
  }

  void UniversalBlePlugin::IsPaired(
      const std::string &device_id,
      std::function<void(ErrorOr<bool> reply)> result)
  {
    IsPairedAsync(device_id, result);
  };

  std::optional<FlutterError> UniversalBlePlugin::Pair(const std::string &device_id)
  {
    try
    {
      auto device = async_get(BluetoothLEDevice::FromBluetoothAddressAsync(_str_to_mac_address(device_id)));
      auto deviceInformation = device.DeviceInformation();
      bool isPaired = deviceInformation.Pairing().IsPaired();
      if (isPaired)
        return FlutterError("Device is already paired");
      bool canPair = deviceInformation.Pairing().CanPair();
      if (!canPair)
        return FlutterError("Device is not pairable");

      auto customPairing = deviceInformation.Pairing().Custom();
      winrt::event_token token = customPairing.PairingRequested([this](const Enumeration::DeviceInformationCustomPairing &sender, const Enumeration::DevicePairingRequestedEventArgs &eventArgs)
                                                                {
                                                                // eventArgs.AcceptWithPasswordCredential(nullptr, nullptr);
                                                                // eventArgs.Pin();
                                                                // Accept all pairing request
                                                                eventArgs.Accept(); });
      // DevicePairingKinds => None, ConfirmOnly, DisplayPin, ProvidePin, ConfirmPinMatch, ProvidePasswordCredential
      // DevicePairingProtectionLevel =>  Default, None, Encryption, EncryptionAndAuthentication
      auto async_c = customPairing.PairAsync(
          Enumeration::DevicePairingKinds::ConfirmOnly,
          Enumeration::DevicePairingProtectionLevel::None);
      async_c.Completed([this, customPairing, token, device_id](IAsyncOperation<DevicePairingResult> const &sender, AsyncStatus const args)
                        {
                          auto result = sender.GetResults();
                          customPairing.PairingRequested(token);
                          auto isPaired = result.Status() == Enumeration::DevicePairingResultStatus::Paired;
                          // Post to main thread
                          PairStateStruct *pairStateStruct = new PairStateStruct(device_id, isPaired, parsePairingFailError(result)); 
                          ::PostMessage(GetWindow(), WM_PAIR_CHANGE, reinterpret_cast<WPARAM>(pairStateStruct), 0); });

      return std::nullopt;
    }
    catch (const FlutterError &err)
    {
      return err;
    }
  };

  std::optional<FlutterError> UniversalBlePlugin::UnPair(const std::string &device_id)
  {
    try
    {
      auto device = async_get(BluetoothLEDevice::FromBluetoothAddressAsync(_str_to_mac_address(device_id)));
      auto deviceInformation = device.DeviceInformation();
      bool isPaired = deviceInformation.Pairing().IsPaired();
      if (!isPaired)
        return FlutterError("Device is not paired");

      auto deviceUnpairingResult = async_get(deviceInformation.Pairing().UnpairAsync());
      auto unpairingStatus = deviceUnpairingResult.Status();
      if (unpairingStatus == Enumeration::DeviceUnpairingResultStatus::Failed)
        return FlutterError("Failed to unpair device");
      if (unpairingStatus == Enumeration::DeviceUnpairingResultStatus::AccessDenied)
        return FlutterError("Access denied");
      if (unpairingStatus == Enumeration::DeviceUnpairingResultStatus::AlreadyUnpaired)
        return FlutterError("Device is already unpaired");
      if (unpairingStatus == Enumeration::DeviceUnpairingResultStatus::OperationAlreadyInProgress)
        return FlutterError("OperationAlreadyInProgress");
      return std::nullopt;
    }
    catch (const FlutterError &err)
    {
      return err;
    }
  };

  void UniversalBlePlugin::GetConnectedDevices(
      const flutter::EncodableList &with_services,
      std::function<void(ErrorOr<flutter::EncodableList> reply)> result)
  {
    std::vector<std::string> with_services_str = std::vector<std::string>();
    for (const auto &item : with_services)
    {
      auto serviceId = std::get<std::string>(item);
      with_services_str.push_back(serviceId);
    }
    GetConnectedDevicesAsync(with_services_str, result);
  }

  /// Helper Methods
  winrt::fire_and_forget UniversalBlePlugin::InitializeAsync()
  {
    auto bluetoothAdapter = co_await BluetoothAdapter::GetDefaultAsync();
    bluetoothRadio = co_await bluetoothAdapter.GetRadioAsync();
    if (bluetoothRadio)
    {
      radioStateChangedRevoker = bluetoothRadio.StateChanged(winrt::auto_revoke, {this, &UniversalBlePlugin::Radio_StateChanged});
    }
  }

  AvailabilityState UniversalBlePlugin::getAvailabilityStateFromRadio(RadioState radioState)
  {
    auto state = [=]() -> AvailabilityState
    {
      if (radioState == RadioState::Unknown)
      {
        return AvailabilityState::unknown;
      }
      else if (radioState == RadioState::Off)
      {
        return AvailabilityState::poweredOff;
      }
      else if (radioState == RadioState::On)
      {
        return AvailabilityState::poweredOn;
      }
      else if (radioState == RadioState::Disabled)
      {
        return AvailabilityState::unsupported;
      }
      else
      {
        return AvailabilityState::unknown;
      }
    }();
    return state;
  }

  void UniversalBlePlugin::Radio_StateChanged(Radio radio, IInspectable args)
  {
    auto radioState = !radio ? RadioState::Disabled : radio.State();
    if (oldRadioState == radioState)
    {
      return;
    }
    oldRadioState = radioState;
    auto state = getAvailabilityStateFromRadio(radioState);
    ::PostMessage(GetWindow(), WM_AVAILABILITY_CHANGE, static_cast<int>(state), 0);
  }

  std::vector<uint8_t> parseManufacturerDataHead(BluetoothLEAdvertisement advertisement, std::string deviceId)
  {
    try
    {
      if (advertisement.ManufacturerData().Size() == 0)
      {
        return std::vector<uint8_t>();
      }
      auto manufacturerData = advertisement.ManufacturerData().GetAt(0);
      // FIXME Compat with REG_DWORD_BIG_ENDIAN
      uint8_t *prefix = uint16_t_union{manufacturerData.CompanyId()}.bytes;
      auto result = std::vector<uint8_t>{prefix, prefix + sizeof(uint16_t_union)};

      auto data = to_bytevc(manufacturerData.Data());
      result.insert(result.end(), data.begin(), data.end());
      return result;
    }
    catch (...)
    {
      std::cout << "Error in parsing manufacturer data: " << deviceId << std::endl;
      return std::vector<uint8_t>();
    }
  }

  void UniversalBlePlugin::BluetoothLEWatcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
  {
    try
    {
      auto deviceId = _mac_address_to_str(args.BluetoothAddress());
      auto universalScanResult = new UniversalBleScanResult(deviceId);
      hstring localName = args.Advertisement().LocalName();
      if (!localName.empty())
        universalScanResult->set_name(winrt::to_string(localName));

      universalScanResult->set_manufacturer_data_head(parseManufacturerDataHead(args.Advertisement(), deviceId));
      universalScanResult->set_rssi(args.RawSignalStrengthInDBm());
      // Cache connectable status
      deviceConnectableStatus[_str_to_mac_address(deviceId)] = args.IsConnectable();
      ::PostMessage(GetWindow(), WM_SCAN_RESULT, reinterpret_cast<WPARAM>(universalScanResult), 0);
    }
    catch (...)
    {
      std::cout << "ScanResultErrorInParsing" << std::endl;
    }
  }

  std::string GattCommunicationStatusToString(GattCommunicationStatus status)
  {
    switch (status)
    {
    case GattCommunicationStatus::Success:
      return "Success";
    case GattCommunicationStatus::Unreachable:
      return "Unreachable";
    case GattCommunicationStatus::ProtocolError:
      return "ProtocolError";
    case GattCommunicationStatus::AccessDenied:
      return "AccessDenied";
    default:
      return "Unknown";
    }
  }

  winrt::fire_and_forget UniversalBlePlugin::ConnectAsync(uint64_t bluetoothAddress)
  {
    auto device = co_await BluetoothLEDevice::FromBluetoothAddressAsync(bluetoothAddress);
    auto servicesResult = co_await device.GetGattServicesAsync((BluetoothCacheMode::Uncached));
    if (servicesResult.Status() != GattCommunicationStatus::Success)
    {
      PostConnectionUpdate(bluetoothAddress, ConnectionState::disconnected);
      co_return;
    }

    std::map<std::string, gatt_service_t> gatt_map_;
    auto gatt_services = servicesResult.Services();
    for (GattDeviceService &&service : gatt_services)
    {
      gatt_service_t gatt_service;
      gatt_service.obj = service;
      std::string service_uuid = guid_to_uuid(service.Uuid());
      auto characteristics_result = co_await service.GetCharacteristicsAsync(BluetoothCacheMode::Uncached);
      if (characteristics_result.Status() != GattCommunicationStatus::Success)
      {
        std::cout << "Failed to get characteristics for service: " << service_uuid << ", With Status: " << GattCommunicationStatusToString(characteristics_result.Status()) << std::endl;
        continue;
        // PostConnectionUpdate(bluetoothAddress, ConnectionState::disconnected);
        // co_return;
      }
      auto gatt_characteristics = characteristics_result.Characteristics();
      for (GattCharacteristic &&characteristic : gatt_characteristics)
      {
        gatt_characteristic_t gatt_characteristic;
        gatt_characteristic.obj = characteristic;
        std::string characteristic_uuid = guid_to_uuid(characteristic.Uuid());
        gatt_service.characteristics.emplace(characteristic_uuid, std::move(gatt_characteristic));
      }
      gatt_map_.emplace(service_uuid, std::move(gatt_service));
    }

    auto connnectionStatusChangedToken = device.ConnectionStatusChanged({this, &UniversalBlePlugin::BluetoothLEDevice_ConnectionStatusChanged});
    auto deviceAgent = std::make_unique<BluetoothDeviceAgent>(device, connnectionStatusChangedToken, gatt_map_);
    auto pair = std::make_pair(bluetoothAddress, std::move(deviceAgent));
    connectedDevices.insert(std::move(pair));
    PostConnectionUpdate(bluetoothAddress, ConnectionState::connected);
  }

  void UniversalBlePlugin::BluetoothLEDevice_ConnectionStatusChanged(BluetoothLEDevice sender, IInspectable args)
  {
    if (sender.ConnectionStatus() == BluetoothConnectionStatus::Disconnected)
    {
      CleanConnection(sender.BluetoothAddress());
      PostConnectionUpdate(sender.BluetoothAddress(), ConnectionState::disconnected);
    }
  }

  void UniversalBlePlugin::CleanConnection(uint64_t bluetoothAddress)
  {
    auto node = connectedDevices.extract(bluetoothAddress);
    if (!node.empty())
    {
      auto deviceAgent = std::move(node.mapped());
      deviceAgent->device.ConnectionStatusChanged(deviceAgent->connnectionStatusChangedToken);
      // Clean up all characteristics tokens
      for (auto &servicePair : deviceAgent->gatt_map_)
      {
        auto &service = servicePair.second;
        for (auto &characteristicPair : service.characteristics)
        {
          gatt_characteristic_t &characteristic = characteristicPair.second;
          auto gattCharacteristic = characteristic.obj;
          auto uniqTokenKey = to_uuidstr(gattCharacteristic.Uuid()) + _mac_address_to_str(gattCharacteristic.Service().Device().BluetoothAddress());
          if (characteristicsTokens.count(uniqTokenKey) != 0)
          {
            characteristic.obj.ValueChanged(characteristicsTokens[uniqTokenKey]);
            characteristicsTokens[uniqTokenKey] = {0};
          }
        }
      }
      deviceAgent->gatt_map_.clear();
    }
  }

  winrt::fire_and_forget UniversalBlePlugin::GetConnectedDevicesAsync(
      std::vector<std::string> with_services,
      std::function<void(ErrorOr<flutter::EncodableList> reply)> result)
  {
    try
    {
      auto selector = BluetoothLEDevice::GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus::Connected);
      Enumeration::DeviceInformationCollection devices = co_await Enumeration::DeviceInformation::FindAllAsync(selector);
      flutter::EncodableList results = flutter::EncodableList();
      for (auto &&deviceInfo : devices)
      {
        BluetoothLEDevice device = co_await BluetoothLEDevice::FromIdAsync(deviceInfo.Id());
        auto deviceId = _mac_address_to_str(device.BluetoothAddress());
        // Filter by services
        if (!with_services.empty())
        {
          auto serviceResult = co_await device.GetGattServicesAsync(BluetoothCacheMode::Cached);
          if (serviceResult.Status() == GattCommunicationStatus::Success)
          {
            bool hasService = false;
            for (auto service : serviceResult.Services())
            {
              std::string serviceUUID = to_uuidstr(service.Uuid());
              if (std::find(with_services.begin(), with_services.end(), serviceUUID) != with_services.end())
              {
                hasService = true;
                break;
              }
            }
            if (!hasService)
              continue;
          }
        }
        // Add to results, if pass all filters
        auto universalScanResult = UniversalBleScanResult(deviceId);
        universalScanResult.set_name(winrt::to_string(deviceInfo.Name()));
        universalScanResult.set_is_paired(deviceInfo.Pairing().IsPaired());
        results.push_back(flutter::CustomEncodableValue(universalScanResult));
        deviceConnectableStatus[_str_to_mac_address(deviceId)] = true;
      }
      result(results);
    }
    catch (...)
    {
      result(FlutterError("Unknown error"));
    }
  }

  winrt::fire_and_forget UniversalBlePlugin::DiscoverServicesAsync(BluetoothDeviceAgent &bluetoothDeviceAgent, std::function<void(ErrorOr<flutter::EncodableList> reply)> result)
  {
    try
    {
      auto deviceId = _mac_address_to_str(bluetoothDeviceAgent.device.BluetoothAddress());
      auto serviceResult = co_await bluetoothDeviceAgent.device.GetGattServicesAsync();
      if (serviceResult.Status() != GattCommunicationStatus::Success)
      {
        result(FlutterError("DiscoverServiceError: No services found for device"));
        co_return;
      }
      auto services = serviceResult.Services();
      auto universalServices = flutter::EncodableList();
      for (auto service : serviceResult.Services())
      {
        auto characteristicResult = co_await service.GetCharacteristicsAsync();
        flutter::EncodableList universalCharacteristics;
        if (characteristicResult.Status() == GattCommunicationStatus::Success)
        {
          for (auto c : characteristicResult.Characteristics())
          {
            flutter::EncodableList properties = flutter::EncodableList();
            auto propertiesValue = c.CharacteristicProperties();
            if ((propertiesValue & GattCharacteristicProperties::Broadcast) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::broadcast));
            }
            if ((propertiesValue & GattCharacteristicProperties::Read) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::read));
            }
            if ((propertiesValue & GattCharacteristicProperties::Write) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::write));
            }
            if ((propertiesValue & GattCharacteristicProperties::WriteWithoutResponse) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::writeWithoutResponse));
            }
            if ((propertiesValue & GattCharacteristicProperties::Notify) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::notify));
            }
            if ((propertiesValue & GattCharacteristicProperties::Indicate) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::indicate));
            }
            if ((propertiesValue & GattCharacteristicProperties::AuthenticatedSignedWrites) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::authenticatedSignedWrites));
            }
            if ((propertiesValue & GattCharacteristicProperties::ExtendedProperties) != GattCharacteristicProperties::None)
            {
              properties.push_back(static_cast<int>(CharacteristicProperty::extendedProperties));
            }
            universalCharacteristics.push_back(
                flutter::CustomEncodableValue(UniversalBleCharacteristic(to_uuidstr(c.Uuid()), properties)));
          }
        }
        else
        {
          std::cout << "Failed to get characteristics for service: " << to_uuidstr(service.Uuid()) << ", With Status: " << GattCommunicationStatusToString(characteristicResult.Status()) << std::endl;
        }
        auto universalBleService = UniversalBleService(to_uuidstr(service.Uuid()));
        universalBleService.set_characteristics(universalCharacteristics);
        universalServices.push_back(flutter::CustomEncodableValue(universalBleService));
      }
      result(universalServices);
    }
    catch (...)
    {
      result(FlutterError("DiscoverServiceError: Unknown error"));
      std::cerr << "DiscoverServiceError: Unknown error" << '\n';
    }
  }

  winrt::fire_and_forget UniversalBlePlugin::IsPairedAsync(
      std::string device_id,
      std::function<void(ErrorOr<bool> reply)> result)
  {
    try
    {
      auto device = co_await BluetoothLEDevice::FromBluetoothAddressAsync(_str_to_mac_address(device_id));
      bool isPaired = device.DeviceInformation().Pairing().IsPaired();
      result(isPaired);
    }
    catch (...)
    {
      std::cout << "IsPairedAsync: Error " << std::endl;
      result(FlutterError("Unknown error"));
    }
  };

  winrt::fire_and_forget UniversalBlePlugin::SetNotifiableAsync(BluetoothDeviceAgent &bluetoothDeviceAgent, const std::string &service,
                                                                const std::string &characteristic, GattClientCharacteristicConfigurationDescriptorValue descriptorValue)
  {
    gatt_characteristic_t &gatt_characteristic_holder = bluetoothDeviceAgent._fetch_characteristic(service, characteristic);
    GattCharacteristic gattCharacteristic = gatt_characteristic_holder.obj;

    auto uuid = to_uuidstr(gattCharacteristic.Uuid());
    // Write to the descriptor.
    try
    {
      auto status = co_await gattCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(descriptorValue);
      switch (status)
      {
      case GattCommunicationStatus::Success:
        break;
      case GattCommunicationStatus::Unreachable:
        std::cout << "FailedToSubscribe: Unreachable" << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
        break;
      case GattCommunicationStatus::ProtocolError:
        std::cout << "FailedToSubscribe: ProtocolError" << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
        break;
      case GattCommunicationStatus::AccessDenied:
        std::cout << "FailedToSubscribe: AccessDenied" << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
        break;
      default:
        std::cout << "FailedToSubscribe: Unknown" << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
      }
      if (status != GattCommunicationStatus::Success)
        co_return;
    }
    catch (...)
    {
      std::cout << "FailedToPerformThisOperationOn: " << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
      co_return;
    }
    // create uniqKey with uuid and deviceId
    // TODO: store token key in gatt_characteristic_t struct instead of using map
    auto uniqTokenKey = uuid + _mac_address_to_str(gattCharacteristic.Service().Device().BluetoothAddress());

    // Register/UnRegister handler for the ValueChanged event.
    if (descriptorValue == GattClientCharacteristicConfigurationDescriptorValue::None)
    {
      if (characteristicsTokens.count(uniqTokenKey) != 0)
      {
        gattCharacteristic.ValueChanged(characteristicsTokens[uniqTokenKey]);
        characteristicsTokens[uuid] = {0};
        std::cout << "Unsubscribed " << to_uuidstr(gattCharacteristic.Uuid()) << std::endl;
      }
    }
    else
    {
      // If a notification for the given characteristic is already in progress, swap the callbacks.
      if (characteristicsTokens.count(uniqTokenKey) != 0)
      {
        std::cout << "A notification for the given characteristic is already in progress. Swapping callbacks." << std::endl;
        gattCharacteristic.ValueChanged(characteristicsTokens[uniqTokenKey]);
        characteristicsTokens[uniqTokenKey] = {0};
      }
      characteristicsTokens[uniqTokenKey] = gattCharacteristic.ValueChanged({this, &UniversalBlePlugin::GattCharacteristic_ValueChanged});
    }
  }

  void UniversalBlePlugin::GattCharacteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
  {
    auto uuid = to_uuidstr(sender.Uuid());
    auto bytes = to_bytevc(args.CharacteristicValue());
    ValueChangeStruct *valueChangeStruct = new ValueChangeStruct(_mac_address_to_str(sender.Service().Device().BluetoothAddress()), uuid, bytes);
    ::PostMessage(GetWindow(), WM_VALUE_CHANGE, reinterpret_cast<WPARAM>(valueChangeStruct), 0);
  }

  std::string UniversalBlePlugin::parsePairingFailError(Enumeration::DevicePairingResult result)
  {
    switch (result.Status())
    {
    case Enumeration::DevicePairingResultStatus::Paired:
      return "";
    case Enumeration::DevicePairingResultStatus::AlreadyPaired:
      return "AlreadyPaired";

    case Enumeration::DevicePairingResultStatus::ConnectionRejected:
      return "ConnectionRejected";

    case Enumeration::DevicePairingResultStatus::NotPaired:
      return "NotPaired";

    case Enumeration::DevicePairingResultStatus::NotReadyToPair:
      return "NotReadyToPair";

    case Enumeration::DevicePairingResultStatus::TooManyConnections:
      return "TooManyConnections";

    case Enumeration::DevicePairingResultStatus::HardwareFailure:
      return "HardwareFailure";

    case Enumeration::DevicePairingResultStatus::AuthenticationTimeout:
      return "AuthenticationTimeout";

    case Enumeration::DevicePairingResultStatus::AuthenticationNotAllowed:
      return "AuthenticationNotAllowed";

    case Enumeration::DevicePairingResultStatus::AuthenticationFailure:
      return "AuthenticationFailure";

    case Enumeration::DevicePairingResultStatus::NoSupportedProfiles:
      return "NoSupportedProfiles";

    case Enumeration::DevicePairingResultStatus::ProtectionLevelCouldNotBeMet:
      return "ProtectionLevelCouldNotBeMet";

    case Enumeration::DevicePairingResultStatus::AccessDenied:
      return "AccessDenied";

    case Enumeration::DevicePairingResultStatus::InvalidCeremonyData:
      return "InvalidCeremonyData";

    case Enumeration::DevicePairingResultStatus::PairingCanceled:
      return "PairingCanceled";

    case Enumeration::DevicePairingResultStatus::OperationAlreadyInProgress:
      return "OperationAlreadyInProgress";

    case Enumeration::DevicePairingResultStatus::RequiredHandlerNotRegistered:
      return "RequiredHandlerNotRegistered";

    case Enumeration::DevicePairingResultStatus::RejectedByHandler:
      return "RejectedByHandler";

    case Enumeration::DevicePairingResultStatus::RemoteDeviceHasAssociation:
      return "RemoteDeviceHasAssociation";

    case Enumeration::DevicePairingResultStatus::Failed:
      return "Failed to pair";

    default:
      return "Failed to pair";
    }
  }

} // namespace universal_ble