use crate::{
    channel::{self, Channel},
    clock::DateTime,
    event::Sequence,
    login::Login,
    message::{self, Message},
};

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct ChannelEvent {
    #[serde(skip)]
    pub sequence: Sequence,
    pub at: DateTime,
    #[serde(flatten)]
    pub data: ChannelEventData,
}

impl ChannelEvent {
    pub fn created(channel: Channel) -> Self {
        Self {
            at: channel.created_at,
            sequence: channel.created_sequence,
            data: CreatedEvent { channel }.into(),
        }
    }

    pub fn channel_id(&self) -> &channel::Id {
        match &self.data {
            ChannelEventData::Created(event) => &event.channel.id,
            ChannelEventData::Message(event) => &event.channel.id,
            ChannelEventData::MessageDeleted(event) => &event.channel.id,
            ChannelEventData::Deleted(event) => &event.channel,
        }
    }
}

impl<'c> From<&'c ChannelEvent> for Sequence {
    fn from(event: &'c ChannelEvent) -> Self {
        event.sequence
    }
}

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ChannelEventData {
    Created(CreatedEvent),
    Message(MessageEvent),
    MessageDeleted(MessageDeletedEvent),
    Deleted(DeletedEvent),
}

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct CreatedEvent {
    pub channel: Channel,
}

impl From<CreatedEvent> for ChannelEventData {
    fn from(event: CreatedEvent) -> Self {
        Self::Created(event)
    }
}

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct MessageEvent {
    pub channel: Channel,
    pub sender: Login,
    pub message: Message,
}

impl From<MessageEvent> for ChannelEventData {
    fn from(event: MessageEvent) -> Self {
        Self::Message(event)
    }
}

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct MessageDeletedEvent {
    pub channel: Channel,
    pub message: message::Id,
}

impl From<MessageDeletedEvent> for ChannelEventData {
    fn from(event: MessageDeletedEvent) -> Self {
        Self::MessageDeleted(event)
    }
}

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct DeletedEvent {
    pub channel: channel::Id,
}

impl From<DeletedEvent> for ChannelEventData {
    fn from(event: DeletedEvent) -> Self {
        Self::Deleted(event)
    }
}