//! # nject ![Rust](https://github.com/nicolascotton/nject/workflows/Rust/badge.svg)
//! Simple zero cost dependency injection library made for rust
//! ## Install
//! Add the following to your `Cargo.toml`:
//! ```toml
//! [dependencies]
//! nject = "0.2"
//! ```
//! ## Use cases
//! ### Removes the need to specify dependencies across your modules
//! ```rust
//! use nject::{injectable, provider};
//!
//! #[injectable]
//! struct DepOne;
//!
//! #[injectable]
//! struct DepTwo {
//!     dep: DepOne,
//! }
//!
//! #[injectable]
//! struct Facade {
//!     dep: DepTwo,
//! }
//!
//! #[provider]
//! struct Provider;
//!
//! fn main() {
//!     let _facade: Facade = Provider.provide();
//! }
//!
//! ```
//! ### Works with lifetimes - enables shared dependencies
//! ```rust
//! use nject::{injectable, provide, provider};
//!
//! #[injectable]
//! struct DepOne;
//!
//! #[injectable]
//! struct Facade<'a> {
//!     dep: &'a DepOne,
//! }
//!
//! #[provider]
//! #[provide(&'a DepOne, self.shared)]
//! struct Provider<'a> {
//!     shared: &'a DepOne,
//! }
//!
//! fn main() {
//!     let provider = Provider { shared: &DepOne };
//!     let _facade: Facade = provider.provide();
//! }
//!
//! ```
//! ### Works with dyn traits
//! ```rust
//! use nject::{injectable, provide, provider};
//!
//! trait Greeter {
//!     fn greet(&self);
//! }
//!
//! #[injectable]
//! struct GreeterOne;
//!
//! impl Greeter for GreeterOne {
//!     fn greet(&self) {
//!         println!("Greeting");
//!     }
//! }
//!
//! #[injectable]
//! struct Facade<'a> {
//!     boxed_dep: Box<dyn Greeter>,
//!     ref_dep: &'a dyn Greeter,
//! }
//!
//! #[provider]
//! #[provide(Box<dyn Greeter>, Box::<GreeterOne>::new(self.provide()))]
//! #[provide(&'prov dyn Greeter, &self.greeter)]
//! struct Provider {
//!     greeter: GreeterOne,
//! }
//!
//! fn main() {
//!     let provider = Provider { greeter: GreeterOne };
//!     let _facade: Facade = provider.provide();
//! }
//!
//! ```
//! ### Works with generics
//! ```rust
//! use nject::{injectable, provider};
//!
//! #[injectable]
//! struct DepOne;
//!
//! #[injectable]
//! struct Facade<T> {
//!     dep: T,
//! }
//!
//! #[provider]
//! struct Provider;
//!
//! fn main() {
//!     let _facade: Facade<DepOne> = Provider.provide();
//! }
//!
//! ```
//! ### Works with generic providers
//! ```rust
//! use nject::{injectable, provide, provider};
//!
//! trait Greeter {
//!     fn greet(&self);
//! }
//!
//! #[injectable]
//! struct DevGreeter;
//!
//! impl Greeter for DevGreeter {
//!     fn greet(&self) {
//!         println!("Greeting Dev");
//!     }
//! }
//!
//! #[injectable]
//! struct ProdGreeter;
//!
//! impl Greeter for ProdGreeter {
//!     fn greet(&self) {
//!         println!("Greeting production");
//!     }
//! }
//!
//! #[injectable]
//! struct Facade<'a> {
//!     dep: &'a dyn Greeter,
//! }
//!
//! #[provider]
//! #[provide(&'a dyn Greeter, self.0)]
//! struct Provider<'a, T: Greeter>(&'a T);
//!
//! fn main() {
//!     let _dev_facade: Facade = Provider(&DevGreeter).provide();
//!     let _prod_facade: Facade = Provider(&ProdGreeter).provide();
//! }
//! ```
//! ### Easily inject non-injectable dependencies
//! ```rust
//! use nject::{inject, injectable, provide, provider};
//!
//! #[inject(Self { non_injectable_value: 123 })]
//! struct NonInjectableWithInjectAttr {
//!     non_injectable_value: i32,
//! }
//!
//! struct NonInjectable {
//!     non_injectable_value: i32,
//! }
//!
//! #[injectable]
//! struct Facade {
//!     dep_from_injected: NonInjectableWithInjectAttr,
//!     #[inject(NonInjectable { non_injectable_value: 456 })]
//!     dep_from_inject_attr: NonInjectable,
//!     #[inject(NonInjectableWithInjectAttr { non_injectable_value: 789 })]
//!     dep_from_inject_attr_override: NonInjectableWithInjectAttr,
//! }
//!
//! #[provider]
//! struct Provider;
//!
//! fn main() {
//!     let _facade = Provider.provide::<Facade>();
//! }
//! ```
//! ## Examples
//! You can look into the [axum](https://github.com/nicolascotton/nject/tree/main/examples/axum) example for a web API use case.
//! ## Credits
//! - [Syn](https://github.com/dtolnay/syn) - [MIT](https://github.com/dtolnay/syn/blob/master/LICENSE-MIT) or [Apache-2.0](https://github.com/dtolnay/syn/blob/master/LICENSE-APACHE)
//! - [Quasi-Quoting](https://github.com/dtolnay/quote) - [MIT](https://github.com/dtolnay/quote/blob/master/LICENSE-MIT) or [Apache-2.0](https://github.com/dtolnay/quote/blob/master/LICENSE-APACHE)
//! - [Rust](https://github.com/rust-lang/rust) - [MIT](https://github.com/rust-lang/rust/blob/master/LICENSE-MIT) or [Apache-2.0](https://github.com/rust-lang/rust/blob/master/LICENSE-APACHE)

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    parse_macro_input, DeriveInput, Expr, ExprParen, GenericParam, Ident, Token, Type,
};

/// For internal purposes only. Should not be used.
#[proc_macro_derive(InjectableHelperAttr, attributes(inject))]
pub fn injectable_helper_attr(_item: TokenStream) -> TokenStream {
    TokenStream::new()
}

/// Attribute to mark a struct as injectable.
/// ```rust
/// use nject_macro::{injectable, provider};
///
/// #[injectable]
/// struct Facade;
///
/// #[provider]
/// struct Provider;
///
/// fn main() {
///     let _facade: Facade = Provider.provide();
/// }
/// ```
#[proc_macro_attribute]
pub fn injectable(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let ident = &input.ident;
    let fields = match &input.data {
        syn::Data::Struct(d) => &d.fields,
        _ => panic!("Unsupported type. Macro should be used on a struct"),
    };
    let types = fields.iter().map(|f| &f.ty).collect::<Vec<&Type>>();
    let keys = fields
        .iter()
        .map(|f| f.ident.as_ref())
        .filter_map(|i| i)
        .collect::<Vec<&Ident>>();
    let attributes = fields
        .iter()
        .map(
            |f| match f.attrs.iter().filter(|a| a.path.is_ident("inject")).last() {
                Some(a) => Some(syn::parse2::<ExprParen>(a.tokens.clone()).unwrap().expr),
                None => None,
            },
        )
        .collect::<Vec<_>>();
    let generic_params = &input.generics.params.iter().collect::<Vec<&GenericParam>>();
    let generic_keys = &generic_params
        .iter()
        .map(|p| match p {
            GenericParam::Type(t) => {
                let identity = &t.ident;
                quote! { #identity }
            }
            GenericParam::Const(c) => {
                let identity = &c.ident;
                quote! { #identity }
            }
            GenericParam::Lifetime(l) => quote! { #l },
        })
        .collect::<Vec<_>>();
    let lifetime_keys = &generic_params
        .iter()
        .filter_map(|p| match p {
            GenericParam::Lifetime(l) => Some(quote! { #l }),
            _ => None,
        })
        .collect::<Vec<_>>();
    let prov_lifetimes = match lifetime_keys.len() > 0 {
        true => quote! { 'prov: #(#lifetime_keys)+*, },
        false => quote! {},
    };
    let where_predicates = match &input.generics.where_clause {
        Some(w) => {
            let predicates = &w.predicates;
            quote! { #predicates }
        }
        None => quote! {},
    };
    let creation_output = match keys.is_empty() && !types.is_empty() {
        true => {
            let items = types.iter().zip(&attributes).map(|(_, a)| match a {
                Some(attr) => quote! { #attr },
                None => quote! { provider.provide() },
            });
            quote! { #ident(#(#items),*) }
        }
        false => {
            let items = keys.iter().zip(&attributes).map(|(k, a)| match a {
                Some(attr) => quote! { #k: #attr },
                None => quote! { #k: provider.provide() },
            });
            quote! { #ident { #(#items),* } }
        }
    };
    let prov_types = types
        .iter()
        .zip(&attributes)
        .filter_map(|(t, a)| match a {
            Some(_) => None,
            None => Some(t),
        })
        .collect::<Vec<_>>();
    let output = quote! {
        #[derive(nject::InjectableHelperAttr)]
        #input

        impl<'prov, #(#generic_params,)*NjectProvider> nject::Injectable<'prov, #ident<#(#generic_keys),*>, NjectProvider> for #ident<#(#generic_keys),*>
            where
                #prov_lifetimes
                NjectProvider: #(nject::Provider<'prov, #prov_types>)+*,#where_predicates
        {
            fn inject(provider: &'prov NjectProvider) -> #ident<#(#generic_keys),*> {
                #creation_output
            }
        }
    };
    output.into()
}

/// Attribute to specify a desired injected value.
/// ```rust
/// use nject_macro::{inject, injectable, provider};
///
/// #[inject(Self { value: 42 })]
/// struct DepOne {
///     value: i32,
/// }
///
/// #[injectable]
/// struct Facade(DepOne, #[inject(123)] i32);
///
/// #[provider]
/// struct Provider;
///
/// fn main() {
///     let _facade: Facade = Provider.provide();
/// }
/// ```
#[proc_macro_attribute]
pub fn inject(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let creation_output = parse_macro_input!(attr as Expr);
    let ident = &input.ident;
    let generic_params = &input.generics.params.iter().collect::<Vec<&GenericParam>>();
    let generic_keys = &generic_params
        .iter()
        .map(|p| match p {
            GenericParam::Type(t) => {
                let identity = &t.ident;
                quote! { #identity }
            }
            GenericParam::Const(c) => {
                let identity = &c.ident;
                quote! { #identity }
            }
            GenericParam::Lifetime(l) => quote! { #l },
        })
        .collect::<Vec<_>>();
    let lifetime_keys = &generic_params
        .iter()
        .filter_map(|p| match p {
            GenericParam::Lifetime(l) => Some(quote! { #l }),
            _ => None,
        })
        .collect::<Vec<_>>();
    let prov_lifetimes = match lifetime_keys.len() > 0 {
        true => quote! { 'prov: #(#lifetime_keys)+*, },
        false => quote! {},
    };
    let where_predicates = match &input.generics.where_clause {
        Some(w) => {
            let predicates = &w.predicates;
            quote! { #predicates }
        }
        None => quote! {},
    };
    let output = quote! {
        #input

        impl<'prov, #(#generic_params,)*NjectProvider> nject::Injectable<'prov, #ident<#(#generic_keys),*>, NjectProvider> for #ident<#(#generic_keys),*>
            where
                #prov_lifetimes
                #where_predicates
        {
            fn inject(provider: &'prov NjectProvider) -> #ident<#(#generic_keys),*> {
                #creation_output
            }
        }
    };
    output.into()
}

/// Attribute to mark a struct as a provider.
/// ```rust
/// use nject_macro::{injectable, provider};
///
/// #[injectable]
/// struct Facade;
///
/// #[provider]
/// struct Provider;
///
/// fn main() {
///     let _facade: Facade = Provider.provide();
/// }
/// ```
#[proc_macro_attribute]
pub fn provider(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let ident = &input.ident;
    let generic_params = &input.generics.params.iter().collect::<Vec<&GenericParam>>();
    let generic_keys = &generic_params
        .iter()
        .map(|p| match p {
            GenericParam::Type(t) => {
                let identity = &t.ident;
                quote! { #identity }
            }
            GenericParam::Const(c) => {
                let identity = &c.ident;
                quote! { #identity }
            }
            GenericParam::Lifetime(l) => quote! { #l },
        })
        .collect::<Vec<_>>();
    let where_predicates = match &input.generics.where_clause {
        Some(w) => {
            let predicates = &w.predicates;
            quote! { #predicates }
        }
        None => quote! {},
    };
    let output = quote! {
        #input

        impl<'prov, #(#generic_params,)*Njecty> nject::Provider<'prov, Njecty> for #ident<#(#generic_keys),*>
            where Njecty: nject::Injectable<'prov, Njecty, #ident<#(#generic_keys),*>>,#where_predicates
        {
            fn provide(&'prov self) -> Njecty {
                Njecty::inject(self)
            }
        }

        impl<#(#generic_params),*> #ident<#(#generic_keys),*>
            where #where_predicates
        {
            pub fn provide<'prov, Njecty>(&'prov self) -> Njecty
                where Self: nject::Provider<'prov, Njecty>
            {
                <Self as nject::Provider<'prov, Njecty>>::provide(self)
            }
        }
    };
    output.into()
}

struct TypeExpr(Type, Expr);
impl Parse for TypeExpr {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let parsed_type = input.parse().unwrap();
        input.parse::<Token![,]>().unwrap();
        let parsed_value: Expr = input.parse().unwrap();
        return Ok(TypeExpr(parsed_type, parsed_value));
    }
}

/// Attribute to provide a given instance for a specific type.
/// ```rust
/// use nject_macro::{injectable, provide, provider};
///
/// struct Dependency {
///     value: i32,
/// }
///
/// #[injectable]
/// struct Facade(Dependency);
///
/// #[provider]
/// #[provide(Dependency, Dependency { value: 123 })]
/// struct Provider;
///
/// fn main() {
///     let _dependency: Dependency = Provider.provide();
///     let _facade: Facade = Provider.provide();
/// }
/// ```
#[proc_macro_attribute]
pub fn provide(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attributes: TypeExpr = syn::parse(attr).unwrap();
    let input = parse_macro_input!(item as DeriveInput);
    let ident = &input.ident;
    let generic_params = &input.generics.params.iter().collect::<Vec<&GenericParam>>();
    let generic_keys = &generic_params
        .iter()
        .map(|p| match p {
            GenericParam::Type(t) => {
                let identity = &t.ident;
                quote! { #identity }
            }
            GenericParam::Const(c) => {
                let identity = &c.ident;
                quote! { #identity }
            }
            GenericParam::Lifetime(l) => quote! { #l },
        })
        .collect::<Vec<_>>();
    let where_predicates = match &input.generics.where_clause {
        Some(w) => {
            let predicates = &w.predicates;
            quote! { #predicates }
        }
        None => quote! {},
    };
    let output_type = &attributes.0;
    let output_value = &attributes.1;
    let output = quote! {
        #input

        impl<'prov, #(#generic_params),*> nject::Provider<'prov, #output_type> for #ident<#(#generic_keys),*>
            where #where_predicates
        {
            fn provide(&'prov self) -> #output_type {
                #output_value
            }
        }
    };
    output.into()
}