use std::{io, net::SocketAddr, path::Path};

use protocol::BUFFER_LENGTH;
use s2n_quic::{Client, client::Connect};
use tokio::{
    io::AsyncReadExt,
    sync::{broadcast, oneshot},
};

use crate::{
    ClientConfig,
    voice::{play, record},
};

pub async fn connect(client_config: &ClientConfig) {
    let client = Client::builder()
        .with_io("0:0")
        .unwrap()
        .with_tls(Path::new("certificates/cert.pem"))
        .unwrap()
        .start()
        .unwrap();

    println!("Client Address = {}", client.local_addr().unwrap());
    let connect = Connect::new(client_config.server_address.parse::<SocketAddr>().unwrap())
        .with_server_name("localhost");
    let mut connection = match client.connect(connect).await {
        Ok(connection) => connection,
        Err(err_val) => {
            eprintln!("Error: Client Connection | {}", err_val);
            return;
        }
    };
    connection.keep_alive(true).unwrap();

    let stream = connection.open_bidirectional_stream().await.unwrap();
    let (mut receive_stream, mut send_stream) = stream.split();

    let (microphone_sender, mut microphone_receiver) = broadcast::channel::<f32>(BUFFER_LENGTH);
    let (speaker_sender, speaker_receiver) = broadcast::channel::<f32>(BUFFER_LENGTH);

    let (microphone_stop_signal_sender, microphone_stop_signal_receiver) =
        oneshot::channel::<bool>();
    let (spearker_stop_signal_sender, speaker_stop_signal_receiver) = oneshot::channel::<bool>();

    tokio::spawn(play(speaker_receiver, speaker_stop_signal_receiver));
    tokio::spawn(record(microphone_sender, microphone_stop_signal_receiver));
    tokio::spawn(async move {
        while let Ok(data) = receive_stream.read_f32_le().await {
            speaker_sender.send(data).unwrap();
        }
    });
    tokio::spawn(async move {
        while let Ok(data) = microphone_receiver.recv().await {
            send_stream
                .send(data.to_le_bytes().to_vec().into())
                .await
                .unwrap();
        }
    });
    let mut read_buffer = String::default();
    io::stdin().read_line(&mut read_buffer).unwrap();
    microphone_stop_signal_sender.send(true).unwrap();
    spearker_stop_signal_sender.send(true).unwrap();
}