use proc_macro2::TokenStream as TokenStream2;
use update_macro_base::*;

fn resource_only_events_and_systems(update: &Update) -> TokenStream2 {
    let resource_tokens = update.resourece_tokens();

    let resource_types = &resource_tokens.resource_types;
    let resource_type_impls = &resource_tokens.resource_type_impls;
    let resources = &resource_tokens.resources;
    let resource_requirement = &resource_tokens.resource_requirement;
    let resource_store = &resource_tokens.resource_store;
    let resource_idents = &resource_tokens.resource_idents;

    todo!()
}

fn events_and_systems(update: &Update) -> TokenStream2 {
    let query_tokens = update.query_tokens();

    let filter_types = &query_tokens.filter_types;
    let filter_type_impls = &query_tokens.filter_type_impls;
    let query_types = &query_tokens.query_types;
    let query_type_impls = &query_tokens.query_type_impls;
    let queries = query_tokens.queries;
    let filter_requirements = &query_tokens.filter_requirements;
    let component_requirements = &query_tokens.component_requirements;
    let query_count = query_tokens.query_count;
    let verify_dedup = &query_tokens.verify_dedup;
    let check_entities = &query_tokens.check_entities;
    let component_stores = &query_tokens.component_stores;
    let query_structs = &query_tokens.query_structs;
    let query_idents = &query_tokens.query_idents;

    let resource_tokens = update.resourece_tokens();

    let resource_types = &resource_tokens.resource_types;
    let resource_type_impls = &resource_tokens.resource_type_impls;
    let resources = &resource_tokens.resources;
    let resource_requirement = &resource_tokens.resource_requirement;
    let resource_store = &resource_tokens.resource_store;
    let resource_idents = &resource_tokens.resource_idents;

    todo!()
}

fn update(max_components: usize, max_resources: usize) -> TokenStream2 {
    let mut queries: Vec<Vec<usize>> = Vec::new();

    for c in Update::MIN_COMPONENTS..=max_components {
        queries.push(vec![c]);
    }

    for x in Update::MIN_COMPONENTS..=max_components {
        for y in Update::MIN_COMPONENTS..=max_components {
            queries.push(vec![x, y]);
        }
    }

    for x in Update::MIN_COMPONENTS..=max_components {
        for y in Update::MIN_COMPONENTS..=max_components {
            for z in Update::MIN_COMPONENTS..=max_components {
                queries.push(vec![x, y, z]);
            }
        }
    }

    let mut resources = Vec::new();

    for resource in Update::MIN_RESOURCE..=max_resources {
        resources.push(resource);
    }

    let mut updates = Vec::new();

    for query in queries.iter() {
        for resource_count in resources.iter() {
            updates.push(events_and_systems(&Update::new(
                query.iter().cloned(),
                *resource_count,
            )));
        }
    }

    let mut events = Vec::new();

    for resource_count in resources.iter() {
        let q =
            resource_only_events_and_systems(&Update::new(vec![1].into_iter(), *resource_count));

        events.push(q);
    }

    // updates.push(Update::new(vec![1].into_iter(), 0));

    // let q = quote! {
    //     #( #updates )*
    // };

    // panic!("{q}");

    TokenStream::from(quote! {
        #( #updates )*
        #( #events )*
    })
}