pub mod zuu {
    use std::cell::Cell;
    use std::collections::HashMap;
    use std::thread::sleep;
    use std::time::{Duration, Instant};
    use progress_bar::{Color, finalize_progress_bar, inc_progress_bar, init_progress_bar, print_progress_bar_info, set_progress_bar_action, Style};
    use colored_truecolor::Colorize;



    #[macro_export]
    macro_rules! take {
    // This match captures the `expr` passed in as `$e`,
    // which the macro will assume is callable (E.g. a closure or function)
    ($e:expr) =>
    {

        let mut x = Performances::new();
        for (k,v) in $e.iter()
        {
            x.capture(k,v);
        }
        x.print().expect("Failed");
   };
    ($e:expr,$t:expr) =>
    {
        let mut x = Performances::new();
        for (k,v) in $e.iter()
        {
            x.capture(k,v);
        }
        x.sleep_time($t);
        x.print().expect("Failed");
   };
}

    pub struct Performances {
        start: Instant,
        all: Cell<usize>,
        callback: HashMap<String, u128>,
        sleep_time: u64,
    }

    impl Performances {
        ///
        /// Constructor
        ///
        ///
        pub fn new() -> Performances
        {
            println!("\n     {}\n", "Calculate function execution time".magenta().bold());
            Self {
                start: Instant::now(),
                all: Cell::new(0),
                callback: HashMap::new(),
                sleep_time: 500,
            }
        }
        pub fn sleep_time(&mut self, t: u64) -> &mut Performances
        {
            self.sleep_time = t;
            return self;
        }
        ///
        /// Capture the execution time of the callback
        ///
        /// - `name` The function name
        /// - `f` The pointer to the callback
        ///
        ///
        pub fn capture<T>(&mut self, name: &str, f: &dyn Fn() -> T) -> &mut Performances
        {
            self.all.set(self.all.get() + 1);

            f();
            let time = self.start.elapsed();
            self.start = Instant::now();
            self.callback.insert(String::from(name), time.as_micros());

            return self;
        }


        ///
        ///
        /// Print the result
        ///
        ///```
        /// use std::thread::sleep;
        /// use std::time::Duration;
        /// use performances::zuu::Performances;
        ///
        /// fn kool() -> bool
        /// {
        ///    return false;
        /// }
        /// fn look() -> bool
        /// {
        ///    return true;
        /// }
        ///
        /// fn s() -> i32
        /// {
        ///    return 0;
        /// }
        ///
        /// fn get_fans() -> i32
        /// {
        ///    return 255;
        /// }
        /// fn f() -> i32
        /// {
        ///    return 1;
        /// }
        ///
        /// fn bad()
        /// {
        ///    sleep(Duration::from_nanos(50));
        /// }
        ///
        /// Performances::new().capture("bad", &bad)
        ///                    .capture("kool", &kool)
        ///                    .capture("look", &look)
        ///                    .capture("s", &s)
        ///                    .capture("get_fans", &get_fans)
        ///                    .print()
        ///                    .expect("panic message");
        ///```
        ///
        pub fn print(&mut self) -> Result<(), String>
        {
            if self.all.get() < 1 {
                return Err(String::from("No captured function founded"));
            }
            init_progress_bar(self.all.get());
            set_progress_bar_action("Loading", Color::Blue, Style::Bold);
            for test in self.callback.iter() {
                sleep(Duration::from_millis(self.sleep_time));
                print_progress_bar_info(test.0, format!("{} µs", String::from(test.1.to_string()).blue().bold()).as_str(), Color::Green, Style::Bold);
                inc_progress_bar();
            }
            set_progress_bar_action("Finnish", Color::Green, Style::Bold);
            finalize_progress_bar();
            Ok(())
        }
    }
}