resonator 0.3.2

use socketioxide::{
    extract::{Data, SocketRef},
    SocketIo
};
use tower::ServiceBuilder;
use tower_http::services::ServeDir;

use std::{sync::{Arc, Mutex}};
use crate::{config::{AUDIO_BUFFER_SIZE}};
use crate::common::clientport::ClientPort;
use crate::common::packet::Packet;

pub struct AudioData {
    pub sender: u32,
    pub reciever: u32,
    pub buffer_size: i32,
    pub sample_rate: i32,
    pub samples: [f32; AUDIO_BUFFER_SIZE],
}

pub struct ResonatorServer {
    pub handshake_port: u16,                                                        //Port used on initial client connection to specify the client receive port
    pub client_receive_ports: Arc<Mutex< Vec<Arc<Mutex<ClientPort>>> >>,     //A vec of all of the client receive ports currently in use
    pub client_send_ports: Arc<Mutex< Vec<Arc<Mutex<ClientPort>>> >>,        //A vec of all of the client send ports currently in use
}

impl ResonatorServer {
    /**

     * Constructs a new Resonator using the specified ports
     */
    pub fn new(handshake_port: u16) -> ResonatorServer {
        ResonatorServer {
            client_send_ports: Arc::new(Mutex::new(Vec::new())),
            handshake_port,
            client_receive_ports: Arc::new(Mutex::new(Vec::new()))
        }
    }

    /**

     * Begins the server, listening for incoming connections on the specified ports
     */
    pub async fn begin(&self) {
        println!("Beginning socket.io server");

        let (layer, io) = SocketIo::builder().build_layer();
        io.ns("/", |s: SocketRef| {
            s.on("joinsession", |s: SocketRef, Data::<String>(id)| {
                println!("Client joined session {}", id);
                s.join(id).unwrap();
            });
            s.on("audiobuffer", |s: SocketRef, Data::<Packet>(msg)| {
                println!("Received audio buffer from client");
                println!("{:#?}", msg);
                s.broadcast().to(msg.header.room_id.clone()).emit("audiobuffer", msg.clone()).unwrap();
            });
            s.on("connect", |s: SocketRef, Data::<String>(msg)| {
                println!("Client connected to server");
            });
        });

        let app = axum::Router::new()
            .nest_service("/", ServeDir::new("dist"))
            .layer(
                ServiceBuilder::new()
                    .layer(layer)
            );

        let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
        axum::serve(listener, app).await.unwrap()
    }
}