#![doc(hidden)]
#![expect(
    clippy::redundant_pub_crate,
    reason = "this private projection module centralizes CLI/config coercion helpers and reuses the split CLI surface without repeating a long import list"
)]

use super::{
    BtStatusReport, CliError, CommandSurface, ConfigDocument, ConfigLoadReport, ConfigLocationKind,
    ConfigProfile, ConfigScope, ConfigSource, HeaderKind, HttpHeader, HttpSessionModel, Invocation,
    ParsedArguments, Path, PathBuf, Protocol, RpcValue, RuntimeConfig, RuntimeMode, StartupProfile,
    TransferSelection, fs,
};
use aria2_rust_pro_compat::{parse_config, parse_config_lenient};
use aria2_rust_pro_protocol::{ProxyConfig, RetryPolicy, RetryStrategy, TlsConfig};

/// Extracts a string-like RPC field from a generic RPC value.
fn rpc_string(value: Option<&RpcValue>) -> Option<String> {
    match value {
        Some(RpcValue::String(value)) => Some(value.clone()),
        Some(RpcValue::Number(value)) => Some(value.to_string()),
        Some(RpcValue::Bool(value)) => Some(value.to_string()),
        _ => None,
    }
}

/// Extracts a boolean-like RPC field from a generic RPC value.
pub(crate) fn rpc_bool(value: Option<&RpcValue>) -> Option<bool> {
    match value {
        Some(RpcValue::Bool(value)) => Some(*value),
        Some(RpcValue::String(value)) => parse_bool_text(value),
        Some(RpcValue::Number(value)) => Some(*value != 0),
        _ => None,
    }
}

/// Extracts an unsigned integer-like RPC field from a generic RPC value.
pub(crate) fn rpc_u64(value: Option<&RpcValue>) -> Option<u64> {
    match value {
        Some(RpcValue::Number(value)) => (*value).try_into().ok(),
        Some(RpcValue::String(value)) => value.parse().ok(),
        Some(RpcValue::Bool(value)) => Some(u64::from(*value)),
        _ => None,
    }
}

/// Returns the length of an RPC array field when the value is an array.
const fn rpc_array_len(value: Option<&RpcValue>) -> Option<usize> {
    match value {
        Some(RpcValue::Array(values)) => Some(values.len()),
        _ => None,
    }
}

/// Projects `BitTorrent`-specific tellStatus fields into the CLI report model.
pub(crate) fn parse_bt_status_report(
    status: &std::collections::BTreeMap<String, RpcValue>,
) -> Option<BtStatusReport> {
    let is_bt = rpc_bool(status.get("isBt"));
    let metadata_only = rpc_bool(status.get("metadataOnly"));
    let magnet_uri = rpc_string(status.get("magnetUri"));
    let announce_list_tier_count = rpc_array_len(status.get("announceList"));
    let seeder = rpc_bool(status.get("seeder"));
    let num_seeders = rpc_u64(status.get("numSeeders"));
    let share_ratio = rpc_string(status.get("shareRatio"));
    let share_ratio_progress = rpc_string(status.get("shareRatioProgress"));
    let share_ratio_remaining = rpc_string(status.get("shareRatioRemaining"));
    let share_time = rpc_u64(status.get("shareTime"));

    if is_bt.is_none()
        && metadata_only.is_none()
        && magnet_uri.is_none()
        && announce_list_tier_count.is_none()
        && seeder.is_none()
        && num_seeders.is_none()
        && share_ratio.is_none()
        && share_ratio_progress.is_none()
        && share_ratio_remaining.is_none()
        && share_time.is_none()
    {
        return None;
    }

    Some(BtStatusReport {
        is_bt,
        metadata_only,
        magnet_uri,
        announce_list_tier_count,
        seeder,
        num_seeders,
        share_ratio,
        share_ratio_progress,
        share_ratio_remaining,
        share_time,
    })
}

/// Returns whether an input ends with an ASCII suffix, ignoring case.
fn has_ascii_case_insensitive_suffix(input: &str, suffix: &str) -> bool {
    input
        .get(input.len().saturating_sub(suffix.len())..)
        .is_some_and(|tail| tail.eq_ignore_ascii_case(suffix))
}

#[must_use]
/// Classifies a transfer input by the user-visible download surface it implies.
pub fn classify_transfer(input: &str) -> TransferSelection {
    if input
        .get(.."magnet:?".len())
        .is_some_and(|scheme| scheme.eq_ignore_ascii_case("magnet:?"))
    {
        TransferSelection::Magnet
    } else if has_ascii_case_insensitive_suffix(input, ".torrent") {
        TransferSelection::Torrent
    } else if has_ascii_case_insensitive_suffix(input, ".meta4")
        || has_ascii_case_insensitive_suffix(input, ".metalink")
    {
        TransferSelection::Metalink
    } else {
        TransferSelection::Uri
    }
}

#[must_use]
/// Parses a supported transfer protocol from a URI-like input.
pub fn parse_protocol(input: &str) -> Option<Protocol> {
    let (scheme, _) = input.split_once(':')?;
    if scheme.eq_ignore_ascii_case("http") {
        Some(Protocol::Http)
    } else if scheme.eq_ignore_ascii_case("https") {
        Some(Protocol::Https)
    } else if scheme.eq_ignore_ascii_case("ftp") {
        Some(Protocol::Ftp)
    } else if scheme.eq_ignore_ascii_case("sftp") {
        Some(Protocol::Sftp)
    } else if scheme.eq_ignore_ascii_case("magnet") {
        Some(Protocol::Magnet)
    } else if scheme.eq_ignore_ascii_case("file") {
        Some(Protocol::File)
    } else {
        None
    }
}

#[must_use]
/// Chooses the execution surface implied by a parsed invocation.
pub fn command_surface(parsed: &ParsedArguments) -> CommandSurface {
    match &parsed.invocation {
        Invocation::Version => CommandSurface::PrintVersion,
        Invocation::Help { query } => CommandSurface::PrintHelp {
            query: query.clone(),
        },
        Invocation::Run { config_path, uris } => {
            if parsed.profile.dry_run {
                config_path.clone().map_or_else(
                    || CommandSurface::Foreground(parsed.invocation.clone()),
                    |config_path| CommandSurface::ValidateConfig {
                        config_path,
                        strict: true,
                    },
                )
            } else if parsed.profile.rpc.enabled || parsed.profile.mode != RuntimeMode::Foreground {
                CommandSurface::RpcDaemon {
                    config_path: config_path.clone(),
                    inputs: uris.clone(),
                }
            } else {
                CommandSurface::Foreground(parsed.invocation.clone())
            }
        }
    }
}

/// Loads a config file and returns a summary report.
///
/// # Errors
///
/// Returns I/O or parse errors while reading the config file.
pub fn load_config_report(path: &Path, strict: bool) -> Result<ConfigLoadReport, CliError> {
    let config = fs::read_to_string(path).map_err(|error| CliError::Io(error.to_string()))?;
    let directives = if strict {
        parse_config(&config).map_err(CliError::Config)?
    } else {
        parse_config_lenient(&config).map_err(CliError::Config)?
    };
    let directive_count = directives.len();
    Ok(ConfigLoadReport {
        path: path.to_path_buf(),
        directive_count,
        strict,
        profile: ConfigProfile {
            name: path.to_string_lossy().into_owned(),
            source: ConfigSource::UserConfig,
            document: ConfigDocument {
                directives,
                location: ConfigLocationKind::File,
                scope: ConfigScope::Mixed,
            },
        },
    })
}

#[must_use]
/// Projects the effective config directives into a simple option map.
pub fn profile_option_map(profile: &ConfigProfile) -> std::collections::BTreeMap<String, String> {
    profile
        .document
        .directives
        .iter()
        .filter_map(|directive| {
            directive
                .value
                .as_ref()
                .map(|value| (directive.name.clone(), value.clone()))
        })
        .collect()
}

#[must_use]
/// Returns the effective last-wins directive value for one option name.
pub(crate) fn profile_option_value<'a>(
    profile: &'a ConfigProfile,
    option_name: &str,
) -> Option<&'a str> {
    for directive in profile.document.directives.iter().rev() {
        if directive.name == option_name {
            return directive.value.as_deref();
        }
    }
    None
}

/// Parses aria2-style boolean text accepted by config and RPC surfaces.
pub(crate) fn parse_bool_text(value: &str) -> Option<bool> {
    let value = value.trim();
    if matches!(value, "1")
        || value.eq_ignore_ascii_case("true")
        || value.eq_ignore_ascii_case("yes")
        || value.eq_ignore_ascii_case("on")
    {
        Some(true)
    } else if matches!(value, "0")
        || value.eq_ignore_ascii_case("false")
        || value.eq_ignore_ascii_case("no")
        || value.eq_ignore_ascii_case("off")
    {
        Some(false)
    } else {
        None
    }
}

/// Parses a trimmed unsigned integer from text.
pub(crate) fn parse_u64_text(value: &str) -> Option<u64> {
    value.trim().parse().ok()
}

/// Parses a trimmed TCP/UDP port from text.
pub(crate) fn parse_u16_text(value: &str) -> Option<u16> {
    value.trim().parse().ok()
}

/// Parses an aria2-style size literal such as `4M`.
pub(crate) fn parse_size_text(value: &str) -> Option<u64> {
    let trimmed = value.trim();
    let digits = trimmed.trim_end_matches(|c: char| c.is_ascii_alphabetic());
    let suffix = &trimmed[digits.len()..];
    let base: u64 = digits.parse().ok()?;
    let multiplier = if suffix.is_empty() {
        1
    } else if suffix.eq_ignore_ascii_case("k") {
        1024
    } else if suffix.eq_ignore_ascii_case("m") {
        1024 * 1024
    } else if suffix.eq_ignore_ascii_case("g") {
        1024 * 1024 * 1024
    } else {
        return None;
    };
    Some(base.saturating_mul(multiplier))
}

/// Splits a comma-separated option value into trimmed entries.
pub(crate) fn parse_csv_text(value: &str) -> Vec<String> {
    value
        .split(',')
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(str::to_owned)
        .collect()
}

/// Derives the effective RPC listen host from config and startup overrides.
pub(crate) fn derive_rpc_listen_host(
    profile: Option<&ConfigProfile>,
    startup: &StartupProfile,
) -> String {
    let mut listen_host = startup.rpc.listen_host.clone();
    if let Some(profile) = profile
        && parse_bool_text(profile_option_value(profile, "rpc-listen-all").unwrap_or_default())
            == Some(true)
    {
        "0.0.0.0".clone_into(&mut listen_host);
    }
    listen_host
}

/// Derives the effective RPC secret from startup overrides or config.
pub(crate) fn derive_rpc_secret(
    profile: Option<&ConfigProfile>,
    startup: &StartupProfile,
) -> Option<String> {
    if let Some(secret) = startup.rpc.secret.clone() {
        return Some(secret);
    }
    profile
        .and_then(|profile| profile_option_value(profile, "rpc-secret"))
        .map(ToOwned::to_owned)
}

/// Parses a proxy URL into the protocol-layer proxy model.
pub(crate) fn parse_proxy_text(value: &str, bypass_hosts: Vec<String>) -> Option<ProxyConfig> {
    let (scheme, rest) = value.split_once("://").unwrap_or(("http", value));
    let (auth_part, host_part) = match rest.rsplit_once('@') {
        Some((auth, host)) => (Some(auth), host),
        None => (None, rest),
    };
    let (host, port) = host_part.rsplit_once(':')?;
    let (username, password) = match auth_part.and_then(|auth| auth.split_once(':')) {
        Some((username, password)) => (Some(username.to_owned()), Some(password.to_owned())),
        None => (auth_part.map(str::to_owned), None),
    };
    Some(ProxyConfig {
        scheme: scheme.to_owned(),
        host: host.to_owned(),
        port: port.parse().ok()?,
        username,
        password,
        bypass_hosts,
        no_proxy: false,
    })
}

/// Returns the layered proxy-auth override value for a selected proxy family.
pub(crate) fn layered_proxy_auth_override(
    profile: &ConfigProfile,
    primary_key: &str,
    fallback_key: &str,
) -> Option<String> {
    profile_option_value(profile, primary_key)
        .map(ToOwned::to_owned)
        .or_else(|| {
            if primary_key == fallback_key {
                None
            } else {
                profile_option_value(profile, fallback_key).map(ToOwned::to_owned)
            }
        })
}

/// Applies aria2-style proxy auth overrides on top of a parsed proxy endpoint.
pub(crate) fn apply_proxy_auth_overrides(
    proxy: &mut ProxyConfig,
    profile: &ConfigProfile,
    user_key: &str,
    password_key: &str,
) {
    if let Some(username) = layered_proxy_auth_override(profile, user_key, "all-proxy-user") {
        proxy.username = Some(username);
    }
    if let Some(password) = layered_proxy_auth_override(profile, password_key, "all-proxy-passwd") {
        proxy.password = Some(password);
    }
}

/// Saturating conversion from `u64` to `usize`.
pub(crate) fn saturating_usize_from_u64(value: u64) -> usize {
    usize::try_from(value).unwrap_or(usize::MAX)
}

/// Saturating conversion from `u64` to `u32`.
pub(crate) fn saturating_u32_from_u64(value: u64) -> u32 {
    u32::try_from(value).unwrap_or(u32::MAX)
}

/// Saturating conversion from `usize` to `u32`.
pub(crate) fn saturating_u32_from_usize(value: usize) -> u32 {
    u32::try_from(value).unwrap_or(u32::MAX)
}

/// Saturating conversion from `usize` to `u16`.
pub(crate) fn saturating_u16_from_usize(value: usize) -> u16 {
    u16::try_from(value).unwrap_or(u16::MAX)
}

/// Fallible-in-practice conversion from `usize` to `u64` with saturation fallback.
pub(crate) fn lossless_u64_from_usize(value: usize) -> u64 {
    u64::try_from(value).unwrap_or(u64::MAX)
}

/// Derives the core runtime configuration from CLI and config inputs.
#[must_use]
pub fn derive_runtime_config(
    profile: Option<&ConfigProfile>,
    startup: &StartupProfile,
) -> RuntimeConfig {
    let mut runtime = RuntimeConfig::default();
    runtime.allow_jsonrpc = startup.rpc.enabled || startup.mode == RuntimeMode::RpcOnly;
    runtime.allow_xmlrpc = runtime.allow_jsonrpc;
    runtime.rpc_port = startup.rpc.listen_port;
    if let Some(profile) = profile {
        let option = |name| profile_option_value(profile, name);
        if let Some(value) = option("rpc-listen-port").and_then(parse_u16_text) {
            runtime.rpc_port = value;
        }
        if let Some(value) = option("listen-port").and_then(parse_u16_text) {
            runtime.listen_port = value;
        }
        if let Some(value) = option("dht-listen-port").and_then(parse_u16_text) {
            runtime.listen_port = value;
        }
        if let Some(value) = option("max-concurrent-downloads").and_then(parse_u64_text) {
            runtime.max_active_downloads = saturating_usize_from_u64(value.max(1));
        }
        if let Some(value) = option("max-connection-per-server").and_then(parse_u64_text) {
            let connection_budget = saturating_usize_from_u64(value);
            runtime.max_connections_per_server = connection_budget;
            runtime.max_connection_per_server = connection_budget;
        }
        if let Some(value) = option("max-overall-download-limit").and_then(parse_size_text) {
            runtime.max_overall_download_limit = (value > 0).then_some(value);
        }
        if let Some(value) = option("max-download-limit").and_then(parse_size_text) {
            runtime.max_download_limit = (value > 0).then_some(value);
        }
        if let Some(value) = option("max-overall-upload-limit").and_then(parse_size_text) {
            runtime.max_overall_upload_limit = (value > 0).then_some(value);
        }
        if let Some(value) = option("max-upload-limit").and_then(parse_size_text) {
            runtime.max_upload_limit = (value > 0).then_some(value);
        }
        if let Some(value) = option("split").and_then(parse_u64_text) {
            runtime.split = saturating_usize_from_u64(value.max(1));
        }
        if let Some(value) = option("disk-cache").and_then(parse_size_text) {
            runtime.disk_cache_bytes = value;
        }
        if let Some(value) = option("min-split-size").and_then(parse_size_text) {
            runtime.min_split_size = value;
        }
        if let Some(value) = option("piece-length").and_then(parse_size_text) {
            runtime.piece_length = value;
        }
        if let Some(value) = option("save-session") {
            runtime.session_path = Some(PathBuf::from(value));
        }
        if let Some(value) = option("save-session-interval").and_then(parse_u64_text) {
            runtime.save_session_interval_secs = value;
        }
        if let Some(value) = option("enable-rpc").and_then(parse_bool_text) {
            runtime.allow_jsonrpc = value;
            runtime.allow_xmlrpc = value;
        }
        if let Some(value) = option("disable-ipv6").and_then(parse_bool_text) {
            runtime.enable_ipv6 = !value;
        }
        if let Some(value) = option("retry-on-400").and_then(parse_bool_text) {
            runtime.retry_on_400 = value;
        }
        if let Some(value) = option("retry-on-403").and_then(parse_bool_text) {
            runtime.retry_on_403 = value;
        }
        if let Some(value) = option("retry-on-406").and_then(parse_bool_text) {
            runtime.retry_on_406 = value;
        }
        if let Some(value) = option("retry-on-unknown").and_then(parse_bool_text) {
            runtime.retry_on_unknown = value;
        }
    }
    runtime
}

/// Derives the HTTP session model from CLI and config inputs.
#[must_use]
#[expect(
    clippy::too_many_lines,
    reason = "session derivation intentionally keeps option-to-field mapping in one audit-friendly routine"
)]
pub fn derive_http_session(
    profile: Option<&ConfigProfile>,
    startup: &StartupProfile,
) -> HttpSessionModel {
    let mut session = HttpSessionModel {
        session_id: "local-http-session".to_owned(),
        user_agent: None,
        default_headers: Vec::new(),
        cookies: Vec::new(),
        auth: None,
        proxy: None,
        tls: Some(TlsConfig {
            verify_peer: true,
            verify_host: true,
            min_version: None,
            max_version: None,
            ca_file: None,
            cert_file: None,
            key_file: None,
        }),
        retry: default_retry_strategy(),
    };

    let _ = startup;
    if let Some(profile) = profile {
        let option = |name| profile_option_value(profile, name);
        if let Some(value) = option("user-agent") {
            session.user_agent = Some(value.to_owned());
        }
        if let Some(value) = option("header") {
            session.default_headers = parse_csv_text(value)
                .into_iter()
                .filter_map(|header| {
                    header.split_once(':').map(|(name, value)| HttpHeader {
                        name: name.trim().to_owned(),
                        value: value.trim().to_owned(),
                        kind: HeaderKind::Request,
                    })
                })
                .collect();
        }
        let bypass_hosts = option("no-proxy").map_or_else(Vec::new, parse_csv_text);
        if let Some(proxy_text) = option("https-proxy") {
            session.proxy = parse_proxy_text(proxy_text, bypass_hosts);
            if let Some(proxy) = &mut session.proxy {
                apply_proxy_auth_overrides(
                    proxy,
                    profile,
                    "https-proxy-user",
                    "https-proxy-passwd",
                );
            }
        } else if let Some(proxy_text) = option("http-proxy") {
            session.proxy = parse_proxy_text(proxy_text, bypass_hosts);
            if let Some(proxy) = &mut session.proxy {
                apply_proxy_auth_overrides(proxy, profile, "http-proxy-user", "http-proxy-passwd");
            }
        } else if let Some(proxy_text) = option("all-proxy") {
            session.proxy = parse_proxy_text(proxy_text, bypass_hosts);
            if let Some(proxy) = &mut session.proxy {
                apply_proxy_auth_overrides(proxy, profile, "all-proxy-user", "all-proxy-passwd");
            }
        }
        if let Some(check) = option("check-certificate").and_then(parse_bool_text)
            && let Some(tls) = &mut session.tls
        {
            tls.verify_peer = check;
            tls.verify_host = check;
        }
        if let Some(value) = option("ca-certificate")
            && let Some(tls) = &mut session.tls
        {
            tls.ca_file = Some(value.to_owned());
        }
        if let Some(value) = option("certificate")
            && let Some(tls) = &mut session.tls
        {
            tls.cert_file = Some(value.to_owned());
        }
        if let Some(value) = option("private-key")
            && let Some(tls) = &mut session.tls
        {
            tls.key_file = Some(value.to_owned());
        }
        if let Some(value) = option("retry-wait").and_then(parse_u64_text) {
            session.retry.policy.initial_backoff_ms = value.saturating_mul(1000);
            session.retry.policy.max_backoff_ms = value.saturating_mul(1000);
            if value > 0 {
                session.retry.policy.retry_on_5xx = true;
                session.retry.policy.retry_on_timeout = true;
                session.retry.policy.retry_on_network_error = true;
            }
        }
        if let Some(value) = option("max-tries").and_then(parse_u64_text) {
            session.retry.policy.max_attempts = saturating_u32_from_u64(value);
            if value > 1 {
                session.retry.policy.retry_on_5xx = true;
                session.retry.policy.retry_on_timeout = true;
                session.retry.policy.retry_on_network_error = true;
            }
        }
        if let Some(value) = option("retry-on-400").and_then(parse_bool_text) {
            session.retry.policy.retry_on_4xx |= value;
        }
        if let Some(value) = option("retry-on-403").and_then(parse_bool_text) {
            session.retry.policy.retry_on_4xx |= value;
        }
        if let Some(value) = option("retry-on-406").and_then(parse_bool_text) {
            session.retry.policy.retry_on_4xx |= value;
        }
        if let Some(value) = option("retry-on-unknown").and_then(parse_bool_text) {
            session.retry.policy.retry_on_network_error |= value;
        }
    }

    session
}

/// Returns the default retry strategy used for one-shot synthetic transfer tasks.
pub(crate) const fn default_retry_strategy() -> RetryStrategy {
    RetryStrategy {
        policy: RetryPolicy {
            max_attempts: 1,
            initial_backoff_ms: 0,
            max_backoff_ms: 0,
            retry_on_3xx: false,
            retry_on_4xx: false,
            retry_on_5xx: false,
            retry_on_network_error: false,
            retry_on_timeout: false,
        },
        jitter: None,
        max_elapsed_ms: None,
    }
}

#[cfg(test)]
mod tests {
    use super::{load_config_report, profile_option_value};
    use crate::CliError;
    use aria2_rust_pro_compat::{
        ConfigDirective, ConfigDocument, ConfigLocationKind, ConfigProfile, ConfigScope,
        ConfigSource,
    };
    use std::fs;

    #[test]
    fn load_config_report_strict_rejects_unknown_options() {
        let temp_dir = std::env::temp_dir().join("aria2-rust-pro-projection-strict");
        let _ = fs::create_dir_all(&temp_dir);
        let config_path = temp_dir.join("aria2.conf");
        fs::write(&config_path, "split=4\nunknown-option=yes\n")
            .expect("config should be writable");

        let error =
            load_config_report(&config_path, true).expect_err("strict config load should fail");
        assert!(matches!(error, CliError::Config(_)));

        let _ = fs::remove_dir_all(temp_dir);
    }

    #[test]
    fn load_config_report_lenient_preserves_known_directives() {
        let temp_dir = std::env::temp_dir().join("aria2-rust-pro-projection-lenient");
        let _ = fs::create_dir_all(&temp_dir);
        let config_path = temp_dir.join("aria2.conf");
        fs::write(
            &config_path,
            "split=4\nunknown-option=yes\nmin-split-size=1M\n",
        )
        .expect("config should be writable");

        let report =
            load_config_report(&config_path, false).expect("lenient config load should work");
        assert_eq!(report.directive_count, 3);
        assert_eq!(report.profile.document.directives.len(), 3);
        let directive_names = report
            .profile
            .document
            .directives
            .iter()
            .map(|directive| directive.name.as_str())
            .collect::<Vec<_>>();
        assert_eq!(
            directive_names,
            ["split", "unknown-option", "min-split-size"]
        );

        let _ = fs::remove_dir_all(temp_dir);
    }

    #[test]
    fn profile_option_value_uses_last_wins_directive_order() {
        let profile = ConfigProfile {
            name: "test".to_owned(),
            source: ConfigSource::RuntimeOverride,
            document: ConfigDocument {
                directives: vec![
                    ConfigDirective {
                        name: "dir".to_owned(),
                        value: Some("downloads-a".to_owned()),
                    },
                    ConfigDirective {
                        name: "split".to_owned(),
                        value: Some("2".to_owned()),
                    },
                    ConfigDirective {
                        name: "dir".to_owned(),
                        value: Some("downloads-b".to_owned()),
                    },
                ],
                location: ConfigLocationKind::Inline,
                scope: ConfigScope::Mixed,
            },
        };

        assert_eq!(profile_option_value(&profile, "dir"), Some("downloads-b"));
        assert_eq!(profile_option_value(&profile, "split"), Some("2"));
        assert_eq!(profile_option_value(&profile, "missing"), None);
    }
}