use leptos::logging::log;
use wasm_bindgen_futures::JsFuture;
use web_sys::{
    RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSdpType, RtcSessionDescriptionInit,
    js_sys::{Array, Reflect},
    wasm_bindgen::{JsCast, JsValue},
};

use crate::{
    signal::{receive_answer, receive_offer, send_answer, send_offer},
    sleep,
};

async fn create_peer_connection_with_configuration() -> RtcPeerConnection {
    let ice_server_addresses = vec![JsValue::from("stun:stun.l.google.com:19302")]
        .into_iter()
        .collect::<Array>();
    let ice_server = RtcIceServer::new();
    ice_server.set_urls(&JsValue::from(ice_server_addresses));
    let ice_servers = vec![ice_server].into_iter().collect::<Array>();
    let rtc_configuration = RtcConfiguration::new();
    rtc_configuration.set_ice_servers(&ice_servers);
    RtcPeerConnection::new_with_configuration(&rtc_configuration).unwrap()
}

pub async fn offer(username: String) {
    let peer_connection = create_peer_connection_with_configuration().await;
    let peer_connection_create_offer_promise = peer_connection.create_offer();
    let peer_connection_session_offer = JsFuture::from(peer_connection_create_offer_promise)
        .await
        .unwrap();
    log!("{:#?}", peer_connection_session_offer);
    let peer_connection_session_offer = peer_connection_session_offer
        .as_ref()
        .unchecked_ref::<RtcSessionDescriptionInit>();
    log!("{:#?}", peer_connection_session_offer);
    JsFuture::from(peer_connection.set_local_description(peer_connection_session_offer))
        .await
        .unwrap();
    let peer_connection_session_offer =
        Reflect::get(&peer_connection_session_offer, &JsValue::from_str("sdp"))
            .unwrap()
            .as_string()
            .unwrap();
    log!("{}", peer_connection_session_offer);
    let data = peer_connection_session_offer;

    if let Err(err_val) = send_offer(&username, &data).await {
        log!("Error: Send Offer | {}", err_val)
    }
    for _ in 0..10 {
        match receive_answer(&username).await {
            Ok(received_answer) => {
                log!("{:#?}", received_answer);
                let peer_connection_session_answer =
                    RtcSessionDescriptionInit::new(RtcSdpType::Answer);
                peer_connection_session_answer.set_sdp(received_answer.get_data().as_str());
                JsFuture::from(
                    peer_connection.set_remote_description(&peer_connection_session_answer),
                )
                .await
                .unwrap();
                break;
            }
            Err(err_val) => log!("Error: Receive Answer | {}", err_val),
        }
        sleep(1000).await;
    }
}

pub async fn answer(username: String) {
    for _ in 0..10 {
        match receive_offer(&username).await {
            Ok(offer) => {
                let peer_connection = create_peer_connection_with_configuration().await;
                let peer_connection_session_offer =
                    RtcSessionDescriptionInit::new(RtcSdpType::Offer);
                peer_connection_session_offer.set_sdp(offer.get_data().as_str());
                JsFuture::from(
                    peer_connection.set_remote_description(&peer_connection_session_offer),
                )
                .await
                .unwrap();
                let peer_connection_create_answer_promise = peer_connection.create_answer();
                let peer_connection_answer = JsFuture::from(peer_connection_create_answer_promise)
                    .await
                    .unwrap();
                let peer_connection_answer = peer_connection_answer
                    .as_ref()
                    .unchecked_ref::<RtcSessionDescriptionInit>();
                JsFuture::from(peer_connection.set_local_description(peer_connection_answer))
                    .await
                    .unwrap();
                let session_answer = Reflect::get(&peer_connection_answer, &JsValue::from("sdp"))
                    .unwrap()
                    .as_string()
                    .unwrap();
                log!("{}", session_answer);
                let data = session_answer;

                send_answer(&username, &data).await.unwrap();
                break;
            }
            Err(err_val) => log!("Error: Receive Offer | {}", err_val),
        }
        sleep(1000).await;
    }
}