use heck::ToUpperCamelCase;

use heck::{ToKebabCase, ToUpperCamelCase};

    fn id(&self) -> &'resource str {
        match self {
            Self::Message(message) => message.id.name,
        }
    }

    pub fn derive_enum(
        &self,
        ident: syn::Ident,
        enum_data: syn::DataEnum,
    ) -> proc_macro2::TokenStream {
        let mut idents = Vec::with_capacity(enum_data.variants.len());
        let mut messages = Vec::with_capacity(enum_data.variants.len());

    // TODO: turn this into a well-formed `match` expression
    pub fn to_syn(&self) -> Vec<syn::Expr> {
        self.children
            .iter()
            .map(GroupEntry::to_syn)
            .collect::<Vec<_>>()

        for variant in enum_data.variants {
            let kebab_case_ident = variant.ident.to_string().to_kebab_case();
            let message = self
                .children
                .iter()
                .find(|child| child.id() == kebab_case_ident)
                .unwrap();
            idents.push(variant.ident);
            messages.push(message.to_syn());
        }
        quote! {
            impl #ident {
                fn localize(&self) -> String {
                    match self {
                        #(Self::#idents => #messages),*
                    }
                }
            }
        }

use quote::quote;

use syn::parse_quote;

    // Example from https://projectfluent.org/fluent/guide/selectors.html
    let ftl = r#"emails =
{ $unreadEmails ->
    [one] You have one unread email.
    *[other] You have { $unreadEmails } unread emails.
}"#;

    let ftl = r#"first = one
second = two"#;

    let syn_expressions = group
        .to_syn()
        .iter()
        .map(|expr| quote! {#expr})
        .collect::<Vec<_>>();

    let source: syn::DeriveInput = parse_quote! {
        enum Test {
            First,
            Second,
        }
    };

    let file_contents = quote! {
        #(#syn_expressions)*;

    let data = match source.data {
        syn::Data::Enum(enum_data) => enum_data,
        _ => todo!(),

    let file_contents = group.derive_enum(source.ident, data);