nylas-types 0.1.1

//! Grant types for Nylas API v3.
//!
//! Grants represent authenticated connections to email and calendar providers.

use serde::{Deserialize, Serialize};

use crate::common::{GrantId, Provider};

/// Custom authentication settings for different providers
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CustomAuthSettings {
    /// Google OAuth settings
    Google {
        /// Google OAuth refresh token
        refresh_token: String,

        /// Google client ID
        #[serde(skip_serializing_if = "Option::is_none")]
        client_id: Option<String>,

        /// Google client secret
        #[serde(skip_serializing_if = "Option::is_none")]
        client_secret: Option<String>,
    },

    /// Microsoft OAuth settings
    Microsoft {
        /// Microsoft OAuth refresh token
        refresh_token: String,

        /// Microsoft client ID
        #[serde(skip_serializing_if = "Option::is_none")]
        client_id: Option<String>,

        /// Microsoft client secret
        #[serde(skip_serializing_if = "Option::is_none")]
        client_secret: Option<String>,
    },

    /// IMAP credentials
    Imap {
        /// IMAP host
        imap_host: String,

        /// IMAP port
        imap_port: u16,

        /// IMAP username
        imap_username: String,

        /// IMAP password
        imap_password: String,

        /// SMTP host
        smtp_host: String,

        /// SMTP port
        smtp_port: u16,

        /// SMTP username
        #[serde(skip_serializing_if = "Option::is_none")]
        smtp_username: Option<String>,

        /// SMTP password
        #[serde(skip_serializing_if = "Option::is_none")]
        smtp_password: Option<String>,
    },
}

/// Grant settings (OAuth token or custom credentials)
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GrantSettings {
    /// Use access token from hosted OAuth
    AccessToken {
        /// Access token
        access_token: String,
    },

    /// Use custom authentication
    Custom(CustomAuthSettings),
}

/// Grant status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum GrantStatus {
    /// Grant is valid and active.
    Valid,
    /// Grant is invalid or expired.
    Invalid,
}

/// Grant model.
///
/// Represents a Nylas grant which provides access to a user's account.
///
/// # Example
///
/// ```
/// # use nylas_types::{Grant, GrantId, Provider, GrantStatus};
/// let grant = Grant {
///     id: GrantId::new("grant_123"),
///     provider: Provider::Google,
///     grant_status: Some(GrantStatus::Valid),
///     email: Some("user@example.com".to_string()),
///     scope: Some(vec!["https://www.googleapis.com/auth/gmail.readonly".to_string()]),
///     user_timezone: None,
///     created_at: Some(1234567890),
///     updated_at: Some(1234567890),
///     provider_user_id: None,
///     ip: None,
///     state: None,
///     user_agent: None,
///     settings: None,
///     metadata: None,
/// };
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Grant {
    /// Unique identifier for the grant.
    pub id: GrantId,

    /// Provider for this grant.
    pub provider: Provider,

    /// Grant status.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub grant_status: Option<GrantStatus>,

    /// Email address associated with this grant.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,

    /// OAuth scopes granted to this connection.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scope: Option<Vec<String>>,

    /// User's timezone.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_timezone: Option<String>,

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

    /// Updated timestamp (Unix time).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<i64>,

    /// Provider-specific user identifier.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider_user_id: Option<String>,

    /// IP address from the authentication request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,

    /// OAuth state parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// User agent from the authentication request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_agent: Option<String>,

    /// Provider-specific settings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub settings: Option<serde_json::Value>,

    /// Custom metadata (key-value pairs).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,
}

/// Request to create a new grant.
///
/// Grants can be created from OAuth tokens or custom authentication credentials.
///
/// # Example
///
/// ```
/// # use nylas_types::{CreateGrantRequest, Provider, GrantSettings};
/// // Create from OAuth access token
/// let request = CreateGrantRequest::from_access_token(
///     Provider::Google,
///     "oauth_access_token".to_string(),
/// );
/// ```
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateGrantRequest {
    /// Provider type.
    pub provider: Provider,

    /// Grant settings (OAuth or custom)
    pub settings: GrantSettings,

    /// Grant state (defaults to "valid")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<GrantStatus>,

    /// OAuth scopes to request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scope: Option<Vec<String>>,

    /// Custom metadata.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,
}

impl CreateGrantRequest {
    /// Create a builder for CreateGrantRequest.
    pub fn builder(provider: Provider) -> CreateGrantRequestBuilder {
        CreateGrantRequestBuilder::new(provider)
    }

    /// Create from OAuth access token
    ///
    /// # Example
    ///
    /// ```
    /// # use nylas_types::{CreateGrantRequest, Provider};
    /// let request = CreateGrantRequest::from_access_token(
    ///     Provider::Google,
    ///     "oauth_token_123".to_string(),
    /// );
    /// assert_eq!(request.provider, Provider::Google);
    /// ```
    pub fn from_access_token(provider: Provider, access_token: String) -> Self {
        Self {
            provider,
            settings: GrantSettings::AccessToken { access_token },
            state: None,
            scope: None,
            metadata: None,
        }
    }

    /// Create from custom authentication settings
    ///
    /// # Example
    ///
    /// ```
    /// # use nylas_types::{CreateGrantRequest, Provider, CustomAuthSettings};
    /// let custom_auth = CustomAuthSettings::Imap {
    ///     imap_host: "imap.example.com".to_string(),
    ///     imap_port: 993,
    ///     imap_username: "user@example.com".to_string(),
    ///     imap_password: "password".to_string(),
    ///     smtp_host: "smtp.example.com".to_string(),
    ///     smtp_port: 587,
    ///     smtp_username: None,
    ///     smtp_password: None,
    /// };
    ///
    /// let request = CreateGrantRequest::from_custom_auth(
    ///     Provider::Imap,
    ///     custom_auth,
    /// );
    /// assert_eq!(request.provider, Provider::Imap);
    /// ```
    pub fn from_custom_auth(provider: Provider, settings: CustomAuthSettings) -> Self {
        Self {
            provider,
            settings: GrantSettings::Custom(settings),
            state: None,
            scope: None,
            metadata: None,
        }
    }
}

/// Builder for CreateGrantRequest.
#[derive(Debug, Clone)]
pub struct CreateGrantRequestBuilder {
    provider: Provider,
    settings: Option<GrantSettings>,
    grant_status: Option<GrantStatus>,
    scope: Option<Vec<String>>,
    metadata: Option<serde_json::Value>,
}

impl CreateGrantRequestBuilder {
    /// Create a new builder.
    pub fn new(provider: Provider) -> Self {
        Self {
            provider,
            settings: None,
            grant_status: None,
            scope: None,
            metadata: None,
        }
    }

    /// Set grant settings (OAuth token or custom auth).
    pub fn settings(mut self, settings: GrantSettings) -> Self {
        self.settings = Some(settings);
        self
    }

    /// Set access token (shorthand for OAuth token).
    pub fn access_token(mut self, token: String) -> Self {
        self.settings = Some(GrantSettings::AccessToken {
            access_token: token,
        });
        self
    }

    /// Set custom authentication settings.
    pub fn custom_auth(mut self, auth: CustomAuthSettings) -> Self {
        self.settings = Some(GrantSettings::Custom(auth));
        self
    }

    /// Set grant status.
    pub fn grant_status(mut self, status: GrantStatus) -> Self {
        self.grant_status = Some(status);
        self
    }

    /// Set OAuth scopes.
    pub fn scope(mut self, scope: Vec<String>) -> Self {
        self.scope = Some(scope);
        self
    }

    /// Set custom metadata.
    pub fn metadata(mut self, metadata: serde_json::Value) -> Self {
        self.metadata = Some(metadata);
        self
    }

    /// Build the CreateGrantRequest.
    ///
    /// # Panics
    ///
    /// Panics if settings are not provided.
    pub fn build(self) -> CreateGrantRequest {
        CreateGrantRequest {
            provider: self.provider,
            settings: self.settings.expect("settings are required"),
            state: self.grant_status,
            scope: self.scope,
            metadata: self.metadata,
        }
    }
}

/// Request to update a grant.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateGrantRequest {
    /// Update grant settings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub settings: Option<GrantSettings>,

    /// Update grant state.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<GrantStatus>,

    /// Update OAuth scopes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scope: Option<Vec<String>>,

    /// Update custom metadata.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,
}

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

/// Builder for UpdateGrantRequest.
#[derive(Debug, Clone, Default)]
pub struct UpdateGrantRequestBuilder {
    settings: Option<GrantSettings>,
    state: Option<GrantStatus>,
    scope: Option<Vec<String>>,
    metadata: Option<serde_json::Value>,
}

impl UpdateGrantRequestBuilder {
    /// Set grant settings.
    pub fn settings(mut self, settings: GrantSettings) -> Self {
        self.settings = Some(settings);
        self
    }

    /// Set grant state.
    pub fn state(mut self, state: GrantStatus) -> Self {
        self.state = Some(state);
        self
    }

    /// Set OAuth scopes.
    pub fn scope(mut self, scope: Vec<String>) -> Self {
        self.scope = Some(scope);
        self
    }

    /// Set custom metadata.
    pub fn metadata(mut self, metadata: serde_json::Value) -> Self {
        self.metadata = Some(metadata);
        self
    }

    /// Build the UpdateGrantRequest.
    pub fn build(self) -> UpdateGrantRequest {
        UpdateGrantRequest {
            settings: self.settings,
            state: self.state,
            scope: self.scope,
            metadata: self.metadata,
        }
    }
}

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

    #[test]
    fn test_grant_serialization() {
        let grant = Grant {
            id: GrantId::new("grant_123"),
            provider: Provider::Google,
            grant_status: Some(GrantStatus::Valid),
            email: Some("user@example.com".to_string()),
            scope: Some(vec![
                "https://www.googleapis.com/auth/gmail.readonly".to_string()
            ]),
            user_timezone: None,
            created_at: Some(1234567890),
            updated_at: Some(1234567890),
            provider_user_id: None,
            ip: None,
            state: None,
            user_agent: None,
            settings: None,
            metadata: None,
        };

        let json = serde_json::to_string(&grant).unwrap();
        assert!(json.contains("grant_123"));
        assert!(json.contains("google"));
        assert!(json.contains("user@example.com"));
    }

    #[test]
    fn test_grant_deserialization() {
        let json = r#"{
            "id": "grant_123",
            "provider": "google",
            "grant_status": "valid",
            "email": "user@example.com",
            "scope": ["https://www.googleapis.com/auth/gmail.readonly"],
            "created_at": 1234567890,
            "updated_at": 1234567890
        }"#;

        let grant: Grant = serde_json::from_str(json).unwrap();
        assert_eq!(grant.id.as_str(), "grant_123");
        assert_eq!(grant.provider, Provider::Google);
        assert_eq!(grant.grant_status, Some(GrantStatus::Valid));
        assert_eq!(grant.email, Some("user@example.com".to_string()));
    }

    #[test]
    fn test_grant_status_serialization() {
        assert_eq!(
            serde_json::to_string(&GrantStatus::Valid).unwrap(),
            r#""valid""#
        );
        assert_eq!(
            serde_json::to_string(&GrantStatus::Invalid).unwrap(),
            r#""invalid""#
        );
    }

    #[test]
    fn test_create_grant_request_builder() {
        let request = CreateGrantRequest::builder(Provider::Google)
            .access_token("token_123".to_string())
            .scope(vec![
                "https://www.googleapis.com/auth/gmail.readonly".to_string()
            ])
            .grant_status(GrantStatus::Valid)
            .build();

        assert_eq!(request.provider, Provider::Google);
        assert!(request.scope.is_some());
        assert_eq!(request.state, Some(GrantStatus::Valid));
        assert!(request.metadata.is_none());
    }

    #[test]
    fn test_create_grant_request_with_metadata() {
        let metadata = serde_json::json!({"team": "engineering"});
        let request = CreateGrantRequest::builder(Provider::Microsoft)
            .access_token("token_456".to_string())
            .metadata(metadata.clone())
            .build();

        assert_eq!(request.provider, Provider::Microsoft);
        assert_eq!(request.metadata, Some(metadata));
    }

    #[test]
    fn test_create_grant_from_access_token() {
        let request =
            CreateGrantRequest::from_access_token(Provider::Google, "token_123".to_string());

        assert_eq!(request.provider, Provider::Google);
        assert!(matches!(
            request.settings,
            GrantSettings::AccessToken { .. }
        ));
    }

    #[test]
    fn test_create_grant_from_custom_auth() {
        let custom_auth = CustomAuthSettings::Imap {
            imap_host: "imap.example.com".to_string(),
            imap_port: 993,
            imap_username: "user@example.com".to_string(),
            imap_password: "password".to_string(),
            smtp_host: "smtp.example.com".to_string(),
            smtp_port: 587,
            smtp_username: None,
            smtp_password: None,
        };

        let request = CreateGrantRequest::from_custom_auth(Provider::Imap, custom_auth);

        assert_eq!(request.provider, Provider::Imap);
        assert!(matches!(request.settings, GrantSettings::Custom(_)));
    }

    #[test]
    fn test_update_grant_request_builder() {
        let metadata = serde_json::json!({"updated": true});
        let request = UpdateGrantRequest::builder()
            .metadata(metadata.clone())
            .scope(vec!["new_scope".to_string()])
            .state(GrantStatus::Invalid)
            .build();

        assert_eq!(request.metadata, Some(metadata));
        assert_eq!(request.scope, Some(vec!["new_scope".to_string()]));
        assert_eq!(request.state, Some(GrantStatus::Invalid));
        assert!(request.settings.is_none());
    }

    #[test]
    fn test_update_grant_request_default() {
        let request = UpdateGrantRequest::default();
        assert!(request.settings.is_none());
        assert!(request.state.is_none());
        assert!(request.scope.is_none());
        assert!(request.metadata.is_none());
    }
}