mod macros;
pub mod metric;

#[cfg(test)]
mod tests {
    use crate::metric::*;
    use crate::metric::Mass;
    use crate::metric::Time;
    use crate::metric::Force;
    use crate::metric::Length;
    use crate::metric::Pressure;
    use crate::metric::CelsiusTemperature;

    /* 
    use crate::metric::Unit;
    use crate::metric::Primitive;
    */

    fn avg_force(ds: Length, dt: Time, m: Mass) -> Force {
        let dv = ds / dt;
        let a = dv / dt;
        m * a
    }

    fn main() {
        let dist = Mile(100.0);
        let time = Minute(12.5);
        let mass = Pound(800.0);
        let force = avg_force(dist, time, mass);
        let area = Litre(100.0) / Foot(5.0);

        let result = match Bar(0.0).to_si_unit() {
            Pressure::Base(_, from_si, symbol) => format!("{}[{}]", from_si((force / area).to_si_primitive()), symbol),
            _ => panic!("not base")
        };

        println!(
            "Force on body with mass {m} that moves {d} in {t}: {f}\n\
            The pressure per {a} is {p}",
            d = dist, t = time, m = mass, f = force, a = area, p = result
        );
    }

    #[test]
    fn it_works() {
        println!();
        main();

        println!();
        let single = Kilogram(1.0);
        let mut double = single;
        double *= 2.0;
        let mut dived = double;
        dived /= 2.0;

        println!("single: {}", single);
        println!("double: {}", double);
        println!("single * 2.0: {}", single * 2.0);
        println!("2.0 * single: {}", 2.0 * single);
        println!("double / 2.0: {}", double / 2.0);
        println!("dived: {}", dived);

        println!("single + double: {}", single + double);

        println!();
        let gram = Gram(1000.0);
        println!("gram: {}", gram);
        println!("gram * 2.0: {}", gram * 2.0);

        println!();
        println!("gram + double = {}", gram + double);
        println!("double + gram = {}", double + gram);
        println!("gram - double = {}", gram - double);
        println!("double - gram = {}", double - gram);

        println!();
        let k = Kelvin(20.0);
        let c = Celsius(0.0) + k;
        println!("{}", c);

        println!();
        let cel = Celsius(20.0);
        let fah = match Fahrenheit(0.0).to_si_unit() {
            CelsiusTemperature::Base(_, from_si, symbol) => CelsiusTemperature::Base(cel.to_si_primitive(), from_si, symbol),
            _ => panic!("non si after to_si() call")
        };
        println!("{} = {}", cel, fah);

        println!();
        let d = Degree(180.0);
        let rad = Radian(0.0);
        println!("{}", (rad + d).to_si_primitive() - std::f64::consts::PI);

        println!();
        let e = Kilocalorie(70.0);
        let j = KiloJoule(0.0) + e;
        println!("{} = {}", e, j);
    }
}