//! This crate creates `miniconf::Tree` implementations fields in a struct. These carry some extra
//! extra information about the field.

use std::iter::once;

use convert_case::{Case, Casing};
use proc_macro::TokenStream;
use proc_macro2::{Span as Span2, TokenStream as TokenStream2, TokenTree as TokenTree2};
use quote::{format_ident, quote, ToTokens};
use syn::{
    parse_macro_input, parse_quote, Attribute, DataStruct, DeriveInput, Expr, ExprLit, Field,
    Ident, Lit, Type, Visibility,
};

/// Creates structs for the values to extend them with extra metadata.
///
/// supported metadata is `min`, `max` and `default`. Doc comments are parsed as `description`
///
/// # Example
/// ```
/// use macroconf::config;
///
/// #[config]
/// struct Config {
///     /// This will be parsed as description
///     #[min] // This will use i32::MIN for the minimum
///     #[max = 50] // The value 50 is used for the maximum
///     #[default = 42] // A `Default` implementation will be generated returning 42
///     field1: i32,
/// }
/// ```
#[proc_macro_attribute]
pub fn config(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let mut input = parse_macro_input!(item as DeriveInput);
    let mut new_types = vec![];

    match input.data {
        syn::Data::Struct(DataStruct {
            struct_token: _,
            ref mut fields,
            semi_token: _,
        }) => {
            for field in fields.iter_mut() {
                if let Some(new_type) = generate_helper_struct(field, &input.ident, &input.vis) {
                    new_types.push(new_type);
                }
            }
        }
        syn::Data::Enum(_) => {
            return quote! {compile_error!("Enums are not supported")}.into();
        }
        syn::Data::Union(_) => {
            return quote! {compile_error!("Unions are not supported")}.into();
        }
    }

    if let Some(attr) = input
        .attrs
        .iter_mut()
        .find(|attr| attr.path().is_ident("derive"))
    {
        if let Ok(meta) = attr.meta.require_list() {
            let derives_tree = meta
                .tokens
                .clone()
                .into_iter()
                .filter_map(|token| match token {
                    TokenTree2::Ident(ident) if ident == Ident::new("Tree", ident.span()) => {
                        Some(ident)
                    }
                    _ => None,
                })
                .count()
                == 1;
            if !derives_tree {
                input.attrs.push(parse_quote!(#[derive(::miniconf::Tree)]));
            }
        }
    } else {
        input.attrs.push(parse_quote!(#[derive(::miniconf::Tree)]));
    }

    quote! {
        #input
        #(#new_types)*
    }
    .into()
}

fn generate_helper_struct(
    field: &mut Field,
    input_ident: &Ident,
    input_visibility: &Visibility,
) -> Option<TokenStream2> {
    let ty = field.ty.clone();
    let new_type_ident = format_ident!(
        "__{}{}",
        input_ident,
        field
            .ident
            .as_ref()
            .map_or("Value".to_owned(), |v| v.to_string().to_case(Case::Pascal))
    );
    let mut new_type_impls = TokenStream2::new();
    let mut new_type_miniconf_names = vec![];
    let mut new_type_miniconf_consts = vec![];
    let mut extra_new_checks = TokenStream2::new();
    for attr in &field.attrs {
        if let Some((new_type_impl, new_check, const_ident, key)) =
            parse_min(&new_type_ident, attr, &ty)
        {
            new_type_impls.extend(new_type_impl);
            new_type_miniconf_consts.push(const_ident);
            new_type_miniconf_names.push(key);
            extra_new_checks.extend(new_check);
        }
        if let Some((new_type_impl, new_check, const_ident, key)) =
            parse_max(&new_type_ident, attr, &ty)
        {
            new_type_impls.extend(new_type_impl);
            new_type_miniconf_consts.push(const_ident);
            new_type_miniconf_names.push(key);
            extra_new_checks.extend(new_check);
        }
        if let Some((new_type_impl, const_ident, key)) = parse_default(&new_type_ident, attr, &ty) {
            new_type_impls.extend(new_type_impl);
            new_type_miniconf_consts.push(const_ident);
            new_type_miniconf_names.push(key);
        }
        if let Some((new_type_impl, const_ident, key)) = parse_description(&new_type_ident, attr) {
            new_type_impls.extend(new_type_impl);
            new_type_miniconf_consts.push(const_ident);
            new_type_miniconf_names.push(key);
        }
    }
    if new_type_miniconf_names.is_empty() {
        return None;
    }
    field.attrs.retain(|attr| {
        !["min", "max", "default"]
            .iter()
            .any(|key| attr.path().is_ident(key))
    });

    field.attrs.push(parse_quote!(#[tree(depth=1)]));
    let vis = if matches!(field.vis, Visibility::Public(_))
        || matches!(field.vis, Visibility::Inherited)
    {
        input_visibility
    } else {
        &field.vis
    };
    field.ty = parse_quote!(#new_type_ident);
    let miniconf_fields = new_type_miniconf_names.len() + 1;

    let new = generate_new(&new_type_ident, &ty, &extra_new_checks);
    let serde = generate_serde(&new_type_ident, &ty, !extra_new_checks.is_empty());

    let tree_key = generate_tree_key(&new_type_ident, new_type_miniconf_names.iter());
    let tree_serialize = generate_tree_serialize(&new_type_ident, &new_type_miniconf_consts[..]);
    let tree_deserialize = generate_tree_deserialize(&new_type_ident, miniconf_fields);
    let tree_any = generate_tree_any(&new_type_ident, &new_type_miniconf_consts, miniconf_fields);

    Some(quote! {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Debug, PartialEq, PartialOrd, Clone, Copy)]
        #vis struct #new_type_ident(#ty);

        #new_type_impls

        #new
        #serde

        #tree_key
        #tree_serialize
        #tree_deserialize
        #tree_any
    })
}

fn parse_min(
    ident: &Ident,
    attr: &Attribute,
    ty: &Type,
) -> Option<(TokenStream2, Option<TokenStream2>, Ident, &'static str)> {
    const KEY: &str = "min";
    if !attr.path().is_ident(KEY) {
        return None;
    }
    let const_ident = Ident::new(KEY.to_case(Case::Upper).as_str(), Span2::mixed_site());
    let (value, new_check) = attr.meta.require_path_only().map_or_else(
        |_| {
            let value = match &attr.meta.require_name_value() {
                Ok(meta) => &meta.value,
                Err(e) => return (e.to_owned().into_compile_error(), None),
            };
            (
                value.to_token_stream(),
                Some(quote! {
                    if (value < Self::#const_ident.0) {
                        return None;
                    }
                }),
            )
        },
        |_| (quote!(#ty::#const_ident), None),
    );
    let impl_quote = quote! {
        impl #ident {
            const #const_ident: Self = Self(#value);
        }
    };
    Some((impl_quote, new_check, const_ident, KEY))
}

fn parse_max(
    ident: &Ident,
    attr: &Attribute,
    ty: &Type,
) -> Option<(TokenStream2, Option<TokenStream2>, Ident, &'static str)> {
    const KEY: &str = "max";
    if !attr.path().is_ident(KEY) {
        return None;
    }
    let const_ident = Ident::new(KEY.to_case(Case::Upper).as_str(), Span2::mixed_site());
    let (value, new_check) = attr.meta.require_path_only().map_or_else(
        |_| {
            let value = match &attr.meta.require_name_value() {
                Ok(meta) => &meta.value,
                Err(e) => return (e.to_owned().into_compile_error(), None),
            };
            (
                value.to_token_stream(),
                Some(quote! {
                    if (value > Self::#const_ident.0) {
                        return None;
                    }
                }),
            )
        },
        |_| (quote!(#ty::#const_ident), None),
    );
    let impl_quote = quote! {
        impl #ident {
            const #const_ident: Self = Self(#value);
        }
    };
    Some((impl_quote, new_check, const_ident, KEY))
}

fn parse_default(
    ident: &Ident,
    attr: &Attribute,
    ty: &Type,
) -> Option<(TokenStream2, Ident, &'static str)> {
    const KEY: &str = "default";
    if !attr.path().is_ident(KEY) {
        return None;
    }
    let const_ident = Ident::new(KEY.to_case(Case::Upper).as_str(), Span2::mixed_site());
    let value = attr.meta.require_path_only().map_or_else(
        |_| match &attr.meta.require_name_value() {
            Ok(meta) => meta.value.to_token_stream(),
            Err(e) => e.to_owned().into_compile_error(),
        },
        |_| quote!(#ty::#const_ident),
    );
    let impl_quote = quote! {
        impl #ident {
            const #const_ident: Self = Self(#value);
        }

        impl ::core::default::Default for #ident {
            fn default() -> Self {
                Self::#const_ident
            }
        }
    };
    Some((impl_quote, const_ident, KEY))
}

fn parse_description(
    ident: &Ident,
    attr: &Attribute,
) -> Option<(TokenStream2, Ident, &'static str)> {
    const KEY: &str = "description";
    if !attr.path().is_ident("doc") {
        return None;
    }
    let const_ident = Ident::new(KEY.to_case(Case::Upper).as_str(), Span2::mixed_site());
    let value = match attr.meta.require_name_value() {
        Ok(meta) => &meta.value,
        Err(e) => {
            return Some((e.into_compile_error(), const_ident, KEY));
        }
    };
    let value = match value {
        Expr::Lit(ExprLit {
            attrs: _,
            lit: Lit::Str(ref string),
        }) => string.value(),
        _ => {
            return Some((
                quote!(compile_error!("doc comment must be a string")),
                const_ident,
                KEY,
            ))
        }
    };
    let trimmed_value = value.trim();
    let impl_quote = quote! {
        impl #ident {
            const #const_ident: &'static str = #trimmed_value;
        }
    };
    Some((impl_quote, const_ident, KEY))
}

fn generate_new(ident: &Ident, ty: &Type, extra_checks: &TokenStream2) -> TokenStream2 {
    if extra_checks.is_empty() {
        quote! {
            impl #ident {
                pub const fn new(value: #ty) -> Self {
                    Self(value)
                }
            }

            impl ::core::ops::Deref for #ident {
                type Target = #ty;
                fn deref(&self) -> &Self::Target {
                    &self.0
                }
            }

            impl ::core::ops::DerefMut for #ident {
                fn deref_mut(&mut self) -> &mut Self::Target {
                    &mut self.0
                }
            }
        }
    } else {
        let const_new = if [
            parse_quote!(u8),
            parse_quote!(u16),
            parse_quote!(u32),
            parse_quote!(u64),
            parse_quote!(u128),
            parse_quote!(i8),
            parse_quote!(i16),
            parse_quote!(i32),
            parse_quote!(i64),
            parse_quote!(i128),
        ]
        .contains(ty)
        {
            Some(quote!(const))
        } else {
            None
        };
        quote! {
            impl #ident {
                pub #const_new fn new(value: #ty) -> ::core::option::Option<Self> {
                    #extra_checks
                    ::core::option::Option::Some(Self(value))
                }

                #[allow(dead_code)]
                const unsafe fn new_unchecked(value: #ty) -> Self {
                    Self(value)
                }
            }

            impl ::core::ops::Deref for #ident {
                type Target = #ty;
                fn deref(&self) -> &Self::Target {
                    &self.0
                }
            }
        }
    }
}

fn generate_serde(ident: &Ident, ty: &Type, checked_new: bool) -> TokenStream2 {
    let conversion = if checked_new {
        quote! {
            Self::new(value).ok_or_else(|| {
                <D::Error as ::serde::de::Error>::custom("checking value bounds")
            })
        }
    } else {
        quote! {
            Ok(Self::new(value))
        }
    };
    quote! {
        impl ::serde::Serialize for #ident {
            fn serialize<S>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error>
            where
                S: ::serde::Serializer,
            {
                self.0.serialize(serializer)
            }
        }

        impl<'de> ::serde::Deserialize<'de> for #ident {
            fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
            where
                D: ::serde::Deserializer<'de>,
            {
                type T = #ty;
                let value = T::deserialize(deserializer)?;
                #conversion
            }
        }
    }
}

fn generate_tree_key<'a>(
    ident: &Ident,
    keys: impl ExactSizeIterator<Item = &'a &'a str> + Clone,
) -> TokenStream2 {
    let keys = once(&"value").chain(keys);
    let num_keys = keys
        .size_hint()
        .1
        .expect("safe because both iterators (once and original keys) are exact");
    let max_length = keys.clone().map(|v| v.len()).max();
    quote! {
        impl ::miniconf::KeyLookup for #ident {
            const LEN: usize = #num_keys;
            const NAMES: &'static [&'static str] = &[#(#keys,)*];

            fn name_to_index(value: &str) -> Option<usize> {
                Self::NAMES.iter().position(|name| *name == value)
            }
        }

        impl ::miniconf::TreeKey<1> for #ident {
            fn metadata() -> miniconf::Metadata {
                let mut metadata = miniconf::Metadata::default();
                metadata.max_depth = 1;
                metadata.count = #num_keys;
                metadata.max_length = #max_length;
                metadata
            }

            fn traverse_by_key<K, F, E>(mut keys: K, mut func: F) -> ::core::result::Result<usize, ::miniconf::Error<E>>
            where
                K: ::miniconf::Keys,
                // Writing this to return an iterator instead of using a callback
                // would have worse performance (O(n^2) instead of O(n) for matching)
                F: FnMut(usize, Option<&'static str>, usize) -> ::core::result::Result<(), E>,
            {
                let ::core::result::Result::Ok(key) = keys.next::<Self>() else { return ::core::result::Result::Ok(0) };
                let index = ::miniconf::Key::find::<Self>(&key).ok_or(::miniconf::Traversal::NotFound(1))?;
                let name = <Self as ::miniconf::KeyLookup>::NAMES
                    .get(index)
                    .ok_or(::miniconf::Traversal::NotFound(1))?;
                func(index, Some(name), #num_keys).map_err(|err| ::miniconf::Error::Inner(1, err))?;
                ::miniconf::Error::increment_result(::core::result::Result::Ok(0))
            }
        }
    }
}

fn generate_tree_serialize(ident: &Ident, consts: &[Ident]) -> TokenStream2 {
    let matches = consts.iter().enumerate().map(|(i, ident)| {
        let index = i + 1;
        quote! {
            #index => Self::#ident.serialize(ser).map_err(|err| ::miniconf::Error::Inner(0, err))?,
        }
    });
    quote! {
        impl ::miniconf::TreeSerialize<1> for #ident {
            fn serialize_by_key<K, S>(
                &self,
                mut keys: K,
                ser: S,
            ) -> ::core::result::Result<usize, ::miniconf::Error<S::Error>>
            where
                K: ::miniconf::Keys,
                S: ::serde::Serializer,
            {
                let ::core::result::Result::Ok(key) = keys.next::<Self>() else {
                    return ::miniconf::Error::increment_result({
                        self.serialize(ser).map_err(|err| ::miniconf::Error::Inner(0, err))?;
                        ::core::result::Result::Ok(0)
                    });
                };
                let index = ::miniconf::Key::find::<Self>(&key).ok_or(miniconf::Traversal::NotFound(1))?;
                if !keys.finalize() {
                    ::core::result::Result::Err(::miniconf::Traversal::TooLong(1))?;
                }
                ::miniconf::Error::increment_result({
                    match index {
                        0 => self.serialize(ser).map_err(|err| ::miniconf::Error::Inner(0, err))?,
                        #(#matches)*
                        _ => unreachable!(),
                    };
                    ::core::result::Result::Ok(0)
                })
            }
        }
    }
}

fn generate_tree_deserialize(ident: &Ident, num_keys: usize) -> TokenStream2 {
    quote! {
        impl<'de> ::miniconf::TreeDeserialize<'de, 1> for #ident {
            fn deserialize_by_key<K, D>(
                &mut self,
                mut keys: K,
                de: D,
            ) -> ::core::result::Result<usize, ::miniconf::Error<D::Error>>
            where
                K: ::miniconf::Keys,
                D: ::serde::Deserializer<'de>,
            {
                let ::core::result::Result::Ok(key) = keys.next::<Self>() else {
                    *self = Self::deserialize(de).map_err(|err| ::miniconf::Error::Inner(0, err))?;
                    return ::core::result::Result::Ok(0);
                };
                let index = ::miniconf::Key::find::<Self>(&key).ok_or(::miniconf::Traversal::NotFound(1))?;
                if !keys.finalize() {
                    ::core::result::Result::Err(::miniconf::Traversal::TooLong(1))?;
                }
                match index {
                    0 => ::miniconf::Error::increment_result((||{
                        *self = Self::deserialize(de).map_err(|err| ::miniconf::Error::Inner(0, err))?;
                        Ok(0)
                    })()),
                    1..=#num_keys => ::core::result::Result::Err(::miniconf::Traversal::Absent(0))?,
                    _ => unreachable!(),
                }
            }
        }
    }
}

fn generate_tree_any(ident: &Ident, consts: &[Ident], num_keys: usize) -> TokenStream2 {
    let matches = consts.iter().enumerate().map(|(i, ident)| {
        let index = i + 1;
        quote! {
            #index => ::core::result::Result::Ok(&Self::#ident),
        }
    });
    quote! {
        impl ::miniconf::TreeAny<1> for #ident {
            fn ref_any_by_key<K>(&self, mut keys: K) -> ::core::result::Result<&dyn ::core::any::Any, ::miniconf::Traversal>
            where
                K: ::miniconf::Keys,
            {
                let ::core::result::Result::Ok(key) = keys.next::<Self>() else {
                    return ::core::result::Result::Ok(&self.0);
                };
                let index = ::miniconf::Key::find::<Self>(&key).ok_or(miniconf::Traversal::NotFound(1))?;
                if !keys.finalize() {
                    ::core::result::Result::Err(::miniconf::Traversal::TooLong(1))?;
                }
                match index {
                    0 => ::core::result::Result::Ok(&self.0),
                    #(#matches)*
                    _ => unreachable!(),
                }
            }

            fn mut_any_by_key<K>(&mut self, mut keys: K) -> ::core::result::Result<&mut dyn ::core::any::Any, ::miniconf::Traversal>
            where
                K: ::miniconf::Keys,
            {
                let ::core::result::Result::Ok(key) = keys.next::<Self>() else {
                    return ::core::result::Result::Ok(&mut self.0);
                };
                let index = ::miniconf::Key::find::<Self>(&key).ok_or(::miniconf::Traversal::NotFound(1))?;
                if !keys.finalize() {
                    ::core::result::Result::Err(::miniconf::Traversal::TooLong(1))?;
                }
                match index {
                    0 => ::core::result::Result::Ok(&mut self.0),
                    1..=#num_keys => ::core::result::Result::Err(::miniconf::Traversal::Absent(0)),
                    _ => unreachable!(),
                }
            }
        }
    }
}