lox/crates/lox-wasm/src/lib.rs

use lox::bridge_table::BridgeLine;
use lox::proto::open_invite;
use lox::{IssuerPubKey, OPENINV_LENGTH};
use serde_json;
use serde::{Deserialize,Serialize};
//use serde_wasm_bindgen;
use std::array::TryFromSliceError;
use std::panic;
use wasm_bindgen::prelude::*;

#[derive(Debug,Deserialize, Serialize)]
struct ReqState {
    request: String,
    state: String,
}

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_namespace = console)]
    pub fn log(s: &str);
}

#[wasm_bindgen]
pub fn set_panic_hook() {
    panic::set_hook(Box::new(console_error_panic_hook::hook));
}

#[wasm_bindgen]
pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
    unsafe {
        log(&format!("Using invite: {:?}", invite));
    }
    let token = match validate(invite) {
        Ok(token) => token,
        Err(e) => return Err(JsValue::from(e.to_string())),
    };
    let (request, state) = open_invite::request(&token);
    let req_state = ReqState {
        request: serde_json::to_string(&request).unwrap(),
        state: serde_json::to_string(&state).unwrap(),
    };
    unsafe {
        log(&format!(
            "Formatted open invite request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

fn concat_string(request: String, state: String) -> String {
    let mut new_string: String = "Request:".to_owned();
    new_string.push_str(&request);
    new_string.push_str(", State:");
    new_string.push_str(&state);
    return new_string;
}

fn deconcat_string(concatString: String) -> (String, String) {

    ("hello".to_owned(), "world".to_owned())

}


#[wasm_bindgen]
pub fn handle_new_lox_credential(open_lox_result: String, open_lox_response: String, lox_pub: String) -> Result<String, JsValue> {
    unsafe {
    log(&format!("Using server response: {:?}", open_lox_result));
    }
    let (state, response) = deconcat_string(open_lox_result);
    let deserialized_state = serde_json::from_str(&state).unwrap();
    let deserialized_response = serde_json::from_str(&response).unwrap();
    let deserialized_pubkey = serde_json::from_str(&lox_pub).unwrap();
    let lox_cred = match open_invite::handle_response(deserialized_state, deserialized_response, &deserialized_pubkey) {
        Ok(lox_cred) => lox_cred,
        Err(e) => return Err(JsValue::from(e.to_string())),
    };
    let serialized_credential = serde_json::to_string(&lox_cred.0).unwrap();
    let serialized_bridgeline= serde_json::to_string(&lox_cred.1).unwrap();
    unsafe {
        log(&format!("Got new Lox Credential: {}", serialized_credential));
        log(&format!("Got new bridgeline: {}", serialized_bridgeline));
    }
    let open_lox_response = concat_string(serialized_credential, serialized_bridgeline);
    Ok(open_lox_response)
}

/* Somehow get pubkeys and return to function
#[wasm_bindgen]
pub async fn get_pubkey(key_type: String) -> Result<JsValue, JsValue> {
    let mut url = "http://localhost:8001/".to_owned() + &key_type;
    let res = reqwest::Client::new()
        .get(url)
        .send()
        .await?;

    let text = res.text().await?;
    let pub_key: IssuerPubKey = serde_json::from_str(&text).unwrap();

    Ok(pub_key)
} */

// This should also check the pubkey
fn validate(invite: &[u8]) -> Result<[u8; OPENINV_LENGTH], TryFromSliceError> {
    invite.try_into()
}