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 parse_attrs(attrs: &Vec<Attribute>) -> MacroAttrs {
    let mut repr: Type = syn::parse_str("u8").unwrap();
    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;

    fn parse_inner_args(
        stream: TokenStream,
        no_display: &mut bool,
        no_debug: &mut bool,
        no_total_eq: &mut bool,
        no_clone: &mut bool,
        no_copy: &mut bool,
    ) {
        let punct = syn::parse_macro_input::parse::<AttributeArgs>(stream)
            .expect("Failed to parse attribute args");
        for meta in punct {
            match meta {
                NestedMeta::Meta(item) => {
                    let ident = item
                        .path()
                        .get_ident()
                        .expect("arg should be single ident, not absolute path")
                        .to_string();
                    match ident.as_str() {
                        "copy" => {
                            *no_copy = true;
                        }
                        "clone" => {
                            *no_clone = true;
                        }
                        "display" => {
                            *no_display = true;
                        }
                        "debug" => {
                            *no_debug = true;
                        }
                        "total_eq" => {
                            *no_total_eq = true;
                        }

                        v => panic!("Unknown variant {v:?}"),
                    }
                }
                _ => panic!("literals are not supported"),
            }
        }
    }

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

            if path.is_ident("enum_disable") {
                if let Ok(args) = attr.parse_args::<proc_macro2::TokenStream>() {
                    parse_inner_args(
                        args.into(),
                        &mut no_display,
                        &mut no_debug,
                        &mut no_total_eq,
                        &mut no_clone,
                        &mut no_copy,
                    );
                } else {
                    panic!("Failed to parse `enum_disable` args");
                }
            } 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) => {
                                let ident = item.path().get_ident().unwrap().to_string();
                                repr = syn::parse_str::<syn::Type>(&ident)
                                    .expect("repr argument should be valid type");
                            }
                            _ => panic!("Invalid repr"),
                        },
                        None => {
                            panic!("Repr requires an argument");
                        }
                    };
                }
            }
        }
    }

    MacroAttrs {
        repr,
        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, attributes(enum_disable))]
pub fn enum_try_from(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let macro_attrs = parse_attrs(&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 {
                    (clone, quote::quote!())
                } else {
                    let copy = quote::quote! { impl core::marker::Copy for #name {} };

                    (clone, copy)
                }
            };

            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"),
    }
}