pub mod client;
pub mod server;
use crate::{datastore::NodeInfo, NodeUpdate};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

pub mod challenge {
    tonic::include_proto!("challenge");
}

impl From<(String, NodeInfo)> for NodeUpdate {
    fn from((ip, info): (String, NodeInfo)) -> Self {
        Self {
            ip,
            started_at: Some(prost_types::Timestamp::from(info.started_at)),
            keepalive: Some(prost_types::Timestamp::from(info.keepalive)),
            mint_requests: info.mint_requests,
            mints: info.mints,
            mratls_conns: info.mratls_conns,
            quote_attacks: info.net_attacks,
            public: info.public,
            restarts: info.restarts,
            disk_attacks: info.disk_attacks,
        }
    }
}

impl From<NodeUpdate> for (String, NodeInfo) {
    fn from(upd: NodeUpdate) -> (String, NodeInfo) {
        let ip = upd.ip;
        let started_at: SystemTime = grpc_timestamp_to_systemtime(upd.started_at);
        let keepalive: SystemTime = grpc_timestamp_to_systemtime(upd.keepalive);
        let self_info = NodeInfo {
            started_at,
            keepalive,
            mint_requests: upd.mint_requests,
            mints: upd.mints,
            mratls_conns: upd.mratls_conns,
            net_attacks: upd.quote_attacks,
            public: upd.public,
            restarts: upd.restarts,
            disk_attacks: upd.disk_attacks,
        };
        (ip, self_info)
    }
}

fn grpc_timestamp_to_systemtime(ts: Option<prost_types::Timestamp>) -> SystemTime {
    if let Some(ts) = ts {
        let duration = Duration::new(ts.seconds as u64, ts.nanos as u32);
        UNIX_EPOCH.checked_add(duration).unwrap_or(SystemTime::now())
    } else {
        println!("Timestamp is None");
        SystemTime::now()
    }
}

#[derive(Clone, PartialEq)]
pub struct InternalNodeUpdate {
    pub sender_ip: String,
    pub update: NodeUpdate,
}

impl From<(String, NodeInfo)> for InternalNodeUpdate {
    fn from((ip, info): (String, NodeInfo)) -> Self {
        Self { sender_ip: ip.clone(), update: (ip, info).into() }
    }
}

impl From<(String, NodeUpdate)> for InternalNodeUpdate {
    fn from((ip, update): (String, NodeUpdate)) -> Self {
        Self { sender_ip: ip, update }
    }
}