use proc_macro2::Span;
use syn::{DeriveInput, Meta, NestedMeta, Ident};
use crate::debug;
use crate::changes::*;

fn hierarchical_storage(ast: &DeriveInput, name: &Ident, ty_generics: &syn::TypeGenerics) -> proc_macro2::TokenStream{
    let storage = ast.attrs.iter()
        .filter_map(|attr| attr.parse_meta().ok().and_then(|meta| match meta {
            Meta::List(ref list) if list.path.is_ident("storage") => Some(list.clone()),
            _ => None,
        }))
        .next()
        .and_then(|list| list.nested.first().and_then(|attr| match attr {
            NestedMeta::Meta(item) => Some(item.clone()),
            _ => None,
        }))
        .and_then(|attr| match attr {
            Meta::Path(path) => Some(path.segments.first().unwrap().ident.clone()),
            _ => None,
        })
        .unwrap_or(Ident::new("Forest", Span::call_site()));
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };

    let storage = quote!(#crate_name::storage::#storage<#name #ty_generics>);

    if changes(ast){
        quote!(#crate_name::storage::Changed<#storage, #name #ty_generics>)
    }else if autochanges(ast) {
        quote!(#crate_name::storage::AutoChanged<#storage, #name #ty_generics>)
    }else{
        storage
    }
}


fn impl_hierarchical_single_tuple_struct(ast: &DeriveInput) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let param_tokens = debug::impl_debug_parameter(ast);

    let storage = hierarchical_storage(ast, name, &ty_generics);
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };

    if let syn::Data::Struct(struct_data) = &ast.data {
        let field = struct_data.fields.iter().next().unwrap();
        let field_ty = &field.ty;
        let component_tokens =  quote! {
            impl #impl_generics #crate_name::Component for #name #ty_generics #where_clause {
                type Storage = #storage;
                type MutStorageCacheGuard = ();
                fn type_name() -> &'static str{
                    concat!(module_path!(), "::", stringify!(#name))
                }

                fn is_reference() -> bool { false }
            }

            impl #impl_generics ::std::ops::Deref for #name #ty_generics #where_clause {
                type Target = #field_ty;
                fn deref(&self) -> &#field_ty{
                    &self.0
                }
            }

            impl #impl_generics ::std::ops::DerefMut for #name #ty_generics #where_clause {
                fn deref_mut(&mut self) -> &mut #field_ty{
                    &mut self.0
                }
            }
        };
        param_tokens.into_iter().chain(component_tokens.into_iter()).collect()
    }else{
        unreachable!()
    }
}

fn impl_hierarchical_other_structs(ast: &DeriveInput) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let param_tokens = debug::impl_debug_parameter(ast);

    let storage = hierarchical_storage(ast, name, &ty_generics);
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };

    let component_tokens = quote! {
        impl #impl_generics #crate_name::Component for #name #ty_generics #where_clause {
            type Storage = #storage;
            type MutStorageCacheGuard = ();
            fn type_name() -> &'static str{
                concat!(module_path!(), "::", stringify!(#name))
            }

            fn is_reference() -> bool { false }
        }
    };
    param_tokens.into_iter().chain(component_tokens.into_iter()).collect()
}

pub fn impl_hierarchical_component(ast: &DeriveInput) -> proc_macro2::TokenStream {
    match &ast.data{
		syn::Data::Struct(struct_data) => match &struct_data.fields {
            syn::Fields::Unnamed(_) => {
                let fields = struct_data.fields.iter().collect::<Vec<_>>();
                if fields.len() == 1{
                    return impl_hierarchical_single_tuple_struct(ast);
                }
            }
            _ => (),
        }
        _ => ()
	}
    impl_hierarchical_other_structs(ast)
}