nylas-types 0.1.1

//! Scheduler types for the Nylas API v3.
//!
//! Scheduler allows users to create booking pages and manage meeting scheduling.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::{CalendarId, SchedulerBookingId, SchedulerConfigId, SchedulerSessionId};

/// Scheduler configuration.
///
/// Defines the settings for a scheduling page.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SchedulerConfig {
    /// Unique identifier for the configuration.
    pub id: SchedulerConfigId,

    /// Name of the configuration.
    pub name: String,

    /// Slug used in the booking URL.
    pub slug: String,

    /// Event title template.
    pub event_title: String,

    /// Event description.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_description: Option<String>,

    /// Event duration in minutes.
    pub duration_minutes: u32,

    /// Event location.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_location: Option<String>,

    /// Calendar IDs to check availability against.
    pub calendar_ids: Vec<CalendarId>,

    /// Availability settings.
    pub availability: AvailabilitySettings,

    /// Booking settings.
    pub booking: BookingSettings,

    /// Whether this configuration is active.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,

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

    /// Unix timestamp when last modified.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modified_at: Option<i64>,
}

/// Availability settings for scheduler.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AvailabilitySettings {
    /// Days of the week available for booking.
    pub days: Vec<DayOfWeek>,

    /// Start time for availability (e.g., "09:00").
    pub start_time: String,

    /// End time for availability (e.g., "17:00").
    pub end_time: String,

    /// Timezone for availability.
    pub timezone: String,

    /// Minimum notice period in minutes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_notice_minutes: Option<u32>,

    /// Buffer time between meetings in minutes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub buffer_minutes: Option<u32>,
}

/// Day of the week for availability.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum DayOfWeek {
    /// Monday
    Monday,
    /// Tuesday
    Tuesday,
    /// Wednesday
    Wednesday,
    /// Thursday
    Thursday,
    /// Friday
    Friday,
    /// Saturday
    Saturday,
    /// Sunday
    Sunday,
}

/// Booking settings for scheduler.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BookingSettings {
    /// Confirmation message shown after booking.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirmation_message: Option<String>,

    /// Confirmation redirect URL.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirmation_redirect_url: Option<String>,

    /// Required fields for booking form.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required_fields: Option<Vec<String>>,

    /// Custom fields for booking form.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_fields: Option<Vec<CustomField>>,

    /// Whether to send confirmation emails.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_confirmation_email: Option<bool>,

    /// Whether to send reminder emails.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_reminder_email: Option<bool>,

    /// Reminder time in minutes before the meeting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reminder_minutes: Option<u32>,
}

/// Custom field for booking form.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CustomField {
    /// Field name.
    pub name: String,

    /// Field label shown to users.
    pub label: String,

    /// Field type.
    #[serde(rename = "type")]
    pub field_type: CustomFieldType,

    /// Whether this field is required.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,

    /// Options for select/radio fields.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<String>>,
}

/// Type of custom field.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum CustomFieldType {
    /// Text input
    Text,
    /// Email input
    Email,
    /// Phone number input
    Phone,
    /// Select dropdown
    Select,
    /// Radio buttons
    Radio,
    /// Checkbox
    Checkbox,
    /// Text area
    Textarea,
}

/// Supported locales for scheduler UI.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Locale {
    /// English
    En,
    /// Spanish
    Es,
    /// French
    Fr,
    /// German
    De,
    /// Japanese
    Ja,
    /// Chinese (Simplified)
    #[serde(rename = "zh")]
    ZhCn,
    /// Korean (NEW in 2024)
    Ko,
}

/// Request to create a scheduler configuration.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateSchedulerConfigRequest {
    /// Name of the configuration.
    pub name: String,

    /// Slug used in the booking URL.
    pub slug: String,

    /// Event title template.
    pub event_title: String,

    /// Event description.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_description: Option<String>,

    /// Event duration in minutes.
    pub duration_minutes: u32,

    /// Event location.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_location: Option<String>,

    /// Calendar IDs to check availability against.
    pub calendar_ids: Vec<String>,

    /// Availability settings.
    pub availability: AvailabilitySettings,

    /// Booking settings.
    pub booking: BookingSettings,
}

/// Request to update a scheduler configuration.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct UpdateSchedulerConfigRequest {
    /// Name of the configuration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// Event title template.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_title: Option<String>,

    /// Event description.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_description: Option<String>,

    /// Event duration in minutes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration_minutes: Option<u32>,

    /// Whether this configuration is active.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
}

/// Scheduler session.
///
/// Represents an active scheduling session for a guest.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SchedulerSession {
    /// Unique identifier for the session.
    pub id: SchedulerSessionId,

    /// Configuration ID this session belongs to.
    pub config_id: SchedulerConfigId,

    /// Guest email address.
    pub email: String,

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

    /// Session expiry timestamp.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<i64>,

    /// Additional session data.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<HashMap<String, String>>,
}

/// Request to create a scheduler session.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateSchedulerSessionRequest {
    /// Configuration ID to create session for.
    pub config_id: String,

    /// Guest email address.
    pub email: String,

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

    /// Additional session metadata.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<HashMap<String, String>>,
}

/// Scheduler booking.
///
/// Represents a confirmed booking created through the scheduler.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SchedulerBooking {
    /// Unique identifier for the booking.
    pub id: SchedulerBookingId,

    /// Configuration ID used for this booking.
    pub config_id: SchedulerConfigId,

    /// Session ID if created through a session.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session_id: Option<SchedulerSessionId>,

    /// Event ID created for this booking.
    pub event_id: String,

    /// Guest email address.
    pub email: String,

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

    /// Booking start time (Unix timestamp).
    pub start_time: i64,

    /// Booking end time (Unix timestamp).
    pub end_time: i64,

    /// Timezone for the booking.
    pub timezone: String,

    /// Booking status.
    pub status: BookingStatus,

    /// Custom field responses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_fields: Option<HashMap<String, String>>,

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

/// Status of a booking.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum BookingStatus {
    /// Booking is confirmed
    Confirmed,
    /// Booking was cancelled
    Cancelled,
    /// Booking is pending
    Pending,
}

/// Request to create a scheduler booking.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateSchedulerBookingRequest {
    /// Configuration ID to book against.
    pub config_id: String,

    /// Session ID if using a session.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,

    /// Guest email address.
    pub email: String,

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

    /// Booking start time (Unix timestamp).
    pub start_time: i64,

    /// Timezone for the booking.
    pub timezone: String,

    /// Custom field responses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_fields: Option<HashMap<String, String>>,
}

/// Request to cancel a scheduler booking.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CancelSchedulerBookingRequest {
    /// Reason for cancellation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

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

    #[test]
    fn test_scheduler_config_id() {
        let id = SchedulerConfigId::new("config_123");
        assert_eq!(id.as_str(), "config_123");
    }

    #[test]
    fn test_day_of_week_serialization() {
        let day = DayOfWeek::Monday;
        let json = serde_json::to_string(&day).unwrap();
        assert_eq!(json, "\"monday\"");

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

    #[test]
    fn test_custom_field_type_serialization() {
        let field_type = CustomFieldType::Email;
        let json = serde_json::to_string(&field_type).unwrap();
        assert_eq!(json, "\"email\"");

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

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

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

    #[test]
    fn test_create_scheduler_booking_request() {
        let request = CreateSchedulerBookingRequest {
            config_id: "config_123".to_string(),
            session_id: Some("session_456".to_string()),
            email: "guest@example.com".to_string(),
            name: Some("Guest Name".to_string()),
            start_time: 1735689600,
            timezone: "America/New_York".to_string(),
            custom_fields: None,
        };

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

    #[test]
    fn test_korean_locale() {
        let locale = Locale::Ko;
        let json = serde_json::to_string(&locale).unwrap();
        assert_eq!(json, "\"ko\"");
    }

    #[test]
    fn test_korean_locale_deserialization() {
        let json = "\"ko\"";
        let locale: Locale = serde_json::from_str(json).unwrap();
        assert_eq!(locale, Locale::Ko);
    }
}