use proc_macro2::TokenStream;

pub fn attribute_native_enum(
	native_type: TokenStream,
	structure: synstructure::Structure,
) -> TokenStream {
	let ast = structure.ast();
	let in_attrs = ast
		.attrs
		.iter()
		.map(|a| quote! {#a})
		.collect::<TokenStream>();
	let in_vis = &ast.vis;
	let name = &ast.ident;

	let known_name = syn::Ident::new(&format!("{}Known", name), proc_macro2::Span::call_site());

	let enumdata = match &ast.data {
		syn::Data::Enum(de) => de,
		_ => panic!("not an enum"),
	};
	let known_enum;

	{
		let variants = &enumdata.variants;
		let doc_str = format!(
			"Known enum variants of [`{}`]\n\n[`{}`]: struct.{}.html\n",
			name, name, name
		);
		known_enum = quote! {
			#[doc = #doc_str]
			#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
			#[repr(#native_type)]
			#[allow(non_camel_case_types)]
			#in_vis enum #known_name {
				#variants
			}
		}
	}

	let mut consts = TokenStream::new();
	let mut convert = TokenStream::new();
	for variant in &enumdata.variants {
		let variant_attrs = variant
			.attrs
			.iter()
			.map(|a| quote! {#a})
			.collect::<TokenStream>();
		let disc_name = &variant.ident;
		let disc = variant
			.discriminant
			.as_ref()
			.map(|(_, d)| quote! {#d})
			.unwrap_or_else(|| {
				quote! {
					#known_name::#disc_name as #native_type
				}
			});
		consts.extend(quote! {
			#variant_attrs
			pub const #disc_name: Self = #name(#disc);
		});
		convert.extend(quote! {
			Self::#disc_name => #known_name::#disc_name,
		});
	}

	quote! {
		#known_enum

		#in_attrs
		#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
		#in_vis struct #name(pub #native_type);

		impl #name {
			#consts

			/// Try converting to known enum values
			pub fn into_known(self) -> Option<#known_name> {
				Some(
					#[allow(unreachable_patterns)]
					match self {
						#convert
						_ => return None,
					}
				)
			}
		}

		impl core::fmt::Debug for #name {
			fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
				match self.into_known() {
					Some(v) => v.fmt(f),
					None => f.debug_tuple(stringify!(#name)).field(&self.0).finish(),
				}
			}
		}

		impl From<#known_name> for #name {
			fn from(v: #known_name) -> Self {
				#name(v as #native_type)
			}
		}
	}
}