eidetica/sync/

user.rs

//! User synchronization methods for the sync system.

use tracing::{debug, info};

use super::{Sync, SyncError, user_sync_manager::UserSyncManager};
use crate::{
    Database, Result, Snapshot, entry::ID, instance::settings_merge::merge_sync_settings,
    store::Table, user::types::TrackedDatabase,
};

impl Sync {
    // === User Synchronization Methods ===

    /// Synchronize a user's preferences with the sync system.
    ///
    /// This establishes tracking for a user's preferences database and synchronizes
    /// their current preferences to the sync tree. The sync system will monitor the
    /// user's preferences and automatically sync databases according to their settings.
    ///
    /// This method ensures the user is tracked and reads their preferences database
    /// to update sync configuration. It detects changes via tip comparison and only
    /// processes updates when preferences have changed.
    ///
    /// This operation is idempotent and can be called multiple times safely.
    ///
    /// **CRITICAL**: All updates to the sync tree happen in a single transaction
    /// to ensure atomicity.
    ///
    /// # Arguments
    /// * `user_uuid` - The user's unique identifier
    /// * `preferences_db_id` - The ID of the user's private database
    ///
    /// # Returns
    /// A Result indicating success or an error.
    ///
    /// # Example
    /// ```rust,ignore
    /// // After creating or logging in a user
    /// let user = instance.login_user("alice", Some("password"))?;
    /// sync.sync_user(user.user_uuid(), user.user_database().root_id())?;
    /// ```
    pub async fn sync_user(
        &self,
        user_uuid: impl AsRef<str>,
        preferences_db_id: &ID,
    ) -> Result<()> {
        let user_uuid_str = user_uuid.as_ref();

        // CRITICAL: Single transaction for all sync tree updates
        let tx = self.sync_tree.new_transaction().await?;
        let user_mgr = UserSyncManager::new(&tx);

        // Ensure user is tracked, get their current preferences state
        let old_tips = match user_mgr.get_tracked_user_state(user_uuid_str).await? {
            Some((_stored_prefs_db_id, tips)) => tips,
            None => {
                // User not yet tracked - register them
                user_mgr
                    .track_user_preferences(user_uuid_str, preferences_db_id)
                    .await?;
                Vec::new() // Empty tips means this is first sync
            }
        };

        // Open user's preferences database with device key (Read permission)
        let instance = self.instance.upgrade().ok_or(SyncError::InstanceDropped)?;
        let device_key = instance.signing_key()?.clone();
        let prefs_db = Database::open(&instance, preferences_db_id)
            .await?
            .with_key(device_key.clone());
        let current_snapshot = prefs_db.snapshot().await?;

        // Check if preferences have changed via snapshot comparison (set-equal).
        if current_snapshot == Snapshot::from(old_tips.clone()) {
            debug!(user_uuid = %user_uuid_str, "No changes to user preferences, skipping update");
            return Ok(());
        }

        debug!(user_uuid = %user_uuid_str, "User preferences changed, updating sync configuration");

        // Read all tracked databases
        let databases_table = prefs_db
            .get_store_viewer::<Table<TrackedDatabase>>("databases")
            .await?;
        let all_tracked = databases_table.search(|_| true).await?; // Get all entries

        // Get databases user previously tracked
        let old_databases = user_mgr.get_linked_databases(user_uuid_str).await?;

        // Build set of current database IDs
        let current_databases: std::collections::HashSet<_> = all_tracked
            .iter()
            .map(|(_uuid, tracked)| tracked)
            .filter(|t| t.sync_settings.sync_enabled)
            .map(|t| t.database_id.clone())
            .collect();

        // Track which databases need settings recomputation
        let mut affected_databases = std::collections::HashSet::new();

        // Remove user from databases they no longer track
        for old_db in &old_databases {
            if !current_databases.contains(old_db) {
                user_mgr
                    .unlink_user_from_database(old_db, user_uuid_str)
                    .await?;
                affected_databases.insert(old_db.clone());
                debug!(user_uuid = %user_uuid_str, database_id = %old_db, "Removed user from database");
            }
        }

        // Add/update user for current databases
        for (_uuid, tracked) in &all_tracked {
            if tracked.sync_settings.sync_enabled {
                user_mgr
                    .link_user_to_database(&tracked.database_id, user_uuid_str)
                    .await?;
                affected_databases.insert(tracked.database_id.clone());
            }
        }

        // Recompute combined settings for all affected databases
        let affected_count = affected_databases.len();
        for db_id in affected_databases {
            let users = user_mgr.get_linked_users(&db_id).await?;

            if users.is_empty() {
                // unlink_user_from_database removes the whole record, including
                // stale combined settings, when the last user leaves.
                continue;
            }

            // Collect settings from all users tracking this database
            let instance = self.instance.upgrade().ok_or(SyncError::InstanceDropped)?;
            let device_key = instance.signing_key()?.clone();
            let mut settings_list = Vec::new();
            for uuid in &users {
                // Read preferences from each user's database using device key (Read permission)
                if let Some((user_prefs_db_id, _)) = user_mgr.get_tracked_user_state(uuid).await? {
                    let user_db = Database::open(&instance, &user_prefs_db_id)
                        .await?
                        .with_key(device_key.clone());
                    let user_table = user_db
                        .get_store_viewer::<Table<TrackedDatabase>>("databases")
                        .await?;

                    // Find this database's settings
                    for (_key, tracked) in user_table.search(|_| true).await? {
                        if tracked.database_id == db_id && tracked.sync_settings.sync_enabled {
                            settings_list.push(tracked.sync_settings.clone());
                            break;
                        }
                    }
                }
            }

            // Merge settings using most aggressive strategy
            if !settings_list.is_empty() {
                let combined = merge_sync_settings(settings_list);
                user_mgr.set_combined_settings(&db_id, &combined).await?;
                debug!(database_id = %db_id, "Updated combined settings for database");
            }
        }

        // Update stored tips to reflect processed state
        user_mgr
            .update_tracked_tips(user_uuid_str, current_snapshot.tips())
            .await?;

        // Commit all changes atomically
        tx.commit().await?;

        info!(user_uuid = %user_uuid_str, affected_count = affected_count, "Updated user database sync configuration");
        Ok(())
    }

    /// Remove a user from the sync system.
    ///
    /// Removes all tracking for this user and updates affected databases'
    /// combined settings. This should be called when a user is deleted.
    ///
    /// # Arguments
    /// * `user_uuid` - The user's unique identifier
    ///
    /// # Returns
    /// A Result indicating success or an error.
    pub async fn remove_user(&self, user_uuid: impl AsRef<str>) -> Result<()> {
        let user_uuid_str = user_uuid.as_ref();
        let tx = self.sync_tree.new_transaction().await?;
        let user_mgr = UserSyncManager::new(&tx);

        // Get all databases this user was tracking
        let databases = user_mgr.get_linked_databases(user_uuid_str).await?;

        // Remove user from each database
        for db_id in &databases {
            user_mgr
                .unlink_user_from_database(db_id, user_uuid_str)
                .await?;

            // Recompute combined settings for this database
            let remaining_users = user_mgr.get_linked_users(db_id).await?;
            if remaining_users.is_empty() {
                // No more users, settings will be cleared automatically
                continue;
            }

            // Recompute settings from remaining users
            // (simplified - in practice would read each user's preferences)
            // For now, just note that settings need updating
            debug!(database_id = %db_id, "Database needs settings recomputation after user removal");
        }

        tx.commit().await?;

        info!(user_uuid = %user_uuid_str, database_count = databases.len(), "Removed user from sync system");
        Ok(())
    }
}