use std::{str::FromStr, sync::LazyLock};

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

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

async fn post_json(username: &String, json: &Value) -> Result<Response, reqwest::Error> {
    let mut headers = HeaderMap::new();
    headers
        .try_insert(
            HeaderName::from_str("username").unwrap(),
            username.parse().unwrap(),
        )
        .unwrap();
    REQUEST_CLIENT
        .post(SIGNALLING_ADDRESS)
        .headers(headers)
        .json(json)
        .send()
        .await
}

async fn get_json(username: &String) -> Result<Response, reqwest::Error> {
    let mut headers = HeaderMap::new();
    headers
        .try_insert(
            HeaderName::from_str("username").unwrap(),
            username.parse().unwrap(),
        )
        .unwrap();
    REQUEST_CLIENT
        .get(SIGNALLING_ADDRESS)
        .headers(headers)
        .send()
        .await
}

pub async fn start_signalling(username: String) {
    log!("Start Signalling");
    log!("{}\n{}", username, SIGNALLING_ADDRESS);
    let auth_signal = Signal::new(&username, &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) {
    let rtc_session_offer_signal = Signal::new(username, &SignalType::Offer, data);
    let rtc_session_offer_signal = json!(rtc_session_offer_signal);
    match post_json(username, &rtc_session_offer_signal).await {
        Ok(signal_response) => log!("{:#?}", signal_response),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}

pub async fn receive_offer(username: &String) {
    match get_json(username).await {
        Ok(signal_response) => log!("{:#?}", signal_response),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}

pub async fn send_answer(username: &String, data: &String) {
    let rtc_session_answer_signal = Signal::new(username, &SignalType::Answer, data);
    let rtc_session_answer_signal = json!(rtc_session_answer_signal);
    match post_json(username, &rtc_session_answer_signal).await {
        Ok(signal_response) => log!("{:#?}", signal_response),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}

pub async fn receive_answer(username: &String) {
    match get_json(username).await {
        Ok(signal_response) => log!("{:#?}", signal_response),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}