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

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

    root_id: &'context str,

    path: PathBuf,
    syntax_tree: fluent_syntax::ast::Resource<String>,

    named_source: NamedSource<String>,

        let named_source = NamedSource::new(path.to_string_lossy(), file_contents.clone());

            path,
            syntax_tree,

            named_source,

    /// Calculate the byte offset of the serialized
    fn source_with_message_offset(&self, id: &str) -> (NamedSource<String>, usize) {
        // Find the message position in the AST
        let ast_index = self
            .syntax_tree
            .body
            .iter()
            .position(|entry| {
                if let Entry::Message(message) = entry {
                    message.id.name == id
                } else {
                    false
                }
            })
            .unwrap();
        let options = fluent_syntax::serializer::Options {
            // Make sure to include all source code in error snippet, even if marked as "junk"
            with_junk: true,
        };
        // Serialize everything before this message to get the byte offset
        let source_before_message = fluent_syntax::serializer::serialize_with_options(
            &Resource {
                body: self.syntax_tree.body[0..ast_index].to_vec(),
            },
            options,
        );
        let byte_offset = source_before_message.len();
        let source_after_offset = fluent_syntax::serializer::serialize_with_options(
            &Resource {
                body: self.syntax_tree.body[ast_index..].to_vec(),
            },
            options,
        );
        let source = format!("{source_before_message}{source_after_offset}");
        let named_source = NamedSource::new(self.path.to_string_lossy(), source);
        (named_source, byte_offset)
    }

    // fn remove_expression(
    //     &mut self,
    //     id: &str,
    //     derive_context: &derive::Context,
    // ) -> Result<syn::Expr, Error> {
    //     let message = self.messages.remove(id).unwrap();
    //     let message_context = MessageContext {
    //         source: &self,
    //         root_id: id,
    //         // 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
    //         pattern: message.value.as_ref().unwrap(),
    //         derive_context,
    //     };
    //     ast::message_body(message_context)
    // }

            let mut unexpected_keys = source_file
                .message_ids()
                .filter(|id: &&str| !canonical_keys.contains(id));

            let mut unexpected_keys =
                source_file
                    .messages
                    .iter()
                    .filter(|(message_id, _message_value)| {
                        !canonical_keys.contains(&message_id.as_str())
                    });

            if let Some(unexpected_key) = unexpected_keys.next() {
                let (src, message_offset) = source_file.source_with_message_offset(unexpected_key);

            // TODO: group all unexpected keys into single error
            if let Some((unexpected_key, unexpected_message)) = unexpected_keys.next() {
                let source_code = source_file.named_source.clone();

                    source_code: src,
                    span: SourceSpan::new(message_offset.into(), unexpected_key.len()),

                    source_code,
                    span: SourceSpan::from(unexpected_message.id.span.0.clone()),

            root_id: &id,

                    root_id: &id,

            PatternElement::TextElement { value } => {

            PatternElement::TextElement { value, span: _ } => {

            PatternElement::Placeable { expression } => {

            PatternElement::Placeable {
                expression,
                span: _,
            } => {

                    Expression::Select { selector, variants } => {

                    Expression::Select { selector, variants, span: _ } => {

                    Expression::Inline(expression) => {

                    Expression::Inline(expression, _span) => {

        InlineExpression::StringLiteral { value } => {

        InlineExpression::StringLiteral { value, span: _ } => {

        InlineExpression::NumberLiteral { value } => {

        InlineExpression::NumberLiteral { value, span: _ } => {

        InlineExpression::VariableReference { id } => {

        InlineExpression::VariableReference { id, span } => {

                let (source_code, offset) = message_context
                    .source
                    .source_with_message_offset(message_context.root_id);
                let location = source_code.inner()[offset..]
                    .find(&format!("${fluent_name}"))
                    .unwrap()
                    + offset;

                let source_code = message_context.source.named_source.clone();

                    span: SourceSpan::new(location.into(), fluent_name.len()),

                    span: SourceSpan::from(span.0.to_owned()),

fluent-syntax = "0.11.1"

fluent-syntax = { git = "https://github.com/Ertanic/fluent-rs", branch = "span", features = [
    "spans",
] }

source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a530c4694a6a8d528794ee9bbd8ba0122e779629ac908d15ad5a7ae7763a33d"

source = "git+https://github.com/Ertanic/fluent-rs?branch=span#27615271d3f8d990e935d3c99053329863d6129e"

 "thiserror 1.0.69",

 "memchr",
 "thiserror 2.0.12",