use std::sync::Arc;

use leptos::logging::log;
use protocol::Error;
use wasm_bindgen_futures::JsFuture;
use web_sys::{
    HtmlAudioElement, MediaStream, MediaStreamConstraints, MediaStreamTrack, MediaTrackConstraints,
    wasm_bindgen::{JsCast, JsValue},
    window,
};

use crate::webrtc::WebRTC;

pub async fn get_audio_stream() -> Result<MediaStream, Error> {
    let media_devices = window()
        .ok_or(Error::MediaStream("Accessing Window".to_owned()))?
        .navigator()
        .media_devices()
        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;

    let media_stream_constraints = MediaStreamConstraints::new();
    let media_track_constraints = MediaTrackConstraints::new();

    media_stream_constraints.set_audio(&JsValue::TRUE);
    media_track_constraints.set_echo_cancellation(&JsValue::FALSE);
    media_track_constraints.set_noise_suppression(&JsValue::FALSE);
    media_track_constraints.set_auto_gain_control(&JsValue::FALSE);

    let media_stream_promise = media_devices
        .get_user_media_with_constraints(&media_stream_constraints)
        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
    let media_stream = JsFuture::from(media_stream_promise)
        .await
        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
    let media_stream = media_stream.unchecked_ref::<MediaStream>();

    let audio_stream_tracks = media_stream.get_audio_tracks();
    let audio_stream_tracks = audio_stream_tracks
        .iter()
        .map(|audio_track| MediaStreamTrack::from(audio_track))
        .collect::<Vec<_>>();
    let audio_stream_track = audio_stream_tracks
        .first()
        .ok_or(Error::MediaStream("Get First Media Track".to_owned()))?;

    log!(
        "Local Constraints = {:#?}",
        audio_stream_track.get_constraints()
    );

    let audio_stream_track_apply_constraints_promise = audio_stream_track
        .apply_constraints_with_constraints(&media_track_constraints)
        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
    JsFuture::from(audio_stream_track_apply_constraints_promise)
        .await
        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;

    let audio_stream =
        MediaStream::new().map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
    audio_stream.add_track(audio_stream_track);

    Ok(audio_stream)
}

pub async fn get_remote_audio_stream_and_play(webrtc: Arc<WebRTC>) {
    let audio_element = HtmlAudioElement::new().unwrap();

    let audio_streams = webrtc.get_remote_streams().unwrap();
    let audio_stream = audio_streams.get(0);
    match audio_stream {
        Some(audio_stream) => {
            audio_element.set_src_object(Some(audio_stream));

            let audio_element_play_promise = audio_element.play().unwrap();
            JsFuture::from(audio_element_play_promise).await.ok();
        }
        None => todo!(),
    }
}