use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use models::{RoomId, RoomThreadId, Seq, UserId};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ThreadEventType {
    Created,
    Updated,
    Resolved,
    Archived,
    ParticipantJoined,
    ParticipantLeft,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ThreadEvent {
    Created(ThreadCreatedService),
    Updated(ThreadUpdatedService),
    Resolved(ThreadResolvedService),
    Archived(ThreadArchivedService),
    ParticipantJoined(ThreadParticipantJoinedService),
    ParticipantLeft(ThreadParticipantLeftService),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadCreatedService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub parent: Seq,
    pub created_by: UserId,
    pub participants: serde_json::Value,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadUpdatedService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub last_message_at: DateTime<Utc>,
    pub last_message_preview: Option<String>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadResolvedService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub resolved_by: UserId,
    pub resolved_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadArchivedService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub archived_by: UserId,
    pub archived_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadParticipantJoinedService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub user: UserId,
    pub joined_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadParticipantLeftService {
    pub id: RoomThreadId,
    pub room: RoomId,
    pub user: UserId,
    pub left_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ThreadCreateClient {
    pub room: RoomId,
    pub parent_seq: Seq,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ThreadResolveClient {
    pub thread_id: RoomThreadId,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ThreadArchiveClient {
    pub thread_id: RoomThreadId,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ThreadLoadClient {
    pub thread_id: RoomThreadId,
}