peerspeak/src/config.rs

use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

/// Relay/discovery posture, trading connectivity against how much the n0
/// infrastructure learns about you. See the network module for details.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum NetworkMode {
    /// n0 relay for NAT traversal, but no DNS presence beacon. Peer addresses
    /// come from the join ticket and gossip, so n0 only sees relayed-call
    /// metadata, never a standing "I'm online" record. Default.
    #[default]
    RelayNoDiscovery,
    /// Full n0 defaults: relay plus DNS publish/resolve (most convenient,
    /// most phone-home).
    N0Full,
    /// No relay, no discovery: direct hole-punching only. Fully serverless,
    /// but fails behind symmetric/CGNAT NATs with no fallback.
    DirectOnly,
}

impl NetworkMode {
    /// All variants, for presentation in a picker.
    pub const ALL: [NetworkMode; 3] =
        [NetworkMode::RelayNoDiscovery, NetworkMode::N0Full, NetworkMode::DirectOnly];
}

impl std::fmt::Display for NetworkMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let label = match self {
            NetworkMode::RelayNoDiscovery => "Relay, no presence beacon",
            NetworkMode::N0Full => "n0 defaults (relay + DNS)",
            NetworkMode::DirectOnly => "Direct only (no relay)",
        };
        f.write_str(label)
    }
}

fn default_true() -> bool {
    true
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AppConfig {
    pub input_device: String,
    pub output_device: String,
    pub noise_gate_threshold: f32,
    #[serde(default)]
    pub network_mode: NetworkMode,
    /// Route audio through PipeWire's echo-cancel module (AEC + noise suppression).
    /// Takes effect on the next room join. Off by default.
    #[serde(default)]
    pub echo_cancellation_enabled: bool,
    #[serde(default = "default_true")]
    pub notifications_enabled: bool,
    #[serde(default)]
    pub custom_sound_self_join: Option<String>,
    #[serde(default)]
    pub custom_sound_peer_join: Option<String>,
    #[serde(default)]
    pub custom_sound_peer_leave: Option<String>,
    #[serde(default)]
    pub custom_sound_reconnect_attempt: Option<String>,
    #[serde(default)]
    pub custom_sound_reconnected: Option<String>,
    #[serde(default)]
    pub custom_sound_self_leave: Option<String>,
    #[serde(default)]
    pub custom_sound_mic_toggle: Option<String>,
    #[serde(default)]
    pub custom_sound_reconnect_failed: Option<String>,
}

impl Default for AppConfig {
    fn default() -> Self {
        Self {
            input_device: "".to_string(),
            output_device: "".to_string(),
            noise_gate_threshold: 0.01,
            network_mode: NetworkMode::default(),
            echo_cancellation_enabled: false,
            notifications_enabled: true,
            custom_sound_self_join: None,
            custom_sound_peer_join: None,
            custom_sound_peer_leave: None,
            custom_sound_reconnect_attempt: None,
            custom_sound_reconnected: None,
            custom_sound_self_leave: None,
            custom_sound_mic_toggle: None,
            custom_sound_reconnect_failed: None,
        }
    }
}

impl AppConfig {
    fn config_path() -> Option<PathBuf> {
        dirs::config_dir().map(|mut p| {
            p.push("peerspeak");
            p.push("config.json");
            p
        })
    }

    pub fn load() -> Self {
        if let Some(path) = Self::config_path()
            && let Ok(contents) = fs::read_to_string(&path)
                && let Ok(config) = serde_json::from_str(&contents) {
                    return config;
                }
        Self::default()
    }

    pub fn save(&self) {
        if let Some(path) = Self::config_path() {
            if let Some(dir) = path.parent() {
                let _ = fs::create_dir_all(dir);
            }
            if let Ok(json) = serde_json::to_string_pretty(self) {
                let _ = fs::write(path, json);
            }
        }
    }
}

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

    #[test]
    fn test_round_trip() {
        let original = AppConfig::default();
        let serialized = serde_json::to_string(&original).unwrap();
        let deserialized: AppConfig = serde_json::from_str(&serialized).unwrap();
        assert_eq!(original, deserialized);
    }

    #[test]
    fn test_backward_compat_default_fill() {
        let minimal_json = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01}"#;
        let deserialized: AppConfig = serde_json::from_str(minimal_json).unwrap();
        
        assert_eq!(deserialized.network_mode, NetworkMode::RelayNoDiscovery);
        assert!(!deserialized.echo_cancellation_enabled);
        assert!(deserialized.notifications_enabled);
        assert!(deserialized.custom_sound_self_join.is_none());
        assert!(deserialized.custom_sound_peer_join.is_none());
        assert!(deserialized.custom_sound_peer_leave.is_none());
        assert!(deserialized.custom_sound_reconnect_attempt.is_none());
        assert!(deserialized.custom_sound_reconnected.is_none());
        assert!(deserialized.custom_sound_self_leave.is_none());
        assert!(deserialized.custom_sound_mic_toggle.is_none());
        assert!(deserialized.custom_sound_reconnect_failed.is_none());
    }

    #[test]
    fn test_notifications_enabled_specifically() {
        let missing_notifications = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01}"#;
        let config_missing: AppConfig = serde_json::from_str(missing_notifications).unwrap();
        assert!(config_missing.notifications_enabled);

        let explicit_false = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01,"notifications_enabled":false}"#;
        let config_false: AppConfig = serde_json::from_str(explicit_false).unwrap();
        assert!(!config_false.notifications_enabled);

        let explicit_true = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01,"notifications_enabled":true}"#;
        let config_true: AppConfig = serde_json::from_str(explicit_true).unwrap();
        assert!(config_true.notifications_enabled);
    }

    #[test]
    fn test_network_mode() {
        // NetworkMode::default() == RelayNoDiscovery
        assert_eq!(NetworkMode::default(), NetworkMode::RelayNoDiscovery);

        // ALL.len() == 3 and contains all three variants
        assert_eq!(NetworkMode::ALL.len(), 3);
        assert!(NetworkMode::ALL.contains(&NetworkMode::RelayNoDiscovery));
        assert!(NetworkMode::ALL.contains(&NetworkMode::N0Full));
        assert!(NetworkMode::ALL.contains(&NetworkMode::DirectOnly));

        // each variant serde round-trips to itself
        for mode in NetworkMode::ALL {
            let serialized = serde_json::to_string(&mode).unwrap();
            let deserialized: NetworkMode = serde_json::from_str(&serialized).unwrap();
            assert_eq!(mode, deserialized);
        }

        // the three Display strings are non-empty and distinct
        let display_0 = NetworkMode::RelayNoDiscovery.to_string();
        let display_1 = NetworkMode::N0Full.to_string();
        let display_2 = NetworkMode::DirectOnly.to_string();

        assert!(!display_0.is_empty());
        assert!(!display_1.is_empty());
        assert!(!display_2.is_empty());

        assert_ne!(display_0, display_1);
        assert_ne!(display_1, display_2);
        assert_ne!(display_0, display_2);
    }

    #[test]
    fn test_unknown_field_tolerance() {
        // Unknown/extra field tolerance: a config JSON containing an extra unrecognized key should still deserialize.
        // Assert whatever actually happens and leave a comment; do not add deny_unknown_fields.
        let json_with_extra = r#"{
            "input_device": "",
            "output_device": "",
            "noise_gate_threshold": 0.01,
            "unrecognized_field_xyz_123": "some_value"
        }"#;
        let deserialized_res: Result<AppConfig, _> = serde_json::from_str(json_with_extra);
        
        // Assert that deserialization succeeds even with unrecognized/unknown fields.
        // This confirms that serde does not reject unknown fields (i.e. default behavior).
        assert!(deserialized_res.is_ok(), "Config deserialization failed when an unknown field was present");
        
        let config = deserialized_res.unwrap();
        assert_eq!(config.input_device, "");
        assert_eq!(config.output_device, "");
        assert_eq!(config.noise_gate_threshold, 0.01);
    }
}