mod client;
mod messages;
mod metrics;
pub mod ws_entrypoint;

use crate::config::NetworkConfig;
use crate::models::channel;
use crate::repositories::Repositories;
use crate::rtc::client::RTCClient;
use crate::services::Services;
use event_bus::EventBus;
use rustrtc::{PeerConnection, RtcConfiguration, RtcConfigurationBuilder};
use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
// 1. Client crée une RTCPeerConnection
// 2. Client crée une SDP offer
// 3. Client envoie l'offer via WebSocket
// 4. Serveur crée sa PeerConnection
// 5. Serveur applique l'offer
// 6. Serveur crée une SDP answer
// 7. Serveur renvoie l'answer via WebSocket
// 8. Client et serveur échangent les candidats ICE
// 9. ICE sélectionne un chemin réseau
// 10. La connexion WebRTC devient active

pub struct VoiceRoom {}

pub struct VoiceRoomManager {
    rooms: HashMap<channel::Model, VoiceRoom>,
}

#[derive(Clone)]
pub struct RTCManager {
    pub config: RtcConfiguration,
    pub repositories: Arc<Repositories>,
    pub services: Arc<Services>,
    pub event_bus: Arc<EventBus>,

    //
    rooms: Arc<VoiceRoomManager>,
}

impl fmt::Debug for RTCManager {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("VoiceService")
            .field("config", &self.config)
            // .field("metrics", &self.metrics)
            .finish()
    }
}

impl VoiceRoom {
    pub fn new() -> Self {
        Self {}
    }
}

impl VoiceRoomManager {
    pub fn new() -> Self {
        Self {
            rooms: HashMap::new(),
        }
    }
}

impl RTCManager {
    pub fn new(
        network: &NetworkConfig,
        repositories: Arc<Repositories>,
        services: Arc<Services>,
        event_bus: Arc<EventBus>,
    ) -> Self {
        let builder = RtcConfigurationBuilder::new()
            .ice_udp_mux(true)
            .ice_udp_mux_port(network.udp_port)
            .bind_ip(network.host.to_string());
        let config = builder.build();

        let rooms = Arc::new(VoiceRoomManager::new());

        Self {
            config,
            repositories,
            services,
            event_bus,
            rooms,
        }
    }

    /// Session Description Protocol - Permet de se mettre d'accord sur les paramètres media
    pub async fn handle_sdp_offer(&self, rtc_client: &RTCClient, offer_sdp: String) {
        let pc = rtc_client.peer_connection.clone();
    }

    /// Interactive Connectivity Establishment - Permet de négocier un chemin réseau
    pub async fn handle_ice_candidate(&self) {}

    pub fn new_peer_connection(&self) -> Arc<PeerConnection> {
        let pc = Arc::new(PeerConnection::new(self.config.clone()));
        // todo : some logging ?
        pc
    }
}