use std::collections::HashMap;

use icu_locid::Locale;

use icu_locid::{locale, Locale};

        let message = group
            .children
            .iter()
            .find(|message| message.id.name == kebab_case_ident)
            .unwrap();

        messages.push(crate::parse_fluent::message(message));

        messages.push(crate::parse_fluent::message(
            group.canonical_message_for(&kebab_case_ident),
        ));

pub fn attribute_groups(path_literal: syn::LitStr) -> Vec<Group> {

pub fn attribute_groups(path_literal: syn::LitStr) -> Group {

    let mut groups = Vec::new();

    let mut resources = HashMap::new();

        let group = Group::from_resource(resource, locale);
        groups.push(group);

        resources.insert(locale, resource);

    groups

    Group::new(locale!("en-US"), resources)

    derive_enum(groups[0].clone(), ident, variants)

    derive_enum(groups, ident, variants)

use std::collections::HashMap;

#[derive(Clone, Debug)]
struct LocalizationsForMessage {
    canonical_message: Message<String>,
    pub additional_messages: HashMap<Locale, Message<String>>,
}
impl LocalizationsForMessage {
    fn new(canonical_message: Message<String>) -> Self {
        Self {
            canonical_message,
            additional_messages: HashMap::new(),
        }
    }
}

    locale: Locale,
    pub children: Vec<Message<String>>,

    canonical_locale: Locale,
    messages: HashMap<String, LocalizationsForMessage>,

    pub fn from_resource(resource: Resource<String>, locale: Locale) -> Self {
        let mut children = Vec::new();

    pub fn new(canonical_locale: Locale, mut resources: HashMap<Locale, Resource<String>>) -> Self {
        let canonical_resource = resources.remove(&canonical_locale).unwrap();

        for entry in resource.body {
            let matched_entry = if let Entry::Message(message) = entry {
                message
            } else {
                todo!()
            };

        let mut messages = HashMap::new();

            children.push(matched_entry);

        for entry in canonical_resource.body {
            if let Entry::Message(message) = entry {
                messages.insert(
                    message.id.name.clone(),
                    LocalizationsForMessage::new(message),
                );
            }

        Self { locale, children }

        for (locale, resource) in resources {
            for entry in resource.body {
                if let Entry::Message(message) = entry {
                    let localizations = messages.get_mut(&message.id.name).unwrap();
                    localizations
                        .additional_messages
                        .insert(locale.clone(), message);
                }
            }
        }
        Self {
            canonical_locale,
            messages,
        }

    pub fn canonical_message_for(&self, id: &str) -> &Message<String> {
        &self.messages.get(id).unwrap().canonical_message
    }