use crate::group::Group;

use syn::DeriveInput;

mod group;
pub mod parse_fluent;
mod parse_macro;

mod derive;
mod fluent;

pub use parse_fluent::FluentError;

pub use fluent::Error as FluentError;

pub fn attribute_groups(path_literal: &syn::LitStr) -> Result<Group, AttributeError> {

pub fn locales_from_attribute(
    attribute: &syn::LitStr,
) -> Result<HashMap<Locale, PathBuf>, AttributeError> {

    let attribute_glob = path_literal.value();

    let attribute_glob = attribute.value();

    let mut resources = HashMap::new();
    let mut paths = HashMap::new();

    let mut locales = HashMap::new();

        // Parse the file into a `Group`
        let fluent_contents = std::fs::read_to_string(entry.path()).unwrap();
        let resource = fluent_syntax::parser::parse(fluent_contents).unwrap();
        resources.insert(locale.clone(), resource);
        paths.insert(locale, entry.to_candidate_path().to_string());

        // Insert this locale (and make sure it's unique!)
        let previous_value = locales.insert(locale, entry.into_path());
        assert!(previous_value.is_none());

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

    Ok(locales)

pub fn localize(path: &syn::LitStr, derive_input: &DeriveInput) -> Result<TokenStream, MacroError> {
    let group = attribute_groups(path)?;

pub fn localize(
    attribute: &syn::LitStr,
    derive_input: &syn::DeriveInput,
) -> Result<TokenStream, MacroError> {
    let locales = locales_from_attribute(&attribute)?;
    // let context = todo!();
    // TODO: user-controlled canonical locale
    let group = fluent::Group::new(locale!("en-US"), locales)?;

            parse_macro::derive_struct(group, &derive_input.ident, &struct_data.fields)

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

        syn::Data::Enum(enum_data) => parse_macro::derive_enum(group, &enum_data.variants),

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

use crate::derive::DeriveContext;
use std::collections::HashMap;
use std::path::PathBuf;
use fluent_syntax::ast::{Entry, Message, Pattern, Resource};
use miette::Diagnostic;
use thiserror::Error;
mod ast;
mod group;
pub use group::Group;
#[derive(Diagnostic, Debug, Error)]
#[diagnostic(transparent)]
#[error(transparent)]
pub enum Error {
    InvalidReference(#[from] ast::InvalidReference),
}
#[derive(Clone, Copy, Debug)]
pub struct MessageContext<'context> {
    syntax_tree: &'context Resource<String>,
    pattern: &'context Pattern<String>,
    path: &'context str,
    derive_context: &'context DeriveContext,
}
#[derive(Clone, Debug)]
struct SourceFile {
    path: PathBuf,
    syntax_tree: fluent_syntax::ast::Resource<String>,
    messages: HashMap<String, Message<String>>,
}
impl SourceFile {
    fn new(path: PathBuf) -> Result<Self, Error> {
        let file_contents = std::fs::read_to_string(&path).unwrap();
        // TODO: return an error instead of panic
        let syntax_tree = fluent_syntax::parser::parse(file_contents).unwrap();
        // Keep track of all the messages in our Fluent file
        let mut messages = HashMap::with_capacity(syntax_tree.body.len());
        for entry in &syntax_tree.body {
            match entry {
                Entry::Message(message_entry) => {
                    let message_id = message_entry.id.name.to_owned();
                    // Insert this message id (and make sure it's unique!)
                    let previous_value = messages.insert(message_id, message_entry.clone());
                    assert!(previous_value.is_none());
                }
                Entry::Term(_) => todo!(),
                Entry::Comment(_) => todo!(),
                Entry::GroupComment(_) => todo!(),
                Entry::ResourceComment(_) => todo!(),
                Entry::Junk { .. } => todo!(),
            }
        }
        Ok(Self {
            path,
            syntax_tree,
            messages,
        })
    }
    /// Unique message IDs, to compare with other locales
    fn message_ids(&self) -> impl Iterator<Item = &str> {
        self.messages.keys().map(String::as_str)
    }
    fn contains_expression(&self, id: &str) -> bool {
        self.messages.contains_key(id)
    }
    fn remove_expression(
        &mut self,
        id: &str,
        derive_context: &DeriveContext,
    ) -> Result<syn::Expr, Error> {
        let message = self.messages.remove(id).unwrap();
        let message_context = MessageContext {
            syntax_tree: &self.syntax_tree,
            // Any message where this value is `None` shouldn't be accessed directly, see:
            // https://docs.rs/fluent-syntax/latest/fluent_syntax/ast/struct.Attribute.html#example
            // TODO: return an error instead of panic
            pattern: message.value.as_ref().unwrap(),
            path: &self.path.to_string_lossy(),
            derive_context,
        };
        ast::message_body(message_context)
    }
}

use crate::parse_fluent::{self, FluentError, References};
use std::collections::HashMap;

use super::{Error, SourceFile};
use crate::derive::DeriveContext;
use std::collections::{HashMap, HashSet};
use std::path::PathBuf;

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

struct LocaleGroup {
    locale: Locale,
    messages: Box<[Option<Message<String>>]>,
}
impl LocaleGroup {
    fn new(
        locale: Locale,
        resource: Resource<String>,
        canonical_messages: &[Message<String>],
    ) -> Self {
        let mut messages = vec![None; canonical_messages.len()].into_boxed_slice();
        for entry in resource.body {
            if let Entry::Message(message) = entry {
                let index = canonical_messages
                    .iter()
                    .position(|canonical_message| canonical_message.id.name == message.id.name)
                    .expect("Message ID must be in canonical group");
                assert!(messages[index].is_none());
                messages[index] = Some(message);
            }
        }
        Self { locale, messages }
    }
}
#[derive(Clone, Debug)]

    canonical_messages: Vec<Message<String>>,
    extra_locales: Vec<LocaleGroup>,
    paths: HashMap<Locale, String>,

    locales: HashMap<Locale, SourceFile>,

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

        locale_paths: HashMap<Locale, PathBuf>,
    ) -> Result<Self, Error> {
        let mut locales = HashMap::with_capacity(locale_paths.len());

        let mut canonical_messages = Vec::new();

        for (locale, path) in locale_paths {
            let resource = SourceFile::new(path)?;

        for entry in canonical_resource.body {
            if let Entry::Message(message) = entry {
                canonical_messages.push(message);
            }

            // Insert resource (and make sure it's unique!)
            let previous_value = locales.insert(locale, resource);
            assert!(previous_value.is_none());

        let extra_locales = resources
            .into_iter()
            .map(|(locale, resource)| LocaleGroup::new(locale, resource, &canonical_messages))
            .collect::<Vec<_>>();

        // Collect all keys used in the Fluent source code
        let keys: HashSet<&str> =
            HashSet::from_iter(locales.values().flat_map(|resource| resource.message_ids()));
        // Collect all keys from the canonical resource
        // TODO: return an error instead of panic
        let canonical_resource = locales.get(&canonical_locale).unwrap();
        // TODO: return an error instead of panic
        // Make sure canonical resource contains all message keys
        assert_eq!(keys, HashSet::from_iter(canonical_resource.message_ids()));

        Self {

        Ok(Self {

            canonical_messages,
            extra_locales,
            paths,
        }

            locales,
        })

    pub fn canonical_message(
        &self,

    pub fn remove_canonical_message(
        &mut self,

        references: &References,
    ) -> Result<syn::Expr, FluentError> {
        let message = self
            .canonical_messages
            .iter()
            .find(|message| message.id.name == id)
            .expect("Message id must be valid");

        derive_context: &DeriveContext,
    ) -> Result<syn::Expr, Error> {
        let canonical_resource = self.locales.get_mut(&self.canonical_locale).unwrap();
        let message = canonical_resource.remove_expression(id, derive_context)?;

        let path = self.paths.get(&self.canonical_locale).unwrap();
        parse_fluent::message(message, references, path)

        Ok(message)

    pub fn additional_messages(
        &self,

    pub fn remove_additional_messages(
        &mut self,

        references: &References,
    ) -> Result<Vec<(&Locale, syn::Expr)>, FluentError> {
        let mut messages = Vec::with_capacity(self.extra_locales.len());
        let message_column = self
            .canonical_messages
            .iter()
            .position(|message| message.id.name == id)
            .expect("Message id must be valid");

        derive_context: &DeriveContext,
    ) -> Result<HashMap<&Locale, syn::Expr>, Error> {
        // Create a message for every locale *except* the canonoical locale
        let mut messages = HashMap::with_capacity(self.locales.len() - 1);

        for locale_group in &self.extra_locales {

        for (locale, compiled_messages) in self.locales.iter_mut() {
            // Skip the canonical locale
            if locale == &self.canonical_locale {
                continue;
            }

            if let Some(message) = &locale_group.messages[message_column] {
                let path = self.paths.get(&locale_group.locale).unwrap();
                let message_expr = parse_fluent::message(&message, references, path)?;
                messages.push((&locale_group.locale, message_expr))

            if compiled_messages.contains_expression(id) {
                let message = compiled_messages.remove_expression(id, derive_context)?;
                // Insert this message (and make sure it's unique!)
                let previous_value = messages.insert(locale, message);
                assert!(previous_value.is_none());

use std::collections::HashSet;

use super::{Error, MessageContext};
use crate::derive::ReferenceKind;

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

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

use thiserror::Error;

#[derive(Diagnostic, Debug, Error)]
#[diagnostic(transparent)]
#[error(transparent)]
pub enum FluentError {
    InvalidReference(#[from] InvalidReference),
}
#[derive(Clone, Copy, Debug)]
pub enum ReferenceKind {
    EnumField,
    StructField,
}
#[derive(Clone, Debug)]
pub struct References {
    pub kind: ReferenceKind,
    pub candidates: HashSet<String>,
}
pub(crate) fn pattern(
    message: &Message<String>,
    pattern: &Pattern<String>,
    references: &References,
    path: &str,
) -> Result<syn::Expr, FluentError> {

pub fn message_body(message_context: MessageContext) -> Result<syn::Expr, Error> {

    for element in &pattern.elements {

    for element in &message_context.pattern.elements {

                        let target = inline_expression(message, selector, references, path)?;
                        let arms: Vec<syn::Arm> = variants
                            .iter()
                            .map(|item| variant(message, item, references, path))
                            .collect::<Result<_, FluentError>>()?;

                        let target = inline_expression(selector, message_context)?;
                        let mut arms: Vec<syn::Arm> = Vec::with_capacity(variants.len());
                        for variant in variants {
                            let base_pattern: syn::Pat = match &variant.key {
                                VariantKey::Identifier { name } => {
                                    let ident = format_ident!("{}", name.to_pascal_case());
                                    parse_quote!(::icu_plurals::PluralCategory::#ident)
                                }
                                VariantKey::NumberLiteral { .. } => todo!(),
                            };
                            // Create a new `MessageContext` for each variant
                            let variant_context = MessageContext {
                                pattern: &variant.value,
                                ..message_context
                            };
                            let body = message_body(variant_context)?;
                            // Default patterns match anything else
                            // TODO: this can potentially generate unreachable patterns,
                            // should be replaced with a more sophisticated implementation
                            let pattern = if variant.default {
                                parse_quote!(#base_pattern | _)
                            } else {
                                base_pattern
                            };

                            arms.push(parse_quote!(#pattern => #body));
                        }

                        inline_expression(message, expression, references, path)?

                        inline_expression(expression, message_context)?

    message: &Message<String>,

    references: &References,
    path: &str,
) -> Result<syn::Expr, FluentError> {

    message_context: MessageContext,
) -> Result<syn::Expr, Error> {

            let ident = if let Some(variable) = references.candidates.get(&id.name.to_snake_case())

            let ident = if let Some(variable) = message_context
                .derive_context
                .valid_references
                .get(&id.name.to_snake_case())

                // Create a fake `fluent_syntax::ast::Resource` to serialize into a String
                let error_resource = Resource {
                    body: vec![Entry::Message(message.to_owned())],
                };

                // Serialize the Fluent file AST back into a String

                    &error_resource,

                    &message_context.syntax_tree,

                return Err(FluentError::InvalidReference(InvalidReference {
                    src: NamedSource::new(path, source_string.clone()),

                return Err(Error::InvalidReference(InvalidReference {
                    src: NamedSource::new(message_context.path, source_string.clone()),

                        references
                            .candidates

                        message_context
                            .derive_context
                            .valid_references

            match references.kind {

            match message_context.derive_context.reference_kind {

}
fn variant(
    message: &Message<String>,
    variant: &Variant<String>,
    references: &References,
    path: &str,
) -> Result<syn::Arm, FluentError> {
    let base_pattern = variant_key(&variant.key);
    let body = pattern(message, &variant.value, references, path)?;
    // Default patterns match anything else
    // TODO: this can potentially generate unreachable patterns,
    // should be replaced with a more sophisticated implementation
    let pattern = if variant.default {
        parse_quote!(#base_pattern | _)
    } else {
        base_pattern
    };
    Ok(parse_quote!(#pattern => #body))
}
fn variant_key(variant_key: &VariantKey<String>) -> syn::Pat {
    match variant_key {
        VariantKey::Identifier { name } => {
            let ident = format_ident!("{}", name.to_pascal_case());
            parse_quote!(::icu_plurals::PluralCategory::#ident)
        }
        VariantKey::NumberLiteral { .. } => todo!(),
    }
}
pub(crate) fn message(
    message: &Message<String>,
    references: &References,
    path: &str,
) -> Result<syn::Expr, FluentError> {
    if let Some(value) = message.value.as_ref() {
        pattern(message, value, references, path)
    } else {
        Ok(parse_quote!(()))
    }

use crate::group::Group;
use crate::parse_fluent::{FluentError, ReferenceKind, References};

use crate::fluent;

#[derive(Clone, Copy, Debug)]
pub enum ReferenceKind {
    EnumField,
    StructField,
}

#[derive(Clone, Debug)]
pub struct DeriveContext {
    pub reference_kind: ReferenceKind,
    pub valid_references: HashSet<String>,
}

    group: &Group,

    group: &mut fluent::Group,

    reference_kind: &References,
) -> Result<TokenStream, FluentError> {

    reference_kind: &DeriveContext,
) -> Result<TokenStream, fluent::Error> {

    let canonical_message = group.canonical_message(id, reference_kind)?;

    let canonical_message = group.remove_canonical_message(id, reference_kind)?;

        .additional_messages(id, reference_kind)?

        .remove_additional_messages(id, reference_kind)?

pub fn derive_struct(
    group: Group,

pub fn for_struct(
    mut group: fluent::Group,

) -> Result<TokenStream, FluentError> {

) -> Result<TokenStream, fluent::Error> {

        syn::Fields::Named(named_fields) => References {

        syn::Fields::Named(named_fields) => DeriveContext {

            kind: ReferenceKind::StructField,

            reference_kind: ReferenceKind::StructField,

            candidates: unique_named_fields(named_fields),

            valid_references: unique_named_fields(named_fields),

    expr_for_message(&group, &ident_kebab_case, &references)

    expr_for_message(&mut group, &ident_kebab_case, &references)

pub fn derive_enum(
    group: Group,

pub fn for_enum(
    mut group: fluent::Group,

) -> Result<TokenStream, FluentError> {

) -> Result<TokenStream, fluent::Error> {

            syn::Fields::Named(named_fields) => References {
                kind: ReferenceKind::EnumField,
                candidates: unique_named_fields(named_fields),

            syn::Fields::Named(named_fields) => DeriveContext {
                reference_kind: ReferenceKind::EnumField,
                valid_references: unique_named_fields(named_fields),

        let arm_body = expr_for_message(&group, &variant_kebab_case, &references)?;

        let arm_body = expr_for_message(&mut group, &variant_kebab_case, &references)?;