use proc_macro2::TokenStream;
use procmeta::prelude::*;
use quote::quote;
use roadblk_attr::{ConstraintType, Number};
use roadblk_expand::{ConstraintTypeAttr, ValidateAttr};
use syn::{Attribute, DeriveInput, LitStr};
use syn::{Data, Fields, Result};

use apidoc_attr::prop::ParsedApiDocAttr;
use apidoc_attr::serde::ParsedSerdeAttr;

#[derive(MetaParser)]
pub enum NameAttr {
    Name(LitStr),
}

#[derive(MetaParser)]
pub enum ParsedApiUseAttr {
    ApiUse(Type),
}

pub fn attrs_to_use_ty(attrs: &Vec<Attribute>) -> Result<Option<Type>> {
    let mut result = None;
    for attr in attrs {
        let parsed = ParsedApiUseAttr::parse(&attr.meta);
        if let Ok(api_use) = parsed {
            if result.is_some() {
                return Err(Error::new(Span::call_site(), "duplicate api_use"));
            }
            let ParsedApiUseAttr::ApiUse(ty) = api_use;
            result = Some(ty);
        }
    }
    Ok(result)
}

pub fn attrs_to_prop_token(attrs: &Vec<Attribute>) -> Result<TokenStream> {
    let mut result = quote!();
    for attr in attrs {
        let parsed = ParsedApiDocAttr::parse(&attr.meta);
        if let Ok(api_prop) = parsed {
            result = api_prop.get_token_stream();
        }
    }
    if result.is_empty() {
        return Ok(quote!(None));
    }
    Ok(quote!(Some(#result)))
}

pub fn ident_to_name_token(ident: &Ident) -> TokenStream {
    let name_str = ident.to_string();
    quote!(#name_str.into())
}

fn get_constrait_token_stream(
    new_models: &mut TokenStream,
    attr_constraint_type: ConstraintTypeAttr,
) -> Result<TokenStream> {
    fn lit_to_number(lit: &Lit) -> Result<Number> {
        let num = match lit {
            Lit::Int(i) => Number::NegInt(i.base10_parse()?),
            Lit::Float(f) => Number::Float(f.base10_parse()?),
            _ => return Err(Error::new(Span::call_site(), "invalid number")),
        };
        Ok(num)
    }

    let result = match attr_constraint_type {
        ConstraintTypeAttr::Length(min, max) => {
            let min = min.base10_parse()?;
            let max = max.base10_parse()?;
            ConstraintType::Length(min, max).get_token_stream()
        }
        ConstraintTypeAttr::Range(min, max) => {
            let min = lit_to_number(&min)?;
            let max = lit_to_number(&max)?;
            ConstraintType::Range(min, max).get_token_stream()
        }
        ConstraintTypeAttr::Validator => ConstraintType::SelfValidator.get_token_stream(),
        ConstraintTypeAttr::SpecialValidator(ct) => {
            quote!(#ct ::constraint_type())
        }
        ConstraintTypeAttr::Regex(r) => ConstraintType::Regex(r.value()).get_token_stream(),
        ConstraintTypeAttr::Enumer(e) => {
            *new_models = quote! {
                #new_models
                #e :: api_collect_ty(models);
            };
            quote!(ConstraintType::Enumer (#e :: api_model_id()))
        }
    };
    Ok(result)
}

fn attrs_to_constraint_token(
    new_models: &mut TokenStream,
    field_ty: &Type,
    attrs: &Vec<Attribute>,
) -> Result<TokenStream> {
    let mut result = quote!();
    for attr in attrs {
        let parsed = ValidateAttr::parse(&attr.meta);
        if let Ok(parsed) = parsed {
            let item_constraint = match parsed {
                ValidateAttr::DefaultValidate | ValidateAttr::DefaultValidateWithMsg(_) => {
                    quote!(#field_ty :: constraint_type())
                }
                ValidateAttr::Validate(ct) | ValidateAttr::ValidateWithMsg(ct, _) => {
                    get_constrait_token_stream(new_models, ct)?
                }
            };
            result = quote! {
                #result
                #item_constraint,
            };
        }
    }
    Ok(quote!(vec![#result]))
}

pub fn attrs_to_serde_token(attrs: &Vec<Attribute>) -> Result<TokenStream> {
    let mut result = quote!();
    for attr in attrs {
        let parsed_attr = ParsedSerdeAttr::parse(&attr.meta);
        if let Ok(parsed) = parsed_attr {
            let serde_token_stream = parsed.get_token_stream();
            result = quote! (#result #serde_token_stream,);
        }
    }
    Ok(quote!(vec![#result]))
}

pub fn expand(input: DeriveInput) -> Result<TokenStream> {
    let ty = &input.ident;
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
    let impl_generics_token = impl_generics_join_trait(impl_generics, "ApiTyTrait")?;

    let use_ty = attrs_to_use_ty(&input.attrs)?;
    if let Some(ty) = use_ty {
        return Ok(quote! {
            impl #impl_generics_token  ApiTyTrait for #ty #ty_generics #where_clause {
                fn api_collect_ty(models: &mut HashMap<String, Option<ApiModel>>) -> ApiTy {
                    $ty :: api_collect_ty(models)
                }
            }
        });
    }
    let name_str = ty.to_string();
    let name_token = quote!(#name_str.into());
    let desc_token = attrs_to_desc_token(&input.attrs)?;
    let prop_token = attrs_to_prop_token(&input.attrs)?;
    let serde_token = attrs_to_serde_token(&input.attrs)?;

    let body_token = match &input.data {
        Data::Struct(data) => impl_struct(name_token, desc_token, prop_token, serde_token, data)?,
        Data::Enum(data) => impl_enum(name_token, desc_token, prop_token, serde_token, data)?,
        Data::Union(_) => unimplemented!(),
    };
    let result = quote! {

        impl #impl_generics_token  ApiTyTrait for #ty #ty_generics #where_clause {
            fn api_collect_ty(models: &mut HashMap<String, Option<ApiModel>>) -> ApiTy {
                #body_token
            }
        }

    };
    Ok(result)
}

fn impl_struct(
    name_token: TokenStream,
    desc_token: TokenStream,
    prop_token: TokenStream,
    serde_token: TokenStream,
    data: &syn::DataStruct,
) -> Result<TokenStream> {
    let model_id_token = quote!(Self::api_model_id());
    let model_token = get_model_token(
        model_id_token.clone(),
        name_token,
        desc_token,
        prop_token,
        serde_token,
        quote!(None),
        &data.fields,
    )?;
    Ok(quote! {
        #model_token
        ApiTy::Struct {
            model_id: #model_id_token
        }
    })
}

fn impl_enum(
    name_token: TokenStream,
    desc_token: TokenStream,
    prop_token: TokenStream,
    serde_token: TokenStream,
    data: &syn::DataEnum,
) -> Result<TokenStream> {
    let mut variants_token = quote!();
    let mut model_token = quote!();
    for variant in data.variants.iter() {
        let mut model_value_token = quote!(None);
        if let Some((_, expr)) = &variant.discriminant {
            model_value_token = quote!(Some(#expr));
        }
        let attrs = &variant.attrs;
        let variant_name = variant.ident.to_string();
        let model_name_token = quote!(#variant_name.into());
        let model_prop_token = attrs_to_prop_token(attrs)?;
        let model_serde_token = attrs_to_serde_token(attrs)?;
        let fields = &variant.fields;
        let model_id_token = quote!(format!("{}::{}", Self::api_model_id(), #variant_name));

        let model_desc_token = attrs_to_desc_token(attrs)?;
        let item_model_token = get_model_token(
            model_id_token.clone(),
            model_name_token,
            model_desc_token,
            model_prop_token,
            model_serde_token,
            model_value_token,
            fields,
        )?;
        model_token = quote! {
            #model_token
            #item_model_token
        };
        variants_token = quote!(#variants_token #model_id_token,);
    }
    let result_token = quote! {
        #model_token
        ApiTy::Enumer(Box::new(
            ApiEnumer {
                ident: #name_token,
                name: #desc_token,
                prop: #prop_token,
                serde: #serde_token,
                variants: vec![#variants_token],
            }
        ))
    };
    Ok(result_token)
}

fn get_model_token(
    model_id_token: TokenStream,
    model_name_token: TokenStream,
    model_desc_token: TokenStream,
    model_prop_token: TokenStream,
    model_serde_token: TokenStream,
    model_value_token: TokenStream,
    fields: &Fields,
) -> Result<TokenStream> {
    let mut fields_item_token = quote!();
    let mut new_models_token = quote!();
    for (index, field) in fields.iter().enumerate() {
        let attrs = &field.attrs;
        let field_prop_token = attrs_to_prop_token(attrs)?;
        let field_serde_token = attrs_to_serde_token(attrs)?;
        let use_ty = attrs_to_use_ty(attrs)?;
        let mut field_ty = field.get_type_colon2();
        if let Some(use_ty) = use_ty {
            field_ty = use_ty;
        }
        let field_constraint_token =
            attrs_to_constraint_token(&mut new_models_token, &field_ty, attrs)?;
        let mut ty = field.ty.clone();
        type_add_colon2(&mut ty);
        let field_desc = attrs_to_desc_token(attrs)?;
        match &field.ident {
            Some(field_ident) => {
                let field_name_token = ident_to_name_token(field_ident);
                fields_item_token = quote! {
                    #fields_item_token
                    ApiNamedField {
                        name: #field_desc,
                        ident: #field_name_token,
                        prop: #field_prop_token,
                        option: #ty :: api_option(),
                        ty: #ty :: api_collect_ty(models),
                        constraint: #field_constraint_token,
                        serde: #field_serde_token,
                    },
                };
            }
            None => {
                fields_item_token = quote! {
                    #fields_item_token
                    ApiUnamedField {
                        name: #field_desc,
                        index: #index as i32,
                        prop: #field_prop_token,
                        option: #ty :: api_option(),
                        ty: #ty :: api_collect_ty(models),
                        constraint: #field_constraint_token,
                        serde: #field_serde_token,
                    },
                };
            }
        }
    }
    let fields_token = match fields {
        Fields::Named(_) => {
            quote! {
                ApiFields::Named(vec![#fields_item_token])
            }
        }
        Fields::Unnamed(_) => {
            quote! {
                ApiFields::Unnamed(vec![#fields_item_token])
            }
        }
        Fields::Unit => {
            quote! {
                ApiFields::Unit
            }
        }
    };
    let model_token = quote! {
        ApiModel {
            ident: #model_name_token,
            name: #model_desc_token,
            prop: #model_prop_token,
            value: #model_value_token,
            serde: #model_serde_token,
            fields: #fields_token,
        }
    };
    let result_token = quote! {
        let model_id = #model_id_token;
        if !models.contains_key(&model_id) {
            models.insert(model_id.clone(), None);
            let model = #model_token;
            models.insert(model_id, Some(model));
            #new_models_token
        };
    };
    Ok(result_token)
}

fn attrs_to_desc_token(attrs: &[Attribute]) -> Result<TokenStream> {
    let mut field_desc = None;
    for attr in attrs {
        let parsed_attr = NameAttr::try_from(attr);
        if let Ok(parsed_attr) = parsed_attr {
            if field_desc.is_some() {
                return Err(Error::new(Span::call_site(), "desc attr duplicated"));
            }
            let NameAttr::Name(desc) = parsed_attr;
            field_desc = Some(desc.value());
        }
    }
    Ok(field_desc.get_token_stream())
}