use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse_macro_input, spanned::Spanned, Attribute, AttributeArgs, Data, DeriveInput, Lit, LitStr,
    NestedMeta, Type,
};

struct MacroAttrs {
    pub repr: Type,

    pub no_debug: bool,
    pub no_display: bool,
    pub no_total_eq: bool,

    pub no_clone: bool,
    pub no_copy: bool,
}

fn find_repr(attrs: &Vec<Attribute>) -> MacroAttrs {
    let mut repr: Option<Type> = None;
    let mut no_display = false;
    let mut no_debug = false;
    let mut no_total_eq = false;
    let mut no_clone = false;
    let mut no_copy = false;

    for attr in attrs {
        if let Ok(meta) = attr.parse_meta() {
            let path = meta.path();

            if path.is_ident("no_debug") {
                no_debug = true;
            } else if path.is_ident("repr") {
                if let Ok(args) = attr.parse_args::<proc_macro2::TokenStream>() {
                    let args = args.into();
                    let args = syn::parse_macro_input::parse::<AttributeArgs>(args).unwrap();

                    match args.get(0) {
                        Some(v) => match v {
                            NestedMeta::Meta(item) => {
                                if repr.is_some() {
                                    panic!("Repr is already defined");
                                }

                                let ident = item.path().get_ident().unwrap().to_string();
                                repr = Some(syn::parse_str::<syn::Type>(&ident).unwrap());
                            }
                            _ => panic!("Invalid repr"),
                        },
                        None => {
                            panic!("Repr requires an argument");
                        }
                    };
                }
            } else if path.is_ident("no_display") {
                no_display = true;
            } else if path.is_ident("no_total_eq") {
                no_total_eq = true;
            } else if path.is_ident("no_clone") {
                no_clone = true;
            } else if path.is_ident("no_copy") {
                no_copy = true;
            }
        }
    }

    MacroAttrs {
        repr: repr.expect("Repr is required"),
        no_debug,
        no_display,
        no_total_eq,
        no_clone,
        no_copy,
    }
}

/// Macro that implements bunch of traits for enums that simply
/// are aliases for integer type
///
/// example:
/// ```no_run
/// #[derive(IntegralEnum)]
/// #[repr(u8)]
/// pub enum Yuu {
///     // explicit discriminant is required
///     Hatred = 0,
///     Pain = 1,
/// }
/// ```
///
/// Macro will automatically generate such trait implementations:
/// Clone, Copy, PartialEq, Eq, Debug, Display, TryFrom
#[proc_macro_derive(IntegralEnum)]
pub fn enum_try_from(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let macro_attrs = find_repr(&input.attrs);

    let repr = &macro_attrs.repr;

    match input.data {
        Data::Enum(e) => {
            let name = input.ident;
            let old_variants = e.variants;

            let items: Vec<_> = old_variants
                .iter()
                .map(|variant| {
                    if !variant.fields.is_empty() {
                        panic!("Enum with content is not supported");
                    }

                    let ident = &variant.ident;
                    let (_, discriminant) = variant
                        .discriminant
                        .as_ref()
                        .expect("Discriminant is required");
                    let strlit = Lit::Str(LitStr::new(&ident.to_string(), variant.span()));

                    (
                        quote::quote! {
                            #discriminant => { Ok(Self::#ident) }
                        },
                        quote::quote! {
                            Self::#ident => { #strlit }
                        },
                        quote::quote! {
                            Self::#ident => { Self::#ident }
                        },
                    )
                })
                .collect();

            let convert_arms = items.iter().map(|(d, _, _)| d);
            let display_arms = items.iter().map(|(_, d, _)| d);
            let clone_arms = items.iter().map(|(_, _, d)| d);

            let (display, debug) = if macro_attrs.no_display {
                (quote::quote!(), quote::quote!())
            } else {
                let display = quote::quote! {
                    impl core::fmt::Display for #name {
                        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                            f.write_str(match self {
                                #(#display_arms),*
                            })
                        }
                    }
                };

                if macro_attrs.no_debug {
                    (display, quote::quote!())
                } else {
                    let debug = quote::quote! {
                        impl core::fmt::Debug for #name {
                            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error> {
                                <Self as core::fmt::Display>::fmt(self, f)
                            }
                        }
                    };
                    (display, debug)
                }
            };

            let total_eq = if macro_attrs.no_total_eq {
                quote::quote!()
            } else {
                quote::quote!(impl core::cmp::Eq for #name {})
            };

            let (clone, copy) = if macro_attrs.no_clone {
                (quote::quote!(), quote::quote!())
            } else {
                let clone = quote::quote! {
                    impl core::clone::Clone for #name {
                        #[inline]
                        fn clone(&self) -> Self {
                            match self {
                                #(#clone_arms),*
                            }
                        }
                    }
                };

                if macro_attrs.no_copy {
                    let copy = quote::quote! { impl core::marker::Copy for #name {} };

                    (clone, copy)
                } else {
                    (clone, quote::quote!())
                }
            };

            quote! {
                #clone
                #copy

                impl core::cmp::PartialEq for #name {
                    fn eq(&self, other: &Self) -> bool {
                        core::mem::discriminant(self) == core::mem::discriminant(other)
                    }
                }
                #total_eq

                #display
                #debug

                impl core::convert::TryFrom<#repr> for #name {
                    type Error = ();

                    fn try_from(v: #repr) -> core::result::Result<Self, Self::Error> {
                        match v {
                            #(#convert_arms),*

                            _ => Err(())
                        }
                    }
                }
            }
            .into()
        }

        _ => panic!("Structures or unions are not supported"),
    }
}