use offline_first_core::{AppDbState, LocalDbModel};
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize database
    let db = AppDbState::init("my_database".to_string())?;

    // Create and store data
    let user = LocalDbModel {
        id: "user_123".to_string(),
        hash: "content_hash".to_string(),
        data: json!({"name": "John Doe", "email": "john@example.com"}),
    };

    db.push(user)?;

    // Retrieve data
    let user = db.get_by_id("user_123")?.unwrap();
    println!("User: {}", user.data["name"]);

    Ok(())
}

pub struct LocalDbModel {
    pub id: String,      // Unique identifier (cannot be empty)
    pub hash: String,    // Content hash for versioning
    pub data: JsonValue, // Your JSON data
}

use offline_first_core::{AppDbState, LocalDbModel};
use serde_json::json;

fn save_preferences() -> Result<(), Box<dyn std::error::Error>> {
    let db = AppDbState::init("user_settings".to_string())?;
    
    let preferences = LocalDbModel {
        id: "app_preferences".to_string(),
        hash: "v1.0".to_string(),
        data: json!({
            "theme": "dark",
            "language": "en",
            "notifications": true
        }),
    };
    
    db.push(preferences)?;
    Ok(())
}

fn add_to_cart(product_id: &str, quantity: i32) -> Result<(), Box<dyn std::error::Error>> {
    let db = AppDbState::init("shopping_cart".to_string())?;
    
    let item = LocalDbModel {
        id: product_id.to_string(),
        hash: format!("cart_{}", chrono::Utc::now().timestamp()),
        data: json!({
            "product_id": product_id,
            "quantity": quantity,
            "price": 29.99
        }),
    };
    
    db.push(item)?;
    Ok(())
}

fn cache_article(article_id: &str, content: &str) -> Result<(), Box<dyn std::error::Error>> {
    let db = AppDbState::init("article_cache".to_string())?;
    
    let article = LocalDbModel {
        id: article_id.to_string(),
        hash: format!("article_{}", md5::compute(content)),
        data: json!({
            "title": "Article Title",
            "content": content,
            "cached_at": chrono::Utc::now().to_rfc3339()
        }),
    };
    
    db.push(article)?;
    Ok(())
}

use offline_first_core::{AppDbState, AppResponse};

match db.push(model) {
    Ok(_) => println!("✅ Success"),
    Err(AppResponse::DatabaseError(msg)) => eprintln!("💾 Database error: {}", msg),
    Err(AppResponse::SerializationError(msg)) => eprintln!("📝 JSON error: {}", msg),
    Err(AppResponse::NotFound(msg)) => eprintln!("🔍 Not found: {}", msg),
    Err(other) => eprintln!("🔥 Other error: {}", other),
}

fn bulk_insert(records: Vec<LocalDbModel>) -> Result<usize, Box<dyn std::error::Error>> {
    let db = AppDbState::init("bulk_data".to_string())?;
    let mut success_count = 0;
    
    for model in records {
        if db.push(model).is_ok() {
            success_count += 1;
        }
    }
    
    Ok(success_count)
}

// ❌ Empty IDs not supported
let invalid = LocalDbModel {
    id: "".to_string(), // Will fail!
    // ...
};

// ✅ Always use non-empty IDs
let valid = LocalDbModel {
    id: "user_123".to_string(), // Good!
    // ...
};

// ✅ DO: Reuse connections
let db = AppDbState::init("my_db".to_string())?;
for i in 0..1000 {
    db.push(create_model(i))?; // Efficient
}

// ❌ DON'T: Create new connections
for i in 0..1000 {
    let db = AppDbState::init("my_db".to_string())?; // Slow!
    db.push(create_model(i))?;
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_basic_crud() {
        let db = AppDbState::init("test_db".to_string()).unwrap();
        
        let model = LocalDbModel {
            id: "test_1".to_string(),
            hash: "test_hash".to_string(),
            data: json!({"name": "Test User"}),
        };
        
        // Insert
        assert!(db.push(model).is_ok());
        
        // Read
        let retrieved = db.get_by_id("test_1").unwrap();
        assert!(retrieved.is_some());
        
        // Update
        let mut updated = retrieved.unwrap();
        updated.data["name"] = json!("Updated User");
        assert!(db.update(updated).is_ok());
        
        // Delete
        assert!(db.delete_by_id("test_1").unwrap());
    }
}