mavinspect 0.1.0-alpha2

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::proto::mavlink_messages_v1 as proto;
use crate::protocol::errors::{ParseError, ProtoImportError};

/// Measurement units.
///
/// Used in [`crate::protocol::MessageField`].
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Units {
    /// Time. Second: "s".
    Seconds,
    /// Time. Deci second (second / 10): "ds".
    DeciSeconds,
    /// Time. Centi second (second / 100): "cs".
    CentiSeconds,
    /// Time. Millisecond: "ms".
    MilliSeconds,
    /// Time. Microsecond: "us".
    MicroSeconds,
    /// Time. Nanosecond: "ns".
    NanoSeconds,
    /// Time (frequency). Hertz: "Hz".
    Hertz,
    /// Time (frequency). Megahertz: "MHz".
    MegaHertz,

    /// Distance. Kilometres: "km".
    KiloMetres,
    /// Distance. Decametres: "dam".
    DecaMetres,
    /// Distance. Meter: "m".
    Metres,
    /// Distance (velocity). Metres per second: "m/s".
    MetresPerSecond,
    /// Distance (acceleration). Metres pers second squared: "m/s/s".
    MetresPerSecondSquared,
    /// Distance (velocity). Metres per second: "m/s*5".
    FiveMetresPerSecond,
    /// Distance. Decimetre: "dm".
    DeciMetres,
    /// Distance (velocity). Decimetres per second: "cm/s".
    DeciMetresPerSecond,
    /// Distance. Centimetre: "cm".
    CentiMetres,
    /// Distance (surface). Square centimetre: "cm^2".
    SquareCentiMetres,
    /// Distance (velocity). Centimetres per second: "dm/s".
    CentiMetresPerSecond,
    /// Distance. Millimetre: "mm".
    MilliMetres,
    /// Distance (velocity). Millimetre: "mm/s".
    MilliMetresPerSecond,
    /// Distance (velocity). Millimetres: "mm/h".
    MilliMetresPerHour,

    /// Temperature. Kelvins: "K".
    Kelvins,
    /// Temperature. Degree Celsius: "degC".
    DegreesCelsius,
    /// Temperature. Degree Celsius / 100: "cdegC".
    CentiDegreeCelsius,

    /// Angle. Radians: "rad".
    Radians,
    /// Angle (velocity). Radians per second: "rad/s".
    RadiansPerSecond,
    /// Angle (velocity). Milliradians per second: "mrad/s".
    MilliRadiansPerSecond,
    /// Angle. Degrees: "deg".
    Degrees,
    /// Angle. Half-degrees (degree / 2): "deg/2".
    HalfDegrees,
    /// Angle (velocity). Degrees per second: "deg/s".
    DegreesPerSecond,
    /// Angle. Centi degrees (degree / 100): "cdeg".
    CentiDegrees,
    /// Angle (velocity). Centi degrees (degree / 100) per second: "cdeg/s".
    CentiDegreesPerSecond,
    /// Angle. Degrees / 10^5: "degE5".
    DegreesE5,
    /// Angle. Degrees / 10^7: "degE7".
    DegreesE7,
    /// RotationsPerMinute: "rpm".
    RotationsPerMinute,

    /// Electricity. Volt: "V".
    Volt,
    /// Electricity. Centi volt (volt / 100): "cV".
    CentiVolt,
    /// Electricity. Milli-volt: "mV".
    MilliVolt,
    /// Electricity. Ampere: "A".
    Ampere,
    /// Electricity. Ampere / 100: "cA".
    CentiAmpere,
    /// Electricity. Milli ampere: "mA".
    MilliAmpere,
    /// Electricity. Milli ampere hour: "mAh".
    MilliAmpereHour,

    /// Magnetism. Milli Tesla: "mT".
    MilliTesla,
    /// Magnetism. Gauss: "gauss".
    Gauss,
    /// Magnetism. Milli-gauss: "mgauss".
    MilliGauss,

    /// Energy. Hecto Joule: "hJ".
    HectoJoule,

    /// Power. Watt: "W".
    Watt,

    /// Force. Milli-G: "mG"
    MilliG,

    /// Mass. Gram: "g"
    Grams,
    /// Mass. Gram: "kg"
    KiloGrams,

    /// Pressure. Pascal: "Pa"
    Pascal,
    /// Pressure. Hectopascal: "hPa"
    HectoPascal,
    /// Pressure. Kilopascal: "kPa"
    KiloPascal,
    /// Pressure. Millibar: "mbar"
    MilliBar,

    /// Ratio. Percent: "%".
    Percent,
    /// Ratio. Decipercent (percent / 10): "d%".
    DeciPercent,
    /// Ratio. Centipercent (percent / 100): "c%".
    CentiPercent,
    /// Ratio. Decibel: "dB".
    DeciBel,
    /// Ratio. Decibel milli-Wats: "dBm".
    DeciBelMilliWats,

    /// Digital. Kibibyte (1024 bytes): "KiB".
    KibiByte,
    /// Digital (throughput). Kibibyte (1024 bytes) per second: "KiB/s".
    KibiBytePerSecond,
    /// Digital. Mebibyte (1024*1024 bytes): "MiB".
    MebiByte,
    /// Digital (throughput). Mebibyte (1024*1024 bytes) per second: "MiB/s".
    MebiBytePerSecond,
    /// Digital. Bytes: "bytes".
    Bytes,
    /// Digital (throughput). Bytes per second: "bytes/s".
    BytesPerSecond,
    /// Digital (throughput). Bits per second: "bits/s".
    BitsPerSecond,
    /// Digital. Pixels: "pix".
    Pixels,
    /// Digital. Decipixels (pixel / 10): "dpix".
    DeciPixels,

    /// Flow. Grams per minute: "g/min".
    GramsPerMinute,
    /// Flow. Cubic centimetres per minute: "cm^3/min".
    CubicCentiMetresPerMinute,

    /// Volume. Cubic centimetres: "cm^3".
    CubicCentiMetres,
    /// Volume. Litres: "l".
    Litres,
}

impl Units {
    /// Parses field unit from string
    pub fn parse(s: &str) -> Result<Option<Units>, ParseError> {
        let normalized = s.trim();

        let known = match normalized {
            // Time
            "s" => Units::Seconds,
            "ds" => Units::DeciSeconds,
            "cs" => Units::CentiSeconds,
            "ms" => Units::MilliSeconds,
            "us" => Units::MicroSeconds,
            "ns" => Units::NanoSeconds,
            "Hz" => Units::Hertz,
            "MHz" => Units::MegaHertz,
            // Distance
            "km" => Units::KiloMetres,
            "dam" => Units::DecaMetres,
            "m" => Units::Metres,
            "m/s" => Units::MetresPerSecond,
            "m/s/s" => Units::MetresPerSecondSquared,
            "m/s*5" => Units::FiveMetresPerSecond,
            "dm" => Units::DeciMetres,
            "dm/s" => Units::DeciMetresPerSecond,
            "cm" => Units::CentiMetres,
            "cm^2" => Units::SquareCentiMetres,
            "cm/s" => Units::CentiMetresPerSecond,
            "mm" => Units::MilliMetres,
            "mm/s" => Units::MilliMetresPerSecond,
            "mm/h" => Units::MilliMetresPerHour,
            // Temperature
            "K" => Units::Kelvins,
            "degC" => Units::DegreesCelsius,
            "cdegC" => Units::CentiDegreeCelsius,
            // Angles
            "rad" => Units::Radians,
            "rad/s" => Units::RadiansPerSecond,
            "mrad/s" => Units::MilliRadiansPerSecond,
            "deg" => Units::Degrees,
            "deg/2" => Units::HalfDegrees,
            "deg/s" => Units::DegreesPerSecond,
            "cdeg" => Units::CentiDegrees,
            "cdeg/s" => Units::CentiDegreesPerSecond,
            "degE5" => Units::DegreesE5,
            "degE7" => Units::DegreesE7,
            "rpm" => Units::RotationsPerMinute,
            // Electricity
            "V" => Units::Volt,
            "cV" => Units::CentiVolt,
            "mV" => Units::MilliVolt,
            "A" => Units::Ampere,
            "cA" => Units::CentiAmpere,
            "mA" => Units::MilliAmpere,
            "mAh" => Units::MilliAmpereHour,
            // Magnetism
            "mT" => Units::MilliTesla,
            "gauss" => Units::Gauss,
            "mgauss" => Units::MilliGauss,
            // Energy
            "hJ" => Units::HectoJoule,
            // Power
            "W" => Units::Watt,
            // Force
            "mG" => Units::MilliG,
            // Mass
            "g" => Units::Grams,
            "kg" => Units::KiloGrams,
            // Pressure
            "Pa" => Units::Pascal,
            "hPa" => Units::HectoPascal,
            "kPa" => Units::KiloPascal,
            "mbar" => Units::MilliBar,
            // Ratio
            "%" => Units::Percent,
            "d%" => Units::DeciPercent,
            "c%" => Units::CentiPercent,
            "dB" => Units::DeciBel,
            "dBm" => Units::DeciBelMilliWats,
            // Digital
            "KiB" => Units::KibiByte,
            "KiB/s" => Units::KibiBytePerSecond,
            "MiB" => Units::MebiByte,
            "MiB/s" => Units::MebiBytePerSecond,
            "bytes" => Units::Bytes,
            "bytes/s" => Units::BytesPerSecond,
            "bits/s" => Units::BitsPerSecond,
            "pix" => Units::Pixels,
            "dpix" => Units::DeciPixels,
            // Flow
            "g/min" => Units::GramsPerMinute,
            "cm^3/min" => Units::CubicCentiMetresPerMinute,
            // Volume
            "cm^3" => Units::CubicCentiMetres,
            "l" => Units::Litres,
            unknown => {
                return match unknown {
                    "" => Ok(None),
                    &_ => Err(ParseError::UnitsError(unknown.to_string())),
                }
            }
        };

        Ok(Some(known))
    }

    /// Converts to Protobuf [`proto::Units`]
    pub fn to_proto(&self) -> proto::Units {
        match self {
            // Time
            Self::Seconds => proto::Units::Seconds,
            Self::DeciSeconds => proto::Units::DeciSeconds,
            Self::CentiSeconds => proto::Units::CentiSeconds,
            Self::MilliSeconds => proto::Units::MilliSeconds,
            Self::MicroSeconds => proto::Units::MicroSeconds,
            Self::NanoSeconds => proto::Units::NanoSeconds,
            Self::Hertz => proto::Units::Hertz,
            Self::MegaHertz => proto::Units::MegaHertz,
            // Distance
            Self::KiloMetres => proto::Units::KiloMetres,
            Self::DecaMetres => proto::Units::DecaMetres,
            Self::Metres => proto::Units::Metres,
            Self::MetresPerSecond => proto::Units::MetresPerSecond,
            Self::MetresPerSecondSquared => proto::Units::MetresPerSecondSquared,
            Self::FiveMetresPerSecond => proto::Units::FiveMetresPerSecond,
            Self::DeciMetres => proto::Units::DeciMetres,
            Self::DeciMetresPerSecond => proto::Units::DeciMetresPerSecond,
            Self::CentiMetres => proto::Units::CentiMetres,
            Self::SquareCentiMetres => proto::Units::SquareCentiMetres,
            Self::CentiMetresPerSecond => proto::Units::CentiMetresPerSecond,
            Self::MilliMetres => proto::Units::MilliMetres,
            Self::MilliMetresPerSecond => proto::Units::MilliMetresPerSecond,
            Self::MilliMetresPerHour => proto::Units::MilliMetresPerHour,
            // Temperature
            Self::Kelvins => proto::Units::Kelvins,
            Self::DegreesCelsius => proto::Units::DegreesCelsius,
            Self::CentiDegreeCelsius => proto::Units::CentiDegreeCelsius,
            // Angles
            Self::Radians => proto::Units::Radians,
            Self::RadiansPerSecond => proto::Units::RadiansPerSecond,
            Self::MilliRadiansPerSecond => proto::Units::MilliRadiansPerSecond,
            Self::Degrees => proto::Units::Degrees,
            Self::HalfDegrees => proto::Units::HalfDegrees,
            Self::DegreesPerSecond => proto::Units::DegreesPerSecond,
            Self::CentiDegrees => proto::Units::CentiDegrees,
            Self::CentiDegreesPerSecond => proto::Units::CentiDegreesPerSecond,
            Self::DegreesE5 => proto::Units::DegreesE5,
            Self::DegreesE7 => proto::Units::DegreesE7,
            Self::RotationsPerMinute => proto::Units::RotationsPerMinute,
            // Electricity
            Self::Volt => proto::Units::Volt,
            Self::CentiVolt => proto::Units::CentiVolt,
            Self::MilliVolt => proto::Units::MilliVolt,
            Self::Ampere => proto::Units::Ampere,
            Self::CentiAmpere => proto::Units::CentiAmpere,
            Self::MilliAmpere => proto::Units::MilliAmpere,
            Self::MilliAmpereHour => proto::Units::MilliAmpereHour,
            // Magnetism
            Self::MilliTesla => proto::Units::MilliTesla,
            Self::Gauss => proto::Units::Gauss,
            Self::MilliGauss => proto::Units::MilliGauss,
            // Energy
            Self::HectoJoule => proto::Units::HectoJoule,
            // Power
            Self::Watt => proto::Units::Watt,
            // Force
            Self::MilliG => proto::Units::MilliG,
            // Mass
            Self::Grams => proto::Units::Grams,
            Self::KiloGrams => proto::Units::KiloGrams,
            // Pressure
            Self::Pascal => proto::Units::Pascal,
            Self::HectoPascal => proto::Units::HectoPascal,
            Self::KiloPascal => proto::Units::KiloPascal,
            Self::MilliBar => proto::Units::MilliBar,
            // Ratio
            Self::Percent => proto::Units::Percent,
            Self::DeciPercent => proto::Units::DeciPercent,
            Self::CentiPercent => proto::Units::CentiPercent,
            Self::DeciBel => proto::Units::DeciBel,
            Self::DeciBelMilliWats => proto::Units::DeciBelMilliWats,
            // Digital
            Self::KibiByte => proto::Units::KibiByte,
            Self::KibiBytePerSecond => proto::Units::KibiBytePerSecond,
            Self::MebiByte => proto::Units::MebiByte,
            Self::MebiBytePerSecond => proto::Units::MebiBytePerSecond,
            Self::Bytes => proto::Units::Bytes,
            Self::BytesPerSecond => proto::Units::BytesPerSecond,
            Self::BitsPerSecond => proto::Units::BitsPerSecond,
            Self::Pixels => proto::Units::Pixels,
            Self::DeciPixels => proto::Units::DeciPixels,
            // Flow
            Self::GramsPerMinute => proto::Units::GramsPerMinute,
            Self::CubicCentiMetresPerMinute => proto::Units::CubicCentiMetresPerMinute,
            // Volume
            Self::CubicCentiMetres => proto::Units::CubicCentiMetres,
            Self::Litres => proto::Units::Litres,
        }
    }

    /// Constructs from Protobuf [`proto::Units`]
    pub fn from_proto(proto: &proto::Units) -> Result<Self, ProtoImportError> {
        Ok(match proto {
            // Time
            proto::Units::Seconds => Self::Seconds,
            proto::Units::DeciSeconds => Self::DeciSeconds,
            proto::Units::CentiSeconds => Self::CentiSeconds,
            proto::Units::MilliSeconds => Self::MilliSeconds,
            proto::Units::MicroSeconds => Self::MicroSeconds,
            proto::Units::NanoSeconds => Self::NanoSeconds,
            proto::Units::Hertz => Self::Hertz,
            proto::Units::MegaHertz => Self::MegaHertz,
            // Distance
            proto::Units::KiloMetres => Self::KiloMetres,
            proto::Units::DecaMetres => Self::DecaMetres,
            proto::Units::Metres => Self::Metres,
            proto::Units::MetresPerSecond => Self::MetresPerSecond,
            proto::Units::MetresPerSecondSquared => Self::MetresPerSecondSquared,
            proto::Units::FiveMetresPerSecond => Self::FiveMetresPerSecond,
            proto::Units::DeciMetres => Self::DeciMetres,
            proto::Units::DeciMetresPerSecond => Self::DeciMetresPerSecond,
            proto::Units::CentiMetres => Self::CentiMetres,
            proto::Units::SquareCentiMetres => Self::SquareCentiMetres,
            proto::Units::CentiMetresPerSecond => Self::CentiMetresPerSecond,
            proto::Units::MilliMetres => Self::MilliMetres,
            proto::Units::MilliMetresPerSecond => Self::MilliMetresPerSecond,
            proto::Units::MilliMetresPerHour => Self::MilliMetresPerHour,
            // Temperature
            proto::Units::Kelvins => Self::Kelvins,
            proto::Units::DegreesCelsius => Self::DegreesCelsius,
            proto::Units::CentiDegreeCelsius => Self::CentiDegreeCelsius,
            // Angles
            proto::Units::Radians => Self::Radians,
            proto::Units::RadiansPerSecond => Self::RadiansPerSecond,
            proto::Units::MilliRadiansPerSecond => Self::MilliRadiansPerSecond,
            proto::Units::Degrees => Self::Degrees,
            proto::Units::HalfDegrees => Self::HalfDegrees,
            proto::Units::DegreesPerSecond => Self::DegreesPerSecond,
            proto::Units::CentiDegrees => Self::CentiDegrees,
            proto::Units::CentiDegreesPerSecond => Self::CentiDegreesPerSecond,
            proto::Units::DegreesE5 => Self::DegreesE5,
            proto::Units::DegreesE7 => Self::DegreesE7,
            proto::Units::RotationsPerMinute => Self::RotationsPerMinute,
            // Electricity
            proto::Units::Volt => Self::Volt,
            proto::Units::CentiVolt => Self::CentiVolt,
            proto::Units::MilliVolt => Self::MilliVolt,
            proto::Units::Ampere => Self::Ampere,
            proto::Units::CentiAmpere => Self::CentiAmpere,
            proto::Units::MilliAmpere => Self::MilliAmpere,
            proto::Units::MilliAmpereHour => Self::MilliAmpereHour,
            // Magnetism
            proto::Units::MilliTesla => Self::MilliTesla,
            proto::Units::Gauss => Self::Gauss,
            proto::Units::MilliGauss => Self::MilliGauss,
            // Energy
            proto::Units::HectoJoule => Self::HectoJoule,
            // Power
            proto::Units::Watt => Self::Watt,
            // Force
            proto::Units::MilliG => Self::MilliG,
            // Mass
            proto::Units::Grams => Self::Grams,
            proto::Units::KiloGrams => Self::KiloGrams,
            // Pressure
            proto::Units::Pascal => Self::Pascal,
            proto::Units::HectoPascal => Self::HectoPascal,
            proto::Units::KiloPascal => Self::KiloPascal,
            proto::Units::MilliBar => Self::MilliBar,
            // Ratio
            proto::Units::Percent => Self::Percent,
            proto::Units::DeciPercent => Self::DeciPercent,
            proto::Units::CentiPercent => Self::CentiPercent,
            proto::Units::DeciBel => Self::DeciBel,
            proto::Units::DeciBelMilliWats => Self::DeciBelMilliWats,
            // Digital
            proto::Units::KibiByte => Self::KibiByte,
            proto::Units::KibiBytePerSecond => Self::KibiBytePerSecond,
            proto::Units::MebiByte => Self::MebiByte,
            proto::Units::MebiBytePerSecond => Self::MebiBytePerSecond,
            proto::Units::Bytes => Self::Bytes,
            proto::Units::BytesPerSecond => Self::BytesPerSecond,
            proto::Units::BitsPerSecond => Self::BitsPerSecond,
            proto::Units::Pixels => Self::Pixels,
            proto::Units::DeciPixels => Self::DeciPixels,
            // Flow
            proto::Units::GramsPerMinute => Self::GramsPerMinute,
            proto::Units::CubicCentiMetresPerMinute => Self::CubicCentiMetresPerMinute,
            // Volume
            proto::Units::CubicCentiMetres => Self::CubicCentiMetres,
            proto::Units::Litres => Self::Litres,
            // Unspecified (required by Protobuf conventions)
            proto::Units::Unspecified => {
                return Err(ProtoImportError::UnspecifiedUnitsAreNotSupported)
            }
        })
    }

    /// Constructs from Protobuf enum value
    pub fn from_value(value: i32) -> Result<Self, ProtoImportError> {
        Self::from_proto(
            &proto::Units::try_from(value)
                .map_err(ProtoImportError::InvalidUnitsNumericEnumValue)?,
        )
    }
}