[package]
name = "output_macros"
version = "0.1.0"
edition = "2021"
[lib]
proc-macro = true
[lints]
workspace = true
[dependencies]
proc-macro2 = "1.0.78"
quote = "1.0.35"
syn = { version = "2.0.48", features = ["full"] }

use output_macros::Output;
#[derive(Output)]
struct SimpleOutput {
    first: usize,
    second: String,
}
fn main() {
    // Create builder (auto-generated by #[derive(Output)])
    let mut builder = SimpleOutput::new();
    dbg!(builder.get_first()); // Empty (None)
    builder.first(2); // Set to Some(2)
    dbg!(builder.get_first()); // Full (Some(2))
    dbg!(builder.get_second()); // Empty (None)
    builder.second(String::from("It works!!")); // Set to Some("It works!!")
    dbg!(builder.get_second()); // Full (Some("It works!!"))
}

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{parse_macro_input, DeriveInput};
#[proc_macro_derive(Output)]
pub fn output(input: TokenStream) -> TokenStream {
    let DeriveInput { ident, data, .. } = parse_macro_input!(input);
    match data {
        syn::Data::Struct(struct_data) => {
            let builder_ident = format_ident!("{ident}Builder");
            // Get all field identifiers in the struct
            // Each field is assumed to have a unique identifier (Rust should enforce this?)
            let field_idents = struct_data
                .fields
                .iter()
                .map(|field| field.ident.clone().unwrap()); // TODO: handle tuple structs
            let types = struct_data.fields.iter().map(|field| field.ty.clone());
            let ident_type_mappings = field_idents.clone().zip(types.clone());
            // In the builder struct definition, map each field from `field: T` to `field: Option<T>`
            let optional_mappings = ident_type_mappings
                .clone()
                .map(|(field_ident, ty)| quote! { #field_ident: Option<#ty> });
            // Functions to handle incoming data
            // In the future these functions will include logic for immediate output to stdout (human output),
            // just lazily setting (machine output), or something else (maybe test handler?)
            // TODO: investigate setting collections, e.g. have the setter extend rather than set the collection so that
            // it can be immmediately output rather than to buffer all items in collection
            let setter_functions = ident_type_mappings.clone().map(|(field_ident, ty)| {
                quote! { fn #field_ident(&mut self, value: #ty) -> &mut Self {
                    assert!(self.#field_ident.is_none());
                    self.#field_ident = Some(value);
                    self
                }}
            });
            // Simple getter functions to inspect the value set in the builder
            let getter_functions = field_idents
                .clone()
                .map(|field_ident| format_ident!("get_{field_ident}"))
                .zip(field_idents.clone())
                .zip(types.clone())
                .map(|((function_ident, field_ident), ty)| {
                    quote! { fn #function_ident(&self) -> &Option<#ty> {
                        &self.#field_ident
                    }}
                });
            // Construct the builder implementation and return the token stream
            quote! {
                struct #builder_ident {
                    #(#optional_mappings),*
                }
                impl #builder_ident {
                    const fn new() -> Self {
                        Self {
                            #(#field_idents: None),*
                        }
                    }
                    #(#setter_functions)*
                    #(#getter_functions)*
                }
                impl #ident {
                    pub const fn new() -> #builder_ident {
                        #builder_ident::new()
                    }
                }
            }
            .into()
        }
        _ => todo!("Handle deriving non-structs"),
    }
}

members = ["fluent_embed", "output-macros", "cli_macros", "locale_select", "fluent_embed_runtime"]

members = [
    "fluent_embed",
    "cli_macros",
    "locale_select",
    "fluent_embed_runtime",
]

name = "output_macros"
version = "0.1.0"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.71",
]
[[package]]