// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "device/bluetooth/floss/fake_floss_adapter_client.h"

#include <string>
#include <vector>

#include "base/containers/flat_map.h"
#include "base/logging.h"
#include "base/observer_list.h"
#include "base/task/single_thread_task_runner.h"
#include "device/bluetooth/floss/floss_dbus_client.h"

namespace floss {

namespace {

const int kDelayedTaskMs = 100;

FlossDeviceId ConvertAddressToDevice(const std::string& address) {
  static const base::flat_map<std::string, FlossDeviceId> address_to_device{
      {FakeFlossAdapterClient::kClassicAddress,
       FlossDeviceId{FakeFlossAdapterClient::kClassicAddress,
                     FakeFlossAdapterClient::kClassicName}},
      {FakeFlossAdapterClient::kPinCodeDisplayAddress,
       FlossDeviceId{FakeFlossAdapterClient::kPinCodeDisplayAddress,
                     FakeFlossAdapterClient::kPinCodeDisplayName}},
      {FakeFlossAdapterClient::kPasskeyDisplayAddress,
       FlossDeviceId{FakeFlossAdapterClient::kPasskeyDisplayAddress,
                     FakeFlossAdapterClient::kPasskeyDisplayName}},
      {FakeFlossAdapterClient::kPinCodeRequestAddress,
       FlossDeviceId{FakeFlossAdapterClient::kPinCodeRequestAddress,
                     FakeFlossAdapterClient::kPinCodeRequestName}},
      {FakeFlossAdapterClient::kPhoneAddress,
       FlossDeviceId{FakeFlossAdapterClient::kPhoneAddress,
                     FakeFlossAdapterClient::kPhoneName}},
      {FakeFlossAdapterClient::kPasskeyRequestAddress,
       FlossDeviceId{FakeFlossAdapterClient::kPasskeyRequestAddress,
                     FakeFlossAdapterClient::kPasskeyRequestName}},
      {FakeFlossAdapterClient::kJustWorksAddress,
       FlossDeviceId{FakeFlossAdapterClient::kJustWorksAddress,
                     FakeFlossAdapterClient::kJustWorksName}}};

  auto iter = address_to_device.find(address);
  if (iter != address_to_device.end()) {
    return iter->second;
  }
  return FlossDeviceId{address, ""};
}

uint32_t ConvertAddressToClassOfDevice(const std::string& address) {
  static const base::flat_map<std::string, uint32_t> address_to_cod{
      {FakeFlossAdapterClient::kClassicAddress,
       FakeFlossAdapterClient::kClassicClassOfDevice},
      {FakeFlossAdapterClient::kPinCodeDisplayAddress,
       FakeFlossAdapterClient::kPinCodeDisplayClassOfDevice},
      {FakeFlossAdapterClient::kPasskeyDisplayAddress,
       FakeFlossAdapterClient::kPasskeyDisplayClassOfDevice},
      {FakeFlossAdapterClient::kPinCodeRequestAddress,
       FakeFlossAdapterClient::kPinCodeRequestClassOfDevice},
      {FakeFlossAdapterClient::kPhoneAddress,
       FakeFlossAdapterClient::kPhoneClassOfDevice},
      {FakeFlossAdapterClient::kPasskeyRequestAddress,
       FakeFlossAdapterClient::kPasskeyRequestClassOfDevice},
      {FakeFlossAdapterClient::kJustWorksAddress,
       FakeFlossAdapterClient::kJustWorksClassOfDevice}};

  auto iter = address_to_cod.find(address);
  if (iter != address_to_cod.end()) {
    return iter->second;
  }
  return FakeFlossAdapterClient::kDefaultClassOfDevice;
}

}  // namespace

FakeFlossAdapterClient::FakeFlossAdapterClient()
    : bonded_addresses_({kBondedAddress1, kBondedAddress2}),
      connected_addresses_({}) {}

FakeFlossAdapterClient::~FakeFlossAdapterClient() = default;

const char FakeFlossAdapterClient::kBondedAddress1[] = "11:11:11:11:11:01";
const char FakeFlossAdapterClient::kBondedAddress2[] = "11:11:11:11:11:02";
const char FakeFlossAdapterClient::kPairedAddressBrEdr[] = "11:11:11:11:11:03";
const char FakeFlossAdapterClient::kPairedAddressLE[] = "11:11:11:11:11:04";
const uint32_t FakeFlossAdapterClient::kDefaultClassOfDevice = 0x240418;

const char FakeFlossAdapterClient::kClassicName[] = "Bluetooth 2.0 Mouse";
const char FakeFlossAdapterClient::kClassicAddress[] = "11:35:11:35:00:01";
const uint32_t FakeFlossAdapterClient::kClassicClassOfDevice = 0x002580;
const char FakeFlossAdapterClient::kPinCodeDisplayName[] =
    "Bluetooth 2.0 Keyboard";
const char FakeFlossAdapterClient::kPinCodeDisplayAddress[] =
    "11:35:11:35:00:02";
const uint32_t FakeFlossAdapterClient::kPinCodeDisplayClassOfDevice = 0x002540;
const char FakeFlossAdapterClient::kPasskeyDisplayName[] =
    "Bluetooth 2.1+ Keyboard";
const char FakeFlossAdapterClient::kPasskeyDisplayAddress[] =
    "11:35:11:35:00:03";
const uint32_t FakeFlossAdapterClient::kPasskeyDisplayClassOfDevice = 0x002540;
const char FakeFlossAdapterClient::kPinCodeRequestName[] = "PIN Device";
const char FakeFlossAdapterClient::kPinCodeRequestAddress[] =
    "11:35:11:35:00:04";
const uint32_t FakeFlossAdapterClient::kPinCodeRequestClassOfDevice = 0x240408;
const char FakeFlossAdapterClient::kPhoneName[] = "Phone";
const char FakeFlossAdapterClient::kPhoneAddress[] = "11:35:11:35:00:05";
const uint32_t FakeFlossAdapterClient::kPhoneClassOfDevice = 0x7a020c;
const char FakeFlossAdapterClient::kPasskeyRequestName[] = "Passkey Device";
const char FakeFlossAdapterClient::kPasskeyRequestAddress[] =
    "11:35:11:35:00:06";
const uint32_t FakeFlossAdapterClient::kPasskeyRequestClassOfDevice = 0x7a020c;
const char FakeFlossAdapterClient::kJustWorksName[] = "Just-Works Device";
const char FakeFlossAdapterClient::kJustWorksAddress[] = "11:35:11:35:00:07";
const uint32_t FakeFlossAdapterClient::kJustWorksClassOfDevice = 0x240428;

const uint32_t FakeFlossAdapterClient::kPasskey = 123456;
const char FakeFlossAdapterClient::kPinCode[] = "012345";

void FakeFlossAdapterClient::Init(dbus::Bus* bus,
                                  const std::string& service_name,
                                  const int adapter_index,
                                  base::Version version,
                                  base::OnceClosure on_ready) {
  bus_ = bus;
  adapter_path_ = GenerateAdapterPath(adapter_index);
  service_name_ = service_name;
  version_ = version;
  std::move(on_ready).Run();
}

void FakeFlossAdapterClient::SetName(ResponseCallback<Void> callback,
                                     const std::string& name) {
  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::StartDiscovery(ResponseCallback<Void> callback) {
  // Fail fast if we're meant to fail discovery
  if (fail_discovery_) {
    fail_discovery_ = std::nullopt;

    std::move(callback).Run(base::unexpected(
        Error("org.chromium.bluetooth.Bluetooth.FooError", "Foo error")));
    return;
  }

  // Simulate devices being discovered.

  const auto discoverable_devices = std::vector{
      // Report empty name first to simulate this device sends its name later.
      FlossDeviceId{kClassicAddress, ""},
      FlossDeviceId{kClassicAddress, kClassicName},

      FlossDeviceId{kPinCodeDisplayAddress, kPinCodeDisplayName},
      FlossDeviceId{kPasskeyDisplayAddress, kPasskeyDisplayName},
      FlossDeviceId{kPinCodeRequestAddress, kPinCodeRequestName},
      FlossDeviceId{kPhoneAddress, kPhoneName},
      FlossDeviceId{kPasskeyRequestAddress, kPasskeyRequestName},
      FlossDeviceId{kJustWorksAddress, kJustWorksName}};

  for (const auto& device : discoverable_devices) {
    if (base::Contains(connected_addresses_, device.address)) {
      // Skip connected devices.
      continue;
    }
    for (auto& observer : observers_) {
      observer.AdapterFoundDevice(device);
      observer.AdapterDevicePropertyChanged(
          FlossAdapterClient::BtPropertyType::kBdName, device);
      observer.AdapterDevicePropertyChanged(
          FlossAdapterClient::BtPropertyType::kClassOfDevice, device);
      observer.AdapterDevicePropertyChanged(
          FlossAdapterClient::BtPropertyType::kTypeOfDevice, device);
    }
  }

  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::CancelDiscovery(ResponseCallback<Void> callback) {
  // Will need to stop simulated discovery once the simulation grows.
  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::CreateBond(ResponseCallback<bool> callback,
                                        FlossDeviceId device,
                                        BluetoothTransport transport) {
  if (fail_bonding_) {
    fail_bonding_ = std::nullopt;

    std::move(callback).Run(base::unexpected(
        Error("org.chromium.Error.Failed", "Bonding failed by request")));
    return;
  }

  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(
        device, /*status=*/0,
        FlossAdapterClient::BondState::kBondingInProgress);
  }

  if (device.address == kJustWorksAddress ||
      device.address == kClassicAddress) {
    for (auto& observer : observers_) {
      observer.DeviceBondStateChanged(device, /*status=*/0,
                                      FlossAdapterClient::BondState::kBonded);
    }
    bonded_addresses_.insert(device.address);
    SetConnected(device.address, true);

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else if (device.address == kPasskeyDisplayAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyNotification,
                                 kPasskey);
    }

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else if (device.address == kPhoneAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyConfirmation,
                                 kPasskey);
    }

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else if (device.address == kPasskeyRequestAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyEntry, 0);
    }

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else if (device.address == kPinCodeDisplayAddress) {
    for (auto& observer : observers_) {
      observer.AdapterPinDisplay(device, std::string(kPinCode));
    }

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else if (device.address == kPinCodeRequestAddress) {
    for (auto& observer : observers_) {
      observer.AdapterPinRequest(device, 0, false);
    }

    PostDelayedTask(base::BindOnce(std::move(callback), true));
  } else {
    for (auto& observer : observers_) {
      observer.DeviceBondStateChanged(
          device, static_cast<uint32_t>(BtifStatus::kFail),
          FlossAdapterClient::BondState::kNotBonded);
    }

    PostDelayedTask(base::BindOnce(
        std::move(callback),
        base::unexpected(Error("org.chromium.bluetooth.UnknownDevice", ""))));
  }
}

void FakeFlossAdapterClient::CreateBond(
    ResponseCallback<FlossDBusClient::BtifStatus> callback,
    FlossDeviceId device,
    BluetoothTransport transport) {
  if (fail_bonding_) {
    fail_bonding_ = std::nullopt;

    std::move(callback).Run(base::unexpected(
        Error("org.chromium.Error.Failed", "Bonding failed by request")));
    return;
  }

  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(
        device, /*status=*/0,
        FlossAdapterClient::BondState::kBondingInProgress);
  }

  if (device.address == kJustWorksAddress ||
      device.address == kClassicAddress) {
    for (auto& observer : observers_) {
      observer.DeviceBondStateChanged(device, /*status=*/0,
                                      FlossAdapterClient::BondState::kBonded);
    }
    bonded_addresses_.insert(device.address);
    SetConnected(device.address, true);

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else if (device.address == kPasskeyDisplayAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyNotification,
                                 kPasskey);
    }

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else if (device.address == kPhoneAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyConfirmation,
                                 kPasskey);
    }

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else if (device.address == kPasskeyRequestAddress) {
    for (auto& observer : observers_) {
      observer.AdapterSspRequest(device, /*cod=*/0,
                                 BluetoothSspVariant::kPasskeyEntry, 0);
    }

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else if (device.address == kPinCodeDisplayAddress) {
    for (auto& observer : observers_) {
      observer.AdapterPinDisplay(device, std::string(kPinCode));
    }

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else if (device.address == kPinCodeRequestAddress) {
    for (auto& observer : observers_) {
      observer.AdapterPinRequest(device, 0, false);
    }

    PostDelayedTask(base::BindOnce(std::move(callback),
                                   FlossDBusClient::BtifStatus::kSuccess));
  } else {
    for (auto& observer : observers_) {
      observer.DeviceBondStateChanged(
          device, static_cast<uint32_t>(BtifStatus::kFail),
          FlossAdapterClient::BondState::kNotBonded);
    }

    PostDelayedTask(base::BindOnce(
        std::move(callback),
        base::unexpected(Error("org.chromium.bluetooth.UnknownDevice", ""))));
  }
}

void FakeFlossAdapterClient::CancelBondProcess(ResponseCallback<bool> callback,
                                               FlossDeviceId device) {
  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(device, /*status=*/0,
                                    FlossAdapterClient::BondState::kNotBonded);
  }
  PostDelayedTask(base::BindOnce(std::move(callback), true));
}

void FakeFlossAdapterClient::RemoveBond(ResponseCallback<bool> callback,
                                        FlossDeviceId device) {
  if (!base::Contains(bonded_addresses_, device.address)) {
    PostDelayedTask(base::BindOnce(std::move(callback), false));
    return;
  }

  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(device, /*status=*/0,
                                    FlossAdapterClient::BondState::kNotBonded);
  }
  bonded_addresses_.erase(device.address);
  SetConnected(device.address, false);

  PostDelayedTask(base::BindOnce(std::move(callback), true));
}

void FakeFlossAdapterClient::GetRemoteType(
    ResponseCallback<BluetoothDeviceType> callback,
    FlossDeviceId device) {
  auto remote_type = BluetoothDeviceType::kBredr;
  if (device.address == kBondedAddress1 || device.address == kBondedAddress2 ||
      device.address == kPairedAddressLE) {
    remote_type = BluetoothDeviceType::kBle;
  }
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(std::move(callback), remote_type));
}

void FakeFlossAdapterClient::GetRemoteClass(ResponseCallback<uint32_t> callback,
                                            FlossDeviceId device) {
  uint32_t cod = ConvertAddressToClassOfDevice(device.address);
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(std::move(callback), cod));
}

void FakeFlossAdapterClient::GetRemoteAppearance(
    ResponseCallback<uint16_t> callback,
    FlossDeviceId device) {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(std::move(callback), 0));
}

void FakeFlossAdapterClient::GetConnectionState(
    ResponseCallback<uint32_t> callback,
    const FlossDeviceId& device) {
  FlossAdapterClient::ConnectionState conn_state =
      FlossAdapterClient::ConnectionState::kDisconnected;

  if (base::Contains(connected_addresses_, device.address)) {
    if (device.address == kPairedAddressBrEdr) {
      conn_state = FlossAdapterClient::ConnectionState::kPairedBREDROnly;
    } else if (device.address == kPairedAddressLE) {
      conn_state = FlossAdapterClient::ConnectionState::kPairedLEOnly;
    } else {
      conn_state = FlossAdapterClient::ConnectionState::kConnectedOnly;
    }
  }

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(std::move(callback), static_cast<uint32_t>(conn_state)));
}

void FakeFlossAdapterClient::GetRemoteUuids(
    ResponseCallback<device::BluetoothDevice::UUIDList> callback,
    FlossDeviceId device) {
  device::BluetoothDevice::UUIDList uuid_list;
  PostDelayedTask(base::BindOnce(std::move(callback), std::move(uuid_list)));
}

void FakeFlossAdapterClient::GetRemoteVendorProductInfo(
    ResponseCallback<FlossAdapterClient::VendorProductInfo> callback,
    FlossDeviceId device) {
  FlossAdapterClient::VendorProductInfo info;
  PostDelayedTask(base::BindOnce(std::move(callback), std::move(info)));
}

void FakeFlossAdapterClient::GetRemoteAddressType(
    ResponseCallback<FlossAdapterClient::BtAddressType> callback,
    FlossDeviceId device) {
  PostDelayedTask(base::BindOnce(std::move(callback),
                                 FlossAdapterClient::BtAddressType::kPublic));
}

void FakeFlossAdapterClient::GetBondState(ResponseCallback<uint32_t> callback,
                                          const FlossDeviceId& device) {
  FlossAdapterClient::BondState bond_state =
      base::Contains(bonded_addresses_, device.address)
          ? floss::FlossAdapterClient::BondState::kBonded
          : floss::FlossAdapterClient::BondState::kNotBonded;
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(std::move(callback), static_cast<uint32_t>(bond_state)));
}

void FakeFlossAdapterClient::ConnectAllEnabledProfiles(
    ResponseCallback<Void> callback,
    const FlossDeviceId& device) {
  SetConnected(device.address, true);
  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::ConnectAllEnabledProfiles(
    ResponseCallback<FlossDBusClient::BtifStatus> callback,
    const FlossDeviceId& device) {
  SetConnected(device.address, true);
  PostDelayedTask(base::BindOnce(std::move(callback),
                                 FlossDBusClient::BtifStatus::kSuccess));
}

void FakeFlossAdapterClient::DisconnectAllEnabledProfiles(
    ResponseCallback<Void> callback,
    const FlossDeviceId& device) {
  SetConnected(device.address, false);
  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::PostDelayedTask(base::OnceClosure callback) {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
      FROM_HERE, std::move(callback), base::Milliseconds(kDelayedTaskMs));
}

void FakeFlossAdapterClient::SetConnected(const std::string& address,
                                          bool connected) {
  if (base::Contains(connected_addresses_, address) == connected) {
    return;
  }
  const auto device = ConvertAddressToDevice(address);
  for (auto& observer : observers_) {
    if (connected) {
      connected_addresses_.insert(address);
      observer.AdapterDeviceConnected(device);
    } else {
      connected_addresses_.erase(address);
      observer.AdapterDeviceDisconnected(device);
    }
  }
}

void FakeFlossAdapterClient::NotifyObservers(
    const base::RepeatingCallback<void(Observer*)>& notify) const {
  for (auto& observer : observers_) {
    notify.Run(&observer);
  }
}

void FakeFlossAdapterClient::FailNextDiscovery() {
  fail_discovery_ = std::make_optional(true);
}

void FakeFlossAdapterClient::FailNextBonding() {
  fail_bonding_ = std::make_optional(true);
}

void FakeFlossAdapterClient::SetPairingConfirmation(
    ResponseCallback<Void> callback,
    const FlossDeviceId& device,
    bool accept) {
  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(device, /*status=*/0,
                                    FlossAdapterClient::BondState::kBonded);
  }
  bonded_addresses_.insert(device.address);
  SetConnected(device.address, true);

  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::SetPin(ResponseCallback<Void> callback,
                                    const FlossDeviceId& device,
                                    bool accept,
                                    const std::vector<uint8_t>& pin) {
  for (auto& observer : observers_) {
    observer.DeviceBondStateChanged(device, /*status=*/0,
                                    FlossAdapterClient::BondState::kBonded);
  }
  bonded_addresses_.insert(device.address);
  SetConnected(device.address, true);

  PostDelayedTask(base::BindOnce(std::move(callback), Void{}));
}

void FakeFlossAdapterClient::GetBondedDevices() {
  for (const auto& addr : bonded_addresses_) {
    const auto device_id = ConvertAddressToDevice(addr);
    for (auto& observer : observers_) {
      observer.AdapterFoundDevice(device_id);
    }
  }
}

void FakeFlossAdapterClient::GetConnectedDevices() {
  for (const auto& addr : connected_addresses_) {
    const auto device_id = ConvertAddressToDevice(addr);
    for (auto& observer : observers_) {
      observer.AdapterFoundDevice(device_id);
      observer.AdapterDeviceConnected(device_id);
    }
  }
}

}  // namespace floss