roundabout

use std::{fmt, str::FromStr, time::Duration};

use serde::{Deserialize, Deserializer, Serialize, Serializer, de};

const KIB: u64 = 1024;

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]

pub struct Bytes(pub u64);

impl Bytes {

    pub const ZERO: Self = Self(0);

    pub const fn gib(n: u64) -> Self {

        Self(n * KIB * KIB * KIB)

    }

    pub const fn mib(n: u64) -> Self {

        Self(n * KIB * KIB)

    }

    pub const fn saturating_sub(self, other: Self) -> Self {

        Self(self.0.saturating_sub(other.0))

    }

}

impl std::ops::Add for Bytes {

    type Output = Self;

    fn add(self, other: Self) -> Self {

        Self(self.0.saturating_add(other.0))

    }

}

impl std::ops::AddAssign for Bytes {

    fn add_assign(&mut self, other: Self) {

        *self = *self + other;

    }

}

impl std::iter::Sum for Bytes {

    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {

        iter.fold(Self::ZERO, |a, b| a + b)

    }

}

fn split_number(s: &str) -> Result<(f64, &str), &'static str> {

    let s = s.trim();

    let end = s

        .find(|c: char| !(c.is_ascii_digit() || c == '.'))

        .unwrap_or(s.len());

    let (num, suffix) = s.split_at(end);

    let num = num.parse::<f64>().map_err(|_| "expected a number")?;

    if !num.is_finite() || num < 0.0 {

        return Err("expected a non-negative number");

    }

    Ok((num, suffix.trim()))

}

impl FromStr for Bytes {

    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        let (num, suffix) = split_number(s)?;

        let scale = match suffix.to_ascii_lowercase().as_str() {

            "" | "b" => 1,

            "k" | "kb" | "kib" => KIB,

            "m" | "mb" | "mib" => KIB.pow(2),

            "g" | "gb" | "gib" => KIB.pow(3),

            "t" | "tb" | "tib" => KIB.pow(4),

            _ => return Err("expected a size like 512M or 4GiB"),

        };

        Ok(Self((num * scale as f64) as u64))

    }

}

impl fmt::Display for Bytes {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];

        let mut value = self.0 as f64;

        let mut unit = 0;

        while value >= 1024.0 && unit < UNITS.len() - 1 {

            value /= 1024.0;

            unit += 1;

        }

        if unit == 0 {

            write!(f, "{}B", self.0)

        } else {

            write!(f, "{value:.1}{}", UNITS[unit])

        }

    }

}

impl pound::FromArg for Bytes {

    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {

        s.parse().map_err(|e| pound::ValueError::new(s, e))

    }

}

impl Serialize for Bytes {

    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {

        s.serialize_u64(self.0)

    }

}

impl<'de> Deserialize<'de> for Bytes {

    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {

        struct V;

        impl de::Visitor<'_> for V {

            type Value = Bytes;

            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

                f.write_str("a byte count or a size string like \"4GiB\"")

            }

            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Bytes, E> {

                Ok(Bytes(v))

            }

            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Bytes, E> {

                u64::try_from(v)

                    .map(Bytes)

                    .map_err(|_| E::custom("negative size"))

            }

            fn visit_str<E: de::Error>(self, v: &str) -> Result<Bytes, E> {

                v.parse().map_err(E::custom)

            }

        }

        d.deserialize_any(V)

    }

}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]

pub struct Dur(pub Duration);

impl Dur {

    pub const fn secs(n: u64) -> Self {

        Self(Duration::from_secs(n))

    }

}

impl FromStr for Dur {

    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        let mut rest = s.trim();

        if rest.is_empty() {

            return Err("expected a duration like 90s or 5m");

        }

        let mut total = 0.0;

        while !rest.is_empty() {

            let (num, tail) = split_number(rest)?;

            let unit_len = tail

                .find(|c: char| c.is_ascii_digit() || c == '.')

                .unwrap_or(tail.len());

            let (unit, next) = tail.split_at(unit_len);

            let scale = match unit.trim() {

                "" | "s" | "sec" | "secs" => 1.0,

                "ms" => 0.001,

                "m" | "min" | "mins" => 60.0,

                "h" | "hr" | "hrs" => 3600.0,

                "d" | "day" | "days" => 86400.0,

                _ => return Err("expected a duration like 90s or 5m"),

            };

            total = num.mul_add(scale, total);

            rest = next.trim();

        }

        Ok(Self(Duration::from_secs_f64(total)))

    }

}

impl fmt::Display for Dur {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let s = self.0.as_secs();

        match s {

            0..60 => write!(f, "{s}s"),

            60..3600 if s.is_multiple_of(60) => write!(f, "{}m", s / 60),

            60..3600 => write!(f, "{}m{}s", s / 60, s % 60),

            _ if s.is_multiple_of(3600) => write!(f, "{}h", s / 3600),

            _ => write!(f, "{}h{}m", s / 3600, (s % 3600) / 60),

        }

    }

}

impl pound::FromArg for Dur {

    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {

        s.parse().map_err(|e| pound::ValueError::new(s, e))

    }

}

impl Serialize for Dur {

    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {

        s.serialize_u64(self.0.as_secs())

    }

}

impl<'de> Deserialize<'de> for Dur {

    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {

        struct V;

        impl de::Visitor<'_> for V {

            type Value = Dur;

            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

                f.write_str("seconds or a duration string like \"5m\"")

            }

            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Dur, E> {

                Ok(Dur::secs(v))

            }

            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Dur, E> {

                u64::try_from(v)

                    .map(Dur::secs)

                    .map_err(|_| E::custom("negative duration"))

            }

            fn visit_str<E: de::Error>(self, v: &str) -> Result<Dur, E> {

                v.parse().map_err(E::custom)

            }

        }

        d.deserialize_any(V)

    }

}

#[derive(Clone, Copy, Debug, PartialEq)]

pub enum Amount<T> {

    Abs(T),

    Percent(f64),

}

impl Amount<Bytes> {

    pub fn resolve(self, total: Bytes) -> Bytes {

        match self {

            Self::Abs(b) => b,

            Self::Percent(p) => Bytes((total.0 as f64 * p / 100.0) as u64),

        }

    }

}

impl Amount<u32> {

    pub fn resolve(self, total: u32) -> u32 {

        match self {

            Self::Abs(n) => n,

            Self::Percent(p) => ((f64::from(total) * p / 100.0).round() as u32).max(1),

        }

    }

}

impl<T: FromStr> FromStr for Amount<T> {

    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        if let Some(p) = s.trim().strip_suffix('%') {

            let p = p

                .trim()

                .parse::<f64>()

                .map_err(|_| "expected a percentage")?;

            if !(0.0..=100.0).contains(&p) {

                return Err("percentage must be between 0 and 100");

            }

            Ok(Self::Percent(p))

        } else {

            s.trim()

                .parse()

                .map(Self::Abs)

                .map_err(|_| "expected an amount or a percentage")

        }

    }

}

impl<T: FromStr> pound::FromArg for Amount<T> {

    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {

        s.parse().map_err(|e| pound::ValueError::new(s, e))

    }

}

impl<'de, T: FromStr> Deserialize<'de> for Amount<T> {

    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {

        struct V<T>(std::marker::PhantomData<T>);

        impl<T: FromStr> de::Visitor<'_> for V<T> {

            type Value = Amount<T>;

            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

                f.write_str("an amount or a percentage string like \"75%\"")

            }

            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Amount<T>, E> {

                self.visit_str(&v.to_string())

            }

            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Amount<T>, E> {

                self.visit_str(&v.to_string())

            }

            fn visit_str<E: de::Error>(self, v: &str) -> Result<Amount<T>, E> {

                v.parse().map_err(E::custom)

            }

        }

        d.deserialize_any(V(std::marker::PhantomData))

    }

}