#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Copy, Clone)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[repr(u64)]
pub enum MessageKind {
    {{#each this}}
    {{ name }} = {{ id }},
    {{/each}}
}

#[derive(Debug, Clone)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Message {
    {{#each this}}
    {{ name }}({{ name }}),
    {{/each}}
}

impl Message {
    pub fn decode(message_kind: MessageKind, buffer: &mut &[u8]) -> Result<Self, prost::DecodeError> {
        match message_kind {
        {{#each this}}
            MessageKind::{{ name }} => Ok(Self::{{ name }}({{name}}::decode(buffer)?)),
        {{/each}}
        }
    }

    pub fn encoded_len(&self) -> usize {
        match self {
        {{#each this}}
            Self::{{ name }}(message) => message.encoded_len(),
        {{/each}}
        }
    }

    pub fn encode(&self, buf: &mut impl prost::bytes::BufMut) -> Result<(), prost::EncodeError> {
        match self {
        {{#each this}}
            Self::{{ name }}(message) => message.encode(buf),
        {{/each}}
        }
    }
}

impl From<&Message> for MessageKind {
    fn from(value: &Message) -> Self {
        match value {
        {{#each this}}
            Message::{{ name }}(message) => Self::from(message),
        {{/each}}
        }
    }
}

{{#each this}}
impl From<&{{ name }}> for MessageKind {
    fn from(_value: &{{name}}) -> Self {
        Self::{{name}}
    }
}

impl From<{{ name }}> for Message {
    fn from(value: {{ name }}) -> Self {
        Message::{{ name }}(value)
    }
}
{{/each}}