use serde::{Deserialize, Serialize};
use sp_client::bitcoin::OutPoint;
use std::collections::HashMap;
use crate::{pcd::Member, process::Process};

#[derive(Debug, Serialize, Deserialize)]
pub struct OutPointMemberMap(#[serde(with = "members_map")] pub HashMap<OutPoint, Member>);

#[derive(Debug, Serialize, Deserialize)]
pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>);

pub mod members_map {
    use crate::pcd::Member;
    use serde::{Serialize, Serializer, Deserialize, Deserializer};
    use std::collections::HashMap;
    use sp_client::bitcoin::OutPoint;

    pub fn serialize<S>(
        map: &HashMap<OutPoint, Member>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let map: HashMap<OutPoint, Member> = map
            .iter()
            .map(|(k, v)| (*k, v.to_owned()))
            .collect();
        map.serialize(serializer)
    }

    pub fn deserialize<'de, D>(
        deserializer: D,
    ) -> Result<HashMap<OutPoint, Member>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let map: HashMap<OutPoint, Member> = HashMap::deserialize(deserializer)?;

        Ok(map)
    }
}

pub mod outpoint_map {
    use serde::{Serialize, Serializer, Deserialize, Deserializer};
    use std::collections::HashMap;
    use sp_client::bitcoin::OutPoint;
    use crate::process::Process;

    pub fn serialize<S>(
        map: &HashMap<OutPoint, Process>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Convert OutPoint keys to Strings
        let map: HashMap<String, Process> = map
            .into_iter()
            .map(|(k, v)| (k.to_string(), v.clone()))
            .collect();

        // Serialize as HashMap<String, Process>
        map.serialize(serializer)
    }

    pub fn deserialize<'de, D>(
        deserializer: D,
    ) -> Result<HashMap<OutPoint, Process>, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Deserialize as HashMap<String, Process>
        let map: HashMap<String, Process> = HashMap::deserialize(deserializer)?;

        // Convert String keys back to OutPoint
        let result: Result<HashMap<OutPoint, Process>, D::Error> = map
            .into_iter()
            .map(|(k, v)| {
                let outpoint = k
                    .parse() 
                    .map_err(serde::de::Error::custom)?;
                Ok((outpoint, v))
            })
            .collect();

        result
    }
}