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

use crate::{
    attribute_parser::*,
    discriminant_counter::*,
};

/// 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 mut counter = DiscriminantCounter::new();
            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 span = variant.span();
                    let ident = &variant.ident;
                    let discriminant = counter.consume(span, variant.discriminant.clone());
                    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"
        },
    }
}

mod attribute_parser;
mod discriminant_counter;