use super::messages::VoiceClientMessage;
use crate::models::{channel, user};
use axum::extract::ws::Message;
use rustrtc::peer_connection::PeerConnection;
use std::sync::Arc;
use tokio::sync::mpsc::UnboundedSender;

/// Client connecté à un canal RTC.
#[derive(Clone)]
pub struct RTCClient {
    pub user: Arc<user::Model>,
    pub channel: Arc<channel::Model>,
    pub peer_connection: Arc<PeerConnection>,
    pub websocket_sender: UnboundedSender<Message>,
}

impl RTCClient {
    pub fn new(
        user: user::Model,
        channel: channel::Model,
        peer_connection: Arc<PeerConnection>,
        websocket_sender: UnboundedSender<Message>,
    ) -> Self {
        Self {
            user: Arc::new(user),
            channel: Arc::new(channel),
            peer_connection,
            websocket_sender,
        }
    }

    pub async fn on_message(&self, raw_message: Message) {
        let Message::Text(raw_message) = raw_message else {
            return;
        };

        let parsed = match serde_json::from_str::<VoiceClientMessage>(&raw_message) {
            Ok(message) => message,
            Err(_) => return,
        };

        match parsed {
            VoiceClientMessage::SDPOffer { channel_id, sdp } => {}
            VoiceClientMessage::IceCandidate {
                channel_id,
                candidate,
            } => {}
            VoiceClientMessage::Leave { channel_id } => {}
        }
    }

    /// Ferme proprement la connexion WebRTC.
    pub fn close(&self) {
        self.peer_connection.close();
    }
}