matc 0.1.3

//! Matter TLV encoders and decoders for Messages Cluster
//! Cluster ID: 0x0097
//!
//! This file is automatically generated from Messages.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 FutureMessagePreference {
    /// Similar messages are allowed
    Allowed = 0,
    /// Similar messages should be sent more often
    Increased = 1,
    /// Similar messages should be sent less often
    Reduced = 2,
    /// Similar messages should not be sent
    Disallowed = 3,
    /// No further messages should be sent
    Banned = 4,
}

impl FutureMessagePreference {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(FutureMessagePreference::Allowed),
            1 => Some(FutureMessagePreference::Increased),
            2 => Some(FutureMessagePreference::Reduced),
            3 => Some(FutureMessagePreference::Disallowed),
            4 => Some(FutureMessagePreference::Banned),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum MessagePriority {
    /// Message to be transferred with a low level of importance
    Low = 0,
    /// Message to be transferred with a medium level of importance
    Medium = 1,
    /// Message to be transferred with a high level of importance
    High = 2,
    /// Message to be transferred with a critical level of importance
    Critical = 3,
}

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

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

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

// Bitmap definitions

/// MessageControl bitmap type
pub type MessageControl = u8;

/// Constants for MessageControl
pub mod messagecontrol {
    /// Message requires confirmation from user
    pub const CONFIRMATION_REQUIRED: u8 = 0x01;
    /// Message requires response from user
    pub const RESPONSE_REQUIRED: u8 = 0x02;
    /// Message supports reply message from user
    pub const REPLY_MESSAGE: u8 = 0x04;
    /// Message has already been confirmed
    pub const MESSAGE_CONFIRMED: u8 = 0x08;
    /// Message required PIN/password protection
    pub const MESSAGE_PROTECTED: u8 = 0x10;
}

// Struct definitions

#[derive(Debug, serde::Serialize)]
pub struct MessageResponseOption {
    pub message_response_id: Option<u32>,
    pub label: Option<String>,
}

#[derive(Debug, serde::Serialize)]
pub struct Message {
    pub message_id: Option<u8>,
    pub priority: Option<MessagePriority>,
    pub message_control: Option<MessageControl>,
    pub start_time: Option<u64>,
    pub duration: Option<u64>,
    pub message_text: Option<String>,
    pub responses: Option<Vec<MessageResponseOption>>,
}

// Command encoders

/// Encode PresentMessagesRequest command (0x00)
pub fn encode_present_messages_request(message_id: u8, priority: MessagePriority, message_control: MessageControl, start_time: Option<u64>, duration: Option<u64>, message_text: String, responses: Vec<MessageResponseOption>) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(message_id)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(priority.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt8(message_control)).into(),
        (3, tlv::TlvItemValueEnc::UInt64(start_time.unwrap_or(0))).into(),
        (4, tlv::TlvItemValueEnc::UInt64(duration.unwrap_or(0))).into(),
        (5, tlv::TlvItemValueEnc::String(message_text)).into(),
        (6, tlv::TlvItemValueEnc::Array(responses.into_iter().map(|v| {
                    let mut fields = Vec::new();
                    if let Some(x) = v.message_response_id { fields.push((0, tlv::TlvItemValueEnc::UInt32(x)).into()); }
                    if let Some(x) = v.label { fields.push((1, tlv::TlvItemValueEnc::String(x.clone())).into()); }
                    (0, tlv::TlvItemValueEnc::StructAnon(fields)).into()
                }).collect())).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode CancelMessagesRequest command (0x01)
pub fn encode_cancel_messages_request(message_i_ds: Vec<u8>) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::StructAnon(message_i_ds.into_iter().map(|v| (0, tlv::TlvItemValueEnc::UInt8(v)).into()).collect())).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

// Attribute decoders

/// Decode Messages attribute (0x0000)
pub fn decode_messages(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<Message>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(Message {
                message_id: item.get_int(&[0]).map(|v| v as u8),
                priority: item.get_int(&[1]).and_then(|v| MessagePriority::from_u8(v as u8)),
                message_control: item.get_int(&[2]).map(|v| v as u8),
                start_time: item.get_int(&[3]),
                duration: item.get_int(&[4]),
                message_text: item.get_string_owned(&[5]),
                responses: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[6]) {
                        let mut items = Vec::new();
                        for list_item in l {
                            items.push(MessageResponseOption {
                message_response_id: list_item.get_int(&[0]).map(|v| v as u32),
                label: list_item.get_string_owned(&[1]),
                            });
                        }
                        Some(items)
                    } else {
                        None
                    }
                },
            });
        }
    }
    Ok(res)
}

/// Decode ActiveMessageIDs attribute (0x0001)
pub fn decode_active_message_i_ds(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<u8>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            if let tlv::TlvItemValue::Int(i) = &item.value {
                res.push(*i as u8);
            }
        }
    }
    Ok(res)
}


// 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 != 0x0097 {
        return format!("{{\"error\": \"Invalid cluster ID. Expected 0x0097, got {}\"}}", cluster_id);
    }

    match attribute_id {
        0x0000 => {
            match decode_messages(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_active_message_i_ds(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, "Messages"),
        (0x0001, "ActiveMessageIDs"),
    ]
}

// Command listing

pub fn get_command_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x00, "PresentMessagesRequest"),
        (0x01, "CancelMessagesRequest"),
    ]
}

pub fn get_command_name(cmd_id: u32) -> Option<&'static str> {
    match cmd_id {
        0x00 => Some("PresentMessagesRequest"),
        0x01 => Some("CancelMessagesRequest"),
        _ => None,
    }
}

pub fn get_command_schema(cmd_id: u32) -> Option<Vec<crate::clusters::codec::CommandField>> {
    match cmd_id {
        0x00 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "message_id", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "priority", kind: crate::clusters::codec::FieldKind::Enum { name: "MessagePriority", variants: &[(0, "Low"), (1, "Medium"), (2, "High"), (3, "Critical")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "message_control", kind: crate::clusters::codec::FieldKind::Bitmap { name: "MessageControl", bits: &[(1, "CONFIRMATION_REQUIRED"), (2, "RESPONSE_REQUIRED"), (4, "REPLY_MESSAGE"), (8, "MESSAGE_CONFIRMED"), (16, "MESSAGE_PROTECTED")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "start_time", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 4, name: "duration", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 5, name: "message_text", kind: crate::clusters::codec::FieldKind::String, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "responses", kind: crate::clusters::codec::FieldKind::List { entry_type: "MessageResponseOptionStruct" }, optional: false, nullable: false },
        ]),
        0x01 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "message_i_ds", kind: crate::clusters::codec::FieldKind::List { entry_type: "message-id" }, optional: false, nullable: false },
        ]),
        _ => None,
    }
}

pub fn encode_command_json(cmd_id: u32, _args: &serde_json::Value) -> anyhow::Result<Vec<u8>> {
    match cmd_id {
        0x00 => Err(anyhow::anyhow!("command \"PresentMessagesRequest\" has complex args: use raw mode")),
        0x01 => Err(anyhow::anyhow!("command \"CancelMessagesRequest\" has complex args: use raw mode")),
        _ => Err(anyhow::anyhow!("unknown command ID: 0x{:02X}", cmd_id)),
    }
}

// Typed facade (invokes + reads)

/// Invoke `PresentMessagesRequest` command on cluster `Messages`.
pub async fn present_messages_request(conn: &crate::controller::Connection, endpoint: u16, message_id: u8, priority: MessagePriority, message_control: MessageControl, start_time: Option<u64>, duration: Option<u64>, message_text: String, responses: Vec<MessageResponseOption>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_MESSAGES, crate::clusters::defs::CLUSTER_MESSAGES_CMD_ID_PRESENTMESSAGESREQUEST, &encode_present_messages_request(message_id, priority, message_control, start_time, duration, message_text, responses)?).await?;
    Ok(())
}

/// Invoke `CancelMessagesRequest` command on cluster `Messages`.
pub async fn cancel_messages_request(conn: &crate::controller::Connection, endpoint: u16, message_i_ds: Vec<u8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_MESSAGES, crate::clusters::defs::CLUSTER_MESSAGES_CMD_ID_CANCELMESSAGESREQUEST, &encode_cancel_messages_request(message_i_ds)?).await?;
    Ok(())
}

/// Read `Messages` attribute from cluster `Messages`.
pub async fn read_messages(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<Message>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_MESSAGES, crate::clusters::defs::CLUSTER_MESSAGES_ATTR_ID_MESSAGES).await?;
    decode_messages(&tlv)
}

/// Read `ActiveMessageIDs` attribute from cluster `Messages`.
pub async fn read_active_message_i_ds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_MESSAGES, crate::clusters::defs::CLUSTER_MESSAGES_ATTR_ID_ACTIVEMESSAGEIDS).await?;
    decode_active_message_i_ds(&tlv)
}

#[derive(Debug, serde::Serialize)]
pub struct MessageQueuedEvent {
    pub message_id: Option<u8>,
}

#[derive(Debug, serde::Serialize)]
pub struct MessagePresentedEvent {
    pub message_id: Option<u8>,
}

#[derive(Debug, serde::Serialize)]
pub struct MessageCompleteEvent {
    pub message_id: Option<u8>,
    pub response_id: Option<u32>,
    pub reply: Option<String>,
    pub future_messages_preference: Option<FutureMessagePreference>,
}

// Event decoders

/// Decode MessageQueued event (0x00, priority: info)
pub fn decode_message_queued_event(inp: &tlv::TlvItemValue) -> anyhow::Result<MessageQueuedEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(MessageQueuedEvent {
                                message_id: item.get_int(&[0]).map(|v| v as u8),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode MessagePresented event (0x01, priority: info)
pub fn decode_message_presented_event(inp: &tlv::TlvItemValue) -> anyhow::Result<MessagePresentedEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(MessagePresentedEvent {
                                message_id: item.get_int(&[0]).map(|v| v as u8),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode MessageComplete event (0x02, priority: info)
pub fn decode_message_complete_event(inp: &tlv::TlvItemValue) -> anyhow::Result<MessageCompleteEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(MessageCompleteEvent {
                                message_id: item.get_int(&[0]).map(|v| v as u8),
                                response_id: item.get_int(&[1]).map(|v| v as u32),
                                reply: item.get_string_owned(&[2]),
                                future_messages_preference: item.get_int(&[3]).and_then(|v| FutureMessagePreference::from_u8(v as u8)),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}