mod pair_update;
mod single_update;
mod update;

use pair_update::pair_update;
use single_update::single_update;
use update::update;

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    DeriveInput, Ident, LitInt, Result,
    parse::{Parse, ParseStream},
    parse_macro_input,
    token::Comma,
};

struct UpdateInfo {
    max_components: usize,
    max_queries: usize,
}

impl Parse for UpdateInfo {
    fn parse(input: ParseStream) -> Result<Self> {
        let max_components = input.parse::<LitInt>()?.base10_parse()?;
        input.parse::<Comma>()?;
        let max_queries = input.parse::<LitInt>()?.base10_parse()?;

        Ok(Self {
            max_components,
            max_queries,
        })
    }
}

#[proc_macro]
pub fn implement_updates(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as UpdateInfo);

    update(input.max_components, input.max_queries)
}

struct InputInfo {
    macro_ident: Ident,
    start: usize,
    end: usize,
}

impl Parse for InputInfo {
    fn parse(input: ParseStream) -> Result<Self> {
        let macro_ident = input.parse::<Ident>()?;
        input.parse::<Comma>()?;
        let start = input.parse::<LitInt>()?.base10_parse()?;
        input.parse::<Comma>()?;
        let end = input.parse::<LitInt>()?.base10_parse()?;

        Ok(Self {
            macro_ident,
            start,
            end,
        })
    }
}

#[proc_macro]
pub fn implement_pair_update(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as InputInfo);

    pair_update(input)
}

#[proc_macro]
pub fn implement_single_update(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as InputInfo);

    single_update(input)
}

#[proc_macro_derive(Resource)]
pub fn derive_resource(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    let implementor = ast.ident;

    TokenStream::from(quote! {
        impl ecs::resources::Resource for #implementor {}
    })
}