//! SynaDB Claim Validation Benchmark
use synadb::{SynaDB, Atom, VectorStore, VectorConfig};
use synadb::distance::DistanceMetric;
use std::time::Instant;

fn benchmark_writes(n: usize) {
    // Benchmark write performance
    let mut db = SynaDB::new("bench_write.db").unwrap();
    let start = Instant::now();
    
    for i in 0..n {
        db.append(&format!("key_{}", i), Atom::Float(i as f64)).unwrap();
    }
    
    let elapsed = start.elapsed().as_secs_f64();
    let rate = n as f64 / elapsed;
    println!("Write: {:.0} ops/sec ({} records in {:.2}s)", rate, n, elapsed);
    println!("{}", if rate >= 100_000.0 { "[PASS]" } else { "[FAIL]" });
}

fn benchmark_reads(n: usize) {
    // Benchmark read performance
    let mut db = SynaDB::new("bench_read.db").unwrap();
    
    // Setup: write data first
    for i in 0..n {
        db.append(&format!("key_{}", i), Atom::Float(i as f64)).unwrap();
    }
    
    let start = Instant::now();
    for i in 0..n {
        let _ = db.get(&format!("key_{}", i)).unwrap();
    }
    
    let elapsed = start.elapsed().as_secs_f64();
    let rate = n as f64 / elapsed;
    println!("Read: {:.0} ops/sec ({} records in {:.2}s)", rate, n, elapsed);
    println!("{}", if rate >= 500_000.0 { "[PASS]" } else { "[FAIL]" });
}

fn benchmark_vector_search(n: usize, dims: u16) {
    // Claim: <10ms search for 1M vectors
    let config = VectorConfig {
        dimensions: dims,
        metric: DistanceMetric::Cosine,
        key_prefix: "vec/".to_string(),
        index_threshold: 10000,
    };
    let mut store = VectorStore::new("bench_vec.db", config).unwrap();
    
    // Insert vectors
    for i in 0..n {
        let vec: Vec<f32> = (0..dims).map(|_| rand::random()).collect();
        store.insert(&format!("v_{}", i), &vec).unwrap();
    }
    store.build_index().unwrap();
    
    // Search
    let query: Vec<f32> = (0..dims).map(|_| rand::random()).collect();
    let start = Instant::now();
    let _ = store.search(&query, 10).unwrap();
    let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0;
    
    println!("Vector Search: {:.2}ms ({} vectors)", elapsed_ms, n);
    println!("{}", if elapsed_ms < 10.0 { "[PASS]" } else { "[FAIL]" });
}

fn main() {
    println!("=== SynaDB Claim Validation (Rust) ===");
    benchmark_writes(1_000_000);
    benchmark_reads(1_000_000);
    benchmark_vector_search(100_000, 768);
}

#!/usr/bin/env python3
"""SynaDB Scale Test: 1M, 10M, 100M Records"""
import time
import os
import numpy as np
from synadb import SynaDB

def scale_test(scale: str):
    scales = {"1m": 1_000_000, "10m": 10_000_000, "100m": 100_000_000}
    n = scales[scale]
    db_path = f"scale_test_{scale}.db"
    
    print(f"\n{'='*50}")
    print(f"Scale Test: {n:,} records")
    print(f"{'='*50}")
    
    # Write test
    db = SynaDB(db_path, sync_on_write=False)  # Disable sync for speed
    
    print(f"\nWriting {n:,} records...")
    start = time.perf_counter()
    batch_size = 100_000
    for batch_start in range(0, n, batch_size):
        batch_end = min(batch_start + batch_size, n)
        for i in range(batch_start, batch_end):
            db.put_float(f"sensor/temp/{i}", 20.0 + (i % 100) * 0.1)
        if (batch_start + batch_size) % 1_000_000 == 0:
            elapsed = time.perf_counter() - start
            rate = (batch_start + batch_size) / elapsed
            print(f"  Progress: {(batch_start + batch_size):,} ({rate:,.0f}/sec)")
    
    write_time = time.perf_counter() - start
    write_rate = n / write_time
    print(f"[OK] Write complete: {write_rate:,.0f} ops/sec")
    
    # File size
    file_size = os.path.getsize(db_path) / (1024 ** 3)  # GB
    print(f"File size: {file_size:.2f} GB")
    
    # Read test (random access)
    print(f"\nReading {min(n, 100_000):,} random records...")
    indices = np.random.randint(0, n, size=min(n, 100_000))
    start = time.perf_counter()
    for i in indices:
        _ = db.get_float(f"sensor/temp/{i}")
    read_time = time.perf_counter() - start
    read_rate = len(indices) / read_time
    print(f"[OK] Read complete: {read_rate:,.0f} ops/sec")
    
    # Recovery test
    db.close()
    print(f"\nTesting crash recovery...")
    start = time.perf_counter()
    db2 = SynaDB(db_path)  # Reopen triggers index rebuild
    recovery_time = time.perf_counter() - start
    recovery_rate = n / recovery_time
    print(f"[OK] Recovery: {recovery_time:.2f}s ({recovery_rate:,.0f} entries/sec)")
    
    # Summary
    print(f"\n{'='*50}")
    print(f"SUMMARY: {scale.upper()}")
    print(f"{'='*50}")
    print(f"Write:    {write_rate:>12,.0f} ops/sec {'[PASS]' if write_rate >= 100_000 else '[FAIL]'}")
    print(f"Read:     {read_rate:>12,.0f} ops/sec {'[PASS]' if read_rate >= 500_000 else '[FAIL]'}")
    print(f"Recovery: {recovery_rate:>12,.0f} entries/sec {'[PASS]' if recovery_rate >= 1_000_000 else '[FAIL]'}")
    print(f"Size:     {file_size:>12.2f} GB")
    
    # Cleanup
    os.remove(db_path)

if __name__ == "__main__":
    import sys
    scale = sys.argv[1] if len(sys.argv) > 1 else "1m"
    scale_test(scale)