bacnet-ops 0.15.0

//! Object/property shorthand parsing for integrators.
//!
//! Handles full names (kebab-case), common abbreviations, and numeric values
//! for BACnet object types, property identifiers, and write values.
//! A write value typed for a known property ([`parse_value_for`]) also
//! takes its enumeration and bit names, and dates, times and timestamps
//! in the forms the formatter prints, so what a read shows can be typed
//! back.

mod datetime;
mod json;
mod numeric;
mod typed;

pub use datetime::{parse_date, parse_date_time, parse_time, parse_timestamp};
pub use typed::{parse_value_for, parse_value_for_with_priority};

use bacnet_types::enums::{ObjectType, PropertyIdentifier};
use bacnet_types::primitives::{ObjectIdentifier, PropertyValue};

#[cfg(test)]
mod datetime_tests;
#[cfg(test)]
mod json_tests;
#[cfg(test)]
mod typed_more_tests;
#[cfg(test)]
mod typed_tests;

/// Abbreviation mappings for object types: (abbreviation, raw_value).
///
/// Raw values per ASHRAE 135-2020 Clause 21:
/// 0=analog-input, 1=analog-output, 2=analog-value, 3=binary-input, 4=binary-output,
/// 5=binary-value, 6=calendar, 7=command, 8=device, 10=file, 12=loop,
/// 13=multi-state-input, 14=multi-state-output, 15=notification-class, 16=program,
/// 17=schedule, 19=multi-state-value, 20=trend-log, 23=accumulator, 24=pulse-converter.
const OBJ_ABBREVS: &[(&str, u32)] = &[
    ("ai", 0),   // analog-input
    ("ao", 1),   // analog-output
    ("av", 2),   // analog-value
    ("bi", 3),   // binary-input
    ("bo", 4),   // binary-output
    ("bv", 5),   // binary-value
    ("dev", 8),  // device
    ("msi", 13), // multi-state-input
    ("mso", 14), // multi-state-output
    ("msv", 19), // multi-state-value
    ("lp", 21),  // life-safety-point
    ("lsp", 21), // life-safety-point
    ("sc", 17),  // schedule
    ("cal", 6),  // calendar
    ("nc", 15),  // notification-class
    ("trn", 20), // trend-log
    ("acc", 23), // accumulator
    ("pi", 24),  // pulse-converter
    ("lo", 12),  // loop
    ("prg", 16), // program
    ("cmd", 7),  // command
];

/// Abbreviation mappings for property identifiers: (abbreviation, raw_value).
const PROP_ABBREVS: &[(&str, u32)] = &[
    ("pv", 85),   // present-value
    ("on", 77),   // object-name
    ("ot", 79),   // object-type
    ("desc", 28), // description
    ("sf", 111),  // status-flags
    ("es", 36),   // event-state
    ("oos", 81),  // out-of-service
    ("pa", 87),   // priority-array
    ("rd", 104),  // relinquish-default
    ("ol", 76),   // object-list
    ("all", 8),   // ALL
];

/// Parse an object type from a string.
///
/// Accepts:
/// - Full names case-insensitive with hyphens: `analog-input`, `ANALOG_INPUT`
/// - Common abbreviations: `ai`, `ao`, `av`, `bi`, `bo`, `bv`, `dev`, etc.
/// - Numeric values: `0`, `1`, etc.
pub fn parse_object_type(s: &str) -> Result<ObjectType, String> {
    let s = s.trim();

    // Try numeric first.
    if let Ok(n) = s.parse::<u32>() {
        return Ok(ObjectType::from_raw(n));
    }

    // Try abbreviations (case-insensitive).
    let lower = s.to_ascii_lowercase();
    for &(abbr, raw) in OBJ_ABBREVS {
        if lower == abbr {
            return Ok(ObjectType::from_raw(raw));
        }
    }

    // Try matching against ALL_NAMED (convert hyphens to underscores, case-insensitive).
    let normalized = lower.replace('-', "_");
    for &(name, val) in ObjectType::ALL_NAMED {
        if name.eq_ignore_ascii_case(&normalized) {
            return Ok(val);
        }
    }

    Err(format!("unknown object type: '{s}'"))
}

/// Parse an object specifier like `analog-input:1` or `ai:1` into (ObjectType, instance).
pub fn parse_object_specifier(s: &str) -> Result<(ObjectType, u32), String> {
    let (type_str, inst_str) = s
        .rsplit_once(':')
        .ok_or_else(|| format!("expected 'type:instance' format, got '{s}'"))?;

    let obj_type = parse_object_type(type_str)?;
    let instance = inst_str
        .parse::<u32>()
        .map_err(|_| format!("invalid instance number: '{inst_str}'"))?;

    Ok((obj_type, instance))
}

/// Parse a property identifier from a string.
///
/// Accepts:
/// - Full names case-insensitive with hyphens: `present-value`, `object-name`
/// - Common abbreviations: `pv`, `on`, `ot`, `desc`, `sf`, `es`, `oos`, `pa`, `rd`, `ol`, `all`
/// - Numeric values: `85`, `77`, etc.
/// - Array index syntax: `object-list[3]` → (OBJECT_LIST, Some(3))
///
/// Returns (PropertyIdentifier, Option<array_index>).
pub fn parse_property(s: &str) -> Result<(PropertyIdentifier, Option<u32>), String> {
    let s = s.trim();

    // Check for array index: property[index]
    let (prop_str, array_index) = if let Some(bracket_pos) = s.find('[') {
        let end = s
            .find(']')
            .ok_or_else(|| format!("missing closing ']' in '{s}'"))?;
        if end <= bracket_pos {
            return Err(format!("malformed array index in '{s}'"));
        }
        let idx_str = &s[bracket_pos + 1..end];
        let idx = idx_str
            .parse::<u32>()
            .map_err(|_| format!("invalid array index: '{idx_str}'"))?;
        (&s[..bracket_pos], Some(idx))
    } else {
        (s, None)
    };

    let prop = parse_property_name(prop_str)?;
    Ok((prop, array_index))
}

/// Parse just the property name (without array index).
fn parse_property_name(s: &str) -> Result<PropertyIdentifier, String> {
    // Try numeric first.
    if let Ok(n) = s.parse::<u32>() {
        return Ok(PropertyIdentifier::from_raw(n));
    }

    // Try abbreviations (case-insensitive).
    let lower = s.to_ascii_lowercase();
    for &(abbr, raw) in PROP_ABBREVS {
        if lower == abbr {
            return Ok(PropertyIdentifier::from_raw(raw));
        }
    }

    // Try matching against ALL_NAMED (convert hyphens to underscores, case-insensitive).
    let normalized = lower.replace('-', "_");
    for &(name, val) in PropertyIdentifier::ALL_NAMED {
        if name.eq_ignore_ascii_case(&normalized) {
            return Ok(val);
        }
    }

    Err(format!("unknown property: '{s}'"))
}

/// Parse a write value from a string, with no property to say its
/// datatype. [`parse_value_for`] reads names and named bits for a known
/// property.
///
/// Accepts:
/// - `null` → PropertyValue::Null
/// - `true`/`false` → PropertyValue::Boolean
/// - `active` → PropertyValue::Enumerated(1), `inactive` → PropertyValue::Enumerated(0)
/// - Integer without decimal: `42` → PropertyValue::Unsigned, negative → PropertyValue::Signed
/// - Float with decimal: `72.5` → PropertyValue::Real
/// - Quoted string: `"hello"` → PropertyValue::CharacterString
/// - `enumerated:3` → PropertyValue::Enumerated(3)
/// - `bits(0101)` → PropertyValue::BitString, first bit first
/// - dates, times and date-times as the formatter prints them, bare or
///   after `date:`/`time:`: `2026-10-19`, `2026-10-19 Mon`, `*-*-* Fri`,
///   `07:00`, `14:30:05.25`, `any date`, `any time`; a date and a time
///   (`2026-10-19 07:00`, or `unspecified`) is a BACnetDateTime, a Date
///   then a Time
/// - `object:ai:1` → PropertyValue::ObjectIdentifier
pub fn parse_value(s: &str) -> Result<PropertyValue, String> {
    let s = s.trim();

    // Null.
    if s.eq_ignore_ascii_case("null") {
        return Ok(PropertyValue::Null);
    }

    // Boolean.
    if s.eq_ignore_ascii_case("true") {
        return Ok(PropertyValue::Boolean(true));
    }
    if s.eq_ignore_ascii_case("false") {
        return Ok(PropertyValue::Boolean(false));
    }

    // Active/Inactive as enumerated.
    if s.eq_ignore_ascii_case("active") {
        return Ok(PropertyValue::Enumerated(1));
    }
    if s.eq_ignore_ascii_case("inactive") {
        return Ok(PropertyValue::Enumerated(0));
    }

    // Date prefix: date:YYYY-MM-DD, in any form the formatter prints.
    if let Some(rest) = s.strip_prefix("date:") {
        return parse_date(rest).map(PropertyValue::Date);
    }

    // Time prefix: time:HH:MM[:SS[.hh]]
    if let Some(rest) = s.strip_prefix("time:") {
        return parse_time(rest).map(PropertyValue::Time);
    }

    // Bare dates, times and date-times, as the formatter prints them.
    if s.eq_ignore_ascii_case("any time") || datetime::looks_like_time(s) {
        return parse_time(s).map(PropertyValue::Time);
    }
    let lower = s.to_ascii_lowercase();
    if datetime::looks_like_date(s) || lower.starts_with("any date") || lower == "unspecified" {
        return match parse_date_time(s)? {
            (date, None) => Ok(PropertyValue::Date(date)),
            (date, Some(time)) => Ok(PropertyValue::List(vec![
                PropertyValue::Date(date),
                PropertyValue::Time(time),
            ])),
        };
    }

    // A bit string as its bits, as the formatter prints one without names.
    if let Some(bits) = s.strip_prefix("bits(").and_then(|b| b.strip_suffix(')')) {
        if !bits.bytes().all(|b| b == b'0' || b == b'1') {
            return Err(format!(
                "invalid bits '{bits}': 0/1 digits, first bit first"
            ));
        }
        let set: Vec<bool> = bits.bytes().map(|b| b == b'1').collect();
        return Ok(typed::bit_string(&set));
    }

    // ObjectIdentifier prefix: object:type:instance
    if let Some(rest) = s.strip_prefix("object:") {
        let (obj_type, instance) = parse_object_specifier(rest)?;
        let oid = ObjectIdentifier::new(obj_type, instance)
            .map_err(|e| format!("invalid object identifier: {e}"))?;
        return Ok(PropertyValue::ObjectIdentifier(oid));
    }

    // Enumerated prefix.
    if let Some(rest) = s.strip_prefix("enumerated:") {
        let val = rest
            .parse::<u32>()
            .map_err(|_| format!("invalid enumerated value: '{rest}'"))?;
        return Ok(PropertyValue::Enumerated(val));
    }

    // Quoted string.
    if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
        let inner = &s[1..s.len() - 1];
        return Ok(PropertyValue::CharacterString(inner.to_string()));
    }

    // Numeric — check for decimal point to distinguish integer vs float.
    if s.contains('.') {
        let val = s
            .parse::<f32>()
            .map_err(|_| format!("invalid float value: '{s}'"))?;
        return numeric::finite(PropertyValue::Real(val)).map_err(|e| format!("'{s}': {e}"));
    }

    // Scientific notation (e.g., 1e10, -2.5e3).
    if (s.contains('e') || s.contains('E'))
        && !s.eq_ignore_ascii_case("enumerated")
        && !s.starts_with("enumerated:")
        && let Ok(val) = s.parse::<f32>()
    {
        return numeric::finite(PropertyValue::Real(val)).map_err(|e| format!("'{s}': {e}"));
    }

    // Try integer — negative is Signed, positive is Unsigned.
    if s.starts_with('-') {
        let val = s
            .parse::<i32>()
            .map_err(|_| format!("invalid integer value: '{s}'"))?;
        return Ok(PropertyValue::Signed(val));
    }

    if let Ok(val) = s.parse::<u64>() {
        return Ok(PropertyValue::Unsigned(val));
    }

    Err(format!("cannot parse value: '{s}'"))
}

/// A value's text and its optional `@priority` suffix, the `@` after a
/// quoted string's closing quote when the value is one.
fn split_priority(s: &str) -> Result<(&str, Option<u8>), String> {
    let s = s.trim();

    // Find the last '@' that separates value from priority.
    // Be careful not to split inside a quoted string.
    let at_pos = if let Some(stripped) = s.strip_prefix('"') {
        // For quoted strings, look for '@' after the closing quote.
        if let Some(end_quote) = stripped.find('"') {
            let after_quote = end_quote + 2; // position after closing quote
            s[after_quote..].find('@').map(|p| p + after_quote)
        } else {
            None
        }
    } else {
        s.rfind('@')
    };

    let Some(pos) = at_pos else {
        return Ok((s, None));
    };
    let priority_str = &s[pos + 1..];
    let priority = priority_str
        .parse::<u8>()
        .map_err(|_| format!("invalid priority: '{priority_str}'"))?;
    if !(1..=16).contains(&priority) {
        return Err(format!("priority must be 1-16, got {priority}"));
    }
    Ok((&s[..pos], Some(priority)))
}

/// Parse a value with optional `@priority` suffix.
///
/// Examples: `72.5@8` → (Real(72.5), Some(8)), `null@16` → (Null, Some(16)), `42` → (Unsigned(42), None)
pub fn parse_value_with_priority(s: &str) -> Result<(PropertyValue, Option<u8>), String> {
    let (value, priority) = split_priority(s)?;
    Ok((parse_value(value)?, priority))
}

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

    #[test]
    fn parse_object_type_full_name() {
        assert_eq!(
            parse_object_type("analog-input").unwrap().to_raw(),
            ObjectType::ANALOG_INPUT.to_raw()
        );
        assert_eq!(
            parse_object_type("ANALOG_INPUT").unwrap().to_raw(),
            ObjectType::ANALOG_INPUT.to_raw()
        );
        assert_eq!(
            parse_object_type("Binary-Value").unwrap().to_raw(),
            ObjectType::BINARY_VALUE.to_raw()
        );
    }

    #[test]
    fn parse_object_type_abbreviation() {
        assert_eq!(parse_object_type("ai").unwrap().to_raw(), 0);
        assert_eq!(parse_object_type("bo").unwrap().to_raw(), 4);
        assert_eq!(parse_object_type("dev").unwrap().to_raw(), 8);
        assert_eq!(parse_object_type("msv").unwrap().to_raw(), 19);
        assert_eq!(parse_object_type("AI").unwrap().to_raw(), 0);
    }

    #[test]
    fn parse_object_type_numeric() {
        assert_eq!(parse_object_type("0").unwrap().to_raw(), 0);
        assert_eq!(parse_object_type("8").unwrap().to_raw(), 8);
        assert_eq!(parse_object_type("42").unwrap().to_raw(), 42);
    }

    #[test]
    fn parse_object_type_error() {
        assert!(parse_object_type("nonexistent").is_err());
    }

    #[test]
    fn parse_object_specifier_works() {
        let (ot, inst) = parse_object_specifier("ai:1").unwrap();
        assert_eq!(ot.to_raw(), 0);
        assert_eq!(inst, 1);

        let (ot, inst) = parse_object_specifier("analog-input:100").unwrap();
        assert_eq!(ot.to_raw(), 0);
        assert_eq!(inst, 100);

        let (ot, inst) = parse_object_specifier("dev:1234").unwrap();
        assert_eq!(ot.to_raw(), 8);
        assert_eq!(inst, 1234);
    }

    #[test]
    fn parse_object_specifier_errors() {
        assert!(parse_object_specifier("ai").is_err()); // missing instance
        assert!(parse_object_specifier("ai:abc").is_err()); // bad instance
    }

    #[test]
    fn parse_property_full_name() {
        let (p, idx) = parse_property("present-value").unwrap();
        assert_eq!(p.to_raw(), 85);
        assert_eq!(idx, None);
    }

    #[test]
    fn parse_property_abbreviation() {
        let (p, _) = parse_property("pv").unwrap();
        assert_eq!(p.to_raw(), 85);
        let (p, _) = parse_property("on").unwrap();
        assert_eq!(p.to_raw(), 77);
        let (p, _) = parse_property("all").unwrap();
        assert_eq!(p.to_raw(), 8);
    }

    #[test]
    fn parse_property_numeric() {
        let (p, _) = parse_property("85").unwrap();
        assert_eq!(p.to_raw(), 85);
    }

    #[test]
    fn parse_property_array_index() {
        let (p, idx) = parse_property("object-list[3]").unwrap();
        assert_eq!(p.to_raw(), 76);
        assert_eq!(idx, Some(3));

        let (p, idx) = parse_property("ol[0]").unwrap();
        assert_eq!(p.to_raw(), 76);
        assert_eq!(idx, Some(0));
    }

    #[test]
    fn parse_value_null() {
        assert!(matches!(parse_value("null").unwrap(), PropertyValue::Null));
        assert!(matches!(parse_value("NULL").unwrap(), PropertyValue::Null));
    }

    #[test]
    fn parse_value_boolean() {
        assert!(matches!(
            parse_value("true").unwrap(),
            PropertyValue::Boolean(true)
        ));
        assert!(matches!(
            parse_value("false").unwrap(),
            PropertyValue::Boolean(false)
        ));
    }

    #[test]
    fn parse_value_active_inactive() {
        assert!(matches!(
            parse_value("active").unwrap(),
            PropertyValue::Enumerated(1)
        ));
        assert!(matches!(
            parse_value("inactive").unwrap(),
            PropertyValue::Enumerated(0)
        ));
    }

    #[test]
    fn parse_value_unsigned() {
        match parse_value("42").unwrap() {
            PropertyValue::Unsigned(v) => assert_eq!(v, 42),
            other => panic!("expected Unsigned, got {other:?}"),
        }
    }

    #[test]
    fn parse_value_signed() {
        match parse_value("-5").unwrap() {
            PropertyValue::Signed(v) => assert_eq!(v, -5),
            other => panic!("expected Signed, got {other:?}"),
        }
    }

    #[test]
    fn parse_value_real() {
        match parse_value("72.5").unwrap() {
            PropertyValue::Real(v) => assert!((v - 72.5).abs() < f32::EPSILON),
            other => panic!("expected Real, got {other:?}"),
        }
    }

    #[test]
    fn parse_value_string() {
        match parse_value("\"hello world\"").unwrap() {
            PropertyValue::CharacterString(s) => assert_eq!(s, "hello world"),
            other => panic!("expected CharacterString, got {other:?}"),
        }
    }

    #[test]
    fn parse_value_enumerated() {
        match parse_value("enumerated:3").unwrap() {
            PropertyValue::Enumerated(v) => assert_eq!(v, 3),
            other => panic!("expected Enumerated, got {other:?}"),
        }
    }

    #[test]
    fn parse_value_with_priority_works() {
        let (val, pri) = parse_value_with_priority("72.5@8").unwrap();
        assert!(matches!(val, PropertyValue::Real(_)));
        assert_eq!(pri, Some(8));

        let (val, pri) = parse_value_with_priority("null@16").unwrap();
        assert!(matches!(val, PropertyValue::Null));
        assert_eq!(pri, Some(16));

        let (val, pri) = parse_value_with_priority("42").unwrap();
        assert!(matches!(val, PropertyValue::Unsigned(42)));
        assert_eq!(pri, None);
    }

    #[test]
    fn parse_value_with_priority_invalid() {
        assert!(parse_value_with_priority("42@0").is_err()); // priority 0 invalid
        assert!(parse_value_with_priority("42@17").is_err()); // priority 17 invalid
    }

    #[test]
    fn lp_maps_to_life_safety_point() {
        assert_eq!(parse_object_type("lp").unwrap().to_raw(), 21);
        assert_eq!(parse_object_type("lsp").unwrap().to_raw(), 21);
        assert_eq!(parse_object_type("cal").unwrap().to_raw(), 6);
    }

    #[test]
    fn bracket_ordering_panic() {
        assert!(parse_property("pv]3[").is_err());
    }

    #[test]
    fn scientific_notation_real() {
        match parse_value("1e10").unwrap() {
            PropertyValue::Real(v) => assert!((v - 1e10).abs() < 1e5),
            other => panic!("expected Real, got {other:?}"),
        }
        match parse_value("-2.5e3").unwrap() {
            PropertyValue::Real(v) => assert!((v - (-2500.0)).abs() < f32::EPSILON),
            other => panic!("expected Real, got {other:?}"),
        }
    }

    #[test]
    fn parse_date_value() {
        match parse_value("date:2024-03-15").unwrap() {
            PropertyValue::Date(d) => {
                assert_eq!(d.year, 124); // 2024 - 1900
                assert_eq!(d.month, 3);
                assert_eq!(d.day, 15);
                assert_eq!(d.day_of_week, 0xFF);
            }
            other => panic!("expected Date, got {other:?}"),
        }
    }

    #[test]
    fn parse_time_value() {
        match parse_value("time:14:30:00").unwrap() {
            PropertyValue::Time(t) => {
                assert_eq!(t.hour, 14);
                assert_eq!(t.minute, 30);
                assert_eq!(t.second, 0);
                assert_eq!(t.hundredths, 0);
            }
            other => panic!("expected Time, got {other:?}"),
        }
    }

    #[test]
    fn parse_object_identifier_value() {
        match parse_value("object:ai:1").unwrap() {
            PropertyValue::ObjectIdentifier(oid) => {
                assert_eq!(oid.object_type().to_raw(), 0);
                assert_eq!(oid.instance_number(), 1);
            }
            other => panic!("expected ObjectIdentifier, got {other:?}"),
        }
    }

    #[test]
    fn empty_string_with_priority() {
        let (val, pri) = parse_value_with_priority("\"\"@8").unwrap();
        match val {
            PropertyValue::CharacterString(s) => assert_eq!(s, ""),
            other => panic!("expected CharacterString, got {other:?}"),
        }
        assert_eq!(pri, Some(8));
    }
}