use chrono::{Duration, Utc, NaiveDate};
use std::sync::atomic::{AtomicI64, Ordering};
use julianday::JulianDay;
use lazy_static::lazy_static;
use lox::bridge_table::{BridgeLine,from_scalar,BridgeTable, ENC_BUCKET_BYTES};
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, scalar_u32};
use serde::{Deserialize, Serialize};
use serde_with::{serde_as};
use serde_json;
//use serde_wasm_bindgen;
use std::array::TryFromSliceError;
use std::{panic};
use wasm_bindgen::prelude::*;
use zkp::ProofError;


#[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,
}

#[serde_as]
#[derive(Serialize, Deserialize)]
pub struct EncBridgeTable {
   #[serde_as(as = "Vec<[_; ENC_BUCKET_BYTES]>")]
    pub etable: Vec<[u8; ENC_BUCKET_BYTES]>,
}

#[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 test_today(days: i64) -> u32 {
    let naive_now_plus = (Utc::now() + Duration::days(days)).date_naive();
    JulianDay::from(naive_now_plus).inner().try_into().unwrap()
}


//pub const MAX_LEVEL: usize = 4;
//pub const LEVEL_INTERVAL: [u32; MAX_LEVEL + 1] = [0, 14, 28, 56, 84];
fn calc_test_days(lox_cred: &Lox) -> Result<i64, ProofError> {
    let trust_level: i64 = match scalar_u32(&lox_cred.trust_level) {
        Some(v) => v as i64,
        None => return Err(ProofError::VerificationFailure),
            };
    let mut total = 31;
   // for level in 0..trust_level {
  //      let level_interval: u32 = LEVEL_INTERVAL[trust_level as usize];
  //     total += level_interval;
        total += trust_level*85;
  //  }
    Ok(total)
    }

#[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: {}",
        test_today(31)
    ));
    let tp_result =
        //CHANGE add_today(31) to today() for production
        match trust_promotion::request(&lox_cred.lox_credential, &pubkeys.lox_pub, test_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, encrypted_table: 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 (id, key) = from_scalar(lox_cred.bucket).unwrap();
    let enc_buckets: EncBridgeTable = serde_json::from_str(&encrypted_table).unwrap();
    let bucket = BridgeTable::decrypt_bucket(id, &key, &enc_buckets.etable[id as usize]).unwrap();
    let reach_cred = bucket.1.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
    // decrypt trust level and use to calculate the correct date for now
        // The trust level has to be at least 1

    let test_cumulative_days = match calc_test_days(&lox_cred) {
        Ok(v) => v,
        Err(e) => {
            log(&format!("Error: {:?}", e.to_string()));
            return Err(JsValue::from(e.to_string()));
        }
    };

    log(&format!(
        "TEST ONLY: Add 31 (open invitation) + Trust Level*85 days to today's date: {}",  test_today(test_cumulative_days)
    ));
    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, test_today(test_cumulative_days)) {
            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()
}