use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// Immutable audit event capturing a single action in the system.
///
/// Audit events are append-only: they are inserted but never updated or deleted.
/// Each event records who did what, to which entity, with optional before/after
/// snapshots for reconstructing state changes.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuditEvent {
    /// MongoDB ObjectId hex string. Assigned on insert.
    pub id: String,

    /// When the action occurred.
    pub occurred_at: DateTime<Utc>,

    /// The user who performed the action. None for system-initiated actions
    /// (e.g., TTL-based temp env expiration).
    pub actor_user_id: Option<String>,

    /// The app this event belongs to. None for cross-app actions (e.g., user
    /// notification preference changes).
    pub app_id: Option<String>,

    /// The type of entity affected (e.g., "workspace", "changeset", "release",
    /// "deployment", "temp_environment", "app", "membership", "invite",
    /// "environment", "comment", "notification_preference").
    pub entity_type: String,

    /// The id of the affected entity.
    pub entity_id: String,

    /// The action performed (e.g., "created", "submitted", "approved",
    /// "published", "deployed", "settings_updated"). See section 6.3 for the
    /// full enumeration.
    pub action: String,

    /// Snapshot of the entity state before the action, if applicable.
    pub before: Option<serde_json::Value>,

    /// Snapshot of the entity state after the action, if applicable.
    pub after: Option<serde_json::Value>,

    /// The Git SHA associated with this action, if relevant (e.g., changeset
    /// head_sha at submit, release published_sha).
    pub git_sha: Option<String>,

    /// Request context captured at the time of the action.
    pub context: RequestContext,
}

/// Request metadata captured alongside every audit event for traceability.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RequestContext {
    /// Client IP address, from connection or X-Forwarded-For.
    pub ip: Option<String>,

    /// User-Agent header value.
    pub user_agent: Option<String>,

    /// The request ID that triggered this action.
    pub request_id: String,
}

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// Per-user notification preferences. V1 supports a single on/off toggle
/// for email notifications.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationPreference {
    /// MongoDB ObjectId hex string.
    pub id: String,

    /// The user this preference belongs to. Unique — one preference doc per user.
    pub user_id: String,

    /// Whether the user receives email notifications. Default: true.
    pub email_enabled: bool,

    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

impl NotificationPreference {
    /// Create a default preference for a new user (email enabled).
    pub fn default_for_user(user_id: String) -> Self {
        let now = Utc::now();
        Self {
            id: String::new(), // Assigned on insert
            user_id,
            email_enabled: true,
            created_at: now,
            updated_at: now,
        }
    }
}

/// All notification-worthy events in the system.
///
/// Each variant maps to an email template and a set of recipient resolution
/// rules. See section 6.1 for the fanout logic.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NotificationEvent {
    /// A changeset was submitted for review.
    ChangesetSubmitted,
    /// A user was explicitly requested to review a changeset.
    ReviewRequested,
    /// A changeset was approved by a reviewer.
    ChangesetApproved,
    /// A reviewer requested changes on a changeset.
    ChangesRequested,
    /// A changeset was rejected by a reviewer.
    ChangesetRejected,
    /// An approved changeset was moved to the queue.
    ChangesetQueued,
    /// A new release draft was created.
    ReleaseCreated,
    /// A release was published (tagged and merged to the integration branch).
    ReleasePublished,
    /// A deployment to an environment has started.
    DeploymentStarted,
    /// A deployment to an environment completed successfully.
    DeploymentSucceeded,
    /// A deployment to an environment failed.
    DeploymentFailed,
    /// A temporary environment is approaching its TTL expiry.
    TempEnvExpiryWarning,
    /// A temporary environment has expired.
    TempEnvExpired,
}

impl NotificationEvent {
    /// Return the email template name used by the email provider.
    pub fn template_name(&self) -> &'static str {
        match self {
            Self::ChangesetSubmitted => "changeset_submitted",
            Self::ReviewRequested => "review_requested",
            Self::ChangesetApproved => "changeset_approved",
            Self::ChangesRequested => "changes_requested",
            Self::ChangesetRejected => "changeset_rejected",
            Self::ChangesetQueued => "changeset_queued",
            Self::ReleaseCreated => "release_created",
            Self::ReleasePublished => "release_published",
            Self::DeploymentStarted => "deployment_started",
            Self::DeploymentSucceeded => "deployment_succeeded",
            Self::DeploymentFailed => "deployment_failed",
            Self::TempEnvExpiryWarning => "temp_env_expiry_warning",
            Self::TempEnvExpired => "temp_env_expired",
        }
    }
}

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

/// Payload for a single outbound email. Constructed by the notification
/// service and handed off to the email provider for delivery.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmailPayload {
    /// Recipient email address.
    pub to: String,

    /// Email subject line.
    pub subject: String,

    /// Template identifier recognized by the email provider.
    pub template_name: String,

    /// Key-value data interpolated into the template (e.g., changeset title,
    /// app name, actor name, link URL).
    pub template_data: HashMap<String, serde_json::Value>,
}

use crate::models::audit::RequestContext;
use crate::models::email::EmailPayload;
use crate::models::notification::{NotificationEvent, NotificationPreference};
use crate::ConmanError;

/// Orchestrates notification delivery for all system events.
///
/// For each event, the service determines recipients, checks their notification
/// preferences, builds email payloads, and dispatches them for delivery.
pub struct NotificationService {
    /// Repository for notification preferences.
    notification_pref_repo: NotificationPrefRepo,

    /// Repository for app memberships (used to resolve recipients by role).
    membership_repo: AppMembershipRepo,

    /// Repository for user records (used to look up email addresses).
    user_repo: UserRepo,

    /// Email sending backend (trait object for testability).
    email_sender: Box<dyn EmailSender>,
}

/// Trait abstracting the email delivery backend. Implementations may use
/// an SMTP relay, a transactional email API (SendGrid, SES, etc.), or a
/// no-op sender for tests.
#[async_trait::async_trait]
pub trait EmailSender: Send + Sync {
    /// Send a single email. Returns Ok on accepted-for-delivery.
    /// Implementations should handle retries internally.
    async fn send(&self, payload: &EmailPayload) -> Result<(), ConmanError>;
}

/// Contextual data passed alongside every notification dispatch, used to
/// resolve recipients and build template data.
pub struct NotificationContext {
    /// The app where the event occurred.
    pub app_id: String,
    pub app_name: String,

    /// The user who triggered the event (None for system events).
    pub actor_user_id: Option<String>,
    pub actor_name: Option<String>,

    /// Entity-specific fields for template interpolation.
    pub entity_id: String,
    pub entity_title: Option<String>,

    /// Deep link URL for the notification (e.g., changeset detail page).
    pub link_url: Option<String>,

    /// Additional template data specific to the event type.
    pub extra: std::collections::HashMap<String, serde_json::Value>,
}

impl NotificationService {
    /// Dispatch a notification for the given event.
    ///
    /// 1. Resolve the set of recipient user IDs based on event type and context.
    /// 2. Filter out users who have email_enabled = false.
    /// 3. Filter out the actor (users do not receive notifications for their
    ///    own actions).
    /// 4. Build an EmailPayload per recipient.
    /// 5. Send each email (fire-and-forget; failures are logged, not propagated).
    pub async fn notify(
        &self,
        event: NotificationEvent,
        ctx: &NotificationContext,
    ) -> Result<(), ConmanError> {
        // Determine who should receive this notification.
        let recipient_user_ids = self.resolve_recipients(&event, ctx).await?;

        // Load preferences for all candidate recipients in one query.
        let prefs = self
            .notification_pref_repo
            .find_by_user_ids(&recipient_user_ids)
            .await?;

        // Build a lookup set of users who have opted out.
        let opted_out: std::collections::HashSet<String> = prefs
            .iter()
            .filter(|p| !p.email_enabled)
            .map(|p| p.user_id.clone())
            .collect();

        // Filter: remove opted-out users and the actor themselves.
        let final_recipients: Vec<String> = recipient_user_ids
            .into_iter()
            .filter(|uid| !opted_out.contains(uid))
            .filter(|uid| ctx.actor_user_id.as_ref() != Some(uid))
            .collect();

        // Bail early if no one to notify.
        if final_recipients.is_empty() {
            return Ok(());
        }

        // Look up email addresses for the remaining recipients.
        let users = self.user_repo.find_by_ids(&final_recipients).await?;

        // Build and send one email per recipient.
        let subject = self.build_subject(&event, ctx);
        let template_name = event.template_name().to_string();

        for user in &users {
            let payload = EmailPayload {
                to: user.email.clone(),
                subject: subject.clone(),
                template_name: template_name.clone(),
                template_data: self.build_template_data(&event, ctx, user),
            };

            // Fire-and-forget: log errors but do not fail the caller.
            if let Err(e) = self.email_sender.send(&payload).await {
                tracing::error!(
                    error = %e,
                    to = %user.email,
                    event = ?event,
                    "failed to send notification email"
                );
            }
        }

        Ok(())
    }

    /// Resolve recipient user IDs for a given event type.
    ///
    /// Recipient rules by event:
    /// - ChangesetSubmitted: all reviewers + config_managers + app_admins
    /// - ReviewRequested: the specifically requested reviewer
    /// - ChangesetApproved: changeset author
    /// - ChangesRequested: changeset author
    /// - ChangesetRejected: changeset author
    /// - ChangesetQueued: changeset author + config_managers + app_admins
    /// - ReleaseCreated: all config_managers + app_admins
    /// - ReleasePublished: all app members
    /// - DeploymentStarted: all config_managers + app_admins
    /// - DeploymentSucceeded: all app members
    /// - DeploymentFailed: all config_managers + app_admins
    /// - TempEnvExpiryWarning: temp env creator
    /// - TempEnvExpired: temp env creator
    async fn resolve_recipients(
        &self,
        event: &NotificationEvent,
        ctx: &NotificationContext,
    ) -> Result<Vec<String>, ConmanError> {
        match event {
            NotificationEvent::ChangesetSubmitted => {
                self.membership_repo
                    .find_users_with_roles(
                        &ctx.app_id,
                        &["reviewer", "config_manager", "app_admin"],
                    )
                    .await
            }
            NotificationEvent::ReviewRequested => {
                // The requested reviewer's ID is passed in extra.reviewer_user_id.
                if let Some(reviewer_id) = ctx.extra.get("reviewer_user_id") {
                    Ok(vec![reviewer_id
                        .as_str()
                        .unwrap_or_default()
                        .to_string()])
                } else {
                    Ok(vec![])
                }
            }
            NotificationEvent::ChangesetApproved
            | NotificationEvent::ChangesRequested
            | NotificationEvent::ChangesetRejected => {
                // Notify the changeset author.
                if let Some(author_id) = ctx.extra.get("author_user_id") {
                    Ok(vec![author_id
                        .as_str()
                        .unwrap_or_default()
                        .to_string()])
                } else {
                    Ok(vec![])
                }
            }
            NotificationEvent::ChangesetQueued => {
                let mut recipients = self
                    .membership_repo
                    .find_users_with_roles(
                        &ctx.app_id,
                        &["config_manager", "app_admin"],
                    )
                    .await?;
                if let Some(author_id) = ctx.extra.get("author_user_id") {
                    let author = author_id.as_str().unwrap_or_default().to_string();
                    if !recipients.contains(&author) {
                        recipients.push(author);
                    }
                }
                Ok(recipients)
            }
            NotificationEvent::ReleaseCreated
            | NotificationEvent::DeploymentStarted
            | NotificationEvent::DeploymentFailed => {
                self.membership_repo
                    .find_users_with_roles(
                        &ctx.app_id,
                        &["config_manager", "app_admin"],
                    )
                    .await
            }
            NotificationEvent::ReleasePublished
            | NotificationEvent::DeploymentSucceeded => {
                self.membership_repo
                    .find_all_members(&ctx.app_id)
                    .await
            }
            NotificationEvent::TempEnvExpiryWarning
            | NotificationEvent::TempEnvExpired => {
                if let Some(creator_id) = ctx.extra.get("creator_user_id") {
                    Ok(vec![creator_id
                        .as_str()
                        .unwrap_or_default()
                        .to_string()])
                } else {
                    Ok(vec![])
                }
            }
        }
    }

    /// Build a human-readable subject line for the email.
    fn build_subject(
        &self,
        event: &NotificationEvent,
        ctx: &NotificationContext,
    ) -> String {
        let app = &ctx.app_name;
        let title = ctx.entity_title.as_deref().unwrap_or(&ctx.entity_id);
        match event {
            NotificationEvent::ChangesetSubmitted => {
                format!("[{app}] Changeset submitted: {title}")
            }
            NotificationEvent::ReviewRequested => {
                format!("[{app}] Review requested: {title}")
            }
            NotificationEvent::ChangesetApproved => {
                format!("[{app}] Changeset approved: {title}")
            }
            NotificationEvent::ChangesRequested => {
                format!("[{app}] Changes requested: {title}")
            }
            NotificationEvent::ChangesetRejected => {
                format!("[{app}] Changeset rejected: {title}")
            }
            NotificationEvent::ChangesetQueued => {
                format!("[{app}] Changeset queued: {title}")
            }
            NotificationEvent::ReleaseCreated => {
                format!("[{app}] Release created: {title}")
            }
            NotificationEvent::ReleasePublished => {
                format!("[{app}] Release published: {title}")
            }
            NotificationEvent::DeploymentStarted => {
                format!("[{app}] Deployment started: {title}")
            }
            NotificationEvent::DeploymentSucceeded => {
                format!("[{app}] Deployment succeeded: {title}")
            }
            NotificationEvent::DeploymentFailed => {
                format!("[{app}] Deployment failed: {title}")
            }
            NotificationEvent::TempEnvExpiryWarning => {
                format!("[{app}] Temp environment expiring soon: {title}")
            }
            NotificationEvent::TempEnvExpired => {
                format!("[{app}] Temp environment expired: {title}")
            }
        }
    }

    /// Build template data HashMap for a specific recipient.
    fn build_template_data(
        &self,
        event: &NotificationEvent,
        ctx: &NotificationContext,
        _recipient: &User,
    ) -> std::collections::HashMap<String, serde_json::Value> {
        let mut data = ctx.extra.clone();
        data.insert("app_name".to_string(), serde_json::json!(ctx.app_name));
        data.insert("entity_id".to_string(), serde_json::json!(ctx.entity_id));
        if let Some(title) = &ctx.entity_title {
            data.insert("entity_title".to_string(), serde_json::json!(title));
        }
        if let Some(actor) = &ctx.actor_name {
            data.insert("actor_name".to_string(), serde_json::json!(actor));
        }
        if let Some(link) = &ctx.link_url {
            data.insert("link_url".to_string(), serde_json::json!(link));
        }
        data.insert(
            "event_type".to_string(),
            serde_json::json!(event.template_name()),
        );
        data
    }
}

use chrono::Utc;
use mongodb::bson::{self, doc, oid::ObjectId, Document};
use mongodb::{Collection, Database, IndexModel};
use mongodb::options::IndexOptions;

use conman_core::models::audit::AuditEvent;
use conman_core::ConmanError;

/// Repository for the append-only `audit_events` collection.
///
/// This repository intentionally exposes only insert and query operations.
/// There are no update or delete methods — audit events are immutable once
/// written.
pub struct AuditRepo {
    collection: Collection<Document>,
}

impl AuditRepo {
    pub fn new(db: &Database) -> Self {
        Self {
            collection: db.collection("audit_events"),
        }
    }

    /// Insert an audit event into the collection.
    ///
    /// This is the only write operation. Audit events are fire-and-forget
    /// from the caller's perspective: errors are logged but should not block
    /// the originating request.
    pub async fn emit(&self, event: AuditEvent) -> Result<(), ConmanError> {
        let mut doc = bson::to_document(&event).map_err(|e| ConmanError::Internal {
            message: format!("failed to serialize audit event: {e}"),
        })?;

        // Let MongoDB assign _id automatically.
        doc.remove("id");

        self.collection
            .insert_one(doc)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("failed to insert audit event: {e}"),
            })?;

        Ok(())
    }

    /// Query audit events for an app with optional filters and pagination.
    ///
    /// Supports filtering by entity_type, entity_id, action, and
    /// actor_user_id. Results are ordered by occurred_at descending
    /// (most recent first).
    pub async fn query(
        &self,
        app_id: &str,
        entity_type: Option<&str>,
        entity_id: Option<&str>,
        action: Option<&str>,
        actor_user_id: Option<&str>,
        skip: u64,
        limit: i64,
    ) -> Result<(Vec<AuditEvent>, u64), ConmanError> {
        let mut filter = doc! { "app_id": app_id };

        if let Some(et) = entity_type {
            filter.insert("entity_type", et);
        }
        if let Some(eid) = entity_id {
            filter.insert("entity_id", eid);
        }
        if let Some(a) = action {
            filter.insert("action", a);
        }
        if let Some(uid) = actor_user_id {
            filter.insert("actor_user_id", uid);
        }

        // Count total matching documents for pagination.
        let total = self
            .collection
            .count_documents(filter.clone())
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("audit query count failed: {e}"),
            })?;

        // Fetch the page of results, sorted by occurred_at descending.
        let options = mongodb::options::FindOptions::builder()
            .sort(doc! { "occurred_at": -1 })
            .skip(skip)
            .limit(limit)
            .build();

        let mut cursor = self
            .collection
            .find(filter)
            .with_options(options)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("audit query failed: {e}"),
            })?;

        let mut events = Vec::new();
        while cursor.advance().await.map_err(|e| ConmanError::Internal {
            message: format!("audit cursor error: {e}"),
        })? {
            let doc = cursor.deserialize_current().map_err(|e| ConmanError::Internal {
                message: format!("audit event deserialization failed: {e}"),
            })?;
            let event: AuditEvent =
                bson::from_document(doc).map_err(|e| ConmanError::Internal {
                    message: format!("audit event conversion failed: {e}"),
                })?;
            events.push(event);
        }

        Ok((events, total))
    }
}

#[async_trait::async_trait]
impl EnsureIndexes for AuditRepo {
    async fn ensure_indexes(&self) -> Result<(), ConmanError> {
        let indexes = vec![
            // Primary query pattern: audit events for a specific entity within an app.
            IndexModel::builder()
                .keys(doc! {
                    "app_id": 1,
                    "entity_type": 1,
                    "entity_id": 1,
                    "occurred_at": -1,
                })
                .build(),

            // Query by actor across an app (e.g., "what did this user do?").
            IndexModel::builder()
                .keys(doc! { "actor_user_id": 1, "occurred_at": -1 })
                .build(),

            // Time-range queries (e.g., "all events in the last 24h").
            IndexModel::builder()
                .keys(doc! { "occurred_at": -1 })
                .build(),

            // Filter by app + action (e.g., "all deployments in this app").
            IndexModel::builder()
                .keys(doc! { "app_id": 1, "action": 1, "occurred_at": -1 })
                .build(),
        ];

        self.collection
            .create_indexes(indexes)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("failed to create audit_events indexes: {e}"),
            })?;

        Ok(())
    }
}

use mongodb::bson::{self, doc, oid::ObjectId, Document};
use mongodb::{Collection, Database, IndexModel};
use mongodb::options::IndexOptions;

use conman_core::models::notification::NotificationPreference;
use conman_core::ConmanError;

/// Repository for the `notification_preferences` collection.
pub struct NotificationPrefRepo {
    collection: Collection<Document>,
}

impl NotificationPrefRepo {
    pub fn new(db: &Database) -> Self {
        Self {
            collection: db.collection("notification_preferences"),
        }
    }

    /// Get notification preferences for a user. If no preference document
    /// exists, returns a default preference with email_enabled = true.
    pub async fn get_or_default(
        &self,
        user_id: &str,
    ) -> Result<NotificationPreference, ConmanError> {
        let filter = doc! { "user_id": user_id };
        let result = self
            .collection
            .find_one(filter)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("failed to query notification preferences: {e}"),
            })?;

        match result {
            Some(doc) => {
                bson::from_document(doc).map_err(|e| ConmanError::Internal {
                    message: format!("notification preference deserialization failed: {e}"),
                })
            }
            None => Ok(NotificationPreference::default_for_user(
                user_id.to_string(),
            )),
        }
    }

    /// Upsert notification preferences for a user. Creates the document if it
    /// does not exist, updates it otherwise.
    pub async fn upsert(
        &self,
        pref: &NotificationPreference,
    ) -> Result<NotificationPreference, ConmanError> {
        let filter = doc! { "user_id": &pref.user_id };
        let update = doc! {
            "$set": {
                "email_enabled": pref.email_enabled,
                "updated_at": bson::DateTime::from_chrono(pref.updated_at),
            },
            "$setOnInsert": {
                "user_id": &pref.user_id,
                "created_at": bson::DateTime::from_chrono(pref.created_at),
            },
        };

        let options = mongodb::options::UpdateOptions::builder()
            .upsert(true)
            .build();

        self.collection
            .update_one(filter, update)
            .with_options(options)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("failed to upsert notification preference: {e}"),
            })?;

        self.get_or_default(&pref.user_id).await
    }

    /// Batch-fetch notification preferences for a list of user IDs.
    /// Users without a preference document are not included in the result
    /// (they are treated as having the default: email_enabled = true).
    pub async fn find_by_user_ids(
        &self,
        user_ids: &[String],
    ) -> Result<Vec<NotificationPreference>, ConmanError> {
        let filter = doc! {
            "user_id": { "$in": user_ids }
        };

        let mut cursor = self
            .collection
            .find(filter)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!("failed to query notification preferences: {e}"),
            })?;

        let mut prefs = Vec::new();
        while cursor.advance().await.map_err(|e| ConmanError::Internal {
            message: format!("notification pref cursor error: {e}"),
        })? {
            let doc = cursor.deserialize_current().map_err(|e| ConmanError::Internal {
                message: format!("notification pref deserialization failed: {e}"),
            })?;
            let pref: NotificationPreference =
                bson::from_document(doc).map_err(|e| ConmanError::Internal {
                    message: format!("notification pref conversion failed: {e}"),
                })?;
            prefs.push(pref);
        }

        Ok(prefs)
    }
}

#[async_trait::async_trait]
impl EnsureIndexes for NotificationPrefRepo {
    async fn ensure_indexes(&self) -> Result<(), ConmanError> {
        let indexes = vec![
            // One preference document per user.
            IndexModel::builder()
                .keys(doc! { "user_id": 1 })
                .options(IndexOptions::builder().unique(true).build())
                .build(),
        ];

        self.collection
            .create_indexes(indexes)
            .await
            .map_err(|e| ConmanError::Internal {
                message: format!(
                    "failed to create notification_preferences indexes: {e}"
                ),
            })?;

        Ok(())
    }
}

// Entity-scoped query: "all audit events for changeset X in app Y"
{ "app_id": 1, "entity_type": 1, "entity_id": 1, "occurred_at": -1 }

// Actor query: "what did this user do recently?"
{ "actor_user_id": 1, "occurred_at": -1 }

// Time-range scan: "all events in the last hour"
{ "occurred_at": -1 }

// Action filter: "all deployment events in app Y"
{ "app_id": 1, "action": 1, "occurred_at": -1 }

{
  "_id": ObjectId("665a1b2c3d4e5f6a70b09040"),
  "occurred_at": ISODate("2025-07-15T14:32:10Z"),
  "actor_user_id": "664f1a2b3c4d5e6f70809001",
  "app_id": "664f1a2b3c4d5e6f70809010",
  "entity_type": "changeset",
  "entity_id": "665a1b2c3d4e5f6a70b09030",
  "action": "submitted",
  "before": { "state": "draft" },
  "after": { "state": "submitted", "head_sha": "abc123def456" },
  "git_sha": "abc123def456",
  "context": {
    "ip": "10.0.1.42",
    "user_agent": "Mozilla/5.0 ...",
    "request_id": "req-550e8400-e29b-41d4-a716-446655440000"
  }
}

{
  "_id": ObjectId("665a1b2c3d4e5f6a70b09041"),
  "occurred_at": ISODate("2025-07-16T00:00:05Z"),
  "actor_user_id": null,
  "app_id": "664f1a2b3c4d5e6f70809010",
  "entity_type": "temp_environment",
  "entity_id": "665a1b2c3d4e5f6a70b09035",
  "action": "expired",
  "before": { "state": "active", "expires_at": "2025-07-16T00:00:00Z" },
  "after": { "state": "expired", "grace_until": "2025-07-16T01:00:00Z" },
  "git_sha": null,
  "context": {
    "ip": null,
    "user_agent": null,
    "request_id": "job-ttl-cleanup-20250716"
  }
}

// One preference per user
{ "user_id": 1 }  // unique: true

{
  "_id": ObjectId("665a1b2c3d4e5f6a70b09050"),
  "user_id": "664f1a2b3c4d5e6f70809001",
  "email_enabled": true,
  "created_at": ISODate("2025-06-01T10:00:00Z"),
  "updated_at": ISODate("2025-07-10T08:30:00Z")
}

{
  "_id": ObjectId("665a1b2c3d4e5f6a70b09051"),
  "user_id": "664f1a2b3c4d5e6f70809002",
  "email_enabled": false,
  "created_at": ISODate("2025-06-02T14:30:00Z"),
  "updated_at": ISODate("2025-06-15T09:00:00Z")
}

{
  "data": {
    "user_id": "664f1a2b3c4d5e6f70809001",
    "email_enabled": true,
    "created_at": "2025-06-01T10:00:00Z",
    "updated_at": "2025-07-10T08:30:00Z"
  }
}

{
  "email_enabled": false
}

{
  "data": {
    "user_id": "664f1a2b3c4d5e6f70809001",
    "email_enabled": false,
    "created_at": "2025-06-01T10:00:00Z",
    "updated_at": "2025-07-15T14:00:00Z"
  }
}

{
  "data": [
    {
      "id": "665a1b2c3d4e5f6a70b09040",
      "occurred_at": "2025-07-15T14:32:10Z",
      "actor_user_id": "664f1a2b3c4d5e6f70809001",
      "app_id": "664f1a2b3c4d5e6f70809010",
      "entity_type": "changeset",
      "entity_id": "665a1b2c3d4e5f6a70b09030",
      "action": "submitted",
      "before": { "state": "draft" },
      "after": { "state": "submitted", "head_sha": "abc123def456" },
      "git_sha": "abc123def456",
      "context": {
        "ip": "10.0.1.42",
        "user_agent": "Mozilla/5.0 ...",
        "request_id": "req-550e8400-e29b-41d4-a716-446655440000"
      }
    }
  ],
  "pagination": { "page": 1, "limit": 20, "total": 142 }
}