// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use crate::server::Facade;
use anyhow::{format_err, Error};
use async_trait::async_trait;
use bt_rfcomm::ServerChannel;
use fidl_fuchsia_bluetooth::PeerId;
use fidl_fuchsia_bluetooth_a2dp::Role;
use fidl_fuchsia_bluetooth_hfp::{CallDirection, CallState, NetworkInformation, SignalStrength};
use fidl_fuchsia_bluetooth_le::Filter;
use fidl_fuchsia_bluetooth_sys::{LeSecurityMode, Settings};
use serde_json::{from_value, to_value, Value};
use test_call_manager::TestCallManager as HfpFacade;
use test_rfcomm_client::RfcommManager as RfcommFacade;

// Bluetooth-related functionality
use crate::bluetooth::a2dp_facade::A2dpFacade;
use crate::bluetooth::avdtp_facade::AvdtpFacade;
use crate::bluetooth::avrcp_facade::AvrcpFacade;
use crate::bluetooth::ble_advertise_facade::BleAdvertiseFacade;
use crate::bluetooth::bt_sys_facade::BluetoothSysFacade;
use crate::bluetooth::gatt_client_facade::GattClientFacade;
use crate::bluetooth::gatt_server_facade::GattServerFacade;
use crate::bluetooth::profile_server_facade::ProfileServerFacade;
use crate::bluetooth::types::{
    AbsoluteVolumeCommand, BleAdvertiseResponse, BleConnectPeripheralResponse, CustomBatteryStatus,
    CustomNotificationsFilter, CustomPlayerApplicationSettings,
    CustomPlayerApplicationSettingsAttributeIds, FacadeArg, GattcDiscoverCharacteristicResponse,
};

use crate::common_utils::common::{
    parse_identifier, parse_identifier_as_u64, parse_max_bytes, parse_offset, parse_psm,
    parse_service_identifier, parse_u64_identifier, parse_write_value,
};

use crate::common_utils::common::macros::parse_arg;

#[async_trait(?Send)]
impl Facade for BleAdvertiseFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        // TODO(armansito): Once the facade supports multi-advertising it should generate and
        // return a unique ID for each instance. For now we return this dummy ID for the
        // singleton advertisement.
        let id = to_value(BleAdvertiseResponse::new(Some("singleton-instance".to_string())))?;
        match method.as_ref() {
            "BleAdvertise" => {
                self.start_adv(args).await?;
            }
            "BleStopAdvertise" => {
                self.stop_adv();
            }
            _ => return Err(format_err!("Invalid BleAdvertise FIDL method: {:?}", method)),
        };
        Ok(id)
    }

    fn cleanup(&self) {
        Self::cleanup(self)
    }

    fn print(&self) {
        Self::print(self)
    }
}

#[async_trait(?Send)]
impl Facade for BluetoothSysFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "BluetoothAcceptPairing" => {
                let input = parse_arg!(args, as_str, "input")?;
                let output = parse_arg!(args, as_str, "output")?;
                let result = self.accept_pairing(&input.to_string(), &output.to_string()).await?;
                Ok(to_value(result)?)
            }
            "BluetoothInitSys" => {
                let result = self.init_access_proxy().await?;
                Ok(to_value(result)?)
            }
            "BluetoothGetKnownRemoteDevices" => {
                let result = self.get_known_remote_devices().await?;
                Ok(to_value(result)?)
            }
            "BluetoothSetDiscoverable" => {
                let discoverable = parse_arg!(args, as_bool, "discoverable")?;
                let result = self.set_discoverable(discoverable).await?;
                Ok(to_value(result)?)
            }
            "BluetoothSetName" => {
                let name = parse_arg!(args, as_str, "name")?;
                let result = self.set_name(name.to_string()).await?;
                Ok(to_value(result)?)
            }
            "BluetoothForgetDevice" => {
                let identifier = parse_identifier_as_u64(&args)?;
                let result = self.forget(identifier).await?;
                Ok(to_value(result)?)
            }
            "BluetoothConnectDevice" => {
                let identifier = parse_identifier_as_u64(&args)?;
                let result = self.connect(identifier).await?;
                Ok(to_value(result)?)
            }
            "BluetoothDisconnectDevice" => {
                let identifier = parse_identifier_as_u64(&args)?;
                let result = self.disconnect(identifier).await?;
                Ok(to_value(result)?)
            }
            "BluetoothRequestDiscovery" => {
                let discovery = parse_arg!(args, as_bool, "discovery")?;
                let result = self.start_discovery(discovery).await?;
                Ok(to_value(result)?)
            }
            "BluetoothInputPairingPin" => {
                let pin = parse_arg!(args, as_str, "pin")?;
                let result = self.input_pairing_pin(pin.to_string()).await?;
                Ok(to_value(result)?)
            }
            "BluetoothGetPairingPin" => {
                let result = self.get_pairing_pin().await?;
                Ok(to_value(result)?)
            }
            "BluetoothGetActiveAdapterAddress" => {
                let result = self.get_active_adapter_address().await?;
                Ok(to_value(result)?)
            }
            "BluetoothPairDevice" => {
                let identifier = parse_identifier_as_u64(&args)?;
                let pairing_security_level =
                    match parse_arg!(args, as_u64, "pairing_security_level") {
                        Ok(v) => Some(v),
                        Err(_e) => None,
                    };
                let non_bondable = match parse_arg!(args, as_bool, "non_bondable") {
                    Ok(v) => Some(v),
                    Err(_e) => None,
                };
                let transport = parse_arg!(args, as_u64, "transport")?;

                let result =
                    self.pair(identifier, pairing_security_level, non_bondable, transport).await?;
                Ok(to_value(result)?)
            }
            "BluetoothUpdateSystemSettings" => {
                let le_privacy = parse_arg!(args, as_bool, "le_privacy").ok();
                let le_background_scan = parse_arg!(args, as_bool, "le_background_scan").ok();
                let bredr_connectable_mode =
                    parse_arg!(args, as_bool, "bredr_connectable_mode").ok();
                let le_security_mode = if let Ok(s) = parse_arg!(args, as_str, "le_security_mode") {
                    match s.to_uppercase().as_ref() {
                        "MODE_1" => Some(LeSecurityMode::Mode1),
                        "SECURE_CONNECTIONS_ONLY" => Some(LeSecurityMode::SecureConnectionsOnly),
                        _ => bail!(
                            "Invalid le_security_mode {} passed to BluetoothUpdateSystemSettings",
                            s
                        ),
                    }
                } else {
                    None
                };
                let result = self
                    .update_settings(Settings {
                        le_privacy,
                        le_background_scan,
                        bredr_connectable_mode,
                        le_security_mode,
                        ..Default::default()
                    })
                    .await?;
                Ok(to_value(result)?)
            }
            _ => bail!("Invalid Bluetooth control FIDL method: {:?}", method),
        }
    }

    fn cleanup(&self) {
        Self::cleanup(self)
    }

    fn print(&self) {
        Self::print(self)
    }
}

#[async_trait(?Send)]
impl Facade for GattClientFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "BleStartScan" => {
                let scan_filter = FacadeArg::new(args);
                start_scan_async(&self, Some(scan_filter.try_into()?)).await
            }
            "BleStopScan" => stop_scan_async(self).await,
            "BleGetDiscoveredDevices" => le_get_discovered_devices_async(self).await,
            "BleConnectPeripheral" => {
                let id = parse_identifier(args)?;
                connect_peripheral_async(self, id).await
            }
            "BleDisconnectPeripheral" => {
                let id = parse_identifier(args)?;
                disconnect_peripheral_async(self, id).await
            }
            "GattcConnectToService" => {
                let periph_id = parse_identifier(args.clone())?;
                let service_id = parse_service_identifier(args)?;
                gattc_connect_to_service_async(self, periph_id, service_id).await
            }
            "GattcDiscoverCharacteristics" => gattc_discover_characteristics_async(self).await,
            "GattcWriteCharacteristicById" => {
                let id = parse_u64_identifier(args.clone())?;
                let value = parse_write_value(args)?;
                gattc_write_char_by_id_async(self, id, value).await
            }
            "GattcWriteLongCharacteristicById" => {
                let id = parse_u64_identifier(args.clone())?;
                let offset_as_u64 = parse_offset(args.clone())?;
                let offset = offset_as_u64 as u16;
                let value = parse_write_value(args.clone())?;
                let reliable_mode = parse_arg!(args, as_bool, "reliable_mode")?;
                gattc_write_long_char_by_id_async(self, id, offset, value, reliable_mode).await
            }
            "GattcWriteCharacteristicByIdWithoutResponse" => {
                let id = parse_u64_identifier(args.clone())?;
                let value = parse_write_value(args)?;
                gattc_write_char_by_id_without_response_async(self, id, value).await
            }
            "GattcEnableNotifyCharacteristic" => {
                let id = parse_u64_identifier(args.clone())?;
                gattc_toggle_notify_characteristic_async(self, id, true).await
            }
            "GattcDisableNotifyCharacteristic" => {
                let id = parse_u64_identifier(args.clone())?;
                gattc_toggle_notify_characteristic_async(self, id, false).await
            }
            "GattcReadCharacteristicById" => {
                let id = parse_u64_identifier(args.clone())?;
                gattc_read_char_by_id_async(self, id).await
            }
            "GattcReadCharacteristicByType" => {
                let uuid = parse_arg!(args, as_str, "uuid")?;
                let result = self.gattc_read_char_by_type(uuid.to_string()).await?;
                Ok(to_value(result)?)
            }
            "GattcReadLongCharacteristicById" => {
                let id = parse_u64_identifier(args.clone())?;
                let offset_as_u64 = parse_offset(args.clone())?;
                let offset = offset_as_u64 as u16;
                let max_bytes_as_u64 = parse_max_bytes(args)?;
                let max_bytes = max_bytes_as_u64 as u16;
                gattc_read_long_char_by_id_async(self, id, offset, max_bytes).await
            }
            "GattcReadLongDescriptorById" => {
                let id = parse_u64_identifier(args.clone())?;
                let offset_as_u64 = parse_offset(args.clone())?;
                let offset = offset_as_u64 as u16;
                let max_bytes_as_u64 = parse_max_bytes(args)?;
                let max_bytes = max_bytes_as_u64 as u16;
                gattc_read_long_desc_by_id_async(self, id, offset, max_bytes).await
            }
            "GattcWriteDescriptorById" => {
                let id = parse_u64_identifier(args.clone())?;
                let value = parse_write_value(args)?;
                gattc_write_desc_by_id_async(self, id, value).await
            }
            "GattcWriteLongDescriptorById" => {
                let id = parse_u64_identifier(args.clone())?;
                let offset_as_u64 = parse_offset(args.clone())?;
                let offset = offset_as_u64 as u16;
                let value = parse_write_value(args)?;
                gattc_write_long_desc_by_id_async(self, id, offset, value).await
            }
            "GattcReadDescriptorById" => {
                let id = parse_u64_identifier(args.clone())?;
                gattc_read_desc_by_id_async(self, id.clone()).await
            }
            "GattcListServices" => {
                let id = parse_identifier(args)?;
                list_services_async(self, id).await
            }
            _ => return Err(format_err!("Invalid Gatt Client FIDL method: {:?}", method)),
        }
    }

    fn cleanup(&self) {
        Self::cleanup(self)
    }

    fn print(&self) {
        Self::print(self)
    }
}

#[async_trait(?Send)]
impl Facade for GattServerFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "GattServerPublishServer" => {
                let result = self.publish_server(args).await?;
                Ok(to_value(result)?)
            }
            "GattServerCloseServer" => {
                let result = self.close_server().await;
                Ok(to_value(result)?)
            }
            _ => return Err(format_err!("Invalid Gatt Server FIDL method: {:?}", method)),
        }
    }

    fn cleanup(&self) {
        Self::cleanup(self)
    }

    fn print(&self) {
        Self::print(self)
    }
}

#[async_trait(?Send)]
impl Facade for ProfileServerFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "ProfileServerInit" => {
                let result = self.init_profile_server_proxy().await?;
                Ok(to_value(result)?)
            }
            "ProfileServerAddSearch" => {
                let result = self.add_search(args).await?;
                Ok(to_value(result)?)
            }
            "ProfileServerAddService" => {
                let result = self.add_service(args).await?;
                Ok(to_value(result)?)
            }
            "ProfileServerCleanup" => {
                let result = self.cleanup().await?;
                Ok(to_value(result)?)
            }
            "ProfileServerConnectL2cap" => {
                let id = parse_identifier(args.clone())?;
                let psm = parse_psm(args.clone())?;
                let mode = parse_arg!(args, as_str, "mode")?;
                let result = self.connect(id, psm as u16, &mode.to_string()).await?;
                Ok(to_value(result)?)
            }
            "ProfileServerRemoveService" => {
                let service_id = parse_u64_identifier(args)? as usize;
                let result = self.remove_service(service_id).await?;
                Ok(to_value(result)?)
            }
            _ => return Err(format_err!("Invalid Profile Server FIDL method: {:?}", method)),
        }
    }
}

#[async_trait(?Send)]
impl Facade for AvdtpFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "AvdtpInit" => {
                let initiator_delay = match parse_arg!(args, as_str, "initiator_delay") {
                    Ok(v) => Some(v.to_string()),
                    Err(_e) => None,
                };
                let result = self.init_avdtp_service_proxy(initiator_delay).await?;
                Ok(to_value(result)?)
            }
            "AvdtpGetConnectedPeers" => {
                let result = self.get_connected_peers().await?;
                Ok(to_value(result)?)
            }
            "AvdtpSetConfiguration" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.set_configuration(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpGetConfiguration" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.get_configuration(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpGetCapabilities" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.get_capabilities(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpGetAllCapabilities" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.get_all_capabilities(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpReconfigureStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.reconfigure_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpSuspendStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.suspend_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpSuspendAndReconfigure" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.suspend_and_reconfigure(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpReleaseStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.release_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpEstablishStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.establish_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpStartStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.start_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpAbortStream" => {
                let peer_id = parse_u64_identifier(args)?;
                let result = self.abort_stream(peer_id).await?;
                Ok(to_value(result)?)
            }
            "AvdtpRemoveService" => {
                let result = self.remove_service().await;
                Ok(to_value(result)?)
            }
            _ => bail!("Invalid AVDTP FIDL method: {:?}", method),
        }
    }
}

#[async_trait(?Send)]
impl Facade for A2dpFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "A2dpSetRole" => {
                let a2dp_role = if let Ok(s) = parse_arg!(args, as_str, "a2dp_role") {
                    match s.to_uppercase().as_ref() {
                        "SOURCE" => Role::Source,
                        "SINK" => Role::Sink,
                        _ => bail!("Invalid A2DP role {} passed to A2dpSetRole", s),
                    }
                } else {
                    bail!("Could not parse A2DP role passed to A2dpSetRole")
                };

                self.init_audio_mode_proxy().await?;
                let result = self.set_role(a2dp_role).await?;
                Ok(to_value(result)?)
            }

            _ => {
                bail!("Invalid A2DP FIDL method: {:?}", method)
            }
        }
    }
}

#[async_trait(?Send)]
impl Facade for AvrcpFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "AvrcpInit" => {
                let target_id = parse_arg!(args, as_str, "target_id")?;
                let target_id = target_id.parse::<u64>()?;
                let result = self.init_avrcp(target_id).await?;
                Ok(to_value(result)?)
            }
            "AvrcpGetMediaAttributes" => {
                let result = self.get_media_attributes().await?;
                Ok(to_value(result)?)
            }
            "AvrcpGetPlayStatus" => {
                let result = self.get_play_status().await?;
                Ok(to_value(result)?)
            }
            "AvrcpGetPlayerApplicationSettings" => {
                let attribute_ids: CustomPlayerApplicationSettingsAttributeIds =
                    match from_value(args.clone()) {
                        Ok(attribute_ids) => attribute_ids,
                        _ => bail!(
                            "Invalid json argument to AvrcpGetPlayerApplicationSettings! - {}",
                            args
                        ),
                    };
                let result = self.get_player_application_settings(attribute_ids.clone()).await?;
                Ok(to_value(result)?)
            }
            "AvrcpInformBatteryStatus" => {
                let battery_status: CustomBatteryStatus = match from_value(args.clone()) {
                    Ok(battery_status) => battery_status,
                    _ => bail!("Invalid json argument to AvrcpInformBatteryStatus! - {}", args),
                };
                let result = self.inform_battery_status(battery_status.clone()).await?;
                Ok(to_value(result)?)
            }
            "AvrcpNotifyNotificationHandled" => {
                let result = self.notify_notification_handled().await?;
                Ok(to_value(result)?)
            }
            "AvrcpSetAddressedPlayer" => {
                let player_id: u16 = match from_value(args.clone()) {
                    Ok(settings) => settings,
                    _ => bail!("Invalid json argument to AvrcpSetAddressedPlayer! - {}", args),
                };
                let result = self.set_addressed_player(player_id.clone()).await?;
                Ok(to_value(result)?)
            }
            "AvrcpSetPlayerApplicationSettings" => {
                let settings: CustomPlayerApplicationSettings = match from_value(args.clone()) {
                    Ok(settings) => settings,
                    _ => bail!(
                        "Invalid json argument to AvrcpSetPlayerApplicationSettings! - {}",
                        args
                    ),
                };
                let result = self.set_player_application_settings(settings.clone()).await?;
                Ok(to_value(result)?)
            }
            "AvrcpSendCommand" => {
                let command_str = parse_arg!(args, as_str, "command")?;
                let result = self.send_command(command_str.to_string().into()).await?;
                Ok(to_value(result)?)
            }
            "AvrcpSetAbsoluteVolume" => {
                let absolute_volume_command: AbsoluteVolumeCommand = match from_value(args.clone())
                {
                    Ok(absolute_volume) => absolute_volume,
                    _ => bail!("Invalid json argument to AvrcpSetAbsoluteVolume! - {}", args),
                };
                let result =
                    self.set_absolute_volume(absolute_volume_command.absolute_volume).await?;
                Ok(to_value(result)?)
            }
            "AvrcpSetNotificationFilter" => {
                let custom_notifications: CustomNotificationsFilter = match from_value(args.clone())
                {
                    Ok(custom_notifications) => custom_notifications,
                    _ => bail!("Invalid json argument to AvrcpSetNotificationFilter! - {}", args),
                };
                let result = self
                    .set_notification_filter(
                        custom_notifications.notifications,
                        match custom_notifications.position_change_interval {
                            Some(position_change_interval) => position_change_interval,
                            _ => 0,
                        },
                    )
                    .await?;
                Ok(to_value(result)?)
            }
            _ => bail!("Invalid AVRCP FIDL method: {:?}", method),
        }
    }

    fn cleanup(&self) {}

    fn print(&self) {}
}

async fn start_scan_async(
    facade: &GattClientFacade,
    filter: Option<Filter>,
) -> Result<Value, Error> {
    let start_scan_result = facade.start_scan(filter).await?;
    Ok(to_value(start_scan_result)?)
}

async fn stop_scan_async(facade: &GattClientFacade) -> Result<Value, Error> {
    facade.stop_scan().await?;
    // Get the list of devices discovered by the scan.
    let devices = facade.get_scan_responses();
    match to_value(devices) {
        Ok(dev) => Ok(dev),
        Err(e) => Err(e.into()),
    }
}

async fn le_get_discovered_devices_async(facade: &GattClientFacade) -> Result<Value, Error> {
    // Get the list of devices discovered by the scan.
    match to_value(facade.get_scan_responses()) {
        Ok(dev) => Ok(dev),
        Err(e) => Err(e.into()),
    }
}

async fn connect_peripheral_async(facade: &GattClientFacade, id: String) -> Result<Value, Error> {
    let connect_periph_result = facade.connect_peripheral(id).await?;
    Ok(to_value(connect_periph_result)?)
}

async fn disconnect_peripheral_async(
    facade: &GattClientFacade,
    id: String,
) -> Result<Value, Error> {
    let value = facade.disconnect_peripheral(id).await?;
    Ok(to_value(value)?)
}

// Uses the same return type as connect_peripheral_async -- Returns subset of
// fidl::ServiceInfo
async fn list_services_async(facade: &GattClientFacade, id: String) -> Result<Value, Error> {
    let list_services_result = facade.list_services(id).await?;
    Ok(to_value(BleConnectPeripheralResponse::new(list_services_result))?)
}

async fn gattc_connect_to_service_async(
    facade: &GattClientFacade,
    periph_id: String,
    service_id: u64,
) -> Result<Value, Error> {
    let connect_to_service_result = facade.gattc_connect_to_service(periph_id, service_id).await?;
    Ok(to_value(connect_to_service_result)?)
}

async fn gattc_discover_characteristics_async(facade: &GattClientFacade) -> Result<Value, Error> {
    let discover_characteristics_results = facade.gattc_discover_characteristics().await?;
    Ok(to_value(GattcDiscoverCharacteristicResponse::new(discover_characteristics_results))?)
}

async fn gattc_write_char_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    write_value: Vec<u8>,
) -> Result<Value, Error> {
    let write_char_status = facade.gattc_write_char_by_id(id, write_value).await?;
    Ok(to_value(write_char_status)?)
}

async fn gattc_write_long_char_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    offset: u16,
    write_value: Vec<u8>,
    reliable_mode: bool,
) -> Result<Value, Error> {
    let write_char_status =
        facade.gattc_write_long_char_by_id(id, offset, write_value, reliable_mode).await?;
    Ok(to_value(write_char_status)?)
}

async fn gattc_write_char_by_id_without_response_async(
    facade: &GattClientFacade,
    id: u64,
    write_value: Vec<u8>,
) -> Result<Value, Error> {
    let write_char_status = facade.gattc_write_char_by_id_without_response(id, write_value).await?;
    Ok(to_value(write_char_status)?)
}

async fn gattc_read_char_by_id_async(facade: &GattClientFacade, id: u64) -> Result<Value, Error> {
    let read_char_status = facade.gattc_read_char_by_id(id).await?;
    Ok(to_value(read_char_status)?)
}

async fn gattc_read_long_char_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    offset: u16,
    max_bytes: u16,
) -> Result<Value, Error> {
    let read_long_char_status = facade.gattc_read_long_char_by_id(id, offset, max_bytes).await?;
    Ok(to_value(read_long_char_status)?)
}

async fn gattc_read_long_desc_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    offset: u16,
    max_bytes: u16,
) -> Result<Value, Error> {
    let read_long_desc_status = facade.gattc_read_long_desc_by_id(id, offset, max_bytes).await?;
    Ok(to_value(read_long_desc_status)?)
}

async fn gattc_read_desc_by_id_async(facade: &GattClientFacade, id: u64) -> Result<Value, Error> {
    let read_desc_status = facade.gattc_read_desc_by_id(id).await?;
    Ok(to_value(read_desc_status)?)
}

async fn gattc_write_desc_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    write_value: Vec<u8>,
) -> Result<Value, Error> {
    let write_desc_status = facade.gattc_write_desc_by_id(id, write_value).await?;
    Ok(to_value(write_desc_status)?)
}

async fn gattc_write_long_desc_by_id_async(
    facade: &GattClientFacade,
    id: u64,
    offset: u16,
    write_value: Vec<u8>,
) -> Result<Value, Error> {
    let write_desc_status = facade.gattc_write_long_desc_by_id(id, offset, write_value).await?;
    Ok(to_value(write_desc_status)?)
}

async fn gattc_toggle_notify_characteristic_async(
    facade: &GattClientFacade,
    id: u64,
    value: bool,
) -> Result<Value, Error> {
    let toggle_notify_result = facade.gattc_toggle_notify_characteristic(id, value).await?;
    Ok(to_value(toggle_notify_result)?)
}

#[async_trait(?Send)]
impl Facade for HfpFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "HfpInit" => {
                let result = self.init_hfp_service().await?;
                Ok(to_value(result)?)
            }
            "HfpRemoveService" => {
                self.cleanup().await;
                Ok(to_value(())?)
            }
            "ListPeers" => {
                let result = self.list_peers().await?;
                Ok(to_value(result)?)
            }
            "SetActivePeer" => {
                let id = parse_arg!(args, as_u64, "peer_id")?;
                let result = self.set_active_peer(id).await?;
                Ok(to_value(result)?)
            }
            "ListCalls" => {
                let result = self.list_calls().await?;
                Ok(to_value(result)?)
            }
            "NewCall" => {
                let remote = parse_arg!(args, as_str, "remote")?;
                let state = parse_arg!(args, as_str, "state")?.to_lowercase();
                let state = match &*state {
                    "ringing" => CallState::IncomingRinging,
                    "waiting" => CallState::IncomingWaiting,
                    "dialing" => CallState::OutgoingDialing,
                    "alerting" => CallState::OutgoingAlerting,
                    "active" => CallState::OngoingActive,
                    "held" => CallState::OngoingHeld,
                    _ => bail!("Invalid state argument: {}", state),
                };
                let direction = parse_arg!(args, as_str, "direction")?;
                let direction = match &*direction {
                    "incoming" => CallDirection::MobileTerminated,
                    "outgoing" => CallDirection::MobileOriginated,
                    _ => bail!("Invalid direction argument: {}", direction),
                };
                let result = self.new_call(&remote, state, direction).await?;
                Ok(to_value(result)?)
            }
            "IncomingCall" => {
                let remote = parse_arg!(args, as_str, "remote")?;
                let result = self.incoming_ringing_call(&remote).await?;
                Ok(to_value(result)?)
            }
            "IncomingWaitingCall" => {
                let remote = parse_arg!(args, as_str, "remote")?;
                let result = self.incoming_waiting_call(&remote).await?;
                Ok(to_value(result)?)
            }
            "OutgoingCall" => {
                let remote = parse_arg!(args, as_str, "remote")?;
                let result = self.outgoing_call(&remote).await?;
                Ok(to_value(result)?)
            }
            "SetCallActive" => {
                let call_id = parse_arg!(args, as_u64, "call_id")?;
                let result = self.set_call_active(call_id).await?;
                Ok(to_value(result)?)
            }
            "SetCallHeld" => {
                let call_id = parse_arg!(args, as_u64, "call_id")?;
                let result = self.set_call_held(call_id).await?;
                Ok(to_value(result)?)
            }
            "SetCallTerminated" => {
                let call_id = parse_arg!(args, as_u64, "call_id")?;
                let result = self.set_call_terminated(call_id).await?;
                Ok(to_value(result)?)
            }
            "SetCallTransferredToAg" => {
                let call_id = parse_arg!(args, as_u64, "call_id")?;
                let result = self.set_call_transferred_to_ag(call_id).await?;
                Ok(to_value(result)?)
            }
            "SetSpeakerGain" => {
                let value = parse_arg!(args, as_u64, "value")?;
                let result = self.set_speaker_gain(value).await?;
                Ok(to_value(result)?)
            }
            "SetMicrophoneGain" => {
                let value = parse_arg!(args, as_u64, "value")?;
                let result = self.set_microphone_gain(value).await?;
                Ok(to_value(result)?)
            }
            "SetServiceAvailable" => {
                let service_available = Some(parse_arg!(args, as_bool, "value")?);
                let result = self
                    .update_network_information(NetworkInformation {
                        service_available,
                        ..Default::default()
                    })
                    .await?;
                Ok(to_value(result)?)
            }
            "SetRoaming" => {
                let roaming = Some(parse_arg!(args, as_bool, "value")?);
                let result = self
                    .update_network_information(NetworkInformation {
                        roaming,
                        ..Default::default()
                    })
                    .await?;
                Ok(to_value(result)?)
            }
            "SetSignalStrength" => {
                let signal_strength = parse_arg!(args, as_u64, "value")?;
                let signal_strength = Some(match signal_strength {
                    0 => SignalStrength::None,
                    1 => SignalStrength::VeryLow,
                    2 => SignalStrength::Low,
                    3 => SignalStrength::Medium,
                    4 => SignalStrength::High,
                    5 => SignalStrength::VeryHigh,
                    _ => panic!(""),
                });
                let result = self
                    .update_network_information(NetworkInformation {
                        signal_strength,
                        ..Default::default()
                    })
                    .await?;
                Ok(to_value(result)?)
            }
            "SetSubscriberNumber" => {
                let number = parse_arg!(args, as_str, "value")?;
                self.set_subscriber_number(number).await;
                Ok(to_value(())?)
            }
            "SetOperator" => {
                let value = parse_arg!(args, as_str, "value")?;
                self.set_operator(value).await;
                Ok(to_value(())?)
            }
            "SetNrecSupport" => {
                let support = parse_arg!(args, as_bool, "value")?;
                self.set_nrec_support(support).await;
                Ok(to_value(())?)
            }
            "SetBatteryLevel" => {
                let level = parse_arg!(args, as_u64, "value")?;
                self.set_battery_level(level).await?;
                Ok(to_value(())?)
            }
            "SetLastDialed" => {
                let number = parse_arg!(args, as_str, "number")?.to_string();
                self.set_last_dialed(Some(number)).await;
                Ok(to_value(())?)
            }
            "ClearLastDialed" => {
                self.set_last_dialed(None).await;
                Ok(to_value(())?)
            }
            "SetMemoryLocation" => {
                let location = parse_arg!(args, as_str, "location")?.to_string();
                let number = parse_arg!(args, as_str, "number")?.to_string();
                self.set_memory_location(location, Some(number)).await;
                Ok(to_value(())?)
            }
            "ClearMemoryLocation" => {
                let location = parse_arg!(args, as_str, "location")?.to_string();
                self.set_memory_location(location, None).await;
                Ok(to_value(())?)
            }
            "SetDialResult" => {
                let number = parse_arg!(args, as_str, "number")?.to_string();
                let status = parse_arg!(args, as_i64, "status")?.try_into()?;
                let status = fuchsia_zircon::Status::from_raw(status);
                self.set_dial_result(number, status).await;
                Ok(to_value(())?)
            }
            "GetState" => {
                let result = self.get_state().await;
                Ok(to_value(result)?)
            }
            "SetConnectionBehavior" => {
                let autoconnect = parse_arg!(args, as_bool, "autoconnect")?;
                self.set_connection_behavior(autoconnect).await?;
                Ok(to_value(())?)
            }
            _ => bail!("Invalid Hfp FIDL method: {:?}", method),
        }
    }
}

#[async_trait(?Send)]
impl Facade for RfcommFacade {
    async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
        match method.as_ref() {
            "RfcommInit" => {
                let result = self.advertise()?;
                Ok(to_value(result)?)
            }
            "RfcommRemoveService" => {
                let result = self.clear_services();
                Ok(to_value(result)?)
            }
            "DisconnectSession" => {
                let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
                let result = self.close_session(id.into())?;
                Ok(to_value(result)?)
            }
            "ConnectRfcommChannel" => {
                let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
                let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
                let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
                let result = self.outgoing_rfcomm_channel(id.into(), channel_number).await?;
                Ok(to_value(result)?)
            }
            "DisconnectRfcommChannel" => {
                let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
                let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
                let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
                let result = self.close_rfcomm_channel(id.into(), channel_number)?;
                Ok(to_value(result)?)
            }
            "SendRemoteLineStatus" => {
                let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
                let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
                let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
                let result = self.send_rls(id.into(), channel_number)?;
                Ok(to_value(result)?)
            }
            "RfcommWrite" => {
                let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
                let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
                let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
                let data = parse_arg!(args, as_str, "data")?.to_string();
                let result = self.send_user_data(id.into(), channel_number, data.into_bytes())?;
                Ok(to_value(result)?)
            }
            _ => bail!("Invalid RFCOMM method: {:?}", method),
        }
    }
}