margins.rs

use std::str::FromStr;

use crate::primitives::NonBlankString;
use derivative::Derivative;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

editoast_common::schemas! {
    Margins,
    MarginValue,
}

#[derive(Debug, Clone, Serialize, Derivative, ToSchema)]
#[serde(deny_unknown_fields)]
#[derivative(Default)]
pub struct Margins {
    #[schema(inline)]
    pub boundaries: Vec<NonBlankString>,
    #[derivative(Default(value = "vec![MarginValue::None]"))]
    /// The values of the margins. Must contains one more element than the boundaries
    /// Can be a percentage `X%`, a time in minutes per kilometer `Xmin/km` or `none`
    #[schema(value_type = Vec<String>, example = json!(["none", "5%", "2min/km"]))]
    pub values: Vec<MarginValue>,
}

impl<'de> Deserialize<'de> for Margins {
    fn deserialize<D>(deserializer: D) -> Result<Margins, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct InternalMargins {
            boundaries: Vec<NonBlankString>,
            values: Vec<MarginValue>,
        }

        let InternalMargins { boundaries, values } = InternalMargins::deserialize(deserializer)?;
        if boundaries.len() + 1 != values.len() {
            return Err(serde::de::Error::custom(
                "It's expected to have one more value than boundaries",
            ));
        }
        Ok(Margins { boundaries, values })
    }
}

#[derive(Debug, Copy, Clone, Default, PartialEq, Derivative, ToSchema)]
#[derivative(Hash)]
pub enum MarginValue {
    #[default]
    None,
    Percentage(#[derivative(Hash(hash_with = "editoast_common::hash_float::<3,_>"))] f64),
    MinPerKm(#[derivative(Hash(hash_with = "editoast_common::hash_float::<3,_>"))] f64),
}

impl<'de> Deserialize<'de> for MarginValue {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let value = String::deserialize(deserializer)?;
        if value.to_lowercase() == "none" {
            return Ok(Self::None);
        }
        if value.ends_with('%') {
            let float_value = f64::from_str(value[0..value.len() - 1].trim()).map_err(|_| {
                serde::de::Error::invalid_value(
                    serde::de::Unexpected::Str(&value),
                    &"a valid float",
                )
            })?;
            if float_value <= 0.0 {
                return Err(serde::de::Error::invalid_value(
                    serde::de::Unexpected::Str(&value),
                    &"a strictly positive number",
                ));
            }
            return Ok(Self::Percentage(float_value));
        }
        if value.ends_with("min/km") {
            let float_value: f64 =
                f64::from_str(value[0..value.len() - 6].trim()).map_err(|_| {
                    serde::de::Error::invalid_value(
                        serde::de::Unexpected::Str(&value),
                        &"a valid float",
                    )
                })?;
            if float_value <= 0.0 {
                return Err(serde::de::Error::invalid_value(
                    serde::de::Unexpected::Str(&value),
                    &"a strictly positive float",
                ));
            }
            return Ok(Self::MinPerKm(float_value));
        }
        Err(serde::de::Error::custom("Margin type not recognized"))
    }
}

impl Serialize for MarginValue {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            MarginValue::None => serializer.serialize_str("none"),
            MarginValue::Percentage(value) => serializer.serialize_str(&format!("{}%", value)),
            MarginValue::MinPerKm(value) => serializer.serialize_str(&format!("{}min/km", value)),
        }
    }
}

#[cfg(test)]
mod tests {
    use serde_json::from_str;
    use serde_json::to_string;

    use crate::train_schedule::MarginValue;
    use crate::train_schedule::Margins;

    /// Test that the `MarginValue` enum can be deserialized from a string
    #[test]
    fn deserialize_margin_value() {
        let none: MarginValue = from_str(r#""none""#).unwrap();
        assert_eq!(none, MarginValue::None);

        let percentage: MarginValue = from_str(r#""10%""#).unwrap();
        assert_eq!(percentage, MarginValue::Percentage(10.0));

        let min_per_km: MarginValue = from_str(r#""5.3min/km""#).unwrap();
        assert_eq!(min_per_km, MarginValue::MinPerKm(5.3));
    }

    /// Test invalid `MarginValue` deserialization
    #[test]
    fn deserialize_invalid_margin_value() {
        assert!(from_str::<MarginValue>(r#""3.5""#).is_err());
        assert!(from_str::<MarginValue>(r#""-5%""#).is_err());
        assert!(from_str::<MarginValue>(r#""-0.4min/km""#).is_err());
    }

    /// Test that the `MarginValue` enum can be serialized to a string
    #[test]
    fn serialize_margin_value() {
        let none = to_string(&MarginValue::None).unwrap();
        assert_eq!(none, r#""none""#);

        let percentage = to_string(&MarginValue::Percentage(10.0)).unwrap();
        assert_eq!(percentage, r#""10%""#);

        let min_per_km = to_string(&MarginValue::MinPerKm(5.3)).unwrap();
        assert_eq!(min_per_km, r#""5.3min/km""#);
    }

    /// Test that Margins deserialization checks works
    #[test]
    fn deserialize_margins() {
        let valid_margins = r#"{"boundaries":["a", "b"],"values":["none","10%","20min/km"]}"#;
        assert!(from_str::<Margins>(valid_margins).is_ok());
        let invalid_margins = r#"{"boundaries":["a"],"values":["none","10%","20min/km"]}"#;
        assert!(from_str::<Margins>(invalid_margins).is_err());
        let invalid_margins = r#"{"boundaries":["a", "b"],"values":["none","10%"]}"#;
        assert!(from_str::<Margins>(invalid_margins).is_err());
    }
}