//! Progress bars and such.

use std::any::type_name;
use std::fmt;
use std::io::{self, Write};
use std::process::ExitCode;
use std::time::Duration;

use indicatif::{ProgressBar, ProgressStyle};

use crate::{Completed, Config, EarlyExit, FinishedAll, TestInfo};

/// Templates for progress bars.
const PB_TEMPLATE: &str = "[{elapsed:3} {percent:3}%] {bar:20.cyan/blue} NAME \
        {human_pos:>8}/{human_len:8} {msg} f {per_sec:14} eta {eta:8}";
const PB_TEMPLATE_FINAL: &str = "[{elapsed:3} {percent:3}%] {bar:20.cyan/blue} NAME \
        {human_pos:>8}/{human_len:8} {msg:.COLOR} {per_sec:18} {elapsed_precise}";

/// Thin abstraction over our usage of a `ProgressBar`.
#[derive(Debug)]
pub struct Progress {
    pb: ProgressBar,
    make_final_style: NoDebug<Box<dyn Fn(&'static str) -> ProgressStyle + Sync>>,
}

impl Progress {
    /// Create a new progress bar within a multiprogress bar.
    pub fn new(test: &TestInfo, all_bars: &mut Vec<ProgressBar>) -> Self {
        let initial_template = PB_TEMPLATE.replace("NAME", &test.short_name_padded);
        let final_template = PB_TEMPLATE_FINAL.replace("NAME", &test.short_name_padded);
        let initial_style =
            ProgressStyle::with_template(&initial_template).unwrap().progress_chars("##-");
        let make_final_style = move |color| {
            ProgressStyle::with_template(&final_template.replace("COLOR", color))
                .unwrap()
                .progress_chars("##-")
        };

        let pb = ProgressBar::new(test.total_tests);
        pb.set_style(initial_style);
        pb.set_length(test.total_tests);
        pb.set_message("0");
        all_bars.push(pb.clone());

        Progress { pb, make_final_style: NoDebug(Box::new(make_final_style)) }
    }

    /// Completed a out of b tests.
    pub fn update(&self, completed: u64, failures: u64) {
        // Infrequently update the progress bar.
        if completed % 5_000 == 0 || failures > 0 {
            self.pb.set_position(completed);
        }

        if failures > 0 {
            self.pb.set_message(format! {"{failures}"});
        }
    }

    /// Finalize the progress bar.
    pub fn complete(&self, c: &Completed, real_total: u64) {
        let f = c.failures;
        let (color, msg, finish_fn): (&str, String, fn(&ProgressBar)) = match &c.result {
            Ok(FinishedAll) if f > 0 => {
                ("red", format!("{f} f (completed with errors)",), ProgressBar::finish)
            }
            Ok(FinishedAll) => {
                ("green", format!("{f} f (completed successfully)",), ProgressBar::finish)
            }
            Err(EarlyExit::Timeout) => ("red", format!("{f} f (timed out)"), ProgressBar::abandon),
            Err(EarlyExit::MaxFailures) => {
                ("red", format!("{f} f (failure limit)"), ProgressBar::abandon)
            }
        };

        self.pb.set_position(real_total);
        self.pb.set_style(self.make_final_style.0(color));
        self.pb.set_message(msg);
        finish_fn(&self.pb);
    }

    /// Print a message to stdout above the current progress bar.
    pub fn println(&self, msg: &str) {
        self.pb.suspend(|| println!("{msg}"));
    }
}

/// Print final messages after all tests are complete.
pub fn finish_all(tests: &[TestInfo], total_elapsed: Duration, cfg: &Config) -> ExitCode {
    println!("\n\nResults:");

    let mut failed_generators = 0;
    let mut stopped_generators = 0;

    for t in tests {
        let Completed { executed, failures, elapsed, warning, result } = t.completed.get().unwrap();

        let stat = if result.is_err() {
            stopped_generators += 1;
            "STOPPED"
        } else if *failures > 0 {
            failed_generators += 1;
            "FAILURE"
        } else {
            "SUCCESS"
        };

        println!(
            "    {stat} for generator '{name}'. {passed}/{executed} passed in {elapsed:?}",
            name = t.name,
            passed = executed - failures,
        );

        if let Some(warning) = warning {
            println!("      warning: {warning}");
        }

        match result {
            Ok(FinishedAll) => (),
            Err(EarlyExit::Timeout) => {
                println!("      exited early; exceeded {:?} timeout", cfg.timeout)
            }
            Err(EarlyExit::MaxFailures) => {
                println!("      exited early; exceeded {:?} max failures", cfg.max_failures)
            }
        }
    }

    println!(
        "{passed}/{} tests succeeded in {total_elapsed:?} ({passed} passed, {} failed, {} stopped)",
        tests.len(),
        failed_generators,
        stopped_generators,
        passed = tests.len() - failed_generators - stopped_generators,
    );

    if failed_generators > 0 || stopped_generators > 0 {
        ExitCode::FAILURE
    } else {
        ExitCode::SUCCESS
    }
}

/// indicatif likes to eat panic messages. This workaround isn't ideal, but it improves things.
/// <https://github.com/console-rs/indicatif/issues/121>.
pub fn set_panic_hook(drop_bars: &[ProgressBar]) {
    let hook = std::panic::take_hook();
    let drop_bars = drop_bars.to_owned();
    std::panic::set_hook(Box::new(move |info| {
        for bar in &drop_bars {
            bar.abandon();
            println!();
            io::stdout().flush().unwrap();
            io::stderr().flush().unwrap();
        }
        hook(info);
    }));
}

/// Allow non-Debug items in a `derive(Debug)` struct.
#[derive(Clone)]
struct NoDebug<T>(T);

impl<T> fmt::Debug for NoDebug<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(type_name::<Self>())
    }
}