nylas-types 0.1.1

//! Notetaker types for meeting recording and transcription.

use crate::common::{NotetakerId, RecordingId};
use serde::{Deserialize, Serialize};

/// Notetaker configuration.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Notetaker {
    /// Unique identifier for the notetaker configuration
    pub id: NotetakerId,

    /// Grant ID this notetaker belongs to
    pub grant_id: String,

    /// Whether the notetaker is active
    pub active: bool,

    /// Provider-specific settings
    pub provider_settings: ProviderSettings,

    /// Transcription settings
    pub transcription_settings: Option<TranscriptionSettings>,

    /// AI summary settings
    pub summary_settings: Option<SummarySettings>,

    /// Webhook URL for notifications
    pub webhook_url: Option<String>,

    /// Created timestamp (Unix seconds)
    pub created_at: i64,

    /// Updated timestamp (Unix seconds)
    pub updated_at: i64,
}

/// Provider-specific settings.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "provider", rename_all = "lowercase")]
pub enum ProviderSettings {
    /// Google Meet settings
    #[serde(rename = "google-meet")]
    GoogleMeet {
        /// Auto-join meetings on calendar
        auto_join: bool,
        /// Recording quality
        quality: RecordingQuality,
    },

    /// Microsoft Teams settings
    #[serde(rename = "microsoft-teams")]
    MicrosoftTeams {
        /// Auto-join meetings on calendar
        auto_join: bool,
        /// Recording quality
        quality: RecordingQuality,
    },

    /// Zoom settings
    Zoom {
        /// Auto-join meetings on calendar
        auto_join: bool,
        /// Recording quality
        quality: RecordingQuality,
        /// Cloud recording (vs local)
        cloud_recording: bool,
    },
}

/// Recording quality levels.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RecordingQuality {
    /// Standard definition
    Standard,
    /// High definition
    Hd,
}

/// Transcription settings.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TranscriptionSettings {
    /// Enable transcription
    pub enabled: bool,

    /// Language for transcription (e.g., "en-US")
    pub language: Option<String>,

    /// Enable speaker identification
    pub speaker_identification: bool,

    /// Profanity filtering
    pub profanity_filter: Option<bool>,
}

/// AI summary settings.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SummarySettings {
    /// Enable AI summaries
    pub enabled: bool,

    /// Extract action items
    pub extract_action_items: bool,

    /// Extract key topics
    pub extract_topics: bool,

    /// Extract decisions made
    pub extract_decisions: bool,

    /// Summary length preference
    pub summary_length: SummaryLength,
}

/// Summary length preference.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SummaryLength {
    /// Brief summary
    Brief,
    /// Medium-length summary
    Medium,
    /// Detailed summary
    Detailed,
}

/// Recording from a meeting.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Recording {
    /// Unique identifier for the recording
    pub id: RecordingId,

    /// Notetaker configuration ID
    pub notetaker_id: NotetakerId,

    /// Meeting title
    pub title: String,

    /// Meeting start time (Unix seconds)
    pub start_time: i64,

    /// Meeting end time (Unix seconds)
    pub end_time: Option<i64>,

    /// Recording duration in seconds
    pub duration: Option<i64>,

    /// Recording status
    pub status: RecordingStatus,

    /// Recording file URL (when available)
    pub recording_url: Option<String>,

    /// Transcription (when available)
    pub transcription: Option<Transcription>,

    /// AI-generated summary (when available)
    pub summary: Option<Summary>,

    /// Meeting participants
    pub participants: Vec<MeetingParticipant>,

    /// Created timestamp (Unix seconds)
    pub created_at: i64,

    /// Updated timestamp (Unix seconds)
    pub updated_at: i64,
}

/// Recording status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RecordingStatus {
    /// Recording in progress
    Recording,
    /// Processing (transcribing, summarizing)
    Processing,
    /// Completed and available
    Completed,
    /// Failed
    Failed,
}

/// Meeting transcription.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Transcription {
    /// Full transcript text
    pub text: String,

    /// Transcript segments with timestamps
    pub segments: Vec<TranscriptSegment>,

    /// Detected language
    pub language: String,

    /// Confidence score (0.0 - 1.0)
    pub confidence: f64,
}

/// Transcript segment with speaker and timing.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TranscriptSegment {
    /// Segment text
    pub text: String,

    /// Speaker identifier
    pub speaker: Option<String>,

    /// Start time in seconds from recording start
    pub start_time: f64,

    /// End time in seconds from recording start
    pub end_time: f64,

    /// Confidence score (0.0 - 1.0)
    pub confidence: f64,
}

/// AI-generated meeting summary.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Summary {
    /// Overall meeting summary
    pub summary: String,

    /// Extracted action items
    pub action_items: Vec<ActionItem>,

    /// Key topics discussed
    pub topics: Vec<String>,

    /// Decisions made
    pub decisions: Vec<String>,

    /// Next steps
    pub next_steps: Vec<String>,
}

/// Action item from meeting.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ActionItem {
    /// Description of the action
    pub description: String,

    /// Assigned to (if detected)
    pub assignee: Option<String>,

    /// Due date (if mentioned, Unix seconds)
    pub due_date: Option<i64>,

    /// Priority level (if detected)
    pub priority: Option<Priority>,
}

/// Action item priority.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Priority {
    /// High priority
    High,
    /// Medium priority
    Medium,
    /// Low priority
    Low,
}

/// Meeting participant.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MeetingParticipant {
    /// Participant name
    pub name: String,

    /// Email address (if available)
    pub email: Option<String>,

    /// Join time (Unix seconds)
    pub joined_at: i64,

    /// Leave time (Unix seconds, None if still in meeting)
    pub left_at: Option<i64>,

    /// Speaking time in seconds
    pub speaking_time: Option<i64>,
}

/// Request to create a notetaker configuration.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateNotetakerRequest {
    /// Provider-specific settings
    pub provider_settings: ProviderSettings,

    /// Transcription settings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_settings: Option<TranscriptionSettings>,

    /// AI summary settings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary_settings: Option<SummarySettings>,

    /// Webhook URL for notifications
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,

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

impl CreateNotetakerRequest {
    /// Create a builder for CreateNotetakerRequest.
    pub fn builder(provider_settings: ProviderSettings) -> CreateNotetakerRequestBuilder {
        CreateNotetakerRequestBuilder::new(provider_settings)
    }
}

/// Builder for CreateNotetakerRequest.
#[derive(Debug)]
pub struct CreateNotetakerRequestBuilder {
    request: CreateNotetakerRequest,
}

impl CreateNotetakerRequestBuilder {
    /// Create a new builder.
    pub fn new(provider_settings: ProviderSettings) -> Self {
        Self {
            request: CreateNotetakerRequest {
                provider_settings,
                transcription_settings: None,
                summary_settings: None,
                webhook_url: None,
                active: None,
            },
        }
    }

    /// Set transcription settings.
    pub fn transcription_settings(mut self, settings: TranscriptionSettings) -> Self {
        self.request.transcription_settings = Some(settings);
        self
    }

    /// Set summary settings.
    pub fn summary_settings(mut self, settings: SummarySettings) -> Self {
        self.request.summary_settings = Some(settings);
        self
    }

    /// Set webhook URL.
    pub fn webhook_url(mut self, url: impl Into<String>) -> Self {
        self.request.webhook_url = Some(url.into());
        self
    }

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

    /// Build the request.
    pub fn build(self) -> CreateNotetakerRequest {
        self.request
    }
}

/// Request to update a notetaker configuration.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateNotetakerRequest {
    /// Provider-specific settings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider_settings: Option<ProviderSettings>,

    /// Transcription settings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_settings: Option<TranscriptionSettings>,

    /// AI summary settings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary_settings: Option<SummarySettings>,

    /// Webhook URL for notifications
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,

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

impl UpdateNotetakerRequest {
    /// Create a builder for UpdateNotetakerRequest.
    pub fn builder() -> UpdateNotetakerRequestBuilder {
        UpdateNotetakerRequestBuilder::default()
    }
}

/// Builder for UpdateNotetakerRequest.
#[derive(Debug, Default)]
pub struct UpdateNotetakerRequestBuilder {
    request: UpdateNotetakerRequest,
}

impl UpdateNotetakerRequestBuilder {
    /// Set provider settings.
    pub fn provider_settings(mut self, settings: ProviderSettings) -> Self {
        self.request.provider_settings = Some(settings);
        self
    }

    /// Set transcription settings.
    pub fn transcription_settings(mut self, settings: TranscriptionSettings) -> Self {
        self.request.transcription_settings = Some(settings);
        self
    }

    /// Set summary settings.
    pub fn summary_settings(mut self, settings: SummarySettings) -> Self {
        self.request.summary_settings = Some(settings);
        self
    }

    /// Set webhook URL.
    pub fn webhook_url(mut self, url: impl Into<String>) -> Self {
        self.request.webhook_url = Some(url.into());
        self
    }

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

    /// Build the request.
    pub fn build(self) -> UpdateNotetakerRequest {
        self.request
    }
}

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

    #[test]
    fn test_notetaker_id_creation() {
        let id = NotetakerId::new("notetaker_123");
        assert_eq!(id.as_str(), "notetaker_123");
    }

    #[test]
    fn test_recording_id_creation() {
        let id = RecordingId::new("rec_456");
        assert_eq!(id.as_str(), "rec_456");
    }

    #[test]
    fn test_create_notetaker_request_builder() {
        let provider = ProviderSettings::GoogleMeet {
            auto_join: true,
            quality: RecordingQuality::Hd,
        };

        let transcription = TranscriptionSettings {
            enabled: true,
            language: Some("en-US".to_string()),
            speaker_identification: true,
            profanity_filter: Some(false),
        };

        let request = CreateNotetakerRequest::builder(provider)
            .transcription_settings(transcription)
            .active(true)
            .build();

        assert!(request.active.unwrap());
        assert!(request.transcription_settings.is_some());
    }

    #[test]
    fn test_update_notetaker_request_builder() {
        let request = UpdateNotetakerRequest::builder()
            .active(false)
            .webhook_url("https://example.com/webhook")
            .build();

        assert_eq!(request.active, Some(false));
        assert_eq!(
            request.webhook_url,
            Some("https://example.com/webhook".to_string())
        );
    }

    #[test]
    fn test_recording_status_serialization() {
        let status = RecordingStatus::Processing;
        let json = serde_json::to_string(&status).unwrap();
        assert_eq!(json, "\"processing\"");
    }

    #[test]
    fn test_summary_length_serialization() {
        let length = SummaryLength::Brief;
        let json = serde_json::to_string(&length).unwrap();
        assert_eq!(json, "\"brief\"");
    }
}