use fluent_syntax::ast::{Entry, Message, Resource};

use fluent_syntax::ast::{Entry, Message, PatternElement, Resource};
use syn::parse_quote;

enum GroupEntry<'resource> {

pub enum GroupEntry<'resource> {

}
impl<'resource> GroupEntry<'resource> {
    fn to_syn(&self) -> syn::Expr {
        match self {
            Self::Message(message) => message.value.as_ref().map_or_else(
                || parse_quote! { () },
                |pattern| {
                    let parsed_patterns = pattern.elements.iter().map(match_pattern_element);
                    parse_quote! { #(#parsed_patterns)+* }
                },
            ),
        }
    }

    }
    // 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<_>>()

fn match_pattern_element<'resource>(
    pattern_element: &'resource PatternElement<&'resource str>,
) -> syn::Expr {
    match pattern_element {
        PatternElement::TextElement { value } => parse_quote! { #value },
        _ => todo!(),
    }
}

use quote::quote;

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

    dbg!(group);

    dbg!(syn_expressions);