Emails { unread_emails: u64 },

    Numbers { unread_emails: u64 },
    Plurals { unread_emails: u64 },
}
#[localize("tests/locale/**/selectors.ftl")]
pub struct Numbers {
    unread_emails: u64,

pub struct Emails {

pub struct Plurals {

#[case::zero_en(locale!("en-US"), 0, "You have no unread emails.")]
#[case::one_en(locale!("en-US"), 1, "You have an unread email.")]
#[case::two_en(locale!("en-US"), 2, "You have 2 unread emails.")]
#[case::max_en(
    locale!("en-US"),
    u64::MAX,
    "You have 18,446,744,073,709,551,615 unread emails."
)]
#[case::zero_fr(locale!("fr"), 0, "Vous n'avez aucun e-mail non lu.")]
#[case::one_fr(locale!("fr"), 1, "Vous avez un e-mail non lu.")]
#[case::two_fr(locale!("fr"), 2, "Vous avez 2 e-mails non lus.")]
#[case::max_fr(locale!("fr"), u64::MAX, "Vous avez 18 446 744 073 709 551 615 e-mails non lus.")]
fn numbers(#[case] locale: Locale, #[case] unread_emails: u64, #[case] expected_message: String) {
    compare_message(Numbers { unread_emails }, &expected_message, locale.clone());
    compare_message(
        MessageEnum::Numbers { unread_emails },
        expected_message,
        locale,
    );
}
/// End-to-end test of locale-specific selectors implementation by checking final output
#[rstest]

fn localize_for(
    #[case] locale: Locale,
    #[case] unread_emails: u64,
    #[case] expected_message: String,
) {
    compare_message(Emails { unread_emails }, &expected_message, locale.clone());

fn plurals(#[case] locale: Locale, #[case] unread_emails: u64, #[case] expected_message: String) {
    compare_message(Plurals { unread_emails }, &expected_message, locale.clone());

        MessageEnum::Emails { unread_emails },

        MessageEnum::Plurals { unread_emails },

emails =

# Selectors example from Fluent guide: https://projectfluent.org/fluent/guide/selectors.html
# Poorly translated into French :)
numbers =
    { $unreadEmails ->
        [0] Vous n'avez aucun e-mail non lu.
        [1] Vous avez un e-mail non lu.
       *[other] Vous avez { $unreadEmails } e-mails non lus.
    }
# French singular includes both 0 and 1
plurals =

emails =

numbers =
    { $unreadEmails ->
        [0] You have no unread emails.
        [1] You have an unread email.
       *[other] You have { $unreadEmails } unread emails.
    }
plurals =

use std::num::ParseIntError;

        // span: SourceSpan,
    },
    #[error("invalid number literal")]
    InvalidNumberLiteral {
        invalid_literal: String,
        parse_error: ParseIntError,
        #[source_code]
        source_code: NamedSource<String>,
        // TODO: blocked on https://github.com/projectfluent/fluent-rs/pull/373
        // #[label("This can't be parsed as an unsigned 128-bit integer")]

    #[error("invalid identifier type")]
    InvalidIdentifierType {
        invalid_identifier: String,
        expected_type: ast::VariantType,
        found_type: ast::VariantType,
        #[source_code]
        source_code: NamedSource<String>,
        // TODO: blocked on https://github.com/projectfluent/fluent-rs/pull/373
        // #[label("This can't be parsed as an unsigned 128-bit integer")]
        // span: SourceSpan,
    },

use fluent_syntax::ast::{Expression, InlineExpression, PatternElement, VariantKey};

use fluent_syntax::ast::{
    Expression, InlineExpression, Pattern, PatternElement, Variant, VariantKey,
};

use quote::{format_ident, quote};

use proc_macro2::{Literal, TokenStream};
use quote::{ToTokens, format_ident, quote};

#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub enum VariantType {
    Integer,
    Plural,
}
struct Select<'variants> {
    variant_type: VariantType,
    default_pattern: TokenStream,
    default_expression: &'variants Pattern<String>,
    match_arms: Vec<(TokenStream, &'variants Pattern<String>)>,
}

                        let match_target = inline_expression(selector, message_context)?;
                        let default_arm = OnceCell::new();
                        let mut additional_arms = Vec::with_capacity(variants.len());

                        let select = select(&message_context, variants)?;

                        for variant in variants {
                            let variant_pattern: syn::Pat = match &variant.key {
                                VariantKey::Identifier { name } => {
                                    let ident_pascal_case =
                                        format_ident!("{}", name.to_pascal_case());
                                    parse_quote!(::l10n_embed::macro_prelude::icu_plurals::PluralCategory::#ident_pascal_case)
                                }
                                VariantKey::NumberLiteral { .. } => todo!(),
                            };
                            // Create a new `MessageContext` for each variant body
                            let variant_context = MessageContext {
                                pattern: &variant.value,
                                ..message_context
                            };
                            let variant_body = message_body(variant_context)?;
                            // The default pattern must go last so we don't generate invalid match stataments
                            if variant.default {
                                default_arm
                                    .set(quote!(#variant_pattern | _ => #variant_body))
                                    .expect("Multiple default patterns for match statement.");
                            } else {
                                additional_arms.push(quote!(#variant_pattern => #variant_body));

                        let raw_match_target = inline_expression(selector, message_context)?;
                        let match_target = match select.variant_type {
                            VariantType::Integer { .. } => quote!(#raw_match_target),
                            VariantType::Plural { .. } => {
                                // Only dereference if enum variant
                                let category_reference =
                                    match message_context.derive_context.reference_kind {
                                        ReferenceKind::EnumField => quote!(*#raw_match_target),
                                        ReferenceKind::StructField => quote!(#raw_match_target),
                                    };
                                quote!(plural_rules.category_for(#category_reference))

                        }

                        };

                        // The parser should guarantee a default arm is available
                        let default_arm = default_arm.get().unwrap();

                        let default_match_pattern = select.default_pattern;
                        let default_match_expression = message_body(MessageContext {
                            pattern: select.default_expression,
                            ..message_context
                        })?;

                        // Only dereference if enum variant
                        let category_reference = match message_context.derive_context.reference_kind {
                            ReferenceKind::EnumField => quote!(*#match_target),
                            ReferenceKind::StructField => quote!(#match_target),
                        };

                        let match_patterns = select
                            .match_arms
                            .iter()
                            .map(|(pattern, _expression)| pattern)
                            .collect::<Vec<&TokenStream>>();
                        let match_expressions = select
                            .match_arms
                            .iter()
                            .map(|(_match_pattern, expression)| {
                                message_body(MessageContext {
                                    pattern: expression,
                                    ..message_context
                                })
                            })
                            .collect::<Result<Vec<syn::Expr>, Error>>()?;

                            match plural_rules.category_for(#category_reference) {
                                #(#additional_arms,)*
                                #default_arm,

                            match #match_target {
                                #(#match_patterns => #match_expressions),*
                                #default_match_pattern => #default_match_expression,

fn select<'variants>(
    message_context: &MessageContext,
    variants: &'variants Vec<Variant<String>>,
) -> Result<Select<'variants>, Error> {
    let expected_variant_type = OnceCell::new();
    for variant in variants {
        let variant_type = match &variant.key {
            VariantKey::Identifier { name } => match name.as_str() {
                // "other" is ambiguous as it could be used for plurals or as the default integer case
                "other" => None,
                _ => Some(VariantType::Plural),
            },
            VariantKey::NumberLiteral { .. } => Some(VariantType::Integer),
        };
        // Make sure all variants are of the same type
        if let Some(variant_kind) = variant_type {
            let expected_type = expected_variant_type.get_or_init(|| variant_kind);
            if *expected_type != variant_kind {
                todo!()
            }
        }
    }
    match expected_variant_type.get().unwrap() {
        VariantType::Integer => select_integers(message_context, variants),
        VariantType::Plural => select_plurals(message_context, variants),
    }
}
fn select_integers<'variants>(
    message_context: &MessageContext,
    variants: &'variants Vec<Variant<String>>,
) -> Result<Select<'variants>, Error> {
    let mut default_expression = OnceCell::new();
    let mut match_arms = Vec::new();
    for variant in variants {
        match &variant.key {
            VariantKey::Identifier { name } => match name.to_lowercase().as_str() {
                "other" => default_expression
                    .set(&variant.value)
                    .expect("Multiple default variants"),
                _ => {
                    return Err(Error::InvalidIdentifierType {
                        invalid_identifier: name.clone(),
                        expected_type: VariantType::Integer,
                        found_type: VariantType::Plural,
                        source_code: message_context.source.named_source.clone(),
                    });
                }
            },
            VariantKey::NumberLiteral { value } => {
                let parsed_integer: u128 = match value.parse() {
                    Ok(integer) => integer,
                    Err(parse_error) => {
                        return Err(Error::InvalidNumberLiteral {
                            invalid_literal: value.clone(),
                            parse_error,
                            source_code: message_context.source.named_source.clone(),
                        });
                    }
                };
                let integer_literal = Literal::u128_unsuffixed(parsed_integer);
                match_arms.push((integer_literal.to_token_stream(), &variant.value));
            }
        }
    }
    let default_expression = default_expression.take().expect("No default variant");
    Ok(Select {
        variant_type: VariantType::Integer,
        default_pattern: quote!(_),
        default_expression,
        match_arms,
    })
}
fn select_plurals<'variants>(
    message_context: &MessageContext,
    variants: &'variants Vec<Variant<String>>,
) -> Result<Select<'variants>, Error> {
    let mut default_arm = OnceCell::new();
    let mut match_arms = Vec::new();
    for variant in variants {
        match &variant.key {
            VariantKey::Identifier { name } => {
                let name_pascal_case = name.to_pascal_case();
                let ident = syn::Ident::new(&name_pascal_case, proc_macro2::Span::call_site());
                let pattern =
                    quote!(::l10n_embed::macro_prelude::icu_plurals::PluralCategory::#ident);
                match variant.default {
                    // The default arm should include any enum variants not matched
                    true => default_arm
                        .set((quote!(#pattern | _), &variant.value))
                        .expect("Multiple default variants"),
                    false => match_arms.push((pattern, &variant.value)),
                }
            }
            VariantKey::NumberLiteral { value } => {
                return Err(Error::InvalidIdentifierType {
                    invalid_identifier: value.clone(),
                    expected_type: VariantType::Plural,
                    found_type: VariantType::Integer,
                    source_code: message_context.source.named_source.clone(),
                });
            }
        }
    }
    let (default_pattern, default_expression) = default_arm.take().expect("No default variant");
    Ok(Select {
        variant_type: VariantType::Plural,
        default_pattern,
        default_expression,
        match_arms,
    })
}