use std::fmt;

#[derive(Debug, Clone)]
pub enum Discounting {
    MinusFifteen,
    MinusTen,
    MinusFive,
    Zero,
    Five,
    Ten,
    Fifteen,
    Twenty,
    TwentyFive,
    Thirty,
    ThirtyFive,
    Forty,
    FortyFive,
    Fifty,
    FiftyFive,
    Sixty,
    SixtyFive,
    Seventy,
    SeventyFive,
    Eighty,
    EightyFive,
    Ninety,
    NinetyFive,
    NinetyNine,
}


impl Discounting {

    fn new(x:i64)->Discounting {
        match x {
          // !! shouldn't you have your MinusXX here?
            0  => Discounting::Zero,
            5  => Discounting::Five,
            10 => Discounting::Ten,
            15 => Discounting::Fifteen,
            20 => Discounting::Twenty,
            25 => Discounting::TwentyFive,
            30 => Discounting::Thirty,
            35 => Discounting::ThirtyFive,
            40 => Discounting::Forty,
            45 => Discounting::FortyFive,
            50 => Discounting::Fifty,
            55 => Discounting::FiftyFive,
            60 => Discounting::Sixty,
            65 => Discounting::SixtyFive,
            70 => Discounting::Seventy,
            75 => Discounting::SeventyFive,
            80 => Discounting::Eighty,
            _  => Discounting::SixtyFive,
        }
    }

    fn to_i64(&self)->i64 {
        match *self {
            Discounting::MinusFifteen => -15,
            Discounting::MinusTen => -10,
            Discounting::MinusFive => -5,
            Discounting::Zero => 0,
            Discounting::Five => 5,
            Discounting::Ten => 10,
            Discounting::Fifteen => 15,
            Discounting::Twenty => 20,
            Discounting::TwentyFive => 25,
            Discounting::Thirty => 30,
            Discounting::ThirtyFive => 35,
            Discounting::Forty => 40,
            Discounting::FortyFive => 45,
            Discounting::Fifty => 50,
            Discounting::FiftyFive => 55,
            Discounting::Sixty => 60,
            Discounting::SixtyFive => 65,
            Discounting::Seventy => 70,
            Discounting::SeventyFive => 75,
            Discounting::Eighty => 80,
            _ => 65
        }
    }
}


impl<'de> serde::Deserialize<'de> for Discounting {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct DiscountingVisitor;
        impl<'de> serde::de::Visitor<'de> for DiscountingVisitor {
            type Value = Discounting;
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                println!("here1");
                formatter.write_str(
                    r#"an integer with one of these values: -15, -10, -5, 0,
                5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80"#,
                )
            }
            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    -15 => Ok(Discounting::MinusFifteen),
                    -10 => Ok(Discounting::MinusTen),
                    -5 => Ok(Discounting::MinusFive),
                    _ => Ok(Discounting::SixtyFive),
                }
            }
            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(Discounting::new(value as i64))
            }
        }
        deserializer.deserialize_i64(DiscountingVisitor)
    }
}

impl serde::Serialize for Discounting {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_i64(self.to_i64())
    }
}