Offline Sync

use solidb_client::{SyncConfig, ConflictStrategy, StorageEngine};

let config = SyncConfig {
    // Required settings
    database: "production".to_string(),
    local_storage_path: "./sync_data".to_string(),
    
    // Sync behavior
    auto_sync: true,
    sync_interval_seconds: 60,
    push_on_change: true,           // Sync immediately on local changes
    
    // Conflict resolution strategy
    conflict_strategy: ConflictStrategy::LastWriteWins,
    // Other options:
    // - ConflictStrategy::FirstWriteWins
    // - ConflictStrategy::MergeFields
    // - ConflictStrategy::Custom(Box::new(my_resolver))
    
    // Storage engine (default: SQLite)
    storage_engine: StorageEngine::Sqlite,
    // Alternative: StorageEngine::RocksDB
    
    // Selective sync - only sync matching documents
    sync_filter: Some(
        "FOR doc IN users FILTER doc.user_id == @my_id RETURN doc".to_string()
    ),
    sync_filter_params: Some(vec![("my_id", json!("user-123"))].into_iter().collect()),
    
    // Encryption for local storage
    encryption_key: Some("my-secret-key".to_string()),
};

// Insert document locally
let doc = sync_manager.insert_local(
    "users",
    Some("user-456"),           // Optional key (auto-generated if None)
    json!({
        "name": "Bob",
        "email": "[email protected]",
        "created_at": "2024-01-15T10:00:00Z",
    })
).await?;

// Get document from local store
let user = sync_manager.get_local("users", "user-456").await?;

// Update document (merge mode)
let updated = sync_manager.update_local(
    "users",
    "user-456",
    json!({"email": "[email protected]"}),
    true                        // merge = true (partial update)
).await?;

// Update document (replace mode)
let replaced = sync_manager.update_local(
    "users",
    "user-456",
    json!({
        "name": "Bob",
        "email": "[email protected]",
        "status": "active",
    }),
    false                       // merge = false (full replacement)
).await?;

// Delete document locally
sync_manager.delete_local("users", "user-456").await?;

// List documents with pagination
let (docs, total) = sync_manager.list_local(
    "users",
    Some(50),                   // limit
    Some(0),                    // offset
    Some("name ASC"),           // sort
).await?;

// Simple query
let active_users = sync_manager.query_local(
    "FOR u IN users FILTER u.status == 'active' RETURN u",
    None
).await?;

// Query with bind variables
let mut params = HashMap::new();
params.insert("min_age".to_string(), json!(18));
params.insert("status".to_string(), json!("premium"));

let premium_users = sync_manager.query_local(
    r#"FOR u IN users
       FILTER u.age >= @min_age AND u.status == @status
       SORT u.created_at DESC
       RETURN { name: u.name, email: u.email }"#,
    Some(params)
).await?;

// Aggregation queries
let stats = sync_manager.query_local(
    r#"FOR u IN users
       COLLECT status = u.status WITH COUNT INTO count
       RETURN { status, count }"#,
    None
).await?;

// Joins (local data only)
let orders_with_users = sync_manager.query_local(
    r#"FOR o IN orders
       FOR u IN users FILTER u._key == o.user_id
       RETURN { order: o, user: u.name }"#,
    None
).await?;

// Trigger full bidirectional sync
let result = sync_manager.sync().await?;
println!("Pushed: {}, Pulled: {}", result.pushed, result.pulled);
println!("Conflicts: {}", result.conflicts.len());

// Push only (send local changes to server)
let push_result = sync_manager.push().await?;

// Pull only (get server changes)
let pull_result = sync_manager.pull().await?;

// Sync specific collections only
let partial_result = sync_manager.sync_collections(vec!["users", "orders"]).await?;

// Check sync status
let status = sync_manager.sync_status().await;
println!("Pending changes: {}", status.pending_changes);
println!("Last sync: {:?}", status.last_sync_time);
println!("Is syncing: {}", status.is_syncing);

// Pause/resume auto-sync
sync_manager.pause_sync().await?;
// ... do work without syncing ...
sync_manager.resume_sync().await?;

// Force full re-sync (download everything)
sync_manager.full_resync().await?;