/// Decided to just go with an enum for the day. Seems a bit silly, but seemed the easiest way to do matches and translate from "1" to "One" etc without a dependency on a crate.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Day {
    One = 1,
    Two = 2,
    Three = 3,
    Four = 4,
    Five = 5,
    Six = 6,
    Seven = 7,
    Eight = 8,
    Nine = 9,
    Ten = 10,
    Eleven = 11,
    Twelve = 12,
    Thirteen = 13,
    Fourteen = 14,
    Fifteen = 15,
    Sixteen = 16,
    Seventeen = 17,
    Eighteen = 18,
    Nineteen = 19,
    Twenty = 20,
    TwentyOne = 21,
    TwentyTwo = 22,
    TwentyThree = 23,
    TwentyFour = 24,
    TwentyFive = 25,
}

impl From<Day> for u8 {
    fn from(day: Day) -> Self {
        match day {
            Day::One => 1,
            Day::Two => 2,
            Day::Three => 3,
            Day::Four => 4,
            Day::Five => 5,
            Day::Six => 6,
            Day::Seven => 7,
            Day::Eight => 8,
            Day::Nine => 9,
            Day::Ten => 10,
            Day::Eleven => 11,
            Day::Twelve => 12,
            Day::Thirteen => 13,
            Day::Fourteen => 14,
            Day::Fifteen => 15,
            Day::Sixteen => 16,
            Day::Seventeen => 17,
            Day::Eighteen => 18,
            Day::Nineteen => 19,
            Day::Twenty => 20,
            Day::TwentyOne => 21,
            Day::TwentyTwo => 22,
            Day::TwentyThree => 23,
            Day::TwentyFour => 24,
            Day::TwentyFive => 25,
        }
    }
}

impl core::fmt::Display for Day {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str(match self {
            Day::One => "One",
            Day::Two => "Two",
            Day::Three => "Three",
            Day::Four => "Four",
            Day::Five => "Five",
            Day::Six => "Six",
            Day::Seven => "Seven",
            Day::Eight => "Eight",
            Day::Nine => "Nine",
            Day::Ten => "Ten",
            Day::Eleven => "Eleven",
            Day::Twelve => "Twelve",
            Day::Thirteen => "Thirteen",
            Day::Fourteen => "Fourteen",
            Day::Fifteen => "Fifteen",
            Day::Sixteen => "Sixteen",
            Day::Seventeen => "Seventeen",
            Day::Eighteen => "Eighteen",
            Day::Nineteen => "Nineteen",
            Day::Twenty => "Twenty",
            Day::TwentyOne => "TwentyOne",
            Day::TwentyTwo => "TwentyTwo",
            Day::TwentyThree => "TwentyThree",
            Day::TwentyFour => "TwentyFour",
            Day::TwentyFive => "TwentyFive",
        })
    }
}

impl From<Day> for String {
    fn from(day: Day) -> Self {
        day.to_string()
    }
}

impl core::convert::From<u8> for Day {
    fn from(value: u8) -> Self {
        match value {
            1 => Day::One,
            2 => Day::Two,
            3 => Day::Three,
            4 => Day::Four,
            5 => Day::Five,
            6 => Day::Six,
            7 => Day::Seven,
            8 => Day::Eight,
            9 => Day::Nine,
            10 => Day::Ten,
            11 => Day::Eleven,
            12 => Day::Twelve,
            13 => Day::Thirteen,
            14 => Day::Fourteen,
            15 => Day::Fifteen,
            16 => Day::Sixteen,
            17 => Day::Seventeen,
            18 => Day::Eighteen,
            19 => Day::Nineteen,
            20 => Day::Twenty,
            21 => Day::TwentyOne,
            22 => Day::TwentyTwo,
            23 => Day::TwentyThree,
            24 => Day::TwentyFour,
            25 => Day::TwentyFive,
            _ => panic!("day out of range (1..=25)"),
        }
    }
}

impl core::convert::From<&str> for Day {
    fn from(s: &str) -> Self {
        match s {
            "One" => Day::One,
            "Two" => Day::Two,
            "Three" => Day::Three,
            "Four" => Day::Four,
            "Five" => Day::Five,
            "Six" => Day::Six,
            "Seven" => Day::Seven,
            "Eight" => Day::Eight,
            "Nine" => Day::Nine,
            "Ten" => Day::Ten,
            "Eleven" => Day::Eleven,
            "Twelve" => Day::Twelve,
            "Thirteen" => Day::Thirteen,
            "Fourteen" => Day::Fourteen,
            "Fifteen" => Day::Fifteen,
            "Sixteen" => Day::Sixteen,
            "Seventeen" => Day::Seventeen,
            "Eighteen" => Day::Eighteen,
            "Nineteen" => Day::Nineteen,
            "Twenty" => Day::Twenty,
            "TwentyOne" => Day::TwentyOne,
            "TwentyTwo" => Day::TwentyTwo,
            "TwentyThree" => Day::TwentyThree,
            "TwentyFour" => Day::TwentyFour,
            "TwentyFive" => Day::TwentyFive,
            _ => panic!("unknown day string"),
        }
    }
}

impl core::convert::From<String> for Day {
    fn from(value: String) -> Self {
        Day::from(value.as_str())
    }
}