use crate::quantity::{KILO, Quantity, Value};
use generate_quantity::quantity_type;

const PASCALS_PER_TORR: f64 = 101325.0 / 760.0;
const KILO_PASCALS_PER_PSI: f64 = 6.894757293168364;

//----- Pascals ----------------------------------
quantity_type! {Pascals, "Pa"}

impl<V: Value> Pascals<V> {
    #[inline]
    pub fn to_kilo_pascals(self) -> KiloPascals<V> {
        let divisor = V::from_u16(KILO).unwrap();
        KiloPascals(self.0 / divisor)
    }

    // Should this be in separate imple with `V` bound to `num_traits::Float`?
    #[inline]
    pub fn to_torr(self) -> Torr<V> {
        let divisor = V::from_f64(PASCALS_PER_TORR).unwrap();
        Torr(self.0 / divisor)
    }
}

//----- Kilopascals ----------------------------------
quantity_type! {KiloPascals, "kPa"}

impl<V: Value> KiloPascals<V> {
    #[inline]
    pub fn to_pascals(self) -> Pascals<V> {
        let multiplier = V::from_u16(KILO).unwrap();
        Pascals(self.0 * multiplier)
    }

    #[inline]
    pub fn to_psi(self) -> Psi<V> {
        let divisor = V::from_f64(KILO_PASCALS_PER_PSI).unwrap();
        Psi(self.0 / divisor)
    }
}

//----- Torr ----------------------------------
quantity_type! {Torr, "Torr"}

// Should this bound `V` to `num_traits::Float`?
impl<V: Value> Torr<V> {
    #[inline]
    pub fn to_pascals(self) -> Pascals<V> {
        let multiplier = V::from_f64(PASCALS_PER_TORR).unwrap();
        Pascals(self.0 * multiplier)
    }
}

//----- PSI ----------------------------------
quantity_type! {Psi, "PSI"}

impl<V: Value> Psi<V> {
    #[inline]
    pub fn to_kilo_pascals(self) -> KiloPascals<V> {
        let multiplier = V::from_f64(KILO_PASCALS_PER_PSI).unwrap();
        KiloPascals(self.0 * multiplier)
    }
}

// ---------------------------------------------------------------------------------------------------------------------
// ----- Tests ------------------------
// ---------------------------------------------------------------------------------------------------------------------
#[cfg(test)]
mod tests {
    use super::*;
    use float_cmp::assert_approx_eq;

    #[test]
    fn pascals_kilo_pascals() {
        let pascals: Pascals<u32> = 1_000.pascals();
        let kilo_pascals: KiloPascals<u32> = 1.kilo_pascals();

        assert_eq!(pascals.0, kilo_pascals.to_pascals().0);
        assert_eq!(kilo_pascals.0, pascals.to_kilo_pascals().0);
    }

    #[test]
    fn torr_pascals() {
        let torr: Torr<f32> = 7.5.torr();
        let pascals: Pascals<f32> = 999.9177631578947.pascals();

        assert_approx_eq!(f32, pascals.to_torr().0, torr.0);
        assert_approx_eq!(f32, torr.to_pascals().0, pascals.0);
    }

    #[test]
    fn psi_kilo_pascals() {
        let psi: Psi<f32> = 2.5.psi();
        let kilo_pascals: KiloPascals<f32> = 17.23689323292091.kilo_pascals();

        assert_approx_eq!(f32, psi.to_kilo_pascals().0, kilo_pascals.0);
        assert_approx_eq!(f32, kilo_pascals.to_psi().0, psi.0);
    }
}