pub mod agent;
pub mod error;
pub mod host;
pub mod id;
pub mod interface;

use std::time::{Duration, SystemTime};

use agent::{AgentInfo, AgentStatus};
use chrono::DateTime;
use id::agent_uuid;
use interface::{NetInterface, NetInterfaceAddr};
use mac_address::mac_address_by_name;
use network_interface::{NetworkInterface, NetworkInterfaceConfig};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::host::HostInfo;
use crate::id::{host_uuid, interface_addr_uuid, interface_uuid};

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub struct Heartbeat {
    /// Heartbeat type
    pub hb_type: HeartbeatType,
    /// Current timestamp
    pub timestamp: DateTime<chrono::Utc>,
    /// UUID (v4) of this heartbeat
    pub hb_uuid: Uuid,
    /// Payload
    pub payload: Vec<HeartbeatPayload>,
}

impl Heartbeat {
    pub fn new(
        hb_type: HeartbeatType,
        name: String,
        agent_status: Option<AgentStatus>,
    ) -> Heartbeat {
        let status = match agent_status {
            Some(s) => s,
            None => AgentStatus::Undefined,
        };
        let host_info = HostInfo::new();
        let mut hb = Heartbeat {
            hb_type,
            timestamp: DateTime::from(SystemTime::now()),
            hb_uuid: Uuid::new_v4(),
            payload: vec![
                HeartbeatPayload::AgentInfo(AgentInfo {
                    host_uuid: host_info.host_uuid,
                    uuid: agent_uuid(&host_info.host_uuid, &name),
                    name,
                    status,
                }),
                HeartbeatPayload::HostInfo(host_info.clone()),
                HeartbeatPayload::BuildInfo(BuildInfo::new()),
            ],
        };
        match NetworkInterface::show() {
            Ok(network_interfaces) => {
                for itf in network_interfaces.iter() {
                    println!("{:?}", itf);
                    match mac_address_by_name(&itf.name) {
                        Ok(maybe_mac_address) => {
                            if let Some(mac_address) = maybe_mac_address {
                                let ni_info = NetInterface {
                                    host_uuid: host_info.host_uuid,
                                    uuid: interface_uuid(&host_info.host_uuid, mac_address),
                                    name: itf.name.clone(),
                                    mac_addr: mac_address,
                                };
                                hb.payload
                                    .push(HeartbeatPayload::NetInterface(ni_info.clone()));
                                for a in itf.addr.iter() {
                                    let nia_info = NetInterfaceAddr {
                                        iface_uuid: ni_info.uuid,
                                        uuid: interface_addr_uuid(&ni_info.uuid, a.ip()),
                                        ip_addr: a.ip(),
                                        active: true,
                                    };
                                    hb.payload
                                        .push(HeartbeatPayload::NetInterfaceAddr(nia_info));
                                }
                            } else {
                                eprintln!("Interface {:?} has an empty MAC address, skipping for now (open issue)", itf);
                            }
                        }
                        Err(_) => {
                            eprintln!("Interface {:?} produced an error retrieving the MAC address, skipping for now (open issue)", itf);
                        }
                    };
                }
            }
            Err(_) => {
                eprintln!("Could not retrieve network interfaces");
            }
        };
        hb
        // //let mut ni_info = NetInterfaceInfo::new();
        // for (if_name, ip_addr) in network_interfaces.iter() {
        //     let mut found_if = false;
        //     for ifs in ni_info.interfaces.iter_mut() {
        //         // the interface is known
        //         if ifs.if_name.eq(if_name) {
        //             found_if = true;
        //             // the address is not stored yet
        //             if !ifs.ip_addr.contains(ip_addr) {
        //                 // store address
        //                 ifs.ip_addr.push(*ip_addr);
        //             }
        //         };
        //     }
        //     if !found_if {
        //         // we had no interface matches
        //         ni_info.interfaces.push(NetInterfaceId {
        //             machine_id: get_secure_machine_id(None).unwrap(),
        //             if_name: if_name.clone(),
        //             ip_addr: vec![*ip_addr],
        //         })
        //     }
        // }
    }
    pub fn compact(payload: Vec<HeartbeatPayloadType>) -> Heartbeat {
        let mut hb = Heartbeat {
            hb_type: HeartbeatType::Compact,
            timestamp: DateTime::from(SystemTime::now()),
            hb_uuid: Uuid::new_v4(),
            payload: vec![],
        };
        for p in payload.iter() {
            hb.payload.push(p.to_payload())
        }
        hb
    }
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub enum HeartbeatPayloadType {
    AgentInfo(AgentStatus, String),
    HostInfo,
    BuildInfo,
    NetInterface(NetInterface),
    NetInterfaceAddr(NetInterfaceAddr),
}
impl HeartbeatPayloadType {
    pub fn to_payload(&self) -> HeartbeatPayload {
        match self {
            HeartbeatPayloadType::AgentInfo(status, name) => {
                HeartbeatPayload::AgentInfo(AgentInfo {
                    status: status.to_owned(),
                    name: name.to_string(),
                    host_uuid: host_uuid().unwrap(),
                    uuid: agent_uuid(&host_uuid().unwrap(), name),
                })
            }
            HeartbeatPayloadType::HostInfo => HeartbeatPayload::HostInfo(HostInfo::new()),
            HeartbeatPayloadType::BuildInfo => HeartbeatPayload::BuildInfo(BuildInfo::new()),
            HeartbeatPayloadType::NetInterface(ni) => HeartbeatPayload::NetInterface(ni.clone()),
            HeartbeatPayloadType::NetInterfaceAddr(nia) => {
                HeartbeatPayload::NetInterfaceAddr(nia.clone())
            }
        }
    }
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub enum HeartbeatPayload {
    AgentInfo(AgentInfo),
    HostInfo(HostInfo),
    BuildInfo(BuildInfo),
    NetInterface(NetInterface),
    NetInterfaceAddr(NetInterfaceAddr),
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub enum HeartbeatType {
    /// A full heartbeat contains information in all data structures
    Full,
    /// A compact heartbeat contains a minimal amount of information,
    /// indicating that information is unchanged compared to the previous heartbeat.
    Compact,
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub struct BuildInfo {
    // TODO: Include API crate version here
    // See: https://linear.app/netzwork/issue/NET-31/api-include-api-crate-version-in-the-buildinfo-struct
    build_timestamp: String,
    build_date: String,
    git_branch: String,
    git_timestamp: String,
    git_date: String,
    git_hash: String,
    git_describe: String,
    rustc_host_triple: String,
    rustc_version: String,
    cargo_target_triple: String,
}

impl BuildInfo {
    fn new() -> BuildInfo {
        BuildInfo {
            build_timestamp: String::from(env!("VERGEN_BUILD_TIMESTAMP")),
            build_date: String::from(env!("VERGEN_BUILD_DATE")),
            git_branch: String::from(env!("VERGEN_GIT_BRANCH")),
            git_timestamp: String::from(env!("VERGEN_GIT_COMMIT_TIMESTAMP")),
            git_date: String::from(env!("VERGEN_GIT_COMMIT_DATE")),
            git_hash: String::from(env!("VERGEN_GIT_SHA")),
            git_describe: String::from(env!("VERGEN_GIT_DESCRIBE")),
            rustc_host_triple: String::from(env!("VERGEN_RUSTC_HOST_TRIPLE")),
            rustc_version: String::from(env!("VERGEN_RUSTC_SEMVER")),
            cargo_target_triple: String::from(env!("VERGEN_CARGO_TARGET_TRIPLE")),
        }
    }
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
pub struct ConnectivityMeasurementSample {
    timestamp: SystemTime,
    rtt: Duration,
    fingerprint: [u8; 32],
}

// #[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
// pub struct NetInterfaceConnectivityMeasurement {
//     interface: NetInterfaceId,
//     remote_socket: SocketAddr,
//     samples: Vec<ConnectivityMeasurementSample>,
// }
//
// #[derive(Debug, PartialEq, Deserialize, Serialize, Clone)]
// pub struct NetInterfaceInfo {
//     pub interfaces: Vec<NetInterfaceId>,
//     pub measurements: Vec<NetInterfaceConnectivityMeasurement>,
// }
// impl NetInterfaceInfo {
//     pub fn new() -> NetInterfaceInfo {
//         NetInterfaceInfo {
//             interfaces: vec![],
//             measurements: vec![],
//         }
//     }
//
//     pub fn from_network_interfaces() -> Result<NetInterfaceInfo, local_ip_address::Error> {
//         let network_interfaces = list_afinet_netifas()?;
//         let mut ni_info = NetInterfaceInfo::new();
//         for (if_name, ip_addr) in network_interfaces.iter() {
//             let mut found_if = false;
//             for ifs in ni_info.interfaces.iter_mut() {
//                 // the interface is known
//                 if ifs.if_name.eq(if_name) {
//                     found_if = true;
//                     // the address is not stored yet
//                     if !ifs.ip_addr.contains(ip_addr) {
//                         // store address
//                         ifs.ip_addr.push(*ip_addr);
//                     }
//                 };
//             }
//             if !found_if {
//                 // we had no interface matches
//                 ni_info.interfaces.push(NetInterfaceId {
//                     machine_id: get_secure_machine_id(None).unwrap(),
//                     if_name: if_name.clone(),
//                     ip_addr: vec![*ip_addr],
//                 })
//             }
//         }
//         Ok(ni_info)
//     }
// }
// impl Default for NetInterfaceInfo {
//     fn default() -> Self {
//         Self::new()
//     }
// }