// Copyright 2020 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::{Context as _, Error};
use argh::FromArgs;
use fidl_fuchsia_settings::{ConfigurationInterfaces, LightState, LightValue, Theme};
use fuchsia_component::client::connect_to_protocol;

pub mod accessibility;
pub mod audio;
pub mod display;
pub mod do_not_disturb;
pub mod factory_reset;
pub mod input;
pub mod intl;
pub mod light;
pub mod night_mode;
pub mod privacy;
pub mod setup;
pub mod utils;
pub mod volume_policy;

// SettingClient exercises the functionality found in SetUI service. Currently,
// action parameters are specified at as individual arguments, but the goal is
// to eventually parse details from a JSON file input.
#[derive(FromArgs, Debug)]
/// Get or set setting values. Pass --help to each subcommand for additional info. Calling the
/// subcommands without any parameters treats it as a get.
pub struct SettingClient {
    #[argh(subcommand)]
    pub nested: SettingClientSubcommands,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand)]
pub enum SettingClientSubcommands {
    // Operations that use the new interfaces.
    Accessibility(Accessibility),
    Audio(Audio),
    Display(Display),
    DoNotDisturb(DoNotDisturb),
    FactoryReset(FactoryReset),
    Input(Input),
    // TODO(fxbug.dev/65686): Move back into input when the clients are migrated over.
    // TODO(fxbug.dev/66186): Support multiple input devices to be set.
    // For simplicity, currently only supports setting one input device at a time.
    Input2(InputDeviceOptions),
    Intl(Intl),
    Light(LightGroup),
    NightMode(NightMode),
    Privacy(Privacy),
    Setup(Setup),
    VolumePolicy(VolumePolicy),
}

#[derive(FromArgs, Debug, Clone, Default)]
#[argh(subcommand, name = "accessibility")]
/// pass no options to get current settings
pub struct Accessibility {
    #[argh(option, short = 'a')]
    /// when set to 'true', will turn on an audio track for videos that includes a description
    /// of what is occurring in the video
    pub audio_description: Option<bool>,

    #[argh(option, short = 's')]
    /// when set to 'true', will read aloud elements of the screen selected by the user
    pub screen_reader: Option<bool>,

    #[argh(option, short = 'i')]
    /// when set to 'true', will invert the colors on the screen
    pub color_inversion: Option<bool>,

    #[argh(option, short = 'm')]
    /// when set to 'true', will interpret triple-taps on the touchscreen as a command to zoom in
    pub enable_magnification: Option<bool>,

    #[argh(option, short = 'c', from_str_fn(str_to_color_blindness_type))]
    /// configures the type of color-blindness to correct for. Valid options are none, protanomaly,
    /// deuteranomaly, and tritanomaly
    pub color_correction: Option<fidl_fuchsia_settings::ColorBlindnessType>,

    #[argh(subcommand)]
    pub caption_options: Option<CaptionCommands>,
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand)]
pub enum CaptionCommands {
    CaptionOptions(CaptionOptions),
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand, name = "caption_options")]
/// configuration for which sources get closed caption and how they look
pub struct CaptionOptions {
    #[argh(option, short = 'm')]
    /// enable closed captions for media sources of audio
    pub for_media: Option<bool>,

    #[argh(option, short = 't')]
    /// enable closed captions for Text-To-Speech sources of audio
    pub for_tts: Option<bool>,

    #[argh(option, short = 'w', from_str_fn(str_to_color))]
    /// border color used around the closed captions window. Valid options are red, green, and blue
    pub window_color: Option<fidl_fuchsia_ui_types::ColorRgba>,

    #[argh(option, short = 'b', from_str_fn(str_to_color))]
    /// border color used around the closed captions window. Valid options are red, green, and blue
    pub background_color: Option<fidl_fuchsia_ui_types::ColorRgba>,

    // CaptionFontStyle options below
    #[argh(option, short = 'f', from_str_fn(str_to_font_family))]
    /// font family for captions as specified by 47 CFR §79.102(k). Valid options are unknown,
    /// monospaced_serif, proportional_serif, monospaced_sans_serif, proportional_sans_serif,
    /// casual, cursive, and small_capitals
    pub font_family: Option<fidl_fuchsia_settings::CaptionFontFamily>,

    #[argh(option, short = 'c', from_str_fn(str_to_color))]
    /// color of the closed caption text. Valid options are red, green, and blue
    pub font_color: Option<fidl_fuchsia_ui_types::ColorRgba>,

    #[argh(option, short = 'r')]
    /// size of closed captions text relative to the default captions size, specified in the
    /// range [0.5, 2] as per 47 CFR §79.103(c)(4)
    pub relative_size: Option<f32>,

    #[argh(option, short = 'e', from_str_fn(str_to_edge_style))]
    /// edge style for fonts as specified in 47 CFR §79.103(c)(7). Valid options are none,
    /// drop_shadow, raised, depressed, outline
    pub char_edge_style: Option<fidl_fuchsia_settings::EdgeStyle>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "audio")]
/// get or set audio settings
pub struct Audio {
    // AudioStreams
    /// which stream should be modified. Valid options are background, media, interruption,
    /// system_agent, and communication
    #[argh(option, short = 't', from_str_fn(str_to_audio_stream))]
    stream: Option<fidl_fuchsia_media::AudioRenderUsage>,

    /// which source is changing the stream. Valid options are user, system, and
    /// system_with_feedback
    #[argh(option, short = 's', from_str_fn(str_to_audio_source))]
    source: Option<fidl_fuchsia_settings::AudioStreamSettingSource>,

    // UserVolume
    /// the volume level specified as a float in the range [0, 1]
    #[argh(option, short = 'l')]
    level: Option<f32>,

    /// whether or not the volume is muted
    #[argh(option, short = 'v')]
    volume_muted: Option<bool>,

    // AudioInput
    /// whether or not the input, e.g. microphone, is muted
    #[argh(option, short = 'm')]
    input_muted: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "display")]
/// get or set display settings
pub struct Display {
    /// the brightness value specified as a float in the range [0, 1]
    #[argh(option, short = 'b')]
    brightness: Option<f32>,

    /// the brightness values used to control auto brightness as a float in the range [0, 1]
    #[argh(option, short = 'o')]
    auto_brightness_level: Option<f32>,

    /// when set to 'true', enables auto brightness
    #[argh(option, short = 'a')]
    auto_brightness: Option<bool>,

    /// when passed, reads values from the light sensor rather than display brightness
    #[argh(switch, short = 'l')]
    light_sensor: bool,

    /// which low light mode setting to enable. Valid options are enable, disable, and
    /// disable_immediately
    #[argh(option, short = 'm', from_str_fn(str_to_low_light_mode))]
    low_light_mode: Option<fidl_fuchsia_settings::LowLightMode>,

    /// which theme to set for the device. Valid options are default, dark, light, darkauto, and
    /// lightauto
    #[argh(option, short = 't', from_str_fn(str_to_theme))]
    theme: Option<fidl_fuchsia_settings::Theme>,

    /// when set to 'true' the screen is enabled
    #[argh(option, short = 's')]
    screen_enabled: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "do_not_disturb")]
/// get or set DnD settings
pub struct DoNotDisturb {
    /// when set to 'true', allows the device to enter do not disturb mode
    #[argh(option, short = 'u')]
    user_dnd: Option<bool>,

    /// when set to 'true', forces the device into do not disturb mode
    #[argh(option, short = 'n')]
    night_mode_dnd: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "factory_reset")]
/// get or set factory reset settings
pub struct FactoryReset {
    /// when set to 'true', factory reset can be performed on the device
    #[argh(option, short = 'l')]
    is_local_reset_allowed: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "input")]
/// get or set input settings
pub struct Input {
    /// when set to 'true', mutes the mic and prevents it from being accessed
    #[argh(option, short = 'm')]
    mic_muted: Option<bool>,
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand, name = "input_device")]
/// get or set input device settings
pub struct InputDeviceOptions {
    #[argh(option, short = 't', from_str_fn(str_to_device_type))]
    /// the type of input device. Valid options are camera and microphone
    device_type: Option<fidl_fuchsia_settings::DeviceType>,

    #[argh(option, short = 'n', long = "name")]
    /// the name of the device. Must be unique within a device type
    device_name: Option<String>,

    #[argh(option, short = 's', long = "state", from_str_fn(str_to_device_state))]
    /// the device state flags, pass a comma separated string of the values available, active,
    /// muted, disabled and error. E.g. "-s available,active"
    device_state: Option<fidl_fuchsia_settings::DeviceState>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "intl")]
/// get or set internationalization settings
pub struct Intl {
    /// a valid timezone matching the data available at https://www.iana.org/time-zones
    #[argh(option, short = 'z', from_str_fn(str_to_time_zone))]
    time_zone: Option<fidl_fuchsia_intl::TimeZoneId>,

    #[argh(option, short = 'u', from_str_fn(str_to_temperature_unit))]
    /// the unit to use for temperature. Valid options are celsius and fahrenheit
    temperature_unit: Option<fidl_fuchsia_intl::TemperatureUnit>,

    #[argh(option, short = 'l', from_str_fn(str_to_locale))]
    /// list of locales, separated by spaces, formatted by Unicode BCP-47 Locale Identifier, e.g.
    /// en-us
    locales: Vec<fidl_fuchsia_intl::LocaleId>,

    /// the hour cycle to use. Valid options are h11 for 12-hour clock with 0:10 am after midnight,
    /// h12 for 12-hour clock with 12:10am after midnight, h23 for 24-hour clock with 0:10 after
    /// midnight, and h24 for 24-hour clock with 24:10 after midnight
    #[argh(option, short = 'h', from_str_fn(str_to_hour_cycle))]
    hour_cycle: Option<fidl_fuchsia_settings::HourCycle>,

    #[argh(switch)]
    /// if set, this flag will set locales as an empty list. Overrides the locales arguments
    clear_locales: bool,
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand, name = "light")]
/// get or set light settings
pub struct LightGroup {
    #[argh(option, short = 'n')]
    /// name of a light group to set values for. Required if setting the value of a light group
    pub name: Option<String>,

    #[argh(option, short = 's')]
    /// repeated parameter for a list of simple on/off values to set for a light group.
    pub simple: Vec<bool>,

    #[argh(option, short = 'b')]
    /// repeated parameter for a list of floating point brightness values in the range [0, 1] for a
    /// light group
    pub brightness: Vec<f64>,

    #[argh(option, short = 'r', from_str_fn(str_to_rgb))]
    /// repeated parameter for a list of RGB values to set for a light group. Values should be in
    /// the range [0, 1] and specified as a comma-separated list of the red, green, and blue
    /// components. Ex. 0.1,0.4,0.23
    pub rgb: Vec<fidl_fuchsia_ui_types::ColorRgb>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "night_mode")]
/// get or set night mode settings
pub struct NightMode {
    /// when 'true', enables night mode
    #[argh(option, short = 'n')]
    night_mode_enabled: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "privacy")]
/// get or set privacy settings
pub struct Privacy {
    /// when 'true', is considered to be user giving consent to have their data shared with product
    /// owner, e.g. for metrics collection and crash reporting
    #[argh(option, short = 'u')]
    user_data_sharing_consent: Option<bool>,
}

#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "setup")]
/// get or set setup settings
pub struct Setup {
    /// a supported group of interfaces, specified as a comma-delimited string of the valid values
    /// eth and wifi, e.g. "-i eth,wifi" or "-i wifi"
    #[argh(option, short = 'i', long = "interfaces", from_str_fn(str_to_interfaces))]
    configuration_interfaces: Option<ConfigurationInterfaces>,
}
#[derive(FromArgs, Debug)]
#[argh(subcommand, name = "volume_policy")]
/// configure volume policy
// Reads and modifies volume policies that affect the behavior of the fuchsia.settings.audio.
// To list the policies, run the subcommand without any arguments.
pub struct VolumePolicy {
    /// adds a policy transform.
    #[argh(subcommand)]
    add: Option<VolumePolicyCommands>,

    /// removes a policy transform by its policy ID.
    #[argh(option, short = 'r')]
    remove: Option<u32>,
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand)]
pub enum VolumePolicyCommands {
    AddPolicy(VolumePolicyOptions),
}

#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand, name = "add")]
/// adds a new volume policy
pub struct VolumePolicyOptions {
    /// target stream to apply the policy transform to. Valid options are background, media,
    /// interruption, system_agent, and communication
    #[argh(positional, from_str_fn(str_to_audio_stream))]
    pub target: fidl_fuchsia_media::AudioRenderUsage,

    /// the minimum allowed value for the target
    #[argh(option)]
    pub min: Option<f32>,

    /// the maximum allowed value for the target
    #[argh(option)]
    pub max: Option<f32>,
}

impl Into<Vec<LightState>> for LightGroup {
    fn into(self) -> Vec<LightState> {
        if self.simple.len() > 0 {
            return self
                .simple
                .clone()
                .into_iter()
                .map(|val| LightState { value: Some(LightValue::On(val)), ..LightState::EMPTY })
                .collect::<Vec<_>>();
        }

        if self.brightness.len() > 0 {
            return self
                .brightness
                .clone()
                .into_iter()
                .map(|val| LightState {
                    value: Some(LightValue::Brightness(val)),
                    ..LightState::EMPTY
                })
                .collect::<Vec<_>>();
        }

        if self.rgb.len() > 0 {
            return self
                .rgb
                .clone()
                .into_iter()
                .map(|val| LightState { value: Some(LightValue::Color(val)), ..LightState::EMPTY })
                .collect::<Vec<_>>();
        }

        return Vec::new();
    }
}

pub async fn run_command(command: SettingClient) -> Result<(), Error> {
    match command.nested {
        SettingClientSubcommands::Display(Display {
            brightness,
            auto_brightness_level,
            auto_brightness,
            light_sensor,
            low_light_mode,
            theme,
            screen_enabled,
        }) => {
            let display_service = connect_to_protocol::<fidl_fuchsia_settings::DisplayMarker>()
                .context("Failed to connect to display service")?;
            utils::handle_mixed_result(
                "Display",
                display::command(
                    display_service,
                    brightness,
                    auto_brightness,
                    auto_brightness_level,
                    light_sensor,
                    low_light_mode,
                    theme,
                    screen_enabled,
                )
                .await,
            )
            .await?;
        }
        SettingClientSubcommands::DoNotDisturb(DoNotDisturb { user_dnd, night_mode_dnd }) => {
            let dnd_service = connect_to_protocol::<fidl_fuchsia_settings::DoNotDisturbMarker>()
                .context("Failed to connect to do_not_disturb service")?;
            utils::handle_mixed_result(
                "DoNoDisturb",
                do_not_disturb::command(dnd_service, user_dnd, night_mode_dnd).await,
            )
            .await?;
        }
        SettingClientSubcommands::FactoryReset(FactoryReset { is_local_reset_allowed }) => {
            let factory_reset_service =
                connect_to_protocol::<fidl_fuchsia_settings::FactoryResetMarker>()
                    .context("Failed to connect to factory_reset service")?;
            utils::handle_mixed_result(
                "FactoryReset",
                factory_reset::command(factory_reset_service, is_local_reset_allowed).await,
            )
            .await?;
        }
        SettingClientSubcommands::Intl(Intl {
            time_zone,
            temperature_unit,
            locales,
            hour_cycle,
            clear_locales,
        }) => {
            let intl_service = connect_to_protocol::<fidl_fuchsia_settings::IntlMarker>()
                .context("Failed to connect to intl service")?;
            utils::handle_mixed_result(
                "Intl",
                intl::command(
                    intl_service,
                    time_zone,
                    temperature_unit,
                    locales,
                    hour_cycle,
                    clear_locales,
                )
                .await,
            )
            .await?;
        }
        SettingClientSubcommands::Light(light_group) => {
            let light_mode_service = connect_to_protocol::<fidl_fuchsia_settings::LightMarker>()
                .context("Failed to connect to light service")?;
            utils::handle_mixed_result(
                "Light",
                light::command(light_mode_service, light_group).await,
            )
            .await?;
        }
        SettingClientSubcommands::NightMode(NightMode { night_mode_enabled }) => {
            let night_mode_service =
                connect_to_protocol::<fidl_fuchsia_settings::NightModeMarker>()
                    .context("Failed to connect to night mode service")?;
            utils::handle_mixed_result(
                "NightMode",
                night_mode::command(night_mode_service, night_mode_enabled).await,
            )
            .await?;
        }
        SettingClientSubcommands::Accessibility(accessibility_options) => {
            let accessibility_service =
                connect_to_protocol::<fidl_fuchsia_settings::AccessibilityMarker>()
                    .context("Failed to connect to accessibility service")?;

            utils::handle_mixed_result(
                "Accessibility",
                accessibility::command(accessibility_service, accessibility_options).await,
            )
            .await?;
        }
        SettingClientSubcommands::Privacy(Privacy { user_data_sharing_consent }) => {
            let privacy_service = connect_to_protocol::<fidl_fuchsia_settings::PrivacyMarker>()
                .context("Failed to connect to privacy service")?;
            utils::handle_mixed_result(
                "Privacy",
                privacy::command(privacy_service, user_data_sharing_consent).await,
            )
            .await?;
        }
        SettingClientSubcommands::Audio(Audio {
            stream,
            source,
            level,
            volume_muted,
            input_muted,
        }) => {
            let audio_service = connect_to_protocol::<fidl_fuchsia_settings::AudioMarker>()
                .context("Failed to connect to audio service")?;
            utils::handle_mixed_result(
                "Audio",
                audio::command(audio_service, stream, source, level, volume_muted, input_muted)
                    .await,
            )
            .await?;
        }
        SettingClientSubcommands::Input(Input { mic_muted }) => {
            let input_service = connect_to_protocol::<fidl_fuchsia_settings::InputMarker>()
                .context("Failed to connect to input service")?;
            utils::handle_mixed_result("Input", input::command(input_service, mic_muted).await)
                .await?;
        }
        SettingClientSubcommands::Input2(InputDeviceOptions {
            device_type,
            device_name,
            device_state,
        }) => {
            let input_service = connect_to_protocol::<fidl_fuchsia_settings::InputMarker>()
                .context("Failed to connect to input2 service")?;
            utils::handle_mixed_result(
                "Input2",
                input::command2(input_service, device_type, device_name, device_state).await,
            )
            .await?;
        }
        SettingClientSubcommands::Setup(Setup { configuration_interfaces }) => {
            let setup_service = connect_to_protocol::<fidl_fuchsia_settings::SetupMarker>()
                .context("Failed to connect to setup service")?;
            utils::handle_mixed_result(
                "Setup",
                setup::command(setup_service, configuration_interfaces).await,
            )
            .await?;
        }
        SettingClientSubcommands::VolumePolicy(VolumePolicy { add, remove }) => {
            let setup_service =
                connect_to_protocol::<fidl_fuchsia_settings_policy::VolumePolicyControllerMarker>()
                    .context("Failed to connect to volume policy service")?;
            utils::handle_mixed_result(
                "Volume policy",
                volume_policy::command(setup_service, add, remove).await,
            )
            .await?;
        }
    }
    Ok(())
}

fn str_to_time_zone(src: &str) -> Result<fidl_fuchsia_intl::TimeZoneId, String> {
    Ok(fidl_fuchsia_intl::TimeZoneId { id: src.to_string() })
}

fn str_to_locale(src: &str) -> Result<fidl_fuchsia_intl::LocaleId, String> {
    Ok(fidl_fuchsia_intl::LocaleId { id: src.to_string() })
}

fn str_to_device_type(src: &str) -> Result<fidl_fuchsia_settings::DeviceType, String> {
    let device_type = src.to_lowercase();
    match device_type.as_ref() {
        "microphone" | "m" => Ok(fidl_fuchsia_settings::DeviceType::Microphone),
        "camera" | "c" => Ok(fidl_fuchsia_settings::DeviceType::Camera),
        _ => Err(String::from("Unidentified device type")),
    }
}

fn str_to_device_state(src: &str) -> Result<fidl_fuchsia_settings::DeviceState, String> {
    use fidl_fuchsia_settings::ToggleStateFlags;

    Ok(fidl_fuchsia_settings::DeviceState {
        toggle_flags: Some(src.to_lowercase().split(",").fold(
            Ok(fidl_fuchsia_settings::ToggleStateFlags::empty()),
            |acc, flag| {
                acc.and_then(|acc| {
                    Ok(match flag {
                        "available" | "v" => ToggleStateFlags::Available,
                        "active" | "a" => ToggleStateFlags::Active,
                        "muted" | "m" => ToggleStateFlags::Muted,
                        "disabled" | "d" => ToggleStateFlags::Disabled,
                        "error" | "e" => ToggleStateFlags::Error,
                        flag => {
                            return Err(format!("Unrecognized ToggleStateFlags value {:?}", flag))
                        }
                    } | acc)
                })
            },
        )?),
        ..fidl_fuchsia_settings::DeviceState::EMPTY
    })
}

fn str_to_low_light_mode(src: &str) -> Result<fidl_fuchsia_settings::LowLightMode, String> {
    match src {
        "enable" | "e" => Ok(fidl_fuchsia_settings::LowLightMode::Enable),
        "disable" | "d" => Ok(fidl_fuchsia_settings::LowLightMode::Disable),
        "disable_immediately" | "i" => Ok(fidl_fuchsia_settings::LowLightMode::DisableImmediately),
        _ => Err(String::from("Couldn't parse low light mode")),
    }
}

fn str_to_theme(src: &str) -> Result<fidl_fuchsia_settings::Theme, String> {
    match src {
        "default" => Ok(Theme {
            theme_type: Some(fidl_fuchsia_settings::ThemeType::Default),
            ..Theme::EMPTY
        }),
        "dark" => {
            Ok(Theme { theme_type: Some(fidl_fuchsia_settings::ThemeType::Dark), ..Theme::EMPTY })
        }
        "light" => {
            Ok(Theme { theme_type: Some(fidl_fuchsia_settings::ThemeType::Light), ..Theme::EMPTY })
        }
        "darkauto" => Ok(Theme {
            theme_type: Some(fidl_fuchsia_settings::ThemeType::Dark),
            theme_mode: Some(fidl_fuchsia_settings::ThemeMode::Auto),
            ..Theme::EMPTY
        }),
        "lightauto" => Ok(Theme {
            theme_type: Some(fidl_fuchsia_settings::ThemeType::Light),
            theme_mode: Some(fidl_fuchsia_settings::ThemeMode::Auto),
            ..Theme::EMPTY
        }),
        _ => Err(String::from("Couldn't parse theme.")),
    }
}

fn str_to_interfaces(src: &str) -> Result<ConfigurationInterfaces, String> {
    src.to_lowercase().split(",").fold(Ok(ConfigurationInterfaces::empty()), |acc, flag| {
        acc.and_then(|acc| {
            Ok(match flag {
                "eth" | "ethernet" => ConfigurationInterfaces::Ethernet,
                "wireless" | "wifi" => ConfigurationInterfaces::Wifi,
                bad_ifc => return Err(format!("Unknown interface: {:?}", bad_ifc)),
            } | acc)
        })
    })
}

fn str_to_color(src: &str) -> Result<fidl_fuchsia_ui_types::ColorRgba, String> {
    Ok(match src.to_lowercase().as_str() {
        "red" | "r" => {
            fidl_fuchsia_ui_types::ColorRgba { red: 255.0, green: 0.0, blue: 0.0, alpha: 255.0 }
        }
        "green" | "g" => {
            fidl_fuchsia_ui_types::ColorRgba { red: 0.0, green: 2.055, blue: 0.0, alpha: 255.0 }
        }
        "blue" | "b" => {
            fidl_fuchsia_ui_types::ColorRgba { red: 0.0, green: 0.0, blue: 255.0, alpha: 255.0 }
        }
        _ => return Err(String::from("Couldn't parse color")),
    })
}

/// Converts a comma-separated string of RGB values into a fidl_fuchsia_ui_types::ColorRgb.
fn str_to_rgb(src: &str) -> Result<fidl_fuchsia_ui_types::ColorRgb, String> {
    let mut part_iter =
        src.split(',').map(|p| p.parse::<f32>().map_err(|_| "failed to parse color value"));

    let color = {
        let local_ref = &mut part_iter;
        color_from_parts(local_ref)
    };
    match (color, part_iter.next()) {
        (Some(Ok(color)), None) => Ok(color),
        (Some(Err(err)), _) => Err(err),
        _ => Err(String::from("wrong number of values")),
    }
}

fn color_from_parts<'a, T>(
    part_iter: &mut T,
) -> Option<Result<fidl_fuchsia_ui_types::ColorRgb, String>>
where
    T: Iterator<Item = Result<f32, &'a str>>,
{
    Some(Ok(fidl_fuchsia_ui_types::ColorRgb {
        red: match part_iter.next()? {
            Ok(c) => c,
            Err(e) => return Some(Err(e.to_string())),
        },
        green: match part_iter.next()? {
            Ok(c) => c,
            Err(e) => return Some(Err(e.to_string())),
        },
        blue: match part_iter.next()? {
            Ok(c) => c,
            Err(e) => return Some(Err(e.to_string())),
        },
    }))
}

fn str_to_font_family(src: &str) -> Result<fidl_fuchsia_settings::CaptionFontFamily, String> {
    Ok(match src.to_lowercase().as_str() {
        "unknown" => fidl_fuchsia_settings::CaptionFontFamily::Unknown,
        "monospaced_serif" => fidl_fuchsia_settings::CaptionFontFamily::MonospacedSerif,
        "proportional_serif" => fidl_fuchsia_settings::CaptionFontFamily::ProportionalSerif,
        "monospaced_sans_serif" => fidl_fuchsia_settings::CaptionFontFamily::MonospacedSansSerif,
        "proportional_sans_serif" => {
            fidl_fuchsia_settings::CaptionFontFamily::ProportionalSansSerif
        }
        "casual" => fidl_fuchsia_settings::CaptionFontFamily::Casual,
        "cursive" => fidl_fuchsia_settings::CaptionFontFamily::Cursive,
        "small_capitals" => fidl_fuchsia_settings::CaptionFontFamily::SmallCapitals,
        _ => return Err(String::from("Couldn't parse font family")),
    })
}

fn str_to_edge_style(src: &str) -> Result<fidl_fuchsia_settings::EdgeStyle, String> {
    Ok(match src.to_lowercase().as_str() {
        "none" => fidl_fuchsia_settings::EdgeStyle::None,
        "drop_shadow" => fidl_fuchsia_settings::EdgeStyle::DropShadow,
        "raised" => fidl_fuchsia_settings::EdgeStyle::Raised,
        "depressed" => fidl_fuchsia_settings::EdgeStyle::Depressed,
        "outline" => fidl_fuchsia_settings::EdgeStyle::Outline,
        _ => return Err(String::from("Couldn't parse edge style")),
    })
}

fn str_to_temperature_unit(src: &str) -> Result<fidl_fuchsia_intl::TemperatureUnit, String> {
    match src.to_lowercase().as_str() {
        "c" | "celsius" => Ok(fidl_fuchsia_intl::TemperatureUnit::Celsius),
        "f" | "fahrenheit" => Ok(fidl_fuchsia_intl::TemperatureUnit::Fahrenheit),
        _ => Err(String::from("Couldn't parse temperature")),
    }
}

fn str_to_hour_cycle(src: &str) -> Result<fidl_fuchsia_settings::HourCycle, String> {
    match src.to_lowercase().as_str() {
        "unknown" => Ok(fidl_fuchsia_settings::HourCycle::Unknown),
        "h11" => Ok(fidl_fuchsia_settings::HourCycle::H11),
        "h12" => Ok(fidl_fuchsia_settings::HourCycle::H12),
        "h23" => Ok(fidl_fuchsia_settings::HourCycle::H23),
        "h24" => Ok(fidl_fuchsia_settings::HourCycle::H24),
        _ => Err(String::from("Couldn't parse hour cycle")),
    }
}

fn str_to_color_blindness_type(
    src: &str,
) -> Result<fidl_fuchsia_settings::ColorBlindnessType, String> {
    match src.to_lowercase().as_str() {
        "none" | "n" => Ok(fidl_fuchsia_settings::ColorBlindnessType::None),
        "protanomaly" | "p" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Protanomaly),
        "deuteranomaly" | "d" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Deuteranomaly),
        "tritanomaly" | "t" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Tritanomaly),
        _ => Err(String::from("Couldn't parse color blindness type")),
    }
}

fn str_to_audio_stream(src: &str) -> Result<fidl_fuchsia_media::AudioRenderUsage, String> {
    match src.to_lowercase().as_str() {
        "background" | "b" => Ok(fidl_fuchsia_media::AudioRenderUsage::Background),
        "media" | "m" => Ok(fidl_fuchsia_media::AudioRenderUsage::Media),
        "interruption" | "i" => Ok(fidl_fuchsia_media::AudioRenderUsage::Interruption),
        "system_agent" | "systemagent" | "system agent" | "s" => {
            Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent)
        }
        "communication" | "c" => Ok(fidl_fuchsia_media::AudioRenderUsage::Communication),
        _ => Err(String::from("Couldn't parse audio stream type")),
    }
}

fn str_to_audio_source(
    src: &str,
) -> Result<fidl_fuchsia_settings::AudioStreamSettingSource, String> {
    match src.to_lowercase().as_str() {
        "user" | "u" => Ok(fidl_fuchsia_settings::AudioStreamSettingSource::User),
        "system" | "s" => Ok(fidl_fuchsia_settings::AudioStreamSettingSource::System),
        "system_with_feedback" | "f" => {
            Ok(fidl_fuchsia_settings::AudioStreamSettingSource::SystemWithFeedback)
        }
        _ => Err(String::from("Couldn't parse audio source type")),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Unit test for str_to_audio_stream.
    #[test]
    fn test_str_to_audio_stream() {
        println!("Running test_str_to_audio_stream");
        let test_cases = vec![
            "Background",
            "MEDIA",
            "interruption",
            "SYSTEM_AGENT",
            "SystemAgent",
            "system agent",
            "Communication",
            "unexpected_stream_type",
        ];
        let expected = vec![
            Ok(fidl_fuchsia_media::AudioRenderUsage::Background),
            Ok(fidl_fuchsia_media::AudioRenderUsage::Media),
            Ok(fidl_fuchsia_media::AudioRenderUsage::Interruption),
            Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent),
            Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent),
            Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent),
            Ok(fidl_fuchsia_media::AudioRenderUsage::Communication),
            Err(String::from("Couldn't parse audio stream type")),
        ];
        let mut results = vec![];
        for test_case in test_cases {
            results.push(str_to_audio_stream(test_case));
        }
        for (expected, result) in expected.iter().zip(results.iter()) {
            assert_eq!(expected, result);
        }
    }

    /// Unit test for str_to_audio_source.
    #[test]
    fn test_str_to_audio_source() {
        println!("Running test_str_to_audio_source");
        let test_cases = vec!["USER", "system", "unexpected_source_type"];
        let expected = vec![
            Ok(fidl_fuchsia_settings::AudioStreamSettingSource::User),
            Ok(fidl_fuchsia_settings::AudioStreamSettingSource::System),
            Err(String::from("Couldn't parse audio source type")),
        ];
        let mut results = vec![];
        for test_case in test_cases {
            results.push(str_to_audio_source(test_case));
        }
        for (expected, result) in expected.iter().zip(results.iter()) {
            assert_eq!(expected, result);
        }
    }
}

#[cfg(test)]
mod interface_tests;