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

#[derive(Default)]
struct MacroFlags {
    pub no_debug: bool,
    pub no_display: bool,
    pub no_partial_eq: bool,
    pub no_total_eq: bool,
    pub no_try_from: bool,

    pub no_clone: bool,
    pub no_copy: bool,
}

struct MacroAttrs {
    pub repr: Type,
    pub flags: MacroFlags,
}

fn parse_attrs(attrs: &Vec<Attribute>) -> MacroAttrs {
    let mut macro_attrs = MacroAttrs {
        repr: syn::parse_str("u8").unwrap(),
        flags: Default::default(),
    };

    enum InnerParseError {
        FailedToParseAttributeArgs,
        UnknownVariantSpecified { variant: String },
        LiteralsAreNotSupported,
    }

    fn parse_inner_args(
        stream: TokenStream,
        flags: &mut MacroFlags,
    ) -> Result<(), InnerParseError> {
        let Ok(punct) = syn::parse_macro_input::parse::<AttributeArgs>(stream) else {
            return Err(InnerParseError::FailedToParseAttributeArgs);
        };

        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" => {
                            flags.no_copy = true;
                        }
                        "clone" => {
                            flags.no_clone = true;
                        }
                        "display" => {
                            flags.no_display = true;
                        }
                        "debug" => {
                            flags.no_debug = true;
                        }
                        "total_eq" => {
                            flags.no_total_eq = true;
                        }
                        "partial_eq" => {
                            flags.no_partial_eq = true;
                        }
                        "try_from" => {
                            flags.no_try_from = true;
                        }

                        v => {
                            return Err(
                                InnerParseError::UnknownVariantSpecified {
                                    variant: v.into(),
                                },
                            )
                        }
                    }
                }
                _ => {
                    return Err(
                        InnerParseError::LiteralsAreNotSupported,
                    )
                }
            }
        }

        Ok(())
    }

    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>()
                {
                    if let Err(e) = parse_inner_args(
                        args.into(),
                        &mut macro_attrs.flags,
                    ) {
                        match e {
                            InnerParseError::FailedToParseAttributeArgs => abort! {
                                attr, "Failed to parse attribute args";
                                note = "Possibly your input is not comma-separated idents?"
                            },
                            InnerParseError::LiteralsAreNotSupported => abort! {
                                attr, "Invalid macro argument";
                                help = "Try replace your literal with an ident"
                            },

                            InnerParseError::UnknownVariantSpecified { variant } => abort! {
                                attr, format!("Unknown variant specified: {variant}");
                                help = "Available variants are: display, debug, try_from, \
                                        clone, copy, total_eq, partial_eq"
                            },
                        }
                    }
                } else {
                    abort! {
                        attr, "Failed to parse `enum_disable` args";
                        note = "Possibly your input is not comma-separated list of idents";
                        help = "consider the following example: #[enum_disable(display, clone)],\
                                this will disable Display & Clone trait implementations";
                    };
                }
            } 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();
                                macro_attrs.repr = if let Ok(t) =
                                    syn::parse_str::<syn::Type>(
                                        &ident,
                                    ) {
                                    t
                                } else {
                                    abort! {
                                        v, "repr must be valid integral type";
                                        help = "consider specifying one of: u8, u16, u32, u64,\
                                                u128 and its signed equivalents"
                                    };
                                }
                            }
                            _ => abort! {
                                v, "Invalid repr argument";
                                help = "Specify integral type to repr, for example: `#[repr(u16)]`"
                            },
                        },
                        None => {
                            abort! {
                                meta, "repr is expected to have 1 argument";
                                help = "Consider specifying an argument, for example: `#[repr(u16)]`"
                            }
                        }
                    };
                }
            }
        }
    }

    macro_attrs
}

/// Macro that implements bunch of traits for enums that
/// simply are aliases for integer type
///
/// example:
/// ```
/// use integral_enum::IntegralEnum;
///
/// #[derive(IntegralEnum)]
/// #[repr(u8)]
/// // repr is not required, by default `IntegralEnum` assumes that repr is u8
/// // FIXME: repr should be infered to avoid specific errors
/// pub enum Yuu {
///     // explicit discriminant is required
///     Hatred = 0,
///     Pain = 1,
/// }
///
/// assert_eq!(Yuu::try_from(0), Ok(Yuu::Hatred));
/// assert_eq!(Yuu::try_from(1), Ok(Yuu::Pain));
/// assert_eq!(Yuu::try_from(123), Err(()));
/// ```
///
/// Macro will automatically generate such trait
/// implementations: Clone, Copy, PartialEq, Eq, Debug,
/// Display, TryFrom.
///
/// To resolve conflicts with other derive-macro you should
/// use the #[enum_disable(...)] attribute, it has the
/// following options:
///
/// `debug`, `display`, `clone`, `copy`, `partial_eq`,
/// `total_eq`, `try_from`
///
/// `total_eq` depends on `partial_eq`, `copy` depends on
/// `clone`, so if you disable dependency, dependant
/// implementation will be disabled too, for example:
///
/// ```
/// use integral_enum::IntegralEnum;
///
/// #[derive(Debug, IntegralEnum)]
/// #[enum_disable(debug)]
/// enum Affection {
///     FellInLove = 0,
///     HatesYou = 1,
///     // From love to hate is one step, after all :D
/// }
///
/// assert_eq!(format!("{:?}", Affection::FellInLove), "FellInLove");
/// assert_eq!(format!("{}", Affection::HatesYou), "HatesYou");
/// // display is still available
/// ```
#[proc_macro_derive(IntegralEnum, attributes(enum_disable))]
#[proc_macro_error]
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() {
                        abort! {
                            variant, "Enum fields with non-empty contents are not supported";
                            note = "Possibly your enum is not supposed to be integral"
                        }
                    }

                    let ident = &variant.ident;
                    let Some((_, discriminant)) = variant
                        .discriminant
                        .as_ref()
                    else {
                        abort! {
                            variant, "Explicit discriminant is required";
                            help = "try to specify it as follows: YourField = constant_expr"
                        }
                    };
                    let strlit = Lit::Str(LitStr::new(&ident.to_string(), variant.span()));
                    let display = quote! {
                        Self::#ident => { #strlit }
                    };
                    let debug = display.clone();

                    (
                        quote! {
                            #discriminant => { Ok(Self::#ident) }
                        },
                        display,
                        debug,
                        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 debug_arms = items.iter().map(|(_, _, d, ..)| d);

            let display = if macro_attrs.flags.no_display {
                quote!()
            } else {
                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),*
                            })
                        }
                    }
                }
            };
            let debug = if macro_attrs.flags.no_debug {
                quote!()
            } else {
                quote! {
                    impl ::core::fmt::Debug for #name {
                        fn fmt(
                            &self, f: &mut ::core::fmt::Formatter<'_>
                        ) -> ::core::result::Result<(), ::core::fmt::Error> {
                            f.write_str(match self {
                                #(#debug_arms),*
                            })
                        }
                    }
                }
            };

            let (total_eq, partial_eq) = if macro_attrs
                .flags
                .no_partial_eq
            {
                (quote!(), quote!())
            } else {
                let partial = quote! {
                    impl ::core::cmp::PartialEq for #name {
                        fn eq(&self, other: &Self) -> bool {
                            ::core::mem::discriminant(self) == ::core::mem::discriminant(other)
                        }
                    }
                };
                if macro_attrs.flags.no_total_eq {
                    (partial, quote!())
                } else {
                    (
                        partial,
                        quote!(impl ::core::cmp::Eq for #name {}),
                    )
                }
            };

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

                if macro_attrs.flags.no_copy {
                    (clone, quote!())
                } else {
                    let copy = quote! { impl ::core::marker::Copy for #name {} };

                    (clone, copy)
                }
            };

            let try_from = if macro_attrs.flags.no_try_from {
                quote!()
            } else {
                quote! {
                    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(())
                            }
                        }
                    }
                }
            };

            quote! {
                #clone
                #copy

                #partial_eq
                #total_eq

                #try_from

                #display
                #debug
            }
            .into()
        }

        _ => abort! {
            input, "Structures and unions are not supported"
        },
    }
}