Offline Sync

use solidb_client::{SyncManager, SyncConfig, HttpClient, LocalStore};

// Local storage configuration
let local_store = LocalStore::open(
    "/path/to/sync_data.db",   // SQLite database path
    "device-unique-id".to_string()
)?;

// Or use default path (~/.solidb/app_name/)
let local_store = LocalStore::open_default(
    "my_app",                  // Application name
    "device-uuid".to_string()  // Unique device identifier
)?;

// HTTP client for server communication
let client = HttpClient::new(
    "localhost:6745",          // Server address
    5000                       // Timeout in milliseconds
);

// Sync configuration
let config = SyncConfig {
    // Sync interval when online (seconds)
    sync_interval_secs: 30,

    // Maximum changes to push/pull per batch
    batch_size: 100,

    // Retry attempts for failed syncs
    max_retries: 5,

    // Enable automatic background sync
    auto_sync: true,

    // Collections to sync (empty = all collections)
    collections: vec![
        "users".to_string(),
        "orders".to_string(),
    ],
};

// Create and start sync manager
let mut sync_manager = SyncManager::new(local_store, client, config);
let cmd_tx = sync_manager.start().await;

use serde_json::json;

// Save document locally (insert or update)
sync_manager.save_document(
    "users",                    // collection
    "user-456",                 // document key
    &json!({
        "name": "Bob",
        "email": "[email protected]",
        "created_at": "2024-01-15T10:00:00Z",
    })
).await?;

// Get document from local store
let user = sync_manager.get_document("users", "user-456").await?;
// Returns: Option<Value> - None if not found

// Update existing document
sync_manager.save_document(
    "users",
    "user-456",
    &json!({"email": "[email protected]", "status": "active"})
).await?;

// Delete document locally (queued for sync)
sync_manager.delete_document("users", "user-456").await?;

// List all documents in a collection
let docs = sync_manager.query_documents("users").await?;
// Returns: Vec<(String, Value)> - (key, document) pairs

use std::collections::HashMap;
use serde_json::json;

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

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

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

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

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

// Higher-order functions (FILTER, MAP, etc.)
let filtered = sync_manager.query(
    r#"LET adults = FILTER(users, u -> u.age >= 18)
       FOR u IN adults
       RETURN u.name"#,
    None
).await?;

use solidb_client::SyncCommand;

// Start the sync manager (returns command channel)
let cmd_tx = sync_manager.start().await;

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

// Or send sync command through channel
cmd_tx.send(SyncCommand::SyncNow).await?;

// Subscribe to a specific collection
cmd_tx.send(SyncCommand::Subscribe {
    collection: "users".to_string(),
    filter: Some("status == 'active'".to_string()),
}).await?;

// Unsubscribe from a collection
cmd_tx.send(SyncCommand::Unsubscribe {
    collection: "old_collection".to_string(),
}).await?;

// Set online/offline status manually
cmd_tx.send(SyncCommand::SetOnline(false)).await?;  // Go offline
cmd_tx.send(SyncCommand::SetOnline(true)).await?;   // Go online

// Check if currently syncing
let is_syncing = sync_manager.is_syncing().await;

// Check if online
let is_online = sync_manager.is_online().await;

// Stop the sync manager
cmd_tx.send(SyncCommand::Stop).await?;