use cardano_message_signing as ms;
use cardano_multiplatform_lib::address::Address;
use cardano_multiplatform_lib::crypto::Ed25519Signature;
use cardano_multiplatform_lib::crypto::PublicKey;
use cardano_multiplatform_lib::{
    address::{BaseAddress, StakeCredential},
    error::JsError,
};
use ms::utils::{FromBytes, ToBytes};
use serde::{Deserialize, Serialize};
use std::str;
use wasm_bindgen::prelude::wasm_bindgen;

/**
 *   signature:  COSESign1 bytes
 *   key: COSEKey hex bytes
 */
#[wasm_bindgen]
#[derive(Serialize, Deserialize)]
pub struct DataSignature {
    signature: Vec<u8>, //COSESign1 bytes
    key: Vec<u8>,       //COSEKey bytes
}

#[wasm_bindgen]
impl DataSignature {
    pub fn new(cose_signature: &[u8], cose_key: &[u8]) -> Self {
        Self {
            signature: cose_signature.to_vec(),
            key: cose_key.to_vec(),
        }
    }
    pub fn signature(&self) -> Vec<u8> {
        self.signature.clone()
    }
    pub fn key(&self) -> Vec<u8> {
        self.key.clone()
    }
}

#[wasm_bindgen]
#[derive(Serialize, Deserialize)]
pub struct VerifyResponse {
    error: String,
    is_valid: bool,
}

#[wasm_bindgen]
impl VerifyResponse {
    pub fn new(error: &str, valid: bool) -> Self {
        Self {
            error: error.to_string(),
            is_valid: valid,
        }
    }
    pub fn error(&self) -> String {
        self.error.clone()
    }
    pub fn is_valid(&self) -> bool {
        self.is_valid.clone()
    }
}

/**
 *  **Verify data signed according to CIP-008**
 *   returns ->
 *   VerifyResponse {
 *       error: String,
 *       is_valid: bool,
 *   }
 */
#[wasm_bindgen]
pub fn verify_data_signature(
    dt: DataSignature,
    expected_message: &str,
    expected_address_bech32: &str,
) -> VerifyResponse {
    let sign_res = verify_data_signature_cip008(dt, expected_message, expected_address_bech32);
    match sign_res {
        Ok(val) => VerifyResponse::new("", val),
        Err(er) => VerifyResponse::new(
            &er.as_string()
                .unwrap_or("Failed to verify data signature.".to_string()),
            false,
        ),
    }
}

/**
 *  **Verify data signed according to CIP-008**
 *   returns ->
 *    bool or error message
 */
pub fn verify_data_signature_cip008(
    dt: DataSignature,
    expected_message: &str,
    expected_address_bech32: &str,
) -> Result<bool, JsError> {
    let cose_sign1 = ms::COSESign1::from_bytes(dt.signature).unwrap();

    let payload_to_verify_opt = cose_sign1.payload();

    if payload_to_verify_opt.is_none() {
        return Ok(false);
    }

    let payload_to_verify = payload_to_verify_opt.unwrap();

    let payload_text = str::from_utf8(&payload_to_verify).unwrap_or_else(|_| "DEFAULT");

    if expected_message != payload_text {
        return Ok(false);
    }

    let headers_to_verify = cose_sign1.headers();

    let header_addr_val = headers_to_verify
        .protected()
        .deserialized_headers()
        .header(&ms::Label::new_text("address".to_string()))
        .unwrap()
        .to_bytes();

    let cbor_val_address = ms::cbor::CBORValue::from_bytes(header_addr_val)
        .unwrap()
        .as_bytes()
        .unwrap();

    let address_res = Address::from_bytes(cbor_val_address);

    if address_res.is_err() {
        return Err(JsError::from_str("Failed parsing address from header"));
    }

    let cose_key = ms::COSEKey::from_bytes(dt.key).unwrap();

    let pk = PublicKey::from_bytes(
        &cose_key
            .header(&ms::Label::new_int(&ms::utils::Int::new_negative(
                ms::utils::BigNum::from_str("2").unwrap(),
            )))
            .unwrap()
            .as_bytes()
            .unwrap(),
    )
    .unwrap();

    let is_address_valid =
        verify_signing_address(expected_address_bech32, address_res.unwrap(), &pk);

    if is_address_valid.is_err() || !is_address_valid.unwrap() {
        return Ok(false);
    }

    let signed_data = cose_sign1.signed_data(None, None).unwrap().to_bytes();
    let sig = Ed25519Signature::from_bytes(cose_sign1.signature()).unwrap();

    if pk.verify(&signed_data, &sig) {
        Ok(true)
    } else {
        Ok(false)
    }
}

/**
 *  **Verify signing address, needs to be full base address**
 *   returns ->
 *    Result<bool or error message>
 */

pub fn verify_signing_address(
    expected_address_bech32: &str,
    coseheader_address: Address,
    cose_pubkey: &PublicKey,
) -> Result<bool, JsError> {
    let expected_address = Address::from_bech32(expected_address_bech32)?;
    if coseheader_address.to_bech32(None)? != expected_address.to_bech32(None)? {
        return Ok(false);
    }

    // check if BaseAddress
    let base_address = BaseAddress::from_address(&coseheader_address);

    if base_address.is_none() {
        return Err(JsError::from_str("Signing address is not base address."));
    }

    //reconstruct address
    let payment_key_hash = cose_pubkey.hash();
    let stake_key_hash_opt = base_address.unwrap().stake_cred().to_keyhash();

    if stake_key_hash_opt.is_none() {
        return Err(JsError::from_str("Address doesn't have stake credential."));
    }

    let reconstructed_address = BaseAddress::new(
        expected_address.network_id()?,
        &StakeCredential::from_keyhash(&payment_key_hash),
        &StakeCredential::from_keyhash(&stake_key_hash_opt.unwrap()),
    );
    if expected_address.to_bech32(None)? == reconstructed_address.to_address().to_bech32(None)? {
        return Ok(true);
    }
    return Ok(false);
}


#[derive(Serialize, Deserialize)]
#[wasm_bindgen]
pub struct CustomClaim {
    user_id: String,
    address: String,
}

#[wasm_bindgen]
impl CustomClaim {
    pub fn new(user_id: &str, address: &str) -> Self {
        Self {
            user_id: user_id.to_string(),
            address: address.to_string(),
        }
    }
    pub fn user_id(&self) -> String {
        self.user_id.clone()
    }
    pub fn address(&self) -> String {
        self.address.clone()
    }
}



/**
 *  **Verify data signed according to CIP-30**
 *   returns ->
 *   VerifyResponse {
 *       error: String,
 *       is_valid: bool,
 *   }
 */
#[wasm_bindgen]
pub fn verify_data_signature_new(
    dt: DataSignature,
    expected_message: &str,
    expected_address_bech32: &str,
) -> VerifyResponse {
    let sign_res = verify_data_signature_cip30(dt, expected_message, expected_address_bech32);
    match sign_res {
        Ok(val) => VerifyResponse::new("", val),
        Err(er) => VerifyResponse::new(
            &er.as_string()
                .unwrap_or("Failed to verify data signature.".to_string()),
            false,
        ),
    }
}

/**
 *  **Verify data signed according to CIP-30**
 *   returns ->
 *    bool or error message
 */
pub fn verify_data_signature_cip30(
    dt: DataSignature,
    expected_message: &str,
    expected_address_bech32: &str,
) -> Result<bool, JsError> {
    let cose_sign1 = ms::COSESign1::from_bytes(dt.signature).unwrap();

    let payload_to_verify_opt = cose_sign1.payload();

    if payload_to_verify_opt.is_none() {
        return Ok(false);
    }

    let payload_to_verify = payload_to_verify_opt.unwrap();

    let payload_text = str::from_utf8(&payload_to_verify).unwrap_or_else(|_| "DEFAULT");

    if expected_message != payload_text {
        return Ok(false);
    }

    let cose_key = ms::COSEKey::from_bytes(dt.key).unwrap();

    let pk = PublicKey::from_bytes(
        &cose_key
            .header(&ms::Label::new_int(&ms::utils::Int::new_negative(
                ms::utils::BigNum::from_str("2").unwrap(),
            )))
            .unwrap()
            .as_bytes()
            .unwrap(),
    )
    .unwrap();

    let is_address_valid =
        verify_signing_address_new(expected_address_bech32, &pk);

    if is_address_valid.is_err() || !is_address_valid.unwrap() {
        return Ok(false);
    }

    let signed_data = cose_sign1.signed_data(None, None).unwrap().to_bytes();
    let sig = Ed25519Signature::from_bytes(cose_sign1.signature()).unwrap();

    if pk.verify(&signed_data, &sig) {
        Ok(true)
    } else {
        Ok(false)
    }
}

/**
 *  **Verify signing address, needs to be full base address**
 *   returns ->
 *    Result ( bool or error message )
 */
pub fn verify_signing_address_new(
    expected_address_bech32: &str,
    cose_pubkey: &PublicKey,
) -> Result<bool, JsError> {
    let expected_pubkeyhash = Address::from_bech32(expected_address_bech32)?
            .staking_cred().expect("Address doesn't have staking credential")
            .to_keyhash().expect("We couldn't create keyhash from staking credential")
            .to_hex();

    let stake_key_hash = cose_pubkey.hash().to_hex();
    if expected_pubkeyhash == stake_key_hash {
        return Ok(true);
    }
    return Ok(false);
}