use core::fmt;

use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream, TokenTree};

fn main() {
    divan::main();
}

#[derive(Clone, Copy)]
enum Method {
    Array,
    Manual,
}

impl fmt::Display for Method {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(match self {
            Method::Array => "array",
            Method::Manual => "manual",
        })
    }
}

#[divan::bench(args = [Method::Array, Method::Manual])]
fn bench(method: Method) {
    let mut tokens = TokenStream::new();
    let lifetime = "'lifetime";

    match method {
        Method::Array => {
            tokens.extend([
                TokenTree::Punct(Punct::new('\'', Spacing::Joint)),
                TokenTree::Ident(Ident::new(&lifetime[1..], Span::call_site())),
            ]);
        }
        Method::Manual => {
            struct Lifetime<'a> {
                name: &'a str,
                state: u8,
            }

            impl Iterator for Lifetime<'_> {
                type Item = TokenTree;

                fn next(&mut self) -> Option<Self::Item> {
                    match self.state {
                        0 => {
                            self.state = 1;
                            Some(TokenTree::Punct(Punct::new('\'', Spacing::Joint)))
                        }
                        1 => {
                            self.state = 2;
                            Some(TokenTree::Ident(Ident::new(self.name, Span::call_site())))
                        }
                        _ => None,
                    }
                }
            }

            tokens.extend(Lifetime {
                name: &lifetime[1..],
                state: 0,
            });
        }
    }
}