use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use tsify::Tsify;
use wasm_bindgen::prelude::*;
use std::marker::Copy;


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


#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
//use std :: marker;
//strings can't implement copy
#[wasm_bindgen]
pub struct ItemMember {
    pub role : Role, 
    pub sp_address: u32, 
    //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: u32) -> Self {
        ItemMember {role, sp_address}
    }
}

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

//auto inscription in the list (not included)
/* 
fn auto_enroll(prdlist: &mut Prdlist, role: Role, sp_address: u32) {
    let item_member = ItemMember {
        role, //just as a user 
        sp_address,
    };
    prdlist.gestionnaires.push(item_member); //not gestionnaires but users 
    
}*/ 

//fn send_transaction(prdlist: &Prdlist){}
//fn send_PrdMessage (prdlist: &Prdlist){}

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

#[wasm_bindgen]
pub async 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(())
}