nylas-types 0.1.1

//! Event types for the Nylas API v3.

use serde::{Deserialize, Serialize};

use crate::{CalendarId, EmailAddress, EventId, GrantId};

/// An event object from the Nylas API.
///
/// Events represent calendar events from various providers (Google, Microsoft, etc.).
///
/// # Example
///
/// ```
/// # use nylas_types::{Event, EventId, GrantId, CalendarId, When, EventStatus};
/// let event = Event {
///     id: EventId::new("event_123"),
///     grant_id: GrantId::new("grant_123"),
///     calendar_id: CalendarId::new("cal_123"),
///     title: Some("Team Meeting".to_string()),
///     description: Some("Weekly team sync".to_string()),
///     when: When::Timespan {
///         start_time: 1234567890,
///         end_time: 1234571490,
///         start_timezone: Some("America/New_York".to_string()),
///         end_timezone: Some("America/New_York".to_string()),
///     },
///     location: Some("Conference Room A".to_string()),
///     busy: true,
///     status: EventStatus::Confirmed,
///     participants: vec![],
///     organizer: None,
///     creator: None,
///     conferencing: None,
///     recurrence: None,
///     reminders: None,
///     capacity: None,
///     hide_participants: false,
///     read_only: false,
///     html_link: None,
///     ical_uid: None,
///     resources: vec![],
///     visibility: None,
///     object: "event".to_string(),
///     metadata: None,
///     created_at: Some(1234567890),
///     updated_at: Some(1234567890),
/// };
/// ```
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Event {
    /// Unique identifier for the event.
    pub id: EventId,

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

    /// Calendar ID this event belongs to.
    pub calendar_id: CalendarId,

    /// Title of the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    /// Description of the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// When the event occurs.
    pub when: When,

    /// Location of the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<String>,

    /// Whether the event shows as busy.
    #[serde(default = "default_busy")]
    pub busy: bool,

    /// Status of the event.
    #[serde(default)]
    pub status: EventStatus,

    /// List of participants.
    #[serde(default)]
    pub participants: Vec<Participant>,

    /// Organizer of the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub organizer: Option<EmailAddress>,

    /// Creator of the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<EmailAddress>,

    /// Conference details.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conferencing: Option<Conferencing>,

    /// Recurrence rules for repeating events.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recurrence: Option<Recurrence>,

    /// Reminder settings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reminders: Option<Reminders>,

    /// Maximum capacity for the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub capacity: Option<i32>,

    /// Whether to hide participants from each other.
    #[serde(default)]
    pub hide_participants: bool,

    /// Whether the event is read-only.
    #[serde(default)]
    pub read_only: bool,

    /// Link to view the event in the provider's interface.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub html_link: Option<String>,

    /// iCalendar UID for the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ical_uid: Option<String>,

    /// Resources (rooms, equipment) booked for the event.
    #[serde(default)]
    pub resources: Vec<Resource>,

    /// Visibility of the event (default, public, private).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub visibility: Option<EventVisibility>,

    /// Object type identifier (always "event").
    #[serde(default = "default_event_object_type")]
    pub object: String,

    /// Optional metadata for the event.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,

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

    /// Unix timestamp when the event was last updated.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<i64>,
}

fn default_busy() -> bool {
    true
}

fn default_event_object_type() -> String {
    "event".to_string()
}

/// When the event occurs.
///
/// This can be a specific timespan, an all-day event, or a datespan.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "object", rename_all = "lowercase")]
pub enum When {
    /// A specific time period with start and end times.
    Timespan {
        /// Unix timestamp for the start time.
        start_time: i64,

        /// Unix timestamp for the end time.
        end_time: i64,

        /// Timezone for the start time (IANA format).
        #[serde(skip_serializing_if = "Option::is_none")]
        start_timezone: Option<String>,

        /// Timezone for the end time (IANA format).
        #[serde(skip_serializing_if = "Option::is_none")]
        end_timezone: Option<String>,
    },

    /// An all-day event spanning multiple days.
    Datespan {
        /// Start date in YYYY-MM-DD format.
        start_date: String,

        /// End date in YYYY-MM-DD format.
        end_date: String,
    },

    /// A single all-day event.
    Date {
        /// Date in YYYY-MM-DD format.
        date: String,
    },
}

/// Event status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum EventStatus {
    /// Event is confirmed.
    #[default]
    Confirmed,

    /// Event is tentative.
    Tentative,

    /// Event is cancelled.
    Cancelled,
}

/// Event visibility.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum EventVisibility {
    /// Default visibility.
    Default,

    /// Public event.
    Public,

    /// Private event.
    Private,
}

/// A participant in an event.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Participant {
    /// Email address of the participant.
    pub email: String,

    /// Name of the participant.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// RSVP status of the participant.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<ParticipantStatus>,

    /// Comment from the participant.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,

    /// Phone number (Microsoft Graph only).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
}

impl Participant {
    /// Create a new participant with an email address.
    pub fn new(email: impl Into<String>) -> Self {
        Self {
            email: email.into(),
            name: None,
            status: None,
            comment: None,
            phone_number: None,
        }
    }

    /// Set the participant's name.
    pub fn name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    /// Set the participant's RSVP status.
    pub fn status(mut self, status: ParticipantStatus) -> Self {
        self.status = Some(status);
        self
    }
}

/// Participant RSVP status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ParticipantStatus {
    /// Accepted.
    Yes,

    /// Declined.
    No,

    /// Maybe attending.
    Maybe,

    /// No reply yet.
    Noreply,
}

/// Conference details for an event.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Conferencing {
    /// Conferencing provider (e.g., "Google Meet", "Microsoft Teams", "Zoom Meeting").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,

    /// Conference details.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub details: Option<ConferencingDetails>,
}

/// Details for a conference.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConferencingDetails {
    /// URL for the virtual meeting.
    pub url: String,

    /// Meeting code.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meeting_code: Option<String>,

    /// Password for the meeting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,

    /// PIN for the meeting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<String>,

    /// Dial-in phone numbers.
    #[serde(default)]
    pub phone: Vec<String>,
}

/// Recurrence rules for repeating events.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Recurrence {
    /// Recurrence rule in RRULE format (e.g., "FREQ=WEEKLY;BYDAY=MO,WE,FR").
    #[serde(rename = "rrule")]
    pub rrule: Vec<String>,

    /// Exception dates in EXDATE format (e.g., "20240101T120000Z").
    #[serde(default)]
    pub exdate: Vec<String>,
}

/// Reminder settings for an event.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Reminders {
    /// Whether to use default calendar reminders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub use_default: Option<bool>,

    /// Custom reminder overrides.
    #[serde(default)]
    pub overrides: Vec<ReminderOverride>,
}

/// A custom reminder override.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReminderOverride {
    /// Number of minutes before the event to trigger the reminder.
    pub reminder_minutes: i32,

    /// Reminder method (email, popup, display, sound).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reminder_method: Option<String>,
}

/// A resource (room, equipment) for an event.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Resource {
    /// Email address of the resource.
    pub email: String,

    /// Name of the resource.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// Resource type.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub object: Option<String>,
}

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

    #[test]
    fn test_event_creation() {
        let event = Event {
            id: EventId::new("event_123"),
            grant_id: GrantId::new("grant_123"),
            calendar_id: CalendarId::new("cal_123"),
            title: Some("Test Event".to_string()),
            description: None,
            when: When::Timespan {
                start_time: 1234567890,
                end_time: 1234571490,
                start_timezone: Some("UTC".to_string()),
                end_timezone: Some("UTC".to_string()),
            },
            location: None,
            busy: true,
            status: EventStatus::Confirmed,
            participants: vec![],
            organizer: None,
            creator: None,
            conferencing: None,
            recurrence: None,
            reminders: None,
            capacity: None,
            hide_participants: false,
            read_only: false,
            html_link: None,
            ical_uid: None,
            resources: vec![],
            visibility: None,
            object: "event".to_string(),
            metadata: None,
            created_at: None,
            updated_at: None,
        };

        assert_eq!(event.title, Some("Test Event".to_string()));
        assert!(event.busy);
        assert_eq!(event.status, EventStatus::Confirmed);
    }

    #[test]
    fn test_when_timespan_serialization() {
        let when = When::Timespan {
            start_time: 1234567890,
            end_time: 1234571490,
            start_timezone: Some("America/New_York".to_string()),
            end_timezone: Some("America/New_York".to_string()),
        };

        let json = serde_json::to_string(&when).unwrap();
        assert!(json.contains("timespan"));
        assert!(json.contains("1234567890"));
        assert!(json.contains("America/New_York"));

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

    #[test]
    fn test_when_datespan_serialization() {
        let when = When::Datespan {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-01-03".to_string(),
        };

        let json = serde_json::to_string(&when).unwrap();
        assert!(json.contains("datespan"));
        assert!(json.contains("2024-01-01"));
        assert!(json.contains("2024-01-03"));

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

    #[test]
    fn test_when_date_serialization() {
        let when = When::Date {
            date: "2024-01-15".to_string(),
        };

        let json = serde_json::to_string(&when).unwrap();
        assert!(json.contains("date"));
        assert!(json.contains("2024-01-15"));

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

    #[test]
    fn test_participant_builder() {
        let participant = Participant::new("user@example.com")
            .name("John Doe")
            .status(ParticipantStatus::Yes);

        assert_eq!(participant.email, "user@example.com");
        assert_eq!(participant.name, Some("John Doe".to_string()));
        assert_eq!(participant.status, Some(ParticipantStatus::Yes));
    }

    #[test]
    fn test_participant_status_serialization() {
        let status = ParticipantStatus::Yes;
        let json = serde_json::to_string(&status).unwrap();
        assert_eq!(json, "\"yes\"");

        let status = ParticipantStatus::Maybe;
        let json = serde_json::to_string(&status).unwrap();
        assert_eq!(json, "\"maybe\"");
    }

    #[test]
    fn test_event_status_serialization() {
        let status = EventStatus::Confirmed;
        let json = serde_json::to_string(&status).unwrap();
        assert_eq!(json, "\"confirmed\"");

        let status = EventStatus::Cancelled;
        let json = serde_json::to_string(&status).unwrap();
        assert_eq!(json, "\"cancelled\"");
    }

    #[test]
    fn test_conferencing_serialization() {
        let conferencing = Conferencing {
            provider: Some("Google Meet".to_string()),
            details: Some(ConferencingDetails {
                url: "https://meet.google.com/abc-def-ghi".to_string(),
                meeting_code: Some("abc-def-ghi".to_string()),
                password: None,
                pin: None,
                phone: vec![],
            }),
        };

        let json = serde_json::to_string(&conferencing).unwrap();
        assert!(json.contains("Google Meet"));
        assert!(json.contains("meet.google.com"));

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