use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use sp_client::bitcoin::PublicKey;
//use sp_client::silentpayments::sending::SilentPaymentAddress;
use std::marker::Copy;
use tsify::Tsify;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
#[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Copy)]
pub enum Role {
    Manager,
    #[default]
    User,
}

#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub struct SilentPaymentAddress {
    version: u8,
    scan_pubkey: PublicKey,
    m_pubkey: PublicKey,
    is_testnet: bool,
}

#[derive(Debug, Copy, Clone)]
pub struct ItemMember {
    pub role: Role,
    pub sp_address: SilentPaymentAddress,
    //pre_id: hash(password, part1)
    //shard,
    //priv_key_mainnet_spend, (enc)
    //priv_key_mainnet_scan,
    //priv_key_signet_scan,
}

impl ItemMember {
    pub fn new(role: Role, sp_address: SilentPaymentAddress) -> Self {
        ItemMember { role, sp_address }
    }
}

#[derive(Debug, Clone)]
pub struct Prdlist {
    //pub id: String,
    //pub version: String,
    pub gestionnaires: Vec<ItemMember>,
    // pub gestionnaires: Box<Vec<ItemMember>>,
}

#[derive(Serialize)]
#[wasm_bindgen]
struct RequestBody {
    message: String,
}

pub fn send_PrdRequest(prdlist: &Prdlist) -> Result<(), JsValue> {
    let managers: Vec<&ItemMember> = prdlist
        .gestionnaires
        .iter()
        .filter(|m| m.role == Role::Manager)
        .collect();
    for manager in managers {
        let request_body = RequestBody {
            message: "Asking for the Prd list".to_string(),
        };

        let json_body = serde_json::to_string(&request_body).map_err(|e| {
            JsValue::from_str(&format!("Failed to serialize request body: {:?}", e))
        })?;
        println!("Sending request to manager {:?}", manager.sp_address);
    }
    Ok(())
}