use std::str::FromStr;

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

use super::VersionTriple;

impl<'de> Deserialize<'de> for VersionTriple {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_str(VersionTripleVisitor)
    }
}

struct VersionTripleVisitor;

impl Visitor<'_> for VersionTripleVisitor {
    type Value = VersionTriple;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a version string `major.minor.patch`")
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        VersionTriple::from_str(&v).map_err(serde::de::Error::custom)
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        VersionTriple::from_str(v).map_err(serde::de::Error::custom)
    }

    fn visit_borrowed_str<E>(self, v: &'_ str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        VersionTriple::from_str(v).map_err(serde::de::Error::custom)
    }
}

impl Serialize for VersionTriple {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        format!("{}.{}.{}", self.0, self.1, self.2).serialize(serializer)
    }
}