pub mod area;
pub mod mass;
pub mod time;
pub mod force;
pub mod power;
pub mod energy;
pub mod length;
pub mod volume;
pub mod pressure;
pub mod velocity;
pub mod frequency;
pub mod inductance;
pub mod capacitance;
pub mod conductance;
pub mod illuminance;
pub mod plane_angle;
pub mod solid_angle;
pub mod temperature;
pub mod acceleration;
pub mod absorbed_dose;
pub mod luminous_flux;
pub mod magnetic_flux;
pub mod electric_charge;
pub mod dose_equivalent;
pub mod electric_current;
pub mod catalytic_activity;
pub mod electric_potential;
pub mod luminous_intensity;
pub mod electric_resistance;
pub mod amount_of_substance;
pub mod magnetic_flux_density;

pub use area::*;
pub use mass::*;
pub use time::*;
pub use force::*;
pub use power::*;
pub use energy::*;
pub use length::*;
pub use volume::*;
pub use pressure::*;
pub use velocity::*;
pub use frequency::*;
pub use inductance::*;
pub use capacitance::*;
pub use illuminance::*;
pub use plane_angle::*;
pub use solid_angle::*;
pub use temperature::*;
pub use acceleration::*;
pub use luminous_flux::*;
pub use magnetic_flux::*;
pub use electric_charge::*;
pub use dose_equivalent::*;
pub use electric_current::*;
pub use catalytic_activity::*;
pub use electric_potential::*;
pub use luminous_intensity::*;
pub use electric_resistance::*;
pub use amount_of_substance::*;
pub use magnetic_flux_density::*;

use crate::declare_unit_square;
use crate::declare_unit_multiplication;

use std::ops::{Div, Mul};

/* ---------------------------------------- unit traits ---------------------------------------- */

pub trait Unit<Physical> {
    fn to_si_unit(&self) -> Physical;
}

pub trait Primitive {
    fn to_si_primitive(&self) -> f64;
}

/* -------------------------------------- here be dragons -------------------------------------- */
/*                                    (unit-interoperability)                                    */


// derived units without special names
// m * m² => m³
declare_unit_multiplication!(Length, Area, Volume);
// m * m => m²
declare_unit_square!(Length, Area);
// v = m/s * s => m
declare_unit_multiplication!(Velocity, Time, Length);
// accel * s = m/s² * s = m/s => v
declare_unit_multiplication!(Acceleration, Time, Velocity);

// kg * m/s² => N
declare_unit_multiplication!(Mass, Acceleration, Force);
// N * m => J
declare_unit_multiplication!(Force, Length, Energy);
// katal * s = mol/s * s => mol
declare_unit_multiplication!(CatalyticActivity, Time, AmountOfSubstance);
// A * s => C
declare_unit_multiplication!(ElectricCurrent, Time, ElectricCharge);
// lux = lm/m² * m² => lm
declare_unit_multiplication!(Illuminance, Area, LuminousFlux);

// Pa * m² = N/m² * m² => N
declare_unit_multiplication!(Pressure, Area, Force);
// W * s = J/s * s => J
declare_unit_multiplication!(Power, Time, Energy);
// Wb * s = V/s * s => V
declare_unit_multiplication!(MagneticFlux, Time, ElectricPotential);
// F * V = C/V * V => C
declare_unit_multiplication!(Capacitance, ElectricPotential, ElectricCharge);
// cd * sr => lumen
declare_unit_multiplication!(LuminousIntensity, SolidAngle, LuminousFlux);

// gray * kg = J/kg * kg => J
// alias is DoseEquivalent, see below
// Activity is an alias to Frequency, which has both Hertz and Becquerel
// henry * A = Wb/A * A => Wb
declare_unit_multiplication!(Inductance, ElectricCurrent, MagneticFlux);
// V * A = W/A * A => W
declare_unit_multiplication!(ElectricPotential, ElectricCurrent, Power);
// Ω * A = V/A * A => V
declare_unit_multiplication!(ElectricResistance, ElectricCurrent, ElectricPotential);

// sievert * kg = J/kg * kg => J
declare_unit_multiplication!(DoseEquivalent, Mass, Energy);
// Hertz is in its file
// tesla * m² = Wb/m² * m² => Wb
declare_unit_multiplication!(MagneticFluxDensity, Area, MagneticFlux);
// Conductance is in its file

// extra conversions, because they work : TODO: add some more
// Hz * m = m/s => v
declare_unit_multiplication!(Frequency, Length, Velocity);
// Pa * m² = N/m² * m³ = N*m => J
declare_unit_multiplication!(Pressure, Volume, Energy);
// C * V = A*s * W/A = W/s = J/s * 1/s => J
declare_unit_multiplication!(ElectricCharge, ElectricPotential, Energy);