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

#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct ChannelEvent {
    #[serde(flatten)]
    pub instant: Instant,
    #[serde(flatten)]
    pub data: ChannelEventData,
}

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

impl<'c> From<&'c ChannelEvent> for Sequence {
    fn from(event: &'c ChannelEvent) -> Self {
        event.instant.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)
    }
}