nylas-types 0.1.1

//! Draft types for the Nylas API v3.

use serde::{Deserialize, Serialize};

use crate::{Attachment, DraftId, EmailAddress, FolderId, GrantId, ThreadId};

/// A draft message object from the Nylas API.
///
/// Drafts are email messages that are being composed but not yet sent.
///
/// # Example
///
/// ```
/// # use nylas_types::{Draft, DraftId, GrantId, EmailAddress};
/// let draft = Draft {
///     id: DraftId::new("draft_123"),
///     grant_id: GrantId::new("grant_123"),
///     thread_id: None,
///     subject: Some("Draft Subject".to_string()),
///     from: vec![],
///     to: vec![],
///     cc: vec![],
///     bcc: vec![],
///     reply_to: vec![],
///     body: Some("Draft body".to_string()),
///     starred: Some(false),
///     snippet: Some("Draft snippet...".to_string()),
///     attachments: vec![],
///     folders: vec![],
///     created_at: Some(1234567890),
/// };
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Draft {
    /// Unique identifier for the draft.
    pub id: DraftId,

    /// Grant ID associated with this draft.
    pub grant_id: GrantId,

    /// Thread ID this draft belongs to (for replies).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<ThreadId>,

    /// Subject line of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,

    /// Sender email address(es).
    #[serde(default)]
    pub from: Vec<EmailAddress>,

    /// Recipient email address(es).
    #[serde(default)]
    pub to: Vec<EmailAddress>,

    /// CC recipient email address(es).
    #[serde(default)]
    pub cc: Vec<EmailAddress>,

    /// BCC recipient email address(es).
    #[serde(default)]
    pub bcc: Vec<EmailAddress>,

    /// Reply-to email address(es).
    #[serde(default)]
    pub reply_to: Vec<EmailAddress>,

    /// Body of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,

    /// Whether the draft is starred.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub starred: Option<bool>,

    /// Short snippet of the draft body.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub snippet: Option<String>,

    /// Attachments included with the draft.
    #[serde(default)]
    pub attachments: Vec<Attachment>,

    /// Folder IDs this draft belongs to.
    #[serde(default)]
    pub folders: Vec<FolderId>,

    /// Unix timestamp when the draft was created.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_at: Option<i64>,
}

/// Request to create a new draft.
///
/// # Example
///
/// ```
/// # use nylas_types::{CreateDraftRequest, EmailAddress};
/// let to = vec![EmailAddress::new("recipient@example.com").unwrap()];
/// let draft = CreateDraftRequest::builder()
///     .to(to)
///     .subject("Hello")
///     .body("Draft message")
///     .build();
/// ```
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateDraftRequest {
    /// Subject line of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,

    /// Sender email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<Vec<EmailAddress>>,

    /// Recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<Vec<EmailAddress>>,

    /// CC recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cc: Option<Vec<EmailAddress>>,

    /// BCC recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub bcc: Option<Vec<EmailAddress>>,

    /// Reply-to email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reply_to: Option<Vec<EmailAddress>>,

    /// Body of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,

    /// Thread ID for reply drafts.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,

    /// Whether the draft is starred.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub starred: Option<bool>,
}

impl CreateDraftRequest {
    /// Create a new builder for draft creation.
    pub fn builder() -> CreateDraftRequestBuilder {
        CreateDraftRequestBuilder::default()
    }
}

/// Builder for create draft request.
#[derive(Debug, Clone, Default)]
pub struct CreateDraftRequestBuilder {
    request: CreateDraftRequest,
}

impl CreateDraftRequestBuilder {
    /// Set the subject line.
    pub fn subject(mut self, subject: impl Into<String>) -> Self {
        self.request.subject = Some(subject.into());
        self
    }

    /// Set sender email address(es).
    pub fn from(mut self, from: Vec<EmailAddress>) -> Self {
        self.request.from = Some(from);
        self
    }

    /// Set recipient email address(es).
    pub fn to(mut self, to: Vec<EmailAddress>) -> Self {
        self.request.to = Some(to);
        self
    }

    /// Set CC recipient email address(es).
    pub fn cc(mut self, cc: Vec<EmailAddress>) -> Self {
        self.request.cc = Some(cc);
        self
    }

    /// Set BCC recipient email address(es).
    pub fn bcc(mut self, bcc: Vec<EmailAddress>) -> Self {
        self.request.bcc = Some(bcc);
        self
    }

    /// Set reply-to email address(es).
    pub fn reply_to(mut self, reply_to: Vec<EmailAddress>) -> Self {
        self.request.reply_to = Some(reply_to);
        self
    }

    /// Set the body content.
    pub fn body(mut self, body: impl Into<String>) -> Self {
        self.request.body = Some(body.into());
        self
    }

    /// Set thread ID for reply drafts.
    pub fn thread_id(mut self, thread_id: impl Into<String>) -> Self {
        self.request.thread_id = Some(thread_id.into());
        self
    }

    /// Set starred status.
    pub fn starred(mut self, starred: bool) -> Self {
        self.request.starred = Some(starred);
        self
    }

    /// Build the create draft request.
    pub fn build(self) -> CreateDraftRequest {
        self.request
    }
}

/// Request to update an existing draft.
///
/// # Example
///
/// ```
/// # use nylas_types::UpdateDraftRequest;
/// let update = UpdateDraftRequest::builder()
///     .subject("Updated subject")
///     .body("Updated body")
///     .build();
/// ```
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct UpdateDraftRequest {
    /// Subject line of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,

    /// Sender email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<Vec<EmailAddress>>,

    /// Recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<Vec<EmailAddress>>,

    /// CC recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cc: Option<Vec<EmailAddress>>,

    /// BCC recipient email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub bcc: Option<Vec<EmailAddress>>,

    /// Reply-to email address(es).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reply_to: Option<Vec<EmailAddress>>,

    /// Body of the draft.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,

    /// Whether the draft is starred.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub starred: Option<bool>,
}

impl UpdateDraftRequest {
    /// Create a new builder for draft update.
    pub fn builder() -> UpdateDraftRequestBuilder {
        UpdateDraftRequestBuilder::default()
    }
}

/// Builder for update draft request.
#[derive(Debug, Clone, Default)]
pub struct UpdateDraftRequestBuilder {
    request: UpdateDraftRequest,
}

impl UpdateDraftRequestBuilder {
    /// Update the subject line.
    pub fn subject(mut self, subject: impl Into<String>) -> Self {
        self.request.subject = Some(subject.into());
        self
    }

    /// Update sender email address(es).
    pub fn from(mut self, from: Vec<EmailAddress>) -> Self {
        self.request.from = Some(from);
        self
    }

    /// Update recipient email address(es).
    pub fn to(mut self, to: Vec<EmailAddress>) -> Self {
        self.request.to = Some(to);
        self
    }

    /// Update CC recipient email address(es).
    pub fn cc(mut self, cc: Vec<EmailAddress>) -> Self {
        self.request.cc = Some(cc);
        self
    }

    /// Update BCC recipient email address(es).
    pub fn bcc(mut self, bcc: Vec<EmailAddress>) -> Self {
        self.request.bcc = Some(bcc);
        self
    }

    /// Update reply-to email address(es).
    pub fn reply_to(mut self, reply_to: Vec<EmailAddress>) -> Self {
        self.request.reply_to = Some(reply_to);
        self
    }

    /// Update the body content.
    pub fn body(mut self, body: impl Into<String>) -> Self {
        self.request.body = Some(body.into());
        self
    }

    /// Update starred status.
    pub fn starred(mut self, starred: bool) -> Self {
        self.request.starred = Some(starred);
        self
    }

    /// Build the update draft request.
    pub fn build(self) -> UpdateDraftRequest {
        self.request
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_draft_creation() {
        let draft = Draft {
            id: DraftId::new("draft_123"),
            grant_id: GrantId::new("grant_123"),
            thread_id: Some(ThreadId::new("thread_123")),
            subject: Some("Test Draft".to_string()),
            from: vec![],
            to: vec![],
            cc: vec![],
            bcc: vec![],
            reply_to: vec![],
            body: Some("Draft body".to_string()),
            starred: Some(false),
            snippet: Some("Draft snippet".to_string()),
            attachments: vec![],
            folders: vec![],
            created_at: Some(1234567890),
        };

        assert_eq!(draft.id.as_str(), "draft_123");
        assert_eq!(draft.grant_id.as_str(), "grant_123");
        assert_eq!(draft.subject, Some("Test Draft".to_string()));
    }

    #[test]
    fn test_draft_serialization() {
        let draft = Draft {
            id: DraftId::new("draft_123"),
            grant_id: GrantId::new("grant_123"),
            thread_id: None,
            subject: Some("Test".to_string()),
            from: vec![],
            to: vec![],
            cc: vec![],
            bcc: vec![],
            reply_to: vec![],
            body: Some("Body".to_string()),
            starred: Some(false),
            snippet: Some("Snippet".to_string()),
            attachments: vec![],
            folders: vec![],
            created_at: Some(1234567890),
        };

        let json = serde_json::to_string(&draft).unwrap();
        assert!(json.contains("draft_123"));
        assert!(json.contains("grant_123"));
        assert!(json.contains("Test"));

        let deserialized: Draft = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, draft);
    }

    #[test]
    fn test_create_draft_request_builder() {
        let to = vec![EmailAddress::new("recipient@example.com").unwrap()];
        let draft = CreateDraftRequest::builder()
            .subject("Test")
            .to(to.clone())
            .body("Test body")
            .build();

        assert_eq!(draft.subject, Some("Test".to_string()));
        assert_eq!(draft.to, Some(to));
        assert_eq!(draft.body, Some("Test body".to_string()));
    }

    #[test]
    fn test_create_draft_request_all_fields() {
        let from = vec![EmailAddress::new("sender@example.com").unwrap()];
        let to = vec![EmailAddress::new("recipient@example.com").unwrap()];
        let cc = vec![EmailAddress::new("cc@example.com").unwrap()];

        let draft = CreateDraftRequest::builder()
            .subject("Subject")
            .from(from.clone())
            .to(to.clone())
            .cc(cc.clone())
            .body("Body content")
            .thread_id("thread_123")
            .starred(true)
            .build();

        assert_eq!(draft.subject, Some("Subject".to_string()));
        assert_eq!(draft.from, Some(from));
        assert_eq!(draft.to, Some(to));
        assert_eq!(draft.cc, Some(cc));
        assert_eq!(draft.body, Some("Body content".to_string()));
        assert_eq!(draft.thread_id, Some("thread_123".to_string()));
        assert_eq!(draft.starred, Some(true));
    }

    #[test]
    fn test_create_draft_request_serialization() {
        let to = vec![EmailAddress::new("recipient@example.com").unwrap()];
        let draft = CreateDraftRequest::builder()
            .subject("Test")
            .to(to)
            .body("Body")
            .build();

        let json = serde_json::to_string(&draft).unwrap();
        let deserialized: CreateDraftRequest = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, draft);
    }

    #[test]
    fn test_update_draft_request_builder() {
        let update = UpdateDraftRequest::builder()
            .subject("Updated subject")
            .body("Updated body")
            .starred(true)
            .build();

        assert_eq!(update.subject, Some("Updated subject".to_string()));
        assert_eq!(update.body, Some("Updated body".to_string()));
        assert_eq!(update.starred, Some(true));
    }

    #[test]
    fn test_update_draft_request_with_recipients() {
        let to = vec![EmailAddress::new("new@example.com").unwrap()];
        let update = UpdateDraftRequest::builder()
            .to(to.clone())
            .subject("New subject")
            .build();

        assert_eq!(update.to, Some(to));
        assert_eq!(update.subject, Some("New subject".to_string()));
    }

    #[test]
    fn test_update_draft_request_serialization() {
        let update = UpdateDraftRequest::builder()
            .subject("Test")
            .body("Body")
            .build();

        let json = serde_json::to_string(&update).unwrap();
        let deserialized: UpdateDraftRequest = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, update);
    }
}