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

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

pub fn app() -> impl IntoView {
    let audio_stream = LocalResource::new(|| media::audio());
    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 audio_element = HtmlAudioElement::new().unwrap();

                    let audio_streams = webrtc_audio.get_remote_streams().unwrap();
                    log!("Streams = {:#?}", audio_streams);
                    let audio_stream = audio_streams.get(0);
                    match audio_stream {
                        Some(audio_stream) => {
                            audio_element.set_src_object(Some(audio_stream));
                            let audio_tracks = audio_stream
                                .get_audio_tracks()
                                .iter()
                                .map(|audio_track| MediaStreamTrack::from(audio_track))
                                .collect::<Vec<_>>();
                            log!("How many tracks = {}", audio_tracks.len());
                            log!(
                                "Constraints = {:#?}",
                                audio_tracks.first().unwrap().get_constraints()
                            );

                            let audio_element_play_promise = audio_element.play().unwrap();
                            spawn_local(async move {
                                JsFuture::from(audio_element_play_promise).await.ok();
                            });
                        }
                        None => todo!(),
                    }
                })
                .child("Play");

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

    Show(props)
}