#[derive(thiserror::Error, Debug)]
enum MaxOptimizationThreadsError {
    #[error("Malformed MaxOptimizationThreads")]
    Malformed,
    #[error("Invalid MaxOptimizationThreads setting: {0}")]
    InvalidSetting(#[from] std::num::TryFromIntError),
}

impl From<MaxOptimizationThreadsError> for Status {
    fn from(error: MaxOptimizationThreadsError) -> Self {
        Status::invalid_argument(error.to_string())
    }
}

fn parse_variant(value: &MaxOptimizationThreads) -> Result<&Variant, MaxOptimizationThreadsError> {
    value.variant.as_ref().ok_or(MaxOptimizationThreadsError::Malformed)
}

impl TryFrom<MaxOptimizationThreads> for rest::MaxOptimizationThreads {
    type Error = Status;

    fn try_from(value: MaxOptimizationThreads) -> Result<Self, Self::Error> {
        let variant = parse_variant(&value).map_err(Status::from)?;

        match variant {
            Variant::Setting(setting_int) => {
                let setting = Setting::try_from(*setting_int)
                    .map_err(MaxOptimizationThreadsError::from)
                    .map_err(Status::from)?;
                match setting {
                    Setting::Auto => Ok(Self::Setting(rest::MaxOptimizationThreadsSetting::Auto)),
                }
            }
            Variant::Value(num_threads) => Ok(Self::Threads(*num_threads as usize)),
        }
    }
}

impl TryFrom<MaxOptimizationThreads> for Option<usize> {
    type Error = Status;

    fn try_from(value: MaxOptimizationThreads) -> Result<Self, Self::Error> {
        let variant = parse_variant(&value).map_err(Status::from)?;

        match variant {
            Variant::Setting(setting_int) => {
                let setting = Setting::try_from(*setting_int)
                    .map_err(MaxOptimizationThreadsError::from)
                    .map_err(Status::from)?;
                match setting {
                    Setting::Auto => Ok(None),
                }
            }
            Variant::Value(num_threads) => Ok(Some(*num_threads as usize)),
        }
    }
}