use chrono::{Duration, Utc};
use julianday::JulianDay;
use lox::bridge_table::BridgeLine;
use lox::cred::{BucketReachability, Lox, Migration};
use lox::proto::{open_invite, trust_promotion, migration, level_up,
    issue_invite, redeem_invite, check_blockage, blockage_migration};
use lox::{IssuerPubKey, OPENINV_LENGTH};
use serde::{Deserialize, Serialize};
use serde_json;
//use serde_wasm_bindgen;
use std::array::TryFromSliceError;
use std::{panic};
use wasm_bindgen::prelude::*;

#[derive(Deserialize, Serialize)]
struct OpenReqState {
    request: open_invite::Request,
    state: open_invite::State,
}

#[derive(Deserialize, Serialize)]
struct TrustReqState {
    request: trust_promotion::Request,
    state: trust_promotion::State,
}

#[derive(Deserialize, Serialize)]
struct MigReqState {
    request: migration::Request,
    state: migration::State,
}

#[derive(Deserialize, Serialize)]
struct LevelupReqState {
    request: level_up::Request,
    state: level_up::State,
}

#[derive(Debug, Deserialize, Serialize)]
struct PubKeys {
    lox_pub: IssuerPubKey,
    migration_pub: IssuerPubKey,
    migrationkey_pub: IssuerPubKey,
    reachability_pub: IssuerPubKey,
    invitation_pub: IssuerPubKey,
}

#[derive(Debug, Deserialize, Serialize)]
struct Credential {
    lox_credential: Lox,
    bridgeline: BridgeLine,
}


fn today() -> u32 {
    let naive_now = Utc::now().date_naive();
    JulianDay::from(naive_now).inner().try_into().unwrap()
}

// This should only be used for testing, use today in production
fn add_today(sum: i64) -> u32 {
    let naive_now_plus = (Utc::now() + Duration::days(sum)).date_naive();
    JulianDay::from(naive_now_plus).inner().try_into().unwrap()
}

#[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 = OpenReqState {
        request: request,
        state: state,
    };
    unsafe {
        log(&format!(
            "Formatted open invite request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

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

#[wasm_bindgen]
pub fn trust_promotion(open_lox_cred: String, lox_pub: String) -> Result<String, JsValue> {
    let lox_cred: Credential = serde_json::from_str(&open_lox_cred).unwrap();
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    // To test creation of the credential we need to advance the day to 30
    // in production this should just use the today() function
    log(&format!(
        "TEST ONLY: Add 31 days to today's date: {}",
        add_today(31)
    ));
    let tp_result =
        //CHANGE add_today(31) to today() for production
        match trust_promotion::request(&lox_cred.lox_credential, &pubkeys.lox_pub, add_today(31)) {
            Ok(tp_result) => tp_result,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    let req_state = TrustReqState {
        request: tp_result.0,
        state: tp_result.1,
    };
    unsafe {
        log(&format!(
            "Formatted Trust Promotion request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

#[wasm_bindgen]
pub fn handle_trust_promotion(
    trust_promo_request: String,
    trust_promo_response: String,
) -> Result<String, JsValue> {
    let req_state: TrustReqState = serde_json::from_str(&trust_promo_request).unwrap();
    let deserialized_state = req_state.state;
    let deserialized_response = serde_json::from_str(&trust_promo_response).unwrap();
    let migration_cred =
        match trust_promotion::handle_response(deserialized_state, deserialized_response) {
            Ok(migration_cred) => migration_cred,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    unsafe {
        log(&format!(
            "Got new Migration Credential: {}",
            serde_json::to_string(&migration_cred).unwrap()
        ));
    }
    Ok(serde_json::to_string(&migration_cred).unwrap())
}

#[wasm_bindgen]
pub fn trust_migration(open_lox_cred: String, trust_promo_cred: String, lox_pub: String) -> Result<String, JsValue> {
    let lox_cred: Credential = serde_json::from_str(&open_lox_cred).unwrap();
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let mig_cred: Migration = serde_json::from_str(&trust_promo_cred).unwrap();
    let tm_result =
        match migration::request(&lox_cred.lox_credential, &mig_cred, &pubkeys.lox_pub, &pubkeys.migration_pub) {
            Ok(tm_result) => tm_result,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    let req_state = MigReqState {
        request: tm_result.0,
        state: tm_result.1,
    };
    unsafe {
        log(&format!(
            "Formatted Trust Migration request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

#[wasm_bindgen]
pub fn handle_trust_migration(
    trust_migration_request: String,
    trust_migration_response: String,
    lox_pub: String
) -> Result<String, JsValue> {
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let req_state: MigReqState = serde_json::from_str(&trust_migration_request).unwrap();
    let deserialized_state = req_state.state;
    let deserialized_response = serde_json::from_str(&trust_migration_response).unwrap();
    let level_one_cred =
        match migration::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
            Ok(level_1_cred) => level_1_cred,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    unsafe {
        log(&format!(
            "Got new Level 1 Credential: {}",
            serde_json::to_string(&level_one_cred).unwrap()
        ));
    }
    Ok(serde_json::to_string(&level_one_cred).unwrap())
}

#[wasm_bindgen]
pub fn level_up(level_one_cred: String, reachability_cred: String, lox_pub: String) -> Result<String, JsValue> {
    let lox_cred: Lox = serde_json::from_str(&level_one_cred).unwrap();
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let reach_cred: BucketReachability = serde_json::from_str(&reachability_cred).unwrap();
    // To test level up of the credential we need to advance the day to the correct interval
    // In this case, the maximum of 85 can be used to test all level ups
    // in production this should just use the today() function
    log(&format!(
        "TEST ONLY: Add 85 days to today's date: {}",
        add_today(85)
    ));
    let lu_result =
        //CHANGE add_today(31) to today() for production
        match level_up::request(&lox_cred, &reach_cred, &pubkeys.lox_pub, &pubkeys.reachability_pub, add_today(85)) {
            Ok(lu_result) => lu_result,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    let req_state = LevelupReqState {
        request: lu_result.0,
        state: lu_result.1,
    };
    unsafe {
        log(&format!(
            "Formatted Level Up request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

#[wasm_bindgen]
pub fn handle_level_up(
    levelup_request: String,
    levelup_response: String,
    lox_pub: String
) -> Result<String, JsValue> {
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let req_state: LevelupReqState = serde_json::from_str(&levelup_request).unwrap();
    let deserialized_state = req_state.state;
    let deserialized_response = serde_json::from_str(&levelup_response).unwrap();
    let level_up_cred =
        match level_up::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
            Ok(level_up_cred) => level_up_cred,
            Err(e) => {
                log(&format!("Error: {:?}", e.to_string()));
                return Err(JsValue::from(e.to_string()));
            }
        };
    unsafe {
        log(&format!(
            "Got new Level Up Credential: {}",
            serde_json::to_string(&level_up_cred).unwrap()
        ));
    }
    Ok(serde_json::to_string(&level_up_cred).unwrap())
}


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