extern crate proc_macro;

use inflector::Inflector;
use proc_macro::TokenStream;
use quote::quote;
use syn::parse::{Parse, ParseStream, Result};
use syn::punctuated::Punctuated;
use syn::{parse_macro_input, Error, Expr, ExprLit, Ident, Lit, Token, Visibility};

// TODO: change this to actually get types, but still be able to make the variant names
struct ActivitypubProperty {
    visibility: Visibility,
    name: Ident,
    functional: bool,
    possible_ty: Punctuated<Ident, Token![,]>,
}

impl Parse for ActivitypubProperty {
    fn parse(input: ParseStream) -> Result<Self> {
        let visibility = input.parse()?;
        let name = input.parse()?;
        input.parse::<Token![,]>()?;
        let functional_expr: Expr = input.parse()?;
        input.parse::<Token![,]>()?;
        let possible_ty = input.parse_terminated(Ident::parse)?;

        let functional = if let Expr::Lit(ExprLit {
            lit: Lit::Bool(b), ..
        }) = functional_expr
        {
            b.value
        } else {
            return Err(Error::new_spanned(
                functional_expr,
                "expected true or false",
            ));
        };

        Ok(ActivitypubProperty {
            visibility,
            name,
            possible_ty,
            functional,
        })
    }
}

// Default to using a vec for non-functional fields
#[proc_macro]
pub fn activitypub_property(input: TokenStream) -> TokenStream {
    activitypub_property_vec(input)
}

#[proc_macro]
pub fn activitypub_property_vec(input: TokenStream) -> TokenStream {
    let ActivitypubProperty {
        visibility,
        name,
        possible_ty,
        functional,
    } = parse_macro_input!(input as ActivitypubProperty);

    let variants = possible_ty.iter().map(|ty| {
        let singular_name = format!("{}", ty).to_pascal_case();
        let plural_name = format!("{}", ty).to_pascal_case().to_plural();
        let singular_ident = Ident::new(&singular_name, ty.span());
        let plural_ident = Ident::new(&plural_name, ty.span());
        if functional {
            quote! {
                #singular_ident(Box<#ty>)
            }
        } else {
            quote! {
                #singular_ident(Box<#ty>),
                #plural_ident(Vec<#ty>)
            }
        }
    });

    let constructors = possible_ty.iter().map(|ty| {
        let singular_name = format!("{}", ty).to_pascal_case();
        let plural_name = format!("{}", ty).to_pascal_case().to_plural();
        let singular_ident = Ident::new(&singular_name, ty.span());
        let plural_ident = Ident::new(&plural_name, ty.span());

        let singular_constructor_name = format!("{}", ty).to_snake_case();
        let plural_constructor_name = format!("{}", ty).to_snake_case().to_plural();
        let singular_constructor_ident = Ident::new(&singular_constructor_name, ty.span());
        let plural_constructor_ident = Ident::new(&plural_constructor_name, ty.span());
        if functional {
            quote! {
                #visibility fn #singular_constructor_ident(#ty) -> Self {
                    Self::#singular_ident(Box::new(#ty))
                }
            }
        } else {
            quote! {
                #visibility  fn #singular_constructor_ident(value: #ty) -> Self {
                    Self::#singular_ident(Box::new(value))
                }
                #visibility  fn #plural_constructor_ident(values: Vec<#ty>) -> Self {
                    Self::#plural_ident(values)
                }
            }
        }
    });

    let expanded = quote! {
        #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
        #[serde(untagged)]
        #visibility enum #name {
            None,
            #(#variants,)*
        }

        impl #name {
            #(#constructors)*
        }

        impl Default for #name {
            fn default() -> Self {
                Self::None
            }
        }

        impl ActivitypubProperty for #name {
            fn is_none(&self) -> bool {
                self == &Self::None
            }
        }
    };

    expanded.into()
}

#[proc_macro]
pub fn activitypub_property_hashmap(input: TokenStream) -> TokenStream {
    let ActivitypubProperty {
        visibility,
        name,
        possible_ty,
        functional,
    } = parse_macro_input!(input as ActivitypubProperty);

    let variants = possible_ty.iter().map(|ty| {
        let singular_name = format!("{}", ty).to_pascal_case();
        let plural_name = format!("{}", ty).to_pascal_case().to_plural();
        let singular_ident = Ident::new(&singular_name, ty.span());
        let plural_ident = Ident::new(&plural_name, ty.span());
        if functional {
            quote! {
                #singular_ident(Box<#ty>)
            }
        } else {
            quote! {
                #singular_ident(Box<#ty>),
                #plural_ident(HashMap<String, #ty>)
            }
        }
    });

    let constructors = possible_ty.iter().map(|ty| {
        let singular_name = format!("{}", ty).to_pascal_case();
        let plural_name = format!("{}", ty).to_pascal_case().to_plural();
        let singular_ident = Ident::new(&singular_name, ty.span());
        let plural_ident = Ident::new(&plural_name, ty.span());

        let singular_constructor_name = format!("{}", ty).to_snake_case();
        let plural_constructor_name = format!("{}", ty).to_snake_case().to_plural();
        let singular_constructor_ident = Ident::new(&singular_constructor_name, ty.span());
        let plural_constructor_ident = Ident::new(&plural_constructor_name, ty.span());
        if functional {
            quote! {
                #visibility fn #singular_constructor_ident(#ty) -> Self {
                    Self::#singular_ident(Box::new(#ty))
                }
            }
        } else {
            quote! {
                #visibility  fn #singular_constructor_ident(value: #ty) -> Self {
                    Self::#singular_ident(Box::new(value))
                }
                #visibility  fn #plural_constructor_ident(values: HashMap<String, #ty>) -> Self {
                    Self::#plural_ident(values)
                }
            }
        }
    });

    let expanded = quote! {
        #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
        #[serde(untagged)]
        #visibility enum #name {
            None,
            #(#variants,)*
        }

        impl #name {
            #(#constructors)*
        }

        impl Default for #name {
            fn default() -> Self {
                Self::None
            }
        }

        impl ActivitypubProperty for #name {
            fn is_none(&self) -> bool {
                self == &Self::None
            }
        }
    };

    expanded.into()
}