matc 0.1.3

//! Matter TLV encoders and decoders for Concentration Measurement Clusters
//! Cluster ID: 0x0000
//!
//! This file is automatically generated from ConcentrationMeasurement.xml

#![allow(clippy::too_many_arguments)]

use crate::tlv;
use anyhow;
use serde_json;


// Enum definitions

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LevelValue {
    /// The level is Unknown
    Unknown = 0,
    /// The level is considered Low
    Low = 1,
    /// The level is considered Medium
    Medium = 2,
    /// The level is considered High
    High = 3,
    /// The level is considered Critical
    Critical = 4,
}

impl LevelValue {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LevelValue::Unknown),
            1 => Some(LevelValue::Low),
            2 => Some(LevelValue::Medium),
            3 => Some(LevelValue::High),
            4 => Some(LevelValue::Critical),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LevelValue> for u8 {
    fn from(val: LevelValue) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum MeasurementMedium {
    /// The measurement is being made in Air
    Air = 0,
    /// The measurement is being made in Water
    Water = 1,
    /// The measurement is being made in Soil
    Soil = 2,
}

impl MeasurementMedium {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(MeasurementMedium::Air),
            1 => Some(MeasurementMedium::Water),
            2 => Some(MeasurementMedium::Soil),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<MeasurementMedium> for u8 {
    fn from(val: MeasurementMedium) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum MeasurementUnit {
    /// Parts per Million (10)
    Ppm = 0,
    /// Parts per Billion (10)
    Ppb = 1,
    /// Parts per Trillion (10)
    Ppt = 2,
    /// Milligram per m
    Mgm3 = 3,
    /// Microgram per m
    Ugm3 = 4,
    /// Nanogram per m
    Ngm3 = 5,
    /// Particles per m
    Pm3 = 6,
    /// Becquerel per m
    Bqm3 = 7,
}

impl MeasurementUnit {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(MeasurementUnit::Ppm),
            1 => Some(MeasurementUnit::Ppb),
            2 => Some(MeasurementUnit::Ppt),
            3 => Some(MeasurementUnit::Mgm3),
            4 => Some(MeasurementUnit::Ugm3),
            5 => Some(MeasurementUnit::Ngm3),
            6 => Some(MeasurementUnit::Pm3),
            7 => Some(MeasurementUnit::Bqm3),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<MeasurementUnit> for u8 {
    fn from(val: MeasurementUnit) -> Self {
        val as u8
    }
}

// Attribute decoders

/// Decode MeasuredValue attribute (0x0000)
pub fn decode_measured_value(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u8>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode MinMeasuredValue attribute (0x0001)
pub fn decode_min_measured_value(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u8>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode MaxMeasuredValue attribute (0x0002)
pub fn decode_max_measured_value(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u8>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode PeakMeasuredValue attribute (0x0003)
pub fn decode_peak_measured_value(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u8>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode PeakMeasuredValueWindow attribute (0x0004)
pub fn decode_peak_measured_value_window(inp: &tlv::TlvItemValue) -> anyhow::Result<u32> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u32)
    } else {
        Err(anyhow::anyhow!("Expected UInt32"))
    }
}

/// Decode AverageMeasuredValue attribute (0x0005)
pub fn decode_average_measured_value(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u8>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode AverageMeasuredValueWindow attribute (0x0006)
pub fn decode_average_measured_value_window(inp: &tlv::TlvItemValue) -> anyhow::Result<u32> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u32)
    } else {
        Err(anyhow::anyhow!("Expected UInt32"))
    }
}

/// Decode Uncertainty attribute (0x0007)
pub fn decode_uncertainty(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode MeasurementUnit attribute (0x0008)
pub fn decode_measurement_unit(inp: &tlv::TlvItemValue) -> anyhow::Result<MeasurementUnit> {
    if let tlv::TlvItemValue::Int(v) = inp {
        MeasurementUnit::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode MeasurementMedium attribute (0x0009)
pub fn decode_measurement_medium(inp: &tlv::TlvItemValue) -> anyhow::Result<MeasurementMedium> {
    if let tlv::TlvItemValue::Int(v) = inp {
        MeasurementMedium::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode LevelValue attribute (0x000A)
pub fn decode_level_value(inp: &tlv::TlvItemValue) -> anyhow::Result<LevelValue> {
    if let tlv::TlvItemValue::Int(v) = inp {
        LevelValue::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}


// JSON dispatcher function

/// Decode attribute value and return as JSON string
///
/// # Parameters
/// * `cluster_id` - The cluster identifier
/// * `attribute_id` - The attribute identifier
/// * `tlv_value` - The TLV value to decode
///
/// # Returns
/// JSON string representation of the decoded value or error
pub fn decode_attribute_json(cluster_id: u32, attribute_id: u32, tlv_value: &crate::tlv::TlvItemValue) -> String {
    // Verify this is the correct cluster
    if cluster_id != 0x0000 {
        return format!("{{\"error\": \"Invalid cluster ID. Expected 0x0000, got {}\"}}", cluster_id);
    }

    match attribute_id {
        0x0000 => {
            match decode_measured_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_min_measured_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0002 => {
            match decode_max_measured_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0003 => {
            match decode_peak_measured_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0004 => {
            match decode_peak_measured_value_window(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0005 => {
            match decode_average_measured_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0006 => {
            match decode_average_measured_value_window(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0007 => {
            match decode_uncertainty(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0008 => {
            match decode_measurement_unit(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0009 => {
            match decode_measurement_medium(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000A => {
            match decode_level_value(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        _ => format!("{{\"error\": \"Unknown attribute ID: {}\"}}", attribute_id),
    }
}

/// Get list of all attributes supported by this cluster
///
/// # Returns
/// Vector of tuples containing (attribute_id, attribute_name)
pub fn get_attribute_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x0000, "MeasuredValue"),
        (0x0001, "MinMeasuredValue"),
        (0x0002, "MaxMeasuredValue"),
        (0x0003, "PeakMeasuredValue"),
        (0x0004, "PeakMeasuredValueWindow"),
        (0x0005, "AverageMeasuredValue"),
        (0x0006, "AverageMeasuredValueWindow"),
        (0x0007, "Uncertainty"),
        (0x0008, "MeasurementUnit"),
        (0x0009, "MeasurementMedium"),
        (0x000A, "LevelValue"),
    ]
}

// Typed facade (invokes + reads)

/// Read `MeasuredValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_measured_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_MEASUREDVALUE).await?;
    decode_measured_value(&tlv)
}

/// Read `MinMeasuredValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_min_measured_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_MINMEASUREDVALUE).await?;
    decode_min_measured_value(&tlv)
}

/// Read `MaxMeasuredValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_max_measured_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_MAXMEASUREDVALUE).await?;
    decode_max_measured_value(&tlv)
}

/// Read `PeakMeasuredValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_peak_measured_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_PEAKMEASUREDVALUE).await?;
    decode_peak_measured_value(&tlv)
}

/// Read `PeakMeasuredValueWindow` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_peak_measured_value_window(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_PEAKMEASUREDVALUEWINDOW).await?;
    decode_peak_measured_value_window(&tlv)
}

/// Read `AverageMeasuredValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_average_measured_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_AVERAGEMEASUREDVALUE).await?;
    decode_average_measured_value(&tlv)
}

/// Read `AverageMeasuredValueWindow` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_average_measured_value_window(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_AVERAGEMEASUREDVALUEWINDOW).await?;
    decode_average_measured_value_window(&tlv)
}

/// Read `Uncertainty` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_uncertainty(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_UNCERTAINTY).await?;
    decode_uncertainty(&tlv)
}

/// Read `MeasurementUnit` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_measurement_unit(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<MeasurementUnit> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_MEASUREMENTUNIT).await?;
    decode_measurement_unit(&tlv)
}

/// Read `MeasurementMedium` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_measurement_medium(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<MeasurementMedium> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_MEASUREMENTMEDIUM).await?;
    decode_measurement_medium(&tlv)
}

/// Read `LevelValue` attribute from cluster `Radon Concentration Measurement`.
pub async fn read_level_value(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<LevelValue> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_RADON_CONCENTRATION_MEASUREMENT, crate::clusters::defs::CLUSTER_RADON_CONCENTRATION_MEASUREMENT_ATTR_ID_LEVELVALUE).await?;
    decode_level_value(&tlv)
}