let locales = match &derive_input.data {
        syn::Data::Struct(_struct_data) => derive::locales_for_ident(&group, &derive_input.ident),
        syn::Data::Enum(enum_data) => derive::locales_for_enum(&group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    };

    let body = match &derive_input.data {

    let message_body = match &derive_input.data {

            derive::for_struct(group, &derive_input.ident, &struct_data.fields)

            derive::message_for_struct(group, &derive_input.ident, &struct_data.fields)

        syn::Data::Enum(enum_data) => derive::for_enum(group, &enum_data.variants),

        syn::Data::Enum(enum_data) => derive::messages_for_enum(group, &enum_data.variants),

            fn message_for_locale(&self, locale: &::fluent_embed::icu_locid::LanguageIdentifier) -> String {
                #message_body
            }

                #body

                let available_locales = #locales;
                let selected_locale = ::fluent_embed::locale_select::match_locales(&available_locales, &Self::CANONICAL_LOCALE);
                self.message_for_locale(&selected_locale)

    pub fn locales_for_message<'a>(&'a self, id: &'a str) -> impl Iterator<Item = &Locale> + 'a {
        self.locales
            .iter()
            .filter(|(_locale, messages)| messages.contains_expression(id))
            .map(|(locale, _source_file)| locale)
    }

        // Create a list of available locales to choose from
        let available_locales = [
            // The canonical locale will always be available
            Self::CANONICAL_LOCALE,
            // Any additional locales that contain this message
            #(::fluent_embed::langid!(#additional_locales)),*
        ];
        let locale = ::fluent_embed::select_locale(&available_locales, &Self::CANONICAL_LOCALE);

        const plural_rule_type: ::fluent_embed::PluralRuleType =

        const PLURAL_RULE_TYPE: ::fluent_embed::PluralRuleType =

        let plural_rules = ::fluent_embed::plural_rules(&locale, plural_rule_type).unwrap();

        let plural_rules = ::fluent_embed::plural_rules(&locale, PLURAL_RULE_TYPE).unwrap();

pub fn for_struct(

pub fn locales_for_ident(group: &fluent::Group, ident: &syn::Ident) -> TokenStream {
    let id = ident.to_string().to_kebab_case();
    let locale_literals = group
        .locales_for_message(&id)
        .map(|locale| locale.id.to_string())
        .map(|locale_string| syn::LitStr::new(&locale_string, proc_macro2::Span::call_site()));
    // There is only one message for this struct, so just list every supported locale
    quote!(vec![#(::fluent_embed::langid!(#locale_literals)),*])
}
pub fn message_for_struct(

pub fn for_enum(

pub fn locales_for_enum(
    group: &fluent::Group,
    enum_variants: &Punctuated<syn::Variant, syn::token::Comma>,
) -> TokenStream {
    let mut match_arms: Vec<TokenStream> = Vec::with_capacity(enum_variants.len());
    for enum_variant in enum_variants {
        let variant_ident = &enum_variant.ident;
        // Simplify match code by always ignoring enum fields (even if they don't exist)
        // We are matching the variant name, not any data, so each arm will have something like:
        // Self::VariantName { .. }
        // Even if `Self::VariantName` doesn't contain any data
        let locales_for_variant = locales_for_ident(group, variant_ident);
        match_arms.push(quote!(Self::#variant_ident { .. } => #locales_for_variant));
    }
    quote! {
        match self {
            #(#match_arms),*
        }
    }
}
pub fn messages_for_enum(

    const CANONICAL_LOCALE: LanguageIdentifier = DEFAULT_LOCALE;

}
impl crate::Localize for RelativeTime {
    const CANONICAL_LOCALE: LanguageIdentifier = DEFAULT_LOCALE;

    fn localize(&self) -> String {

    pub fn localize(&self) -> String {

    fn localize(&self) -> String;
}

/// Select which locale to use, falling back to the canonical locale if nothing matches
pub fn select_locale(
    available_locales: &[LanguageIdentifier],
    canonical_locale: &LanguageIdentifier,
) -> LanguageIdentifier {
    locale_select::match_locales(available_locales, canonical_locale)

    fn message_for_locale(&self, locale: &LanguageIdentifier) -> String;
    fn localize(&self) -> String;