// 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 anyhow::{format_err, Error};
use fidl_fuchsia_bluetooth::{Appearance, Uuid as FidlUuid};
use fidl_fuchsia_bluetooth_avdtp_test::PeerControllerProxy;
use fidl_fuchsia_bluetooth_avrcp::{
    AvcPanelCommand, BatteryStatus, CustomAttributeValue, CustomPlayerApplicationSetting,
    Equalizer, PlayStatus, PlaybackStatus, PlayerApplicationSettingAttributeId,
    PlayerApplicationSettings, RepeatStatusMode, ScanMode, ShuffleMode,
};
use fidl_fuchsia_bluetooth_gatt2::{
    AttributePermissions, Characteristic, Descriptor, ReadByTypeResult, SecurityRequirements,
    ServiceHandle, ServiceInfo, ServiceKind,
};
use fidl_fuchsia_bluetooth_le::{
    AdvertisingData, AdvertisingModeHint, AdvertisingParameters, ConnectionOptions, Filter,
    ManufacturerData, ServiceData,
};
use fidl_fuchsia_bluetooth_sys::Peer;
use fuchsia_bluetooth::types::Uuid;
use num_derive::FromPrimitive;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use std::str::FromStr;

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

/// Handling different sessions.
/// Key is a generic id that is generated by the tool that is associated with a remote peer.
/// Value is the controller associated with the remote peer.
pub type PeerFactoryMap = HashMap<String, PeerControllerProxy>;

/// BleScan result type
/// TODO(https://fxbug.dev/42168627): Add support for RemoteDevices when clone() is implemented
#[derive(Serialize, Clone, Debug)]
pub struct BleScanResponse {
    pub id: String,
    pub name: String,
    pub connectable: bool,
}

impl BleScanResponse {
    pub fn new(id: String, name: String, connectable: bool) -> BleScanResponse {
        BleScanResponse { id, name, connectable }
    }
}

/// BleAdvertise result type (only uuid)
/// TODO(https://fxbug.dev/42168627): Add support for AdvertisingData when clone() is implemented
#[derive(Serialize, Clone, Debug)]
pub struct BleAdvertiseResponse {
    pub name: Option<String>,
}

impl BleAdvertiseResponse {
    pub fn new(name: Option<String>) -> BleAdvertiseResponse {
        BleAdvertiseResponse { name }
    }
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct SecurityRequirementsContainer {
    pub encryption_required: bool,
    pub authentication_required: bool,
    pub authorization_required: bool,
}

impl SecurityRequirementsContainer {
    pub fn new(info: Option<SecurityRequirements>) -> SecurityRequirementsContainer {
        match info {
            Some(sec) => SecurityRequirementsContainer {
                encryption_required: sec.encryption_required.unwrap_or(false),
                authentication_required: sec.authentication_required.unwrap_or(false),
                authorization_required: sec.authorization_required.unwrap_or(false),
            },
            None => SecurityRequirementsContainer::default(),
        }
    }
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct AttributePermissionsContainer {
    pub read: SecurityRequirementsContainer,
    pub write: SecurityRequirementsContainer,
    pub update: SecurityRequirementsContainer,
}

impl AttributePermissionsContainer {
    pub fn new(info: Option<AttributePermissions>) -> Result<AttributePermissionsContainer, Error> {
        match info {
            Some(perm) => Ok(AttributePermissionsContainer {
                read: SecurityRequirementsContainer::new(perm.read),
                write: SecurityRequirementsContainer::new(perm.write),
                update: SecurityRequirementsContainer::new(perm.update),
            }),
            None => return Err(format_err!("Unable to get information of AttributePermissions.")),
        }
    }
}

// Discover Characteristic response to hold characteristic info
// as Characteristics are not serializable.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct GattcDiscoverDescriptorResponse {
    pub id: u64,
    pub permissions: Option<AttributePermissionsContainer>,
    pub uuid_type: String,
}

impl GattcDiscoverDescriptorResponse {
    pub fn new(info: Vec<Descriptor>) -> Vec<GattcDiscoverDescriptorResponse> {
        let mut res = Vec::new();
        for v in info {
            let copy = GattcDiscoverDescriptorResponse {
                id: v.handle.unwrap().value,
                permissions: match AttributePermissionsContainer::new(v.permissions) {
                    Ok(n) => Some(n),
                    Err(_) => None,
                },
                uuid_type: Uuid::from(v.type_.unwrap()).to_string(),
            };
            res.push(copy)
        }
        res
    }
}

// Discover Characteristic response to hold characteristic info
// as Characteristics are not serializable.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct GattcDiscoverCharacteristicResponse {
    pub id: u64,
    pub properties: u32,
    pub permissions: Option<AttributePermissionsContainer>,
    pub uuid_type: String,
    pub descriptors: Vec<GattcDiscoverDescriptorResponse>,
}

impl GattcDiscoverCharacteristicResponse {
    pub fn new(info: Vec<Characteristic>) -> Vec<GattcDiscoverCharacteristicResponse> {
        let mut res = Vec::new();
        for v in info {
            let copy = GattcDiscoverCharacteristicResponse {
                id: v.handle.unwrap().value,
                properties: v.properties.unwrap().bits().into(),
                permissions: match AttributePermissionsContainer::new(v.permissions) {
                    Ok(n) => Some(n),
                    Err(_) => None,
                },
                uuid_type: Uuid::from(v.type_.unwrap()).to_string(),
                descriptors: {
                    match v.descriptors {
                        Some(d) => GattcDiscoverDescriptorResponse::new(d),
                        None => Vec::new(),
                    }
                },
            };
            res.push(copy)
        }
        res
    }
}

/// BleConnectPeripheral response (aka ServiceInfo)
/// TODO(https://fxbug.dev/42168627): Add support for ServiceInfo when clone(), serialize(), derived
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct BleConnectPeripheralResponse {
    pub id: u64,
    pub primary: bool,
    pub uuid_type: String,
}

impl BleConnectPeripheralResponse {
    pub fn new(info: Vec<ServiceInfo>) -> Vec<BleConnectPeripheralResponse> {
        let mut res = Vec::new();
        for v in info {
            let copy = BleConnectPeripheralResponse {
                id: v.handle.unwrap().value,
                primary: v.kind.unwrap() == ServiceKind::Primary,
                uuid_type: Uuid::from(v.type_.unwrap()).to_string(),
            };
            res.push(copy)
        }
        res
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct SerializablePeer {
    pub address: Option<[u8; 6]>,
    pub appearance: Option<u32>,
    pub device_class: Option<u32>,
    pub id: Option<String>,
    pub name: Option<String>,
    pub connected: Option<bool>,
    pub bonded: Option<bool>,
    pub rssi: Option<i8>,
    pub services: Option<Vec<[u8; 16]>>,
    pub technology: Option<u32>,
    pub tx_power: Option<i8>,
}

impl From<&Peer> for SerializablePeer {
    fn from(peer: &Peer) -> Self {
        let services = match &peer.services {
            Some(s) => {
                let mut service_list = Vec::new();
                for item in s {
                    service_list.push(item.value);
                }
                Some(service_list)
            }
            None => None,
        };
        SerializablePeer {
            address: peer.address.map(|a| a.bytes),
            appearance: peer.appearance.map(|a| a.into_primitive() as u32),
            device_class: peer.device_class.map(|d| d.value),
            id: peer.id.map(|i| i.value.to_string()),
            name: peer.name.clone(),
            connected: peer.connected,
            bonded: peer.bonded,
            rssi: peer.rssi,
            services: services,
            technology: peer.technology.map(|t| t as u32),
            tx_power: peer.tx_power,
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct SerializableReadByTypeResult {
    pub id: Option<u64>,
    pub value: Option<Vec<u8>>,
}

impl SerializableReadByTypeResult {
    pub fn new(result: ReadByTypeResult) -> Option<Self> {
        if result.error.is_some() {
            return None;
        }
        let id = result.handle.unwrap().value;
        let value = result.value.unwrap().value.unwrap();
        Some(SerializableReadByTypeResult { id: Some(id), value: Some(value) })
    }
}

#[derive(Clone, Debug, Serialize, Eq, Copy)]
pub struct CustomPlayStatus {
    pub song_length: Option<u32>,
    pub song_position: Option<u32>,
    pub playback_status: Option<u8>,
}

impl CustomPlayStatus {
    pub fn new(status: &PlayStatus) -> Self {
        let playback_status = match status.playback_status {
            Some(p) => Some(p as u8),
            None => None,
        };
        CustomPlayStatus {
            song_length: status.song_length,
            song_position: status.song_position,
            playback_status: playback_status,
        }
    }
}

impl From<CustomPlayStatus> for PlayStatus {
    fn from(status: CustomPlayStatus) -> Self {
        let playback_status = match status.playback_status {
            Some(0) => Some(PlaybackStatus::Stopped),
            Some(1) => Some(PlaybackStatus::Playing),
            Some(2) => Some(PlaybackStatus::Paused),
            Some(3) => Some(PlaybackStatus::FwdSeek),
            Some(4) => Some(PlaybackStatus::RevSeek),
            Some(255) => Some(PlaybackStatus::Error),
            None => None,
            _ => panic!("Unknown playback status!"),
        };
        PlayStatus {
            song_length: status.song_length,
            song_position: status.song_position,
            playback_status: playback_status,
            ..Default::default()
        }
    }
}

impl From<PlayStatus> for CustomPlayStatus {
    fn from(status: PlayStatus) -> Self {
        CustomPlayStatus {
            song_length: status.song_length,
            song_position: status.song_position,
            playback_status: match status.playback_status {
                Some(p) => Some(p as u8),
                None => None,
            },
        }
    }
}

impl PartialEq for CustomPlayStatus {
    fn eq(&self, other: &CustomPlayStatus) -> bool {
        self.song_length == other.song_length
            && self.song_position == other.song_position
            && self.playback_status == other.playback_status
    }
}
#[derive(Copy, Clone, Debug, FromPrimitive, Serialize, Deserialize)]
#[repr(u8)]
pub enum CustomAvcPanelCommand {
    Select = 0,
    Up = 1,
    Down = 2,
    Left = 3,
    Right = 4,
    RootMenu = 9,
    ContentsMenu = 11,
    FavoriteMenu = 12,
    Exit = 13,
    OnDemandMenu = 14,
    AppsMenu = 15,
    Key0 = 32,
    Key1 = 33,
    Key2 = 34,
    Key3 = 35,
    Key4 = 36,
    Key5 = 37,
    Key6 = 38,
    Key7 = 39,
    Key8 = 40,
    Key9 = 41,
    Dot = 42,
    Enter = 43,
    ChannelUp = 48,
    ChannelDown = 49,
    ChannelPrevious = 50,
    InputSelect = 52,
    Info = 53,
    Help = 54,
    PageUp = 55,
    PageDown = 56,
    Lock = 58,
    Power = 64,
    VolumeUp = 65,
    VolumeDown = 66,
    Mute = 67,
    Play = 68,
    Stop = 69,
    Pause = 70,
    Record = 71,
    Rewind = 72,
    FastForward = 73,
    Eject = 74,
    Forward = 75,
    Backward = 76,
    List = 77,
    F1 = 113,
    F2 = 114,
    F3 = 115,
    F4 = 116,
    F5 = 117,
    F6 = 118,
    F7 = 119,
    F8 = 120,
    F9 = 121,
    Red = 122,
    Green = 123,
    Blue = 124,
    Yellow = 125,
}

impl From<CustomAvcPanelCommand> for AvcPanelCommand {
    fn from(command: CustomAvcPanelCommand) -> Self {
        match command {
            CustomAvcPanelCommand::Select => AvcPanelCommand::Select,
            CustomAvcPanelCommand::Up => AvcPanelCommand::Up,
            CustomAvcPanelCommand::Down => AvcPanelCommand::Down,
            CustomAvcPanelCommand::Left => AvcPanelCommand::Left,
            CustomAvcPanelCommand::Right => AvcPanelCommand::Right,
            CustomAvcPanelCommand::RootMenu => AvcPanelCommand::RootMenu,
            CustomAvcPanelCommand::ContentsMenu => AvcPanelCommand::ContentsMenu,
            CustomAvcPanelCommand::FavoriteMenu => AvcPanelCommand::FavoriteMenu,
            CustomAvcPanelCommand::Exit => AvcPanelCommand::Exit,
            CustomAvcPanelCommand::OnDemandMenu => AvcPanelCommand::OnDemandMenu,
            CustomAvcPanelCommand::AppsMenu => AvcPanelCommand::AppsMenu,
            CustomAvcPanelCommand::Key0 => AvcPanelCommand::Key0,
            CustomAvcPanelCommand::Key1 => AvcPanelCommand::Key1,
            CustomAvcPanelCommand::Key2 => AvcPanelCommand::Key2,
            CustomAvcPanelCommand::Key3 => AvcPanelCommand::Key3,
            CustomAvcPanelCommand::Key4 => AvcPanelCommand::Key4,
            CustomAvcPanelCommand::Key5 => AvcPanelCommand::Key5,
            CustomAvcPanelCommand::Key6 => AvcPanelCommand::Key6,
            CustomAvcPanelCommand::Key7 => AvcPanelCommand::Key7,
            CustomAvcPanelCommand::Key8 => AvcPanelCommand::Key8,
            CustomAvcPanelCommand::Key9 => AvcPanelCommand::Key9,
            CustomAvcPanelCommand::Dot => AvcPanelCommand::Dot,
            CustomAvcPanelCommand::Enter => AvcPanelCommand::Enter,
            CustomAvcPanelCommand::ChannelUp => AvcPanelCommand::ChannelUp,
            CustomAvcPanelCommand::ChannelDown => AvcPanelCommand::ChannelDown,
            CustomAvcPanelCommand::ChannelPrevious => AvcPanelCommand::ChannelPrevious,
            CustomAvcPanelCommand::InputSelect => AvcPanelCommand::InputSelect,
            CustomAvcPanelCommand::Info => AvcPanelCommand::Info,
            CustomAvcPanelCommand::Help => AvcPanelCommand::Help,
            CustomAvcPanelCommand::PageUp => AvcPanelCommand::PageUp,
            CustomAvcPanelCommand::PageDown => AvcPanelCommand::PageDown,
            CustomAvcPanelCommand::Lock => AvcPanelCommand::Lock,
            CustomAvcPanelCommand::Power => AvcPanelCommand::Power,
            CustomAvcPanelCommand::VolumeUp => AvcPanelCommand::VolumeUp,
            CustomAvcPanelCommand::VolumeDown => AvcPanelCommand::VolumeDown,
            CustomAvcPanelCommand::Mute => AvcPanelCommand::Mute,
            CustomAvcPanelCommand::Play => AvcPanelCommand::Play,
            CustomAvcPanelCommand::Stop => AvcPanelCommand::Stop,
            CustomAvcPanelCommand::Pause => AvcPanelCommand::Pause,
            CustomAvcPanelCommand::Record => AvcPanelCommand::Record,
            CustomAvcPanelCommand::Rewind => AvcPanelCommand::Rewind,
            CustomAvcPanelCommand::FastForward => AvcPanelCommand::FastForward,
            CustomAvcPanelCommand::Eject => AvcPanelCommand::Eject,
            CustomAvcPanelCommand::Forward => AvcPanelCommand::Forward,
            CustomAvcPanelCommand::Backward => AvcPanelCommand::Backward,
            CustomAvcPanelCommand::List => AvcPanelCommand::List,
            CustomAvcPanelCommand::F1 => AvcPanelCommand::F1,
            CustomAvcPanelCommand::F2 => AvcPanelCommand::F2,
            CustomAvcPanelCommand::F3 => AvcPanelCommand::F3,
            CustomAvcPanelCommand::F4 => AvcPanelCommand::F4,
            CustomAvcPanelCommand::F5 => AvcPanelCommand::F5,
            CustomAvcPanelCommand::F6 => AvcPanelCommand::F6,
            CustomAvcPanelCommand::F7 => AvcPanelCommand::F7,
            CustomAvcPanelCommand::F8 => AvcPanelCommand::F8,
            CustomAvcPanelCommand::F9 => AvcPanelCommand::F9,
            CustomAvcPanelCommand::Red => AvcPanelCommand::Red,
            CustomAvcPanelCommand::Green => AvcPanelCommand::Green,
            CustomAvcPanelCommand::Blue => AvcPanelCommand::Blue,
            CustomAvcPanelCommand::Yellow => AvcPanelCommand::Yellow,
        }
    }
}

impl From<String> for CustomAvcPanelCommand {
    fn from(command: String) -> Self {
        match command.as_str() {
            "Select" => CustomAvcPanelCommand::Select,
            "Up" => CustomAvcPanelCommand::Up,
            "Down" => CustomAvcPanelCommand::Down,
            "Left" => CustomAvcPanelCommand::Left,
            "Right" => CustomAvcPanelCommand::Right,
            "RootMenu" => CustomAvcPanelCommand::RootMenu,
            "ContentsMenu" => CustomAvcPanelCommand::ContentsMenu,
            "FavoriteMenu" => CustomAvcPanelCommand::FavoriteMenu,
            "Exit" => CustomAvcPanelCommand::Exit,
            "OnDemandMenu" => CustomAvcPanelCommand::OnDemandMenu,
            "AppsMenu" => CustomAvcPanelCommand::AppsMenu,
            "Key0" => CustomAvcPanelCommand::Key0,
            "Key1" => CustomAvcPanelCommand::Key1,
            "Key2" => CustomAvcPanelCommand::Key2,
            "Key3" => CustomAvcPanelCommand::Key3,
            "Key4" => CustomAvcPanelCommand::Key4,
            "Key5" => CustomAvcPanelCommand::Key5,
            "Key6" => CustomAvcPanelCommand::Key6,
            "Key7" => CustomAvcPanelCommand::Key7,
            "Key8" => CustomAvcPanelCommand::Key8,
            "Key9" => CustomAvcPanelCommand::Key9,
            "Dot" => CustomAvcPanelCommand::Dot,
            "Enter" => CustomAvcPanelCommand::Enter,
            "ChannelUp" => CustomAvcPanelCommand::ChannelUp,
            "ChannelDown" => CustomAvcPanelCommand::ChannelDown,
            "ChannelPrevious" => CustomAvcPanelCommand::ChannelPrevious,
            "InputSelect" => CustomAvcPanelCommand::InputSelect,
            "Info" => CustomAvcPanelCommand::Info,
            "Help" => CustomAvcPanelCommand::Help,
            "PageUp" => CustomAvcPanelCommand::PageUp,
            "PageDown" => CustomAvcPanelCommand::PageDown,
            "Lock" => CustomAvcPanelCommand::Lock,
            "Power" => CustomAvcPanelCommand::Power,
            "VolumeUp" => CustomAvcPanelCommand::VolumeUp,
            "VolumeDown" => CustomAvcPanelCommand::VolumeDown,
            "Mute" => CustomAvcPanelCommand::Mute,
            "Play" => CustomAvcPanelCommand::Play,
            "Stop" => CustomAvcPanelCommand::Stop,
            "Pause" => CustomAvcPanelCommand::Pause,
            "Record" => CustomAvcPanelCommand::Record,
            "Rewind" => CustomAvcPanelCommand::Rewind,
            "FastForward" => CustomAvcPanelCommand::FastForward,
            "Eject" => CustomAvcPanelCommand::Eject,
            "Forward" => CustomAvcPanelCommand::Forward,
            "Backward" => CustomAvcPanelCommand::Backward,
            "List" => CustomAvcPanelCommand::List,
            "F1" => CustomAvcPanelCommand::F1,
            "F2" => CustomAvcPanelCommand::F2,
            "F3" => CustomAvcPanelCommand::F3,
            "F4" => CustomAvcPanelCommand::F4,
            "F5" => CustomAvcPanelCommand::F5,
            "F6" => CustomAvcPanelCommand::F6,
            "F7" => CustomAvcPanelCommand::F7,
            "F8" => CustomAvcPanelCommand::F8,
            "F9" => CustomAvcPanelCommand::F9,
            "Red" => CustomAvcPanelCommand::Red,
            "Green" => CustomAvcPanelCommand::Green,
            "Blue" => CustomAvcPanelCommand::Blue,
            "Yellow" => CustomAvcPanelCommand::Yellow,
            _invalid => panic!("Invalid CustomAvcPanelCommand command:{:?}", _invalid),
        }
    }
}
#[derive(Deserialize)]
pub struct AbsoluteVolumeCommand {
    pub absolute_volume: u8,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct CustomPlayerApplicationSettingsAttributeIds {
    pub attribute_ids: Option<Vec<u8>>,
}

impl CustomPlayerApplicationSettingsAttributeIds {
    pub fn to_vec(&self) -> Vec<PlayerApplicationSettingAttributeId> {
        match &self.attribute_ids {
            Some(vec) => vec
                .into_iter()
                .map(|u8| match u8 {
                    1 => PlayerApplicationSettingAttributeId::Equalizer,
                    2 => PlayerApplicationSettingAttributeId::RepeatStatusMode,
                    3 => PlayerApplicationSettingAttributeId::ShuffleMode,
                    4 => PlayerApplicationSettingAttributeId::ScanMode,
                    invalid => panic!(
                        "Invalid value for PlayerApplicationSettingAttributeId {:?}",
                        invalid
                    ),
                })
                .collect(),
            None => Vec::new(),
        }
    }
}
#[derive(Clone, Debug, Serialize)]
pub enum CustomPlayerApplicationSettingsAttributeId {
    Equalizer = 1,
    RepeatStatusMode = 2,
    ShuffleMode = 3,
    ScanMode = 4,
}

impl From<u8> for CustomPlayerApplicationSettingsAttributeId {
    fn from(attribute_id: u8) -> CustomPlayerApplicationSettingsAttributeId {
        match attribute_id {
            1 => CustomPlayerApplicationSettingsAttributeId::Equalizer,
            2 => CustomPlayerApplicationSettingsAttributeId::RepeatStatusMode,
            3 => CustomPlayerApplicationSettingsAttributeId::ShuffleMode,
            4 => CustomPlayerApplicationSettingsAttributeId::ScanMode,
            _ => panic!("Invalid attribute id: {:?}", attribute_id),
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct CustomPlayerApplicationSettings {
    pub equalizer: Option<CustomEqualizer>,
    pub repeat_status_mode: Option<CustomRepeatStatusMode>,
    pub shuffle_mode: Option<CustomShuffleMode>,
    pub scan_mode: Option<CustomScanMode>,
    pub custom_settings: Option<Vec<CustomCustomPlayerApplicationSetting>>,
}

#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct CustomCustomPlayerApplicationSetting {
    pub attribute_id: Option<u8>,
    pub attribute_name: Option<String>,
    pub possible_values: Option<Vec<CustomCustomAttributeValue>>,
    pub current_value: Option<u8>,
}

#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct CustomCustomAttributeValue {
    pub description: String,
    pub value: u8,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Copy)]
pub enum CustomEqualizer {
    Off = 1,
    On = 2,
}

#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Copy)]
pub enum CustomRepeatStatusMode {
    Off = 1,
    SingleTrackRepeat = 2,
    AllTrackRepeat = 3,
    GroupRepeat = 4,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Copy)]
pub enum CustomShuffleMode {
    Off = 1,
    AllTrackShuffle = 2,
    GroupShuffle = 3,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Copy)]
pub enum CustomScanMode {
    Off = 1,
    AllTrackScan = 2,
    GroupScan = 3,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Copy)]
pub enum CustomBatteryStatus {
    Normal = 0,
    Warning = 1,
    Critical = 2,
    External = 3,
    FullCharge = 4,
    Reserved = 5,
}

impl From<PlayerApplicationSettings> for CustomPlayerApplicationSettings {
    fn from(settings: PlayerApplicationSettings) -> CustomPlayerApplicationSettings {
        CustomPlayerApplicationSettings {
            equalizer: match settings.equalizer {
                Some(equalizer) => match equalizer {
                    Equalizer::Off => Some(CustomEqualizer::Off),
                    Equalizer::On => Some(CustomEqualizer::On),
                },
                None => None,
            },
            repeat_status_mode: match settings.repeat_status_mode {
                Some(repeat_status_mode) => match repeat_status_mode {
                    RepeatStatusMode::Off => Some(CustomRepeatStatusMode::Off),
                    RepeatStatusMode::SingleTrackRepeat => {
                        Some(CustomRepeatStatusMode::SingleTrackRepeat)
                    }
                    RepeatStatusMode::AllTrackRepeat => {
                        Some(CustomRepeatStatusMode::AllTrackRepeat)
                    }
                    RepeatStatusMode::GroupRepeat => Some(CustomRepeatStatusMode::GroupRepeat),
                },
                None => None,
            },
            shuffle_mode: match settings.shuffle_mode {
                Some(shuffle_mode) => match shuffle_mode {
                    ShuffleMode::Off => Some(CustomShuffleMode::Off),
                    ShuffleMode::AllTrackShuffle => Some(CustomShuffleMode::AllTrackShuffle),
                    ShuffleMode::GroupShuffle => Some(CustomShuffleMode::GroupShuffle),
                },
                None => None,
            },
            scan_mode: match settings.scan_mode {
                Some(scan_mode) => match scan_mode {
                    ScanMode::Off => Some(CustomScanMode::Off),
                    ScanMode::AllTrackScan => Some(CustomScanMode::AllTrackScan),
                    ScanMode::GroupScan => Some(CustomScanMode::GroupScan),
                },
                None => None,
            },
            custom_settings: match settings.custom_settings {
                Some(custom_settings_vec) => Some(
                    custom_settings_vec
                        .into_iter()
                        .map(|custom_settings| CustomCustomPlayerApplicationSetting {
                            attribute_id: custom_settings.attribute_id,
                            attribute_name: custom_settings.attribute_name,
                            possible_values: match custom_settings.possible_values {
                                Some(possible_values) => Some(
                                    possible_values
                                        .into_iter()
                                        .map(|possible_value| possible_value.into())
                                        .collect(),
                                ),
                                None => None,
                            },
                            current_value: custom_settings.current_value,
                        })
                        .collect(),
                ),
                None => None,
            },
        }
    }
}

impl From<CustomPlayerApplicationSettings> for PlayerApplicationSettings {
    fn from(settings: CustomPlayerApplicationSettings) -> PlayerApplicationSettings {
        PlayerApplicationSettings {
            equalizer: match settings.equalizer {
                Some(equalizer) => match equalizer {
                    CustomEqualizer::Off => Some(Equalizer::Off),
                    CustomEqualizer::On => Some(Equalizer::On),
                },
                None => None,
            },
            repeat_status_mode: match settings.repeat_status_mode {
                Some(repeat_status_mode) => match repeat_status_mode {
                    CustomRepeatStatusMode::Off => Some(RepeatStatusMode::Off),
                    CustomRepeatStatusMode::SingleTrackRepeat => {
                        Some(RepeatStatusMode::SingleTrackRepeat)
                    }
                    CustomRepeatStatusMode::AllTrackRepeat => {
                        Some(RepeatStatusMode::AllTrackRepeat)
                    }
                    CustomRepeatStatusMode::GroupRepeat => Some(RepeatStatusMode::GroupRepeat),
                },
                None => None,
            },
            shuffle_mode: match settings.shuffle_mode {
                Some(shuffle_mode) => match shuffle_mode {
                    CustomShuffleMode::Off => Some(ShuffleMode::Off),
                    CustomShuffleMode::AllTrackShuffle => Some(ShuffleMode::AllTrackShuffle),
                    CustomShuffleMode::GroupShuffle => Some(ShuffleMode::GroupShuffle),
                },
                None => None,
            },
            scan_mode: match settings.scan_mode {
                Some(scan_mode) => match scan_mode {
                    CustomScanMode::Off => Some(ScanMode::Off),
                    CustomScanMode::AllTrackScan => Some(ScanMode::AllTrackScan),
                    CustomScanMode::GroupScan => Some(ScanMode::GroupScan),
                },
                None => None,
            },
            custom_settings: match settings.custom_settings {
                Some(custom_settings_vec) => Some(
                    custom_settings_vec
                        .into_iter()
                        .map(|custom_settings| CustomPlayerApplicationSetting {
                            attribute_id: custom_settings.attribute_id,
                            attribute_name: custom_settings.attribute_name,
                            possible_values: match custom_settings.possible_values {
                                Some(possible_values) => Some(
                                    possible_values
                                        .into_iter()
                                        .map(|possible_value| possible_value.into())
                                        .collect(),
                                ),
                                None => None,
                            },
                            current_value: custom_settings.current_value,
                            ..Default::default()
                        })
                        .collect(),
                ),
                None => None,
            },
            ..Default::default()
        }
    }
}

impl From<CustomCustomAttributeValue> for CustomAttributeValue {
    fn from(attribute_value: CustomCustomAttributeValue) -> CustomAttributeValue {
        CustomAttributeValue {
            description: attribute_value.description,
            value: attribute_value.value,
        }
    }
}

impl From<CustomAttributeValue> for CustomCustomAttributeValue {
    fn from(attribute_value: CustomAttributeValue) -> CustomCustomAttributeValue {
        CustomCustomAttributeValue {
            description: attribute_value.description,
            value: attribute_value.value,
        }
    }
}

impl From<BatteryStatus> for CustomBatteryStatus {
    fn from(status: BatteryStatus) -> Self {
        match status {
            BatteryStatus::Normal => CustomBatteryStatus::Normal,
            BatteryStatus::Warning => CustomBatteryStatus::Warning,
            BatteryStatus::Critical => CustomBatteryStatus::Critical,
            BatteryStatus::External => CustomBatteryStatus::External,
            BatteryStatus::FullCharge => CustomBatteryStatus::FullCharge,
            BatteryStatus::Reserved => CustomBatteryStatus::Reserved,
        }
    }
}

impl From<CustomBatteryStatus> for BatteryStatus {
    fn from(status: CustomBatteryStatus) -> Self {
        match status {
            CustomBatteryStatus::Normal => BatteryStatus::Normal,
            CustomBatteryStatus::Warning => BatteryStatus::Warning,
            CustomBatteryStatus::Critical => BatteryStatus::Critical,
            CustomBatteryStatus::External => BatteryStatus::External,
            CustomBatteryStatus::FullCharge => BatteryStatus::FullCharge,
            CustomBatteryStatus::Reserved => BatteryStatus::Reserved,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CustomNotificationsFilter {
    pub notifications: u32,
    pub position_change_interval: Option<u32>,
}

pub struct FacadeArg {
    value: Value,
}

impl FacadeArg {
    pub fn new(value: Value) -> Self {
        FacadeArg { value }
    }
}

/// Deserializes a serde json object according to the following schema
///
/// {
///     'advertising_data': {
///         'name': Some(String),
///         'appearance': Some(u64),
///         'service_data': {
///             'uuid': ['fb', '34', '9b', '5f', '80', '00', '00', '80', '00', '10', '00', '00', '01', '18', '00', '00'].
///             'data': "1"
///         },
///         'service_uuids': [
///             ['fb', '34', '9b', '5f', '80', '00', '00', '80', '00', '10', '00', '00', '01', '18', '00', '00'].
///             ['fb', '34', '9b', '5f', '80', '00', '00', '80', '00', '10', '00', '00', '00', '18', '00', '00']
///         ],
///         'manufacturer_data': {
///             'id': 10,
///             'data'
///         },
///         'uris': Some(['telnet://192.0.2.16:80/']),
///         'tx_power_level': Some(1),
///
///     }
///
/// }
///
/// Note: A human readable uuid is represented as a list of bytes:
///     Example Human Readable UUID: '00001801-0000-1000-8000-00805f9b34fb'
///     Actual input:
///         ['fb', '34', '9b', '5f', '80', '00', '00', '80', '00', '10', '00', '00', '01', '18', '00', '00']
impl TryInto<AdvertisingData> for FacadeArg {
    type Error = Error;
    fn try_into(self) -> Result<AdvertisingData, Self::Error> {
        /// Parse json input UUID and return Bluetooth UUID format.
        ///
        /// # Arguments
        /// * `json_uuid`: The JSON UUID in the form of a list of bytes.
        fn parse_uuid(json_uuid: &Value) -> Result<FidlUuid, Error> {
            let mut byte_list = vec![];

            for byte_string in json_uuid.as_array().unwrap() {
                let raw_value = match i64::from_str_radix(byte_string.as_str().unwrap(), 16) {
                    Ok(v) => v as u8,
                    Err(e) => bail!("Failed to convert raw value with: {:?}", e),
                };
                byte_list.push(raw_value);
            }
            Ok(FidlUuid {
                value: byte_list.as_slice().try_into().expect("Failed to set UUID value."),
            })
        }

        /// Parse a list of service uuids from a json input list.
        ///
        /// # Arguments
        /// * `json_service_uuids`: The JSON UUIDs in the form of lists of list of bytes.
        fn parse_service_uuids(json_service_uuids: &Vec<Value>) -> Result<Vec<FidlUuid>, Error> {
            let mut uuid_list = Vec::new();

            for raw_uuid_list in json_service_uuids {
                uuid_list.push(parse_uuid(raw_uuid_list)?);
            }
            Ok(uuid_list)
        }

        /// Parse the json input service data into a list of ServiceData
        ///
        /// # Arguments
        /// * `json_service_data`: The JSON representation of ServiceData to parse.
        fn parse_service_data(json_service_data: &Vec<Value>) -> Result<Vec<ServiceData>, Error> {
            let mut manufacturer_data_list = Vec::new();

            for raw_service_data in json_service_data {
                let uuid = match raw_service_data.get("uuid") {
                    Some(v) => parse_uuid(v)?,
                    None => bail!("Missing Service data info 'uuid'."),
                };
                let data = match raw_service_data.get("data") {
                    Some(d) => d.to_string().into_bytes(),
                    None => bail!("Missing Service data info 'data'."),
                };
                manufacturer_data_list.push(ServiceData { uuid, data });
            }
            Ok(manufacturer_data_list)
        }

        /// Parse the json input manufacturer data into a list of ManufacturerData
        ///
        /// # Arguments
        /// * `json_manufacturer_data`: The JSON representation of ManufacturerData to parse.
        fn parse_manufacturer_data(
            json_manufacturer_data: &Vec<Value>,
        ) -> Result<Vec<ManufacturerData>, Error> {
            let mut manufacturer_data_list = Vec::new();

            for raw_manufacturer_data in json_manufacturer_data {
                let company_id = match raw_manufacturer_data.get("id") {
                    Some(v) => match v.as_u64() {
                        Some(c) => c as u16,
                        None => bail!("Company id not a valid value."),
                    },
                    None => bail!("Missing Manufacturer info 'id'."),
                };
                let data = match raw_manufacturer_data.get("data") {
                    Some(d) => d.to_string().into_bytes(),
                    None => bail!("Missing Manufacturer info 'data'."),
                };
                manufacturer_data_list.push(ManufacturerData { company_id, data });
            }
            Ok(manufacturer_data_list)
        }

        let name: Option<String> = self.value["name"].as_str().map(String::from);
        let service_uuids = match self.value.get("service_uuids") {
            Some(v) => {
                if v.is_null() {
                    None
                } else {
                    match v.clone().as_array() {
                        Some(list) => Some(parse_service_uuids(list)?),
                        None => bail!("Attribute 'service_uuids' is not a parseable list."),
                    }
                }
            }
            None => None,
        };

        let appearance = match self.value.get("appearance") {
            Some(v) => {
                if v.is_null() {
                    None
                } else {
                    match v.as_u64() {
                        Some(c) => Appearance::from_primitive(c as u16),
                        None => None,
                    }
                }
            }
            None => bail!("Value 'appearance' missing."),
        };

        let include_tx_power_level =
            self.value.get("tx_power_level").and_then(|v| Some(!v.is_null()));

        let service_data = match self.value.get("service_data") {
            Some(raw) => {
                if raw.is_null() {
                    None
                } else {
                    match raw.as_array() {
                        Some(list) => Some(parse_service_data(list)?),
                        None => None,
                    }
                }
            }
            None => bail!("Value 'service_data' missing."),
        };

        let manufacturer_data = match self.value.get("manufacturer_data") {
            Some(raw) => {
                if raw.is_null() {
                    None
                } else {
                    match raw.as_array() {
                        Some(list) => Some(parse_manufacturer_data(list)?),
                        None => None,
                    }
                }
            }
            None => bail!("Value 'manufacturer_data' missing."),
        };

        let uris = match self.value.get("uris") {
            Some(raw) => {
                if raw.is_null() {
                    None
                } else {
                    match raw.as_array() {
                        Some(list) => {
                            let mut uri_list = Vec::new();
                            for item in list {
                                match item.as_str() {
                                    Some(i) => uri_list.push(String::from(i)),
                                    None => bail!("Expected URI string"),
                                }
                            }
                            Some(uri_list)
                        }
                        None => None,
                    }
                }
            }
            None => bail!("Value 'uris' missing."),
        };

        Ok(AdvertisingData {
            name,
            appearance,
            service_uuids,
            service_data,
            manufacturer_data,
            uris: uris,
            include_tx_power_level,
            ..Default::default()
        })
    }
}

impl TryInto<AdvertisingParameters> for FacadeArg {
    type Error = Error;
    fn try_into(self) -> Result<AdvertisingParameters, Self::Error> {
        let advertising_data = match self.value.get("advertising_data") {
            Some(adr) => Some(FacadeArg::new(adr.clone()).try_into()?),
            None => bail!("Value 'advertising_data' missing."),
        };

        let scan_response = match self.value.get("scan_response") {
            Some(scn) => {
                if scn.is_null() {
                    None
                } else {
                    Some(FacadeArg::new(scn.clone()).try_into()?)
                }
            }
            None => None,
        };

        let conn_raw = self.value.get("connectable").ok_or(format_err!("Connectable missing"))?;

        let connectable: bool = conn_raw.as_bool().unwrap_or(false);

        let conn_opts = if connectable {
            Some(ConnectionOptions {
                bondable_mode: Some(true),
                service_filter: None,
                ..Default::default()
            })
        } else {
            None
        };

        Ok(AdvertisingParameters {
            data: advertising_data,
            scan_response: scan_response,
            mode_hint: Some(AdvertisingModeHint::VeryFast),
            connection_options: conn_opts,
            ..Default::default()
        })
    }
}

impl TryInto<Filter> for FacadeArg {
    type Error = Error;
    fn try_into(self) -> Result<Filter, Self::Error> {
        let value = self.value.get("filter").ok_or(format_err!("Scan filter missing."))?.clone();
        let name = value["name_substring"].as_str().map(String::from);
        // For now, no scan profile, so default to empty Filter
        Ok(Filter { name, ..Default::default() })
    }
}

impl TryInto<ServiceInfo> for FacadeArg {
    type Error = Error;
    fn try_into(self) -> Result<ServiceInfo, Self::Error> {
        let value = self.value.clone();
        let id = parse_arg!(value, as_u64, "id")?;
        let handle = ServiceHandle { value: id };
        let primary = parse_arg!(value, as_bool, "primary")?;
        let kind = if primary { ServiceKind::Primary } else { ServiceKind::Secondary };
        let type_ = parse_arg!(value, as_str, "type")?.to_string();
        let type_: FidlUuid =
            Uuid::from_str(&type_).map_err(|_| format_err!("Invalid type"))?.into();

        Ok(ServiceInfo {
            handle: Some(handle),
            kind: Some(kind),
            type_: Some(type_),
            // TODO(https://fxbug.dev/42169516): Add support for GATT characteristics and includes
            ..Default::default()
        })
    }
}