use std::cell::Cell;
use std::path::Path;
use std::time::{Instant};
use colored_truecolor::Colorize;

/// Unit
pub struct Unit {
    assertions: Cell<i32>,
    failures: Cell<i32>,
    start: Instant,
}

impl Unit {
    ///
    /// Unit Constructor
    ///
    /// - `description` A short description to describe the test
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// Unit::new("Test description here");
    /// ```
    ///
    pub fn new(description: &str) -> Unit
    {
        println!("{}", description.magenta().bold());
        Self {
            assertions: Cell::from(0),
            failures: Cell::from(0),
            start: Instant::now(),
        }
    }

    ///
    /// Run a test
    ///
    /// - `tdd` The test to execute
    /// ```
    /// use unit::Unit;
    ///
    /// Unit::new("pythagore").check( 3*3 + 4*4 == 5*5).end();
    /// ```
    ///
    pub fn check(self, tdd: bool) -> Unit
    {
        if tdd
        {
            self.assertions.set(self.assertions.get() + 1);
            print!("{}", ".".green().bold());
        } else {
            self.failures.set(self.failures.get() + 1);
            print!("{}", "F".red().bold());
        }
        return self;
    }

    ///
    /// Check if actual match true
    ///
    ///
    /// - `actual` The pointer to the function to check if she return true
    /// ```
    /// use std::env;
    /// use unit::Unit;
    ///
    /// fn is_linux() -> bool
    /// {
    ///     return env::consts::OS == "linux";
    /// }
    ///
    /// Unit::new("Check if it's a linux pc").ok(&is_linux).end();
    /// ```
    pub fn ok(self, actual: &dyn Fn() -> bool) -> Unit
    {
        return self.check(actual());
    }

    ///
    /// Check if actual match false
    ///
    /// - `actual` The pointer to the function to check if she return false
    ///
    /// ```
    /// use std::env;
    /// use unit::Unit;
    ///
    /// fn is_windows() -> bool
    /// {
    ///     return env::consts::OS == "windows";
    /// }
    ///
    /// Unit::new("Check if it's a windows pc").ko(&is_windows).end();
    /// ```
    ///
    pub fn ko(self, actual: &dyn Fn() -> bool) -> Unit
    {
        return self.check(!actual());
    }

    ///
    /// Check if the function return the expected number
    ///
    /// - `actual` The pointer to the function to test
    /// - `expected` The expected return result
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn hypot()-> i32
    /// {
    ///     return 5*5;
    /// }
    ///
    /// Unit::new("Verify the multiplication of the number 5 by 5").equals(&hypot,25)
    /// .end();
    /// ```
    ///
    pub fn equals(self, actual: &dyn Fn() -> i32, expected: i32) -> Unit
    {
        return self.check(actual() == expected);
    }

    ///
    /// Check if the function not return the expected number
    ///
    /// - `actual`      The pointer to the function to test
    /// - `expected`    The expected value
    ///
    /// ```
    ///
    /// use unit::Unit;
    ///
    /// fn get_age()-> i32
    /// {
    ///     return 30;
    /// }
    ///
    /// Unit::new("The age it's not equals to 200 years").unequals(&get_age,200);
    /// ```
    ///
    pub fn unequals(self, actual: &dyn Fn() -> i32, expected: i32) -> Unit
    {
        return self.check(actual() != expected);
    }

    ///
    /// Check if two strings are equals
    ///
    /// - `actual`      The string actual
    /// - `expected`    The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let admin = String::from("taishingi");
    ///
    /// Unit::new("Check if the admin username is correct").identical(&admin,"taishingi").end();
    /// ```
    ///
    pub fn identical(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.eq(expected));
    }

    ///
    /// Check if the actual value is empty
    ///
    /// - `actual` The string to check if is empty
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let users:[&str;3] = ["","nautilus","power"];
    ///
    /// Unit::new("Check if user password is empty").empty(users[0]).end();
    /// ```
    pub fn empty(self, actual: &str) -> Unit
    {
        return self.check(actual == "");
    }

    ///
    /// Check if the actual value is not empty
    ///
    /// - `actual` The string to check if is not empty
    /// ```
    /// use unit::Unit;
    ///
    /// let nums:[&str;3] = ["911","14",""];
    ///
    /// Unit::new("Check if the phone number is defined").not_empty(nums[1]).end();
    ///
    /// ```
    ///
    pub fn not_empty(self, actual: &str) -> Unit
    {
        return self.check(actual != "");
    }

    ///
    ///
    /// Check if two strings are unequals
    ///
    /// - `actual`      The actual value
    /// - `expected`    The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let cars:[&str;3] = ["volvo","citroen","peugeot"];
    ///
    /// Unit::new("Check if users cars has not a ferrari car").different(cars[0],"ferrari").end();
    /// ```
    ///
    pub fn different(self, actual: &str, expected: &str) -> Unit
    {
        return self.check(actual != expected);
    }

    ///
    /// Check if a string start with the expected value
    ///
    /// - `actual` The data to compare
    /// - `expected` The expected data at the beginning of actual
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let phrase = String::from("A superb woman kiss me last night.");
    ///
    /// Unit::new("Check the beginning of a phrase").begin(&phrase, "A").end();
    /// ```
    ///
    pub fn begin(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.starts_with(expected));
    }

    ///
    /// Check if the string finnish wish the expected value
    ///
    /// - `actual` The data to compare
    /// - `expected` The expected data at the end of actual
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let phrase = String::from("A musical who loves programming.");
    ///
    /// Unit::new("Check the end of a phrase").finnish(&phrase, "programming.").end();
    ///
    /// ```
    pub fn finnish(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.ends_with(expected));
    }

    ///
    /// Check if the callback f return 0
    ///
    /// - `f` The pointer to the function to check
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn s()-> i32
    /// {
    ///     return if 2%2 == 0 {0 } else { 1 };
    /// }
    ///
    /// Unit::new("Check if 2 is divisible by 2").success(&s).end();
    /// ```
    ///
    pub fn success(self, f: &dyn Fn() -> i32) -> Unit
    {
        return self.check(f() == 0);
    }

    ///
    /// Check if the callback f return 1
    ///
    /// - `f` The pointer to the callback to check
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn f()-> i32
    /// {
    ///     return if 4%3 == 0 { 0 } else { 1 };
    /// }
    ///
    /// Unit::new("Check if 2 is divisible by 3").failure(&f).end();
    /// ```
    ///
    ///
    pub fn failure(self, f: &dyn Fn() -> i32) -> Unit
    {
        return self.check(f() == 1);
    }

    ///
    /// Check a theory
    ///
    /// - `description`     The theory description
    /// - `f`               The pointer to the function to check
    /// - `expected`        The expected theory value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn matrix()->bool
    /// {
    ///     return false;
    /// }
    ///
    /// Unit::new("We are in the matrices ?").theory("All are real ?",&matrix,false);
    /// ```
    ///
    pub fn theory(self, description: &str, f: &dyn Fn() -> bool, expected: bool) -> Unit
    {
        println!("\n{} {} {}\n", "[".blue().bold(), description.cyan().bold(), "]".blue().bold());
        let r = self.check(f() == expected);
        print!("\n");
        return r;
    }

    ///
    /// Group a test case
    ///
    /// - `description`     The description to the test group
    /// - `f`               The callback to execute
    ///
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn hypot()-> i32
    /// {
    ///     return 25;
    /// }
    ///
    /// fn rectangle(u: Unit)-> Unit
    /// {
    ///     return u.equals(&hypot,3*3+4*4);
    /// }
    ///
    /// Unit::new("Test the pythagore theorem")
    /// .describe("The triangle must be rectangle",&rectangle).end();
    /// ```
    ///
    pub fn describe(self, description: &str, f: &dyn Fn(Unit) -> Unit) -> Unit
    {
        println!("\n{} {} {}\n", "[".blue().bold(), description.cyan().bold(), "]".blue().bold());
        let r = f(self);
        print!("\n");
        return r;
    }

    ///
    /// Check is the string is defined (not empty)
    ///
    /// - `actual` The value to check
    /// ```
    /// use unit::Unit;
    ///
    /// let s = String::from("Cleopatra love cesar");
    ///
    /// Unit::new("The string is empty ?").defined(&s).end();
    /// ```
    pub fn defined(self, actual: &String) -> Unit
    {
        return self.check(!actual.is_empty());
    }

    ///
    /// Check if the actual path exist
    ///
    /// - `actual` The path to check the existence
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// Unit::new("Check if the directory exist").exist("/home").end();
    /// ```
    ///
    pub fn exist(self, actual: &str) -> Unit
    {
        return self.check(Path::new(actual).exists());
    }

    ///
    ///
    /// Check if the actual string is not equal to expected
    ///
    /// - `actual`      The actual value to check
    /// - `expected`    The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let password = "1234"; /// not good ! but better than 0000.
    ///
    /// let bad_password = String::from("0000");
    ///
    /// Unit::new("Check if password don't match 0000").not_equal(&bad_password,password).end();
    /// ```
    ///
    pub fn not_equal(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.ne(expected));
    }

    ///
    ///
    /// Check if actual string is equal to expected
    ///
    /// - `actual`      The actual value to check
    /// - `expected`    The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let expected = "MxPx";
    ///
    /// let pass= String::from("MxPx");
    ///
    /// Unit::new("I've founded the password ?").expect(&pass,expected).end();
    /// ```
    ///
    pub fn expect(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.eq(expected));
    }

    ///
    /// Check if actual is equal to expected
    ///
    /// - `actual` The actual value
    /// - `expected` The expected number
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// Unit::new("birthday month...").expect_number(02,02).end();
    /// ```
    ///
    pub fn expect_number(self, actual: usize, expected: usize) -> Unit
    {
        return self.check(actual == expected);
    }

    ///
    /// Check if expected is found in the actual string
    ///
    /// - `actual` The actual value
    /// - `expected` The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let poem = String::from("Habibi i love you forever");
    ///
    /// Unit::new("Check if forever exist in the poem").found(&poem,"forever").end();
    /// ```
    ///
    pub fn found(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.find(expected) != None);
    }

    ///
    /// Check if expected value is not founded in the actual string
    ///
    ///
    /// - `actual` The string to parse
    /// - `expected` The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let poem = String::from("Habibi i love you forever");
    ///
    /// Unit::new("Check if habibi not exist in the poem").not_founded(&poem,"habibi").end();
    /// ```
    ///
    pub fn not_founded(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.find(expected) == None);
    }

    /// Check if expected value is ascii
    pub fn ascii(self, actual: String) -> Unit
    {
        return self.check(actual.is_ascii());
    }

    ///
    /// Check if a string contains a string
    ///
    /// - `actual` The actual value
    /// - `expected` The expected value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// let x = String::from("500000 pieces d'or");
    ///
    /// Unit::new("Check if a coffer is there").contains(&x,"or").end();
    ///
    /// ```
    ///
    ///
    pub fn contains(self, actual: &String, expected: &str) -> Unit
    {
        return self.check(actual.contains(expected));
    }

    ///
    /// Check if the actual value is superior to the expected value
    ///
    /// - `actual`      The actual value to check
    /// - `expected`    The superior's value expected for the actual value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn get_fans()->i32
    /// {
    ///     return 5000;
    /// }
    ///
    /// Unit::new("We have how many of fans").superior(&get_fans,500).end();
    /// ```
    pub fn superior(self, actual: &dyn Fn() -> i32, expected: i32) -> Unit
    {
        return self.check(actual() > expected);
    }

    ///
    /// Check if the actual value is inferior to the expected value
    ///
    /// - `actual` The pointer to the function
    /// - `expected` The inferior's value for the actual value
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// fn log_size()-> i32
    /// {
    ///     return 410;
    /// }
    ///
    /// Unit::new("Server log more full ?").inferior(&log_size,500).end();
    /// ```
    ///
    ///
    pub fn inferior(self, actual: &dyn Fn() -> i32, expected: i32) -> Unit
    {
        return self.check(actual() < expected);
    }

    ///
    /// Test if actual is between the min and the max value
    ///
    ///
    /// - `actual` The function pointer to the function to check
    /// - `min` The minimum value
    /// - `max` The maximum value
    /// -
    /// ```
    /// use unit::Unit;
    /// fn h()-> i32
    /// {
    ///     return 5*5;
    /// }
    /// Unit::new("test if a number is between 0 and 100").between(&h,24,26).end();
    /// ```
    pub fn between(self, actual: &dyn Fn() -> i32, min: i32, max: i32) -> Unit
    {
        let x = actual();
        return self.check(x < max && x > min);
    }

    ///
    /// End of the tests
    ///
    /// ```
    /// use unit::Unit;
    ///
    /// Unit::new("The superb description").expect_number(1,1).end();
    /// ```
    pub fn end(self) -> i32
    {
        let asserts = self.assertions.get();
        let fails = self.failures.get();
        let total = asserts + fails;

        let mut i = ((asserts * 100) / total) / 2;
        print!("\n{}", "[".white().bold());
        while i > 0 {
            print!("{}", "#".green().bold());
            i = i - 1;
        }
        i = ((fails * 100) / total) / 2;
        while i > 0 {
            print!("{}", "#".red().bold());
            i = i - 1;
        }
        print!("{} {} {} {} {} {:?} {}", "]-[".white().bold(), asserts.to_string().green().bold(), "]-[".white().bold(), fails.to_string().red().bold(), "]-[".white().bold(), self.start.elapsed(), "]".white().bold());
        return if self.failures.get() > 0 { 1 } else { 0 };
    }
}


#[cfg(test)]
mod tests {
    use super::*;

    fn kool() -> bool
    {
        return false;
    }

    fn look() -> bool
    {
        return true;
    }

    fn f() -> i32
    {
        return 1;
    }

    fn theorem() -> bool
    {
        return 4 * 4 + 3 * 3 == 5 * 5;
    }

    fn s() -> i32
    {
        return 0;
    }

    fn status(u: Unit) -> Unit
    {
        return u.failure(&f).success(&s);
    }

    fn diff(u: Unit) -> Unit
    {
        return u.unequals(&f, 2).different("a", "b");
    }

    fn files(u: Unit) -> Unit
    {
        return u.exist(".");
    }

    fn numbers(u: Unit) -> Unit
    {
        return u.equals(&s, 0).equals(&f, 1).unequals(&f, 2).between(&s, -1, 10).superior(&f, 0).inferior(&f, 10);
    }

    fn test_string(u: Unit) -> Unit
    {
        let phrase = String::from("The humanity develop the linux kernel.");
        return u.empty("").not_empty(" ").identical(&phrase, "The humanity develop the linux kernel.").contains(&phrase, "linux").begin(&phrase, "The").finnish(&phrase, "kernel.");
    }

    fn boolean(u: Unit) -> Unit
    {
        return u.ok(&look).ko(&kool);
    }

    #[test]
    fn it_works() {
        let u = Unit::new("Test the unit framework");
        u.describe("Test all boolean", &boolean)
            .describe("Test numbers", &numbers)
            .describe("Test success and failure", &status)
            .describe("Test differences", &diff)
            .describe("Test string", &test_string)
            .describe("Test files", &files)
            .theory("Test pythagore", &theorem, true)
            .end();
    }
}