use leptos::{
    IntoView,
    html::{ElementChild, button, label},
    logging::log,
    prelude::{OnAttribute, Read, Show, ShowProps, ToChildren},
    server::LocalResource,
};
use wasm_bindgen_futures::spawn_local;

use crate::{
    media::{self, get_remote_audio_stream_and_play},
    signal::{send_auth, wait_until_communication_is_ready},
    sleep,
    webrtc::WebRTC,
};

pub fn app() -> impl IntoView {
    let audio_stream = LocalResource::new(|| media::get_audio_stream());
    let wait_until_communication_is_ready =
        LocalResource::new(|| wait_until_communication_is_ready());

    let props = ShowProps::builder()
        .when(move || {
            audio_stream.read().is_some() && wait_until_communication_is_ready.read().is_some()
        })
        .children(ToChildren::to_children(move || {
            let audio_stream = audio_stream.read();
            let audio_stream = audio_stream.as_deref().unwrap().as_ref().unwrap().clone();

            let webrtc = WebRTC::new(Some(audio_stream), None, None).unwrap();
            let webrtc_state = webrtc.clone();
            spawn_local(async move {
                let mut webrtc_status = webrtc_state.get_status();
                loop {
                    if webrtc_status != webrtc_state.get_status() {
                        webrtc_status = webrtc_state.get_status();
                        log!("{:#?}", webrtc_status);
                    }
                    sleep(1000).await;
                }
            });

            let webrtc_offer = webrtc.clone();
            let offer_button = button()
                .on(leptos::ev::click, move |_| {
                    log!("Offer");
                    send_auth(&String::from("Offer")).unwrap();
                    let webrtc_offer = webrtc_offer.clone();
                    spawn_local(async move {
                        if let Err(err_val) = webrtc_offer.offer().await {
                            log!("Error: WebRTC Offer | {}", err_val);
                            return;
                        }
                    });
                })
                .child("Offer");

            let webrtc_answer = webrtc.clone();
            let answer_button = button()
                .on(leptos::ev::click, move |_| {
                    log!("Answer");
                    send_auth(&String::from("Answer")).unwrap();
                    let webrtc_answer = webrtc_answer.clone();
                    spawn_local(async move {
                        if let Err(err_val) = webrtc_answer.answer().await {
                            log!("Error: WebRTC Answer | {}", err_val);
                            return;
                        }
                    });
                })
                .child("Answer");

            let webrtc_audio = webrtc.clone();
            let play_remote_audio_button = button()
                .on(leptos::ev::click, move |_| {
                    let webrtc_audio = webrtc_audio.clone();
                    spawn_local(get_remote_audio_stream_and_play(webrtc_audio));
                })
                .child("Play");

            (offer_button, answer_button, play_remote_audio_button)
        }))
        .fallback(|| label().child("NOOOOOOOOOOOO"))
        .build();

    Show(props)
}