use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct AppChatSettings {
    pub enabled: bool,
    pub topic_prefix: String,
    pub room_group_id: String,
    pub user_group_id: String,
    pub user_view_group_id: String,
    pub dedup_ttl_seconds: u64,
    pub idempotency_ttl_seconds: u64,
    pub upload_ttl_seconds: u64,
    pub presence_ttl_seconds: u64,
    pub unread_ttl_seconds: u64,
}

impl Default for AppChatSettings {
    fn default() -> Self {
        Self {
            enabled: true,
            topic_prefix: "chat".to_string(),
            room_group_id: "chat.room.v1".to_string(),
            user_group_id: "chat.user.v1".to_string(),
            user_view_group_id: "chat.user.view.v1".to_string(),
            dedup_ttl_seconds: 24 * 3600,
            idempotency_ttl_seconds: 24 * 3600,
            upload_ttl_seconds: 3600,
            presence_ttl_seconds: 120,
            unread_ttl_seconds: 30 * 24 * 3600,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct GatewaySettings {
    pub ws_heartbeat_interval_seconds: u64,
    pub ws_idle_timeout_seconds: u64,
    pub ws_auth_timeout_seconds: u64,
    pub max_connections_per_user: usize,
    pub subscriber_id: String,
        pub topic_prefix: String,
    pub upload_presign_ttl_seconds: u64,
    pub typing_debounce_seconds: u64,
}

impl Default for GatewaySettings {
    fn default() -> Self {
        Self {
            ws_heartbeat_interval_seconds: 30,
            ws_idle_timeout_seconds: 120,
            ws_auth_timeout_seconds: 10,
            max_connections_per_user: 8,
            subscriber_id: "chat.gateway".to_string(),
            topic_prefix: "chat".to_string(),
            upload_presign_ttl_seconds: 900,
            typing_debounce_seconds: 2,
        }
    }
}

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

    #[test]
    fn chat_settings_defaults() {
        let s = AppChatSettings::default();
        assert!(s.enabled);
        assert_eq!(s.topic_prefix, "chat");
        assert_eq!(s.room_group_id, "chat.room.v1");
        assert_eq!(s.user_group_id, "chat.user.v1");
        assert_eq!(s.user_view_group_id, "chat.user.view.v1");
        assert_eq!(s.dedup_ttl_seconds, 24 * 3600);
        assert_eq!(s.idempotency_ttl_seconds, 24 * 3600);
        assert_eq!(s.upload_ttl_seconds, 3600);
        assert_eq!(s.presence_ttl_seconds, 120);
        assert_eq!(s.unread_ttl_seconds, 30 * 24 * 3600);
    }

    #[test]
    fn gateway_settings_defaults_sane() {
        let s = GatewaySettings::default();
        assert_eq!(s.ws_heartbeat_interval_seconds, 30);
        assert_eq!(s.ws_idle_timeout_seconds, 120);
        assert_eq!(s.ws_auth_timeout_seconds, 10);
        assert_eq!(s.max_connections_per_user, 8);
        assert_eq!(s.subscriber_id, "chat.gateway");
        assert_eq!(s.topic_prefix, "chat");
        assert_eq!(s.upload_presign_ttl_seconds, 900);
        assert_eq!(s.typing_debounce_seconds, 2);
    }

    #[test]
    fn gateway_settings_serde_roundtrip() {
        let s = GatewaySettings::default();
        let json = serde_json::to_string(&s).unwrap();
        let back: GatewaySettings = serde_json::from_str(&json).unwrap();
        assert_eq!(back.topic_prefix, s.topic_prefix);
        assert_eq!(back.max_connections_per_user, s.max_connections_per_user);
    }
}