mzrs-sdk 0.1.20

//! Protocol constants and enum types for the Mezon SDK.
//!
//! These enums provide strongly-typed alternatives to the raw `i32` values
//! used by the protobuf types. Each implements `From<i32>` and `Into<i32>`.

use serde::{Deserialize, Serialize};

// ── ChannelType ─────────────────────────────────────────────────────

/// Channel types for join/leave operations.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ChannelType {
    /// Standard text channel.
    Text = 1,
    /// Group conversation.
    Group = 2,
    /// Direct message.
    Dm = 3,
    /// Google Meet voice channel.
    GmeetVoice = 4,
    /// Forum channel.
    Forum = 5,
    /// Streaming channel.
    Streaming = 6,
    /// Thread within a channel.
    Thread = 7,
    /// Application channel.
    App = 8,
    /// Announcement channel.
    Announcement = 9,
    /// Mezon native voice channel.
    Voice = 10,
}

impl From<ChannelType> for i32 {
    fn from(c: ChannelType) -> i32 {
        c as i32
    }
}

impl TryFrom<i32> for ChannelType {
    type Error = i32;

    fn try_from(v: i32) -> Result<Self, Self::Error> {
        match v {
            1 => Ok(Self::Text),
            2 => Ok(Self::Group),
            3 => Ok(Self::Dm),
            4 => Ok(Self::GmeetVoice),
            5 => Ok(Self::Forum),
            6 => Ok(Self::Streaming),
            7 => Ok(Self::Thread),
            8 => Ok(Self::App),
            9 => Ok(Self::Announcement),
            10 => Ok(Self::Voice),
            _ => Err(v),
        }
    }
}

// ── MessageCode ─────────────────────────────────────────────────────

/// Message type codes for the `code` field in message send/update.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[repr(i32)]
#[non_exhaustive]
pub enum MessageCode {
    /// Normal chat message.
    Chat = 0,
    /// Message update.
    Update = 1,
    /// Message removal.
    Remove = 2,
    /// Typing indicator.
    Typing = 3,
    /// Thread creation.
    CreateThread = 6,
    /// Pin message.
    CreatePin = 7,
    /// Buzz / attention request.
    MessageBuzz = 8,
    /// Topic message.
    Topic = 9,
    /// Token send event.
    SendToken = 11,
    /// Ephemeral (visible only to sender).
    Ephemeral = 12,
    /// Poll message.
    Poll = 18,
}

impl From<MessageCode> for i32 {
    fn from(c: MessageCode) -> i32 {
        c as i32
    }
}

impl TryFrom<i32> for MessageCode {
    type Error = i32;

    fn try_from(v: i32) -> Result<Self, Self::Error> {
        match v {
            0 => Ok(Self::Chat),
            1 => Ok(Self::Update),
            2 => Ok(Self::Remove),
            3 => Ok(Self::Typing),
            6 => Ok(Self::CreateThread),
            7 => Ok(Self::CreatePin),
            8 => Ok(Self::MessageBuzz),
            9 => Ok(Self::Topic),
            11 => Ok(Self::SendToken),
            12 => Ok(Self::Ephemeral),
            18 => Ok(Self::Poll),
            _ => Err(v),
        }
    }
}

// ── StreamMode ──────────────────────────────────────────────────────

/// Stream mode for message send/receive methods.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum StreamMode {
    /// Standard channel stream.
    Channel = 2,
    /// Group conversation stream.
    Group = 3,
    /// Direct message stream.
    Dm = 4,
    /// Clan-wide stream.
    Clan = 5,
    /// Thread stream.
    Thread = 6,
}

impl From<StreamMode> for i32 {
    fn from(m: StreamMode) -> i32 {
        m as i32
    }
}

impl TryFrom<i32> for StreamMode {
    type Error = i32;

    fn try_from(v: i32) -> Result<Self, Self::Error> {
        match v {
            2 => Ok(Self::Channel),
            3 => Ok(Self::Group),
            4 => Ok(Self::Dm),
            5 => Ok(Self::Clan),
            6 => Ok(Self::Thread),
            _ => Err(v),
        }
    }
}

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

    #[test]
    fn channel_type_roundtrip() {
        let ct = ChannelType::Dm;
        let raw: i32 = ct.into();
        assert_eq!(raw, 3);
        assert_eq!(ChannelType::try_from(3), Ok(ChannelType::Dm));
    }

    #[test]
    fn stream_mode_roundtrip() {
        let sm = StreamMode::Thread;
        let raw: i32 = sm.into();
        assert_eq!(raw, 6);
        assert_eq!(StreamMode::try_from(6), Ok(StreamMode::Thread));
    }

    #[test]
    fn message_code_roundtrip() {
        let mc = MessageCode::Ephemeral;
        let raw: i32 = mc.into();
        assert_eq!(raw, 12);
        assert_eq!(MessageCode::try_from(12), Ok(MessageCode::Ephemeral));
    }

    #[test]
    fn unknown_values_return_err() {
        assert!(ChannelType::try_from(999).is_err());
        assert!(StreamMode::try_from(0).is_err());
        assert!(MessageCode::try_from(99).is_err());
    }
}