use std::sync::LazyLock;

use leptos::logging::log;
use protocol::{Signal, SignalType, UserAndSignal};
use reqwest::{Response, header::HeaderMap};
use serde_json::{Value, json};

const SIGNALLING_ADDRESS: &str = "http://192.168.1.3:4546";
static REQUEST_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(|| reqwest::Client::new());

async fn create_headers(headers: Vec<(&'static str, String)>) -> HeaderMap {
    let mut header_map = HeaderMap::new();
    for (key, val) in headers {
        header_map.insert(key, val.parse().unwrap());
    }
    header_map
}

async fn post_json(username: &String, json: &Value) -> Result<Response, reqwest::Error> {
    let headers = create_headers(vec![]).await;
    REQUEST_CLIENT
        .post(SIGNALLING_ADDRESS)
        .headers(headers)
        .bearer_auth(username)
        .json(json)
        .send()
        .await
}

async fn get_json(username: &String, signal_type: SignalType) -> Result<Response, reqwest::Error> {
    let headers = create_headers(vec![("EXPECTED_SIGNAL", signal_type.to_string())]).await;
    REQUEST_CLIENT
        .get(SIGNALLING_ADDRESS)
        .headers(headers)
        .bearer_auth(username)
        .send()
        .await
}

pub async fn start_signalling(username: String) {
    log!("Start Signalling");
    log!("{}\n{}", username, SIGNALLING_ADDRESS);
    let auth_signal = Signal::new(&SignalType::Auth, &"".to_owned());
    let json = json!(auth_signal);
    match post_json(&username, &json).await {
        Ok(signal_response) => log!("{:#?}", signal_response),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}

pub async fn send_offer(username: &String, data: &String) -> Result<(), reqwest::Error> {
    let rtc_session_offer_signal = Signal::new(&SignalType::Offer, data);
    let rtc_session_offer_signal = json!(rtc_session_offer_signal);
    post_json(username, &rtc_session_offer_signal)
        .await
        .map(|_| Ok(()))?
}

pub async fn receive_offer(username: &String) -> Result<UserAndSignal, Box<dyn std::error::Error>> {
    let result = get_json(username, SignalType::Offer)
        .await
        .map(async |response| response.json::<UserAndSignal>().await)?
        .await?;
    if result.signal.get_signal_type() == SignalType::Offer {
        Ok(result)
    } else {
        Err(protocol::Error::UnexpectedSignalType(
            result.signal.get_signal_type(),
        ))?
    }
}

pub async fn send_answer(username: &String, data: &String) -> Result<(), reqwest::Error> {
    let rtc_session_answer_signal = Signal::new(&SignalType::Answer, data);
    let rtc_session_answer_signal = json!(rtc_session_answer_signal);
    post_json(username, &rtc_session_answer_signal)
        .await
        .map(|_| Ok(()))?
}

pub async fn receive_answer(
    username: &String,
) -> Result<UserAndSignal, Box<dyn std::error::Error>> {
    let result = get_json(username, SignalType::Answer)
        .await
        .map(async |response| response.json::<UserAndSignal>().await)?
        .await?;
    if result.signal.get_signal_type() == SignalType::Answer {
        Ok(result)
    } else {
        Err(protocol::Error::UnexpectedSignalType(
            result.signal.get_signal_type(),
        ))?
    }
}

pub async fn send_ice_candidate(username: &String, data: &String) -> Result<(), reqwest::Error> {
    let rtc_session_answer_signal = Signal::new(&SignalType::ICECandidate, data);
    let rtc_session_answer_signal = json!(rtc_session_answer_signal);
    post_json(username, &rtc_session_answer_signal)
        .await
        .map(|_| Ok(()))?
}

pub async fn receive_ice_candidate(
    username: &String,
) -> Result<UserAndSignal, Box<dyn std::error::Error>> {
    let result = get_json(username, SignalType::Answer)
        .await
        .map(async |response| response.json::<UserAndSignal>().await)?
        .await?;
    if result.signal.get_signal_type() == SignalType::ICECandidate {
        Ok(result)
    } else {
        Err(protocol::Error::UnexpectedSignalType(
            result.signal.get_signal_type(),
        ))?
    }
}