#[derive(Debug, Clone)]
pub enum Flow {
    Password,
}

impl serde::Serialize for Flow {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(match self {
            Flow::Password => "m.login.password",
        })
    }
}

impl<'de> serde::Deserialize<'de> for Flow {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct FlowVisitor;

        impl<'de> serde::de::Visitor<'de> for FlowVisitor {
            type Value = Flow;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("Flow")
            }

            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match v {
                    "m.login.password" => Ok(Flow::Password),
                    _ => Err(serde::de::Error::custom("Unknown flow")),
                }
            }
        }

        deserializer.deserialize_str(FlowVisitor {})
    }
}