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

    #[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.sleep_time(500);
            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,
        begin: Instant,
        all: Cell<usize>,
        callback: HashMap<String, u128>,
        sleep_time: u64,
    }

    impl Default for Performances {
        fn default() -> Self {
            Self::new()
        }
    }

    impl Performances {
        ///
        /// Constructor
        ///
        ///
        pub fn new() -> Performances {
            println!(
                "\n     {}\n",
                "Calculate function execution time".magenta().bold()
            );
            Self {
                start: Instant::now(),
                begin: 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;
            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.begin.elapsed();
            self.begin = Instant::now();
            self.callback.insert(String::from(name), time.as_micros());

            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", 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();
            println!(
                "\n     {} {}\n",
                "Execution time : ".blue().bold(),
                self.start
                    .elapsed()
                    .as_secs()
                    .to_string()
                    .add(" Secs")
                    .cyan()
                    .bold()
            );
            Ok(())
        }
    }
}