use serde::de::{Deserialize, Deserializer};
use serde_derive::Deserialize;

macro_rules! define_matrix_entry {
    ($name:ident, ($run_default:expr, $version_default:expr, $allow_failure_default:expr)) => {
        #[derive(Debug)]
        struct $name<'a> {
            run: bool,
            version: &'a str,
            allow_failure: bool,
        }

        impl<'a> Default for $name<'a> {
            fn default() -> Self {
                $name {
                    run: $run_default,
                    version: $version_default,
                    allow_failure: $allow_failure_default,
                }
            }
        }

        // Since we can't easily (or at all?) pass default expresisons
        // to serde, we have to define our own
        // deserializer. Thankfully, you can deserialize into an
        // intermediate struct and then assign / default the values
        // from Default::default().
        impl<'de: 'a, 'a> Deserialize<'de> for $name<'a> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                #[derive(Deserialize)]
                struct DeserializationStruct<'a> {
                    run: Option<bool>,
                    version: Option<&'a str>,
                    allow_failure: Option<bool>,
                }
                let raw: DeserializationStruct = DeserializationStruct::deserialize(deserializer)?;
                let res = $name {
                    run: raw.run.unwrap_or(Self::default().run),
                    version: raw.version.unwrap_or(Self::default().version),
                    allow_failure: raw.allow_failure.unwrap_or(Self::default().allow_failure),
                };
                Ok(res)
            }
        }
    };
}

define_matrix_entry!(BenchEntry, (false, "nightly", false));