hoicko_lib 0.1.16

use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::fmt;

#[derive(Serialize, Deserialize, Debug, PartialEq, Default, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum ActivityAction {
    #[default]
    Insert,
    Delete,
    Update,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Default, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum ActivityType {
    #[default]
    Domain,
    Row,
    User,
    Workspace,
    Board,
    BoardView,
    Member,
    Team,
    ColumnPermission
}

impl fmt::Display for ActivityAction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ActivityAction::Insert => write!(f, "INSERT"),
            ActivityAction::Update => write!(f, "UPDATE"),
            ActivityAction::Delete => write!(f, "DELETE"),
        }
    }
}

impl fmt::Display for ActivityType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ActivityType::Domain => write!(f, "DOMAIN"),
            ActivityType::ColumnPermission => write!(f, "COLUMN_PERMISSION"),
            ActivityType::Row => write!(f, "ROW"),
            ActivityType::User => write!(f, "USER"),
            ActivityType::Workspace => write!(f, "WORKSPACE"),
            ActivityType::Board => write!(f, "BOARD"),
            ActivityType::BoardView => write!(f, "BOARDVIEW"),
            ActivityType::Member => write!(f, "MEMBER"),
            ActivityType::Team => write!(f, "TEAM"),
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
pub struct ActivityPayload {
    pub action: ActivityAction,
    #[serde(rename = "type")]
    pub activity_type: ActivityType,
    pub document_id: String,
    pub domain_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub board_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub old_value: Option<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_value: Option<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub column_type: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub column_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_address: Option<String>,
    pub user: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NotificationPayload {
    pub body: String,
    pub notifications_type: String,
    pub title: String,
    pub from_user: String,
    pub to_user: String,
    pub domain_id: String,
    pub extra: Option<Value>,
    pub source: Option<String>,
}
impl ActivityPayload {
    /// Creates a new ActivityPayload with required fields
    pub fn new(
        action: ActivityAction,
        activity_type: ActivityType,
        document_id: String,
        domain_id: String,
        user: String,
    ) -> Self {
        Self {
            action: action,
            activity_type: activity_type,
            document_id,
            domain_id,
            user,
            ..Default::default()
        }
    }

    /// Builder method to add board_id
    pub fn with_board_id(mut self, board_id: String) -> Self {
        self.board_id = Some(board_id);
        self
    }

    /// Builder method to add values
    pub fn with_values(mut self, old_value: Option<Value>, new_value: Option<Value>) -> Self {
        self.old_value = old_value;
        self.new_value = new_value;
        self
    }

    /// Builder method to add column information
    pub fn with_column(mut self, column_id: String, column_type: i32) -> Self {
        self.column_id = Some(column_id);
        self.column_type = Some(column_type);
        self
    }
}

impl NotificationPayload {
    pub fn new(
        title: String,
        body: String,
        notifications_type: String,
        from_user: String,
        to_user: String,
        domain_id: String,
    ) -> Self {
        Self {
            title,
            body,
            notifications_type,
            from_user,
            to_user,
            domain_id,
            extra: None,
            source: None,
        }
    }

    pub fn with_extra(mut self, extra: Value) -> Self {
        self.extra = Some(extra);
        self
    }
    pub fn with_source(mut self, source: String) -> Self {
        self.source = Some(source);
        self
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_activity_payload_creation() {
        let payload = ActivityPayload::new(
            ActivityAction::Insert,
            ActivityType::Board,
            "doc123".to_string(),
            "domain123".to_string(),
            "user123".to_string(),
        )
        .with_board_id("board123".to_string())
        .with_values(
            Some(json!({"old": "value"})),
            Some(json!({"new": "value"})),
        );

        assert_eq!(payload.action, ActivityAction::Insert);
        assert_eq!(payload.activity_type, ActivityType::Board);
        assert_eq!(payload.board_id, Some("board123".to_string()));
    }

    #[test]
    fn test_notification_payload_creation() {
        let payload = NotificationPayload::new(
            "Test Title".to_string(),
            "Test Body".to_string(),
            "TEST_TYPE".to_string(),
            "from123".to_string(),
            "to123".to_string(),
            "domain123".to_string(),
        )
        .with_extra(json!({"key": "value"}))
        .with_source("test_source".to_string());

        assert_eq!(payload.title, "Test Title");
        assert_eq!(payload.notifications_type, "TEST_TYPE");
        assert!(payload.extra.is_some());
        assert_eq!(payload.source, Some("test_source".to_string()));
    }
}