use chrono::prelude::*;
use git_testament::{git_testament, render_testament};
use serde::Serialize;

git_testament!(TESTAMENT);

#[derive(Debug, Serialize)]
pub struct SuiteMeasurements {
    measurements: Vec<OpMeasurements>,
    obnam_version: String,
    obnam_benchmark_version: String,
    benchmark_started: String,
    hostname: String,
    host_cpus: usize,
    host_ram: u64,
}

#[derive(Debug, Serialize)]
pub struct OpMeasurements {
    benchmark: String,
    op: Operation,
    measurements: Vec<Measurement>,
}

#[derive(Debug, Serialize)]
pub enum Measurement {
    TotalFiles(u64),
    TotalData(u64),
    DurationMs(u128),
}

#[derive(Debug, Clone, Copy, Serialize)]
pub enum Operation {
    Start,
    Stop,
    Create,
    Rename,
    Delete,
    Backup,
    Restore,
    ManifestLive,
    ManifestRestored,
    CompareManiests,
}

#[derive(Debug, thiserror::Error)]
pub enum SuiteMeasurementsError {
    #[error("failed to get CPU info: {0}")]
    CpuInfo(procfs::ProcError),

    #[error("failed to get RAM info: {0}")]
    MemInfo(procfs::ProcError),

    #[error("failed to get hostname: {0}")]
    Hostname(nix::Error),
}

impl SuiteMeasurements {
    pub fn new(obnam_version: String) -> Result<Self, SuiteMeasurementsError> {
        let cpu = procfs::CpuInfo::new().map_err(SuiteMeasurementsError::CpuInfo)?;
        let mem = procfs::Meminfo::new().map_err(SuiteMeasurementsError::MemInfo)?;
        let mut buf = [0u8; 1024];
        let hostname =
            nix::unistd::gethostname(&mut buf).map_err(SuiteMeasurementsError::Hostname)?;
        let hostname = hostname.to_string_lossy();
        Ok(Self {
            measurements: vec![],
            obnam_version,
            obnam_benchmark_version: render_testament!(TESTAMENT),
            benchmark_started: Utc::now().to_string(),
            hostname: hostname.to_string(),
            host_ram: mem.mem_total,
            host_cpus: cpu.num_cores(),
        })
    }

    pub fn push(&mut self, m: OpMeasurements) {
        self.measurements.push(m);
    }
}

impl OpMeasurements {
    pub fn new(benchmark: &str, op: Operation) -> Self {
        let benchmark = benchmark.to_string();
        Self {
            benchmark,
            op,
            measurements: vec![],
        }
    }

    pub fn push(&mut self, m: Measurement) {
        self.measurements.push(m);
    }
}