ugnos 0.6.0

#![allow(unused_imports)] // Allow unused imports for now during development

use std::collections::HashMap;
use std::fs;
use std::ops::Range;
use std::path::PathBuf;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
use std::time::SystemTime;
use ugnos::*;

// Helper function to create a TagSet from a slice of tuples
fn tags_from(pairs: &[(&str, &str)]) -> TagSet {
    pairs
        .iter()
        .map(|(k, v)| (k.to_string(), v.to_string()))
        .collect()
}

// Helper function to sort query results for comparison
fn sort_results(results: &mut [(Timestamp, Value)]) {
    results.sort_by_key(|&(ts, _)| ts);
}

// Helper function to create and clean test directories
fn setup_test_dir(dir_name: &str) -> PathBuf {
    let path = PathBuf::from(format!("./test_{}", dir_name));
    // Clean up any previous test data
    let _ = fs::remove_dir_all(&path);
    fs::create_dir_all(&path).unwrap();
    path
}

#[test]
fn test_insert_and_query_single_series() {
    // Use a short flush interval for testing
    let data_dir = setup_test_dir("insert_and_query_single_series");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    let series_name = "test_series_1";

    let tags1 = tags_from(&[("host", "serverA"), ("region", "us-east")]);
    let tags2 = tags_from(&[("host", "serverB"), ("region", "us-west")]);

    db.insert(series_name, 100, 10.5, tags1.clone()).unwrap();
    db.insert(series_name, 200, 11.0, tags1.clone()).unwrap();
    db.insert(series_name, 300, 12.5, tags2.clone()).unwrap();
    db.insert(series_name, 150, 9.0, tags1.clone()).unwrap(); // Out of order insert

    // Wait longer than flush interval to ensure data is persisted
    // Or trigger flush manually for deterministic tests
    db.flush().unwrap();

    // Query all data
    let mut results_all = db.query(series_name, 0..400, None).unwrap();
    sort_results(&mut results_all);
    assert_eq!(results_all.len(), 4);
    assert_eq!(
        results_all,
        vec![(100, 10.5), (150, 9.0), (200, 11.0), (300, 12.5)]
    );

    // Query specific time range
    let mut results_range = db.query(series_name, 120..250, None).unwrap();
    sort_results(&mut results_range);
    assert_eq!(results_range.len(), 2);
    assert_eq!(results_range, vec![(150, 9.0), (200, 11.0)]);

    // Query with tag filter (match)
    let filter1 = tags_from(&[("host", "serverA")]);
    let mut results_tag1 = db.query(series_name, 0..400, Some(&filter1)).unwrap();
    sort_results(&mut results_tag1);
    assert_eq!(results_tag1.len(), 3);
    assert_eq!(results_tag1, vec![(100, 10.5), (150, 9.0), (200, 11.0)]);

    // Query with tag filter (match multiple)
    let filter1_full = tags_from(&[("host", "serverA"), ("region", "us-east")]);
    let mut results_tag1_full = db.query(series_name, 0..400, Some(&filter1_full)).unwrap();
    sort_results(&mut results_tag1_full);
    assert_eq!(results_tag1_full.len(), 3);
    assert_eq!(
        results_tag1_full,
        vec![(100, 10.5), (150, 9.0), (200, 11.0)]
    );

    // Query with tag filter (match other tags)
    let filter2 = tags_from(&[("region", "us-west")]);
    let mut results_tag2 = db.query(series_name, 0..400, Some(&filter2)).unwrap();
    sort_results(&mut results_tag2);
    assert_eq!(results_tag2.len(), 1);
    assert_eq!(results_tag2, vec![(300, 12.5)]);

    // Query with tag filter (no match)
    let filter_no_match = tags_from(&[("host", "serverC")]);
    let results_no_match = db
        .query(series_name, 0..400, Some(&filter_no_match))
        .unwrap();
    assert!(results_no_match.is_empty());

    // Query with tag filter (partial match but not all)
    let filter_partial = tags_from(&[("host", "serverA"), ("region", "us-west")]);
    let results_partial = db
        .query(series_name, 0..400, Some(&filter_partial))
        .unwrap();
    assert!(results_partial.is_empty());
}

#[test]
fn test_query_non_existent_series() {
    let data_dir = setup_test_dir("query_non_existent_series");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    let result = db.query("non_existent_series", 0..100, None);
    match result {
        Err(DbError::SeriesNotFound(name)) => assert_eq!(name, "non_existent_series"),
        _ => panic!("Expected SeriesNotFound error"),
    }
}

#[test]
fn test_insert_multiple_series() {
    let data_dir = setup_test_dir("insert_multiple_series");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    let series1 = "cpu_usage";
    let series2 = "memory_usage";

    let tags_s1 = tags_from(&[("host", "server1")]);
    let tags_s2 = tags_from(&[("host", "server2")]);

    db.insert(series1, 100, 0.8, tags_s1.clone()).unwrap();
    db.insert(series2, 110, 55.2, tags_s2.clone()).unwrap();
    db.insert(series1, 200, 0.7, tags_s1.clone()).unwrap();
    db.insert(series2, 210, 56.8, tags_s2.clone()).unwrap();

    db.flush().unwrap();

    // Query series 1
    let mut results1 = db.query(series1, 0..300, None).unwrap();
    sort_results(&mut results1);
    assert_eq!(results1, vec![(100, 0.8), (200, 0.7)]);

    // Query series 2
    let mut results2 = db.query(series2, 0..300, None).unwrap();
    sort_results(&mut results2);
    assert_eq!(results2, vec![(110, 55.2), (210, 56.8)]);
}

#[test]
fn test_concurrent_inserts() {
    let data_dir = setup_test_dir("concurrent_inserts");
    let config = DbConfig {
        flush_interval: Duration::from_millis(20),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = Arc::new(DbCore::with_config(config).unwrap()); // Use Arc for sharing across threads
    let num_threads = 4;
    let points_per_thread = 100;
    let series_name = "concurrent_series";

    let mut handles = vec![];

    for i in 0..num_threads {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            let start_ts = (i * points_per_thread) as u64;
            for j in 0..points_per_thread {
                let ts = start_ts + j as u64;
                let val = ts as f64 * 1.1;
                let tags =
                    tags_from(&[("thread_id", &i.to_string()), ("point_id", &j.to_string())]);
                db_clone.insert(series_name, ts, val, tags).unwrap();
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    // Flush and wait
    db.flush().unwrap();

    // Query all data
    let total_points = num_threads * points_per_thread;
    let results = db
        .query(series_name, 0..(total_points as u64), None)
        .unwrap();

    assert_eq!(results.len(), total_points);

    // Optional: Verify some specific points or properties if needed
    // (Sorting and checking exact values might be complex due to potential minor timing variations)
    let mut timestamps: Vec<u64> = results.iter().map(|(ts, _)| *ts).collect();
    timestamps.sort();
    for i in 0..(total_points as u64) {
        assert_eq!(timestamps[i as usize], i);
    }
}

#[test]
fn test_invalid_time_range() {
    let data_dir = setup_test_dir("invalid_time_range");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    db.insert("test", 100, 1.0, TagSet::new()).unwrap();
    db.flush().unwrap();

    // Intentionally use an invalid range (start > end) to assert API returns InvalidTimeRange.
    #[allow(clippy::reversed_empty_ranges)]
    let result = db.query("test", 100..50, None);
    match result {
        Err(DbError::InvalidTimeRange { start, end }) => {
            assert_eq!(start, 100);
            assert_eq!(end, 50);
        }
        _ => panic!("Expected InvalidTimeRange error"),
    }

    let result_equal = db.query("test", 100..100, None);
    match result_equal {
        Err(DbError::InvalidTimeRange { start, end }) => {
            assert_eq!(start, 100);
            assert_eq!(end, 100);
        }
        _ => panic!("Expected InvalidTimeRange error for equal start/end"),
    }
}

#[test]
fn test_snapshot_and_recover() {
    // Create a test directory
    let data_dir = setup_test_dir("snapshot_recover");

    // Configure database with persistence enabled
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir: data_dir.clone(),
        wal_buffer_size: 10,
        enable_wal: true,
        enable_snapshots: true,
        snapshot_interval: Duration::from_secs(10), // Long enough to not trigger automatically
        enable_segments: false,
        ..DbConfig::default()
    };

    // Lists to store timestamps for verification
    let mut pre_snapshot_timestamps = Vec::new();
    let mut post_snapshot_timestamps = Vec::new();

    // Create database and insert test data
    {
        let db = DbCore::with_config(config.clone()).unwrap();
        let series_name = "test_snapshot_series";

        let tags1 = tags_from(&[("host", "serverA"), ("region", "us-east")]);
        let tags2 = tags_from(&[("host", "serverB"), ("region", "us-west")]);

        println!("Inserting pre-snapshot data...");
        // Insert initial batch with real timestamps (100 points)
        for i in 0..100 {
            // Use current system time + incremental offset for unique timestamps
            let timestamp = SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64
                + i;

            let val = i as f64 * 1.5;
            let tags = if i % 2 == 0 {
                tags1.clone()
            } else {
                tags2.clone()
            };
            db.insert(series_name, timestamp, val, tags).unwrap();
            pre_snapshot_timestamps.push((timestamp, val));

            // Small sleep to ensure unique timestamps
            std::thread::sleep(Duration::from_nanos(1));
        }

        // Flush data to storage
        db.flush().unwrap();
        thread::sleep(Duration::from_millis(100));

        println!("Creating snapshot...");
        // Create snapshot
        db.snapshot().unwrap();
        thread::sleep(Duration::from_millis(100)); // Give time for snapshot to complete

        println!("Inserting post-snapshot data...");
        // Insert additional data after snapshot (50 points)
        for i in 0..50 {
            // Use current system time + incremental offset for unique timestamps
            let timestamp = SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64
                + i;

            let val = i as f64 * 2.0;
            let tags = if i % 2 == 0 {
                tags1.clone()
            } else {
                tags2.clone()
            };
            db.insert(series_name, timestamp, val, tags).unwrap();
            post_snapshot_timestamps.push((timestamp, val));

            // Small sleep to ensure unique timestamps
            std::thread::sleep(Duration::from_nanos(1));
        }

        // Flush again to ensure WAL has the newer entries
        db.flush().unwrap();
        thread::sleep(Duration::from_millis(100));

        // DB will be dropped here and WAL should be flushed
        println!("First DB instance being dropped...");
    }

    println!("Creating new DB instance and recovering data...");
    // Now create a new DB instance and recover data
    {
        let mut db = DbCore::with_config(config).unwrap();

        // Recover data
        db.recover().unwrap();

        // Verify all data was recovered
        let series_name = "test_snapshot_series";

        // Create timestamp range that covers all our data
        let min_ts = pre_snapshot_timestamps
            .iter()
            .chain(post_snapshot_timestamps.iter())
            .map(|(ts, _)| *ts)
            .min()
            .unwrap_or(0);

        let max_ts = pre_snapshot_timestamps
            .iter()
            .chain(post_snapshot_timestamps.iter())
            .map(|(ts, _)| *ts)
            .max()
            .unwrap_or(u64::MAX);

        let mut results = db.query(series_name, min_ts..(max_ts + 1), None).unwrap();
        sort_results(&mut results);

        println!(
            "Expected {} total points ({} pre-snapshot, {} post-snapshot)",
            pre_snapshot_timestamps.len() + post_snapshot_timestamps.len(),
            pre_snapshot_timestamps.len(),
            post_snapshot_timestamps.len()
        );
        println!("Recovered {} points", results.len());

        // Both pre-snapshot and post-snapshot data should be recovered
        assert_eq!(
            results.len(),
            pre_snapshot_timestamps.len() + post_snapshot_timestamps.len(),
            "Expected {} total points, but got {}",
            pre_snapshot_timestamps.len() + post_snapshot_timestamps.len(),
            results.len()
        );

        // Check that pre-snapshot points were recovered
        for (timestamp, value) in &pre_snapshot_timestamps {
            assert!(
                results.contains(&(*timestamp, *value)),
                "Pre-snapshot point ({}, {}) not found in recovered data",
                timestamp,
                value
            );
        }

        // Check that post-snapshot points were recovered (critical test)
        for (timestamp, value) in &post_snapshot_timestamps {
            assert!(
                results.contains(&(*timestamp, *value)),
                "Post-snapshot point ({}, {}) not found in recovered data",
                timestamp,
                value
            );
        }

        println!("All data points were successfully recovered!");
    }

    // Clean up
    let _ = fs::remove_dir_all(data_dir);
}

#[test]
fn test_recover_with_no_persistence() {
    // Create config with persistence disabled
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir: PathBuf::from("./temp_no_persistence"),
        wal_buffer_size: 10,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(10),
        enable_segments: false,
        ..DbConfig::default()
    };

    // Create database
    let mut db = DbCore::with_config(config).unwrap();

    // Recover should succeed even with no persistence enabled
    let result = db.recover();
    assert!(result.is_ok());
}

#[test]
fn test_wal_recovery_only() {
    // Create a test directory
    let data_dir = setup_test_dir("wal_only");

    // Configure database with WAL only (no snapshots)
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir: data_dir.clone(),
        wal_buffer_size: 10,
        enable_wal: true,
        enable_snapshots: false, // No snapshots
        snapshot_interval: Duration::from_secs(10),
        enable_segments: false,
        ..DbConfig::default()
    };

    // Create database and insert test data
    {
        let db = DbCore::with_config(config.clone()).unwrap();
        let series_name = "test_wal_series";

        let tags = tags_from(&[("host", "serverA"), ("region", "us-east")]);

        for i in 0..50 {
            let ts = 1000 + i * 10;
            let val = i as f64;
            db.insert(series_name, ts, val, tags.clone()).unwrap();
        }

        // Flush data to storage and WAL
        db.flush().unwrap();
        thread::sleep(Duration::from_millis(100));

        // DB will be dropped here and WAL should be flushed
    }

    // Now create a new DB instance and recover data
    {
        let mut db = DbCore::with_config(config).unwrap();

        // Recover data
        db.recover().unwrap();

        // Verify all data was recovered from WAL
        let series_name = "test_wal_series";
        let mut results = db.query(series_name, 0..2000, None).unwrap();
        sort_results(&mut results);

        // Should have 50 points
        assert_eq!(results.len(), 50);

        // Check some specific points
        assert!(results.contains(&(1000, 0.0))); // First point
        assert!(results.contains(&(1490, 49.0))); // Last point

        // Verify timestamps are as expected
        for i in 0..50 {
            let ts = 1000 + i * 10;
            let val = i as f64;
            assert!(results.contains(&(ts, val)));
        }
    }

    // Clean up
    let _ = fs::remove_dir_all(data_dir);
}

#[test]
fn test_snapshot_method_error() {
    // Create a test directory and clean it up at the end
    let data_dir = setup_test_dir("snapshot_method_error");

    // Configure database with snapshots disabled
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir: data_dir.clone(),
        wal_buffer_size: 10,
        enable_wal: true,
        enable_snapshots: false, // Snapshots disabled
        snapshot_interval: Duration::from_secs(10),
        enable_segments: false,
        ..DbConfig::default()
    };

    // Create database
    let db = DbCore::with_config(config).unwrap();

    // Snapshot should fail because it's disabled
    let result = db.snapshot();
    assert!(result.is_err());

    if let Err(DbError::ConfigError(msg)) = result {
        assert!(msg.contains("Snapshots are not enabled"));
    } else {
        panic!("Expected ConfigError but got something else");
    }

    // Clean up
    let _ = fs::remove_dir_all(data_dir);
}

#[test]
fn test_wal_recovery_after_snapshot() {
    // Create a test directory
    let data_dir = setup_test_dir("snapshot_wal_recovery");

    // Configure database with persistence enabled
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir: data_dir.clone(),
        wal_buffer_size: 5, // Small buffer to ensure frequent WAL writes
        enable_wal: true,
        enable_snapshots: true,
        snapshot_interval: Duration::from_secs(10),
        enable_segments: false,
        ..DbConfig::default()
    };

    let series_name = "test_recovery_series";

    // Track data for verification
    let mut pre_snapshot_timestamps = Vec::new();
    let mut post_snapshot_timestamps = Vec::new();
    let mut unflushed_timestamps = Vec::new();

    // Create database, create snapshot, then insert more data
    {
        let db = DbCore::with_config(config.clone()).unwrap();

        // Insert initial batch (10 points)
        let tags = tags_from(&[("host", "server1"), ("region", "us-east")]);
        for i in 0..10 {
            // Use real system timestamps
            let timestamp = SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64
                + i;

            let val = i as f64;
            db.insert(series_name, timestamp, val, tags.clone())
                .unwrap();
            pre_snapshot_timestamps.push((timestamp, val));

            // Small sleep to ensure unique timestamps
            std::thread::sleep(Duration::from_nanos(1));
        }

        // Force a flush
        db.flush().unwrap();
        thread::sleep(Duration::from_millis(100));

        // Create a snapshot
        db.snapshot().unwrap();
        thread::sleep(Duration::from_millis(100));

        // Insert a second batch after the snapshot (10 more points)
        for i in 10..20 {
            // Use real system timestamps
            let timestamp = SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64
                + i;

            let val = i as f64;
            db.insert(series_name, timestamp, val, tags.clone())
                .unwrap();
            post_snapshot_timestamps.push((timestamp, val));

            // Small sleep to ensure unique timestamps
            std::thread::sleep(Duration::from_nanos(1));
        }

        // Force flush to ensure WAL entries are written
        db.flush().unwrap();
        thread::sleep(Duration::from_millis(100));

        // Insert a third batch without flushing (might not be recovered depending on implementation)
        for i in 20..30 {
            // Use real system timestamps
            let timestamp = SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64
                + i;

            let val = i as f64;
            db.insert(series_name, timestamp, val, tags.clone())
                .unwrap();
            unflushed_timestamps.push((timestamp, val));

            // Small sleep to ensure unique timestamps
            std::thread::sleep(Duration::from_nanos(1));
        }

        // Don't flush explicitly - test if WAL auto-flush on drop works
    }

    // Create a new instance and recover
    {
        let mut db = DbCore::with_config(config).unwrap();
        db.recover().unwrap();

        // Calculate query range
        let min_ts = pre_snapshot_timestamps
            .iter()
            .chain(post_snapshot_timestamps.iter())
            .chain(unflushed_timestamps.iter())
            .map(|(ts, _)| *ts)
            .min()
            .unwrap_or(0);

        let max_ts = pre_snapshot_timestamps
            .iter()
            .chain(post_snapshot_timestamps.iter())
            .chain(unflushed_timestamps.iter())
            .map(|(ts, _)| *ts)
            .max()
            .unwrap_or(u64::MAX);

        // Query all data
        let mut results = db.query(series_name, min_ts..(max_ts + 1), None).unwrap();
        sort_results(&mut results);

        // Should have at least 20 points (pre-snapshot + post-snapshot), possibly 30 if WAL auto-flush works
        let expected_min = pre_snapshot_timestamps.len() + post_snapshot_timestamps.len();
        let expected_max = expected_min + unflushed_timestamps.len();

        println!("Recovered {} points", results.len());
        println!(
            "Expected between {} and {} points",
            expected_min, expected_max
        );

        assert!(
            results.len() >= expected_min,
            "Expected at least {} points, got {}",
            expected_min,
            results.len()
        );

        // Verify all pre-snapshot points were recovered
        for (timestamp, value) in &pre_snapshot_timestamps {
            assert!(
                results.contains(&(*timestamp, *value)),
                "Pre-snapshot point ({}, {}) not found in recovered data",
                timestamp,
                value
            );
        }

        // Verify all post-snapshot points were recovered
        for (timestamp, value) in &post_snapshot_timestamps {
            assert!(
                results.contains(&(*timestamp, *value)),
                "Post-snapshot point ({}, {}) not found in recovered data",
                timestamp,
                value
            );
        }

        // If we recovered more than 20 points, check which unflushed points were recovered
        if results.len() > expected_min {
            let unflushed_recovered = unflushed_timestamps
                .iter()
                .filter(|(ts, val)| results.contains(&(*ts, *val)))
                .count();

            println!(
                "Recovered {}/{} points from unflushed batch (auto-flush on drop)",
                unflushed_recovered,
                unflushed_timestamps.len()
            );
        }
    }

    // Clean up
    let _ = fs::remove_dir_all(data_dir);
}

#[test]
fn test_empty_inserts_and_tags() {
    let data_dir = setup_test_dir("empty_inserts_and_tags");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();

    // Test with empty tag set
    let empty_tags = TagSet::new();
    let series_name = "empty_tags_series";

    // Insert with empty tags
    let timestamp = SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos() as u64;

    db.insert(series_name, timestamp, 42.0, empty_tags.clone())
        .unwrap();
    db.flush().unwrap();

    // Query with empty tag filter
    let results = db
        .query(series_name, 0..(timestamp + 1), Some(&empty_tags))
        .unwrap();
    assert_eq!(results.len(), 1);
    assert_eq!(results[0], (timestamp, 42.0));

    // Test series with no data
    let empty_series = "no_data_series";
    let results = db.query(empty_series, 0..u64::MAX, None);
    assert!(matches!(results, Err(DbError::SeriesNotFound(_))));

    // Query with non-matching tag filter
    let non_matching_tags = tags_from(&[("region", "nowhere")]);
    let results = db
        .query(series_name, 0..(timestamp + 1), Some(&non_matching_tags))
        .unwrap();
    assert_eq!(
        results.len(),
        0,
        "Query with non-matching tags should return empty results"
    );

    // Test with flush on empty buffer
    db.flush().unwrap();
}

#[test]
fn test_large_number_of_points() {
    // Create DB with short flush interval for testing
    let data_dir = setup_test_dir("large_number_of_points");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    let series_name = "large_series";

    // Number of points to insert
    let num_points = 10_000; // 10k points

    println!("Inserting {} points...", num_points);
    let start_time = std::time::Instant::now();

    // Insert a large number of points with real timestamps
    for i in 0..num_points {
        let timestamp = SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64
            + i as u64;

        let value = i as f64 * 0.1;

        // Alternate between different tag sets
        let tags = if i % 3 == 0 {
            tags_from(&[("region", "us-east"), ("host", "server1")])
        } else if i % 3 == 1 {
            tags_from(&[("region", "us-west"), ("host", "server2")])
        } else {
            tags_from(&[("region", "eu-central"), ("host", "server3")])
        };

        db.insert(series_name, timestamp, value, tags).unwrap();

        // Add small sleep occasionally to ensure unique timestamps and prevent resource exhaustion
        if i % 1000 == 0 {
            thread::sleep(Duration::from_nanos(1));
        }
    }

    let insert_duration = start_time.elapsed();
    println!("Inserted {} points in {:?}", num_points, insert_duration);

    // Flush and ensure data is persisted
    db.flush().unwrap();

    // Get min and max timestamps for querying
    let min_timestamp = SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos() as u64;
    let max_timestamp = min_timestamp + num_points as u64;

    // Query with different filters to verify data integrity
    let query_start = std::time::Instant::now();

    // Query us-east region (should be ~1/3 of points)
    let us_east_filter = tags_from(&[("region", "us-east")]);
    let us_east_results = db
        .query(series_name, 0..max_timestamp, Some(&us_east_filter))
        .unwrap();
    assert!(
        us_east_results.len() > num_points / 4,
        "Expected at least 1/4 of points in us-east"
    );
    assert!(
        us_east_results.len() < num_points / 2,
        "Expected less than 1/2 of points in us-east"
    );

    // Query eu-central + server3 (should be ~1/3 of points)
    let eu_server3_filter = tags_from(&[("region", "eu-central"), ("host", "server3")]);
    let eu_server3_results = db
        .query(series_name, 0..max_timestamp, Some(&eu_server3_filter))
        .unwrap();
    assert!(
        eu_server3_results.len() > num_points / 4,
        "Expected at least 1/4 of points for eu-central+server3"
    );
    assert!(
        eu_server3_results.len() < num_points / 2,
        "Expected less than 1/2 of points for eu-central+server3"
    );

    // Query all points
    let all_results = db.query(series_name, 0..max_timestamp, None).unwrap();
    assert_eq!(
        all_results.len(),
        num_points,
        "All points should be returned in full query"
    );

    let query_duration = query_start.elapsed();
    println!("Queried {} points in {:?}", num_points, query_duration);
}

#[test]
fn test_specific_tag_combinations() {
    let data_dir = setup_test_dir("specific_tag_combinations");
    let config = DbConfig {
        flush_interval: Duration::from_millis(50),
        data_dir,
        enable_segments: true,
        enable_wal: false,
        enable_snapshots: false,
        snapshot_interval: Duration::from_secs(60 * 60),
        ..DbConfig::default()
    };
    let db = DbCore::with_config(config).unwrap();
    let series_name = "tag_combinations";

    // Create points with various tag combinations
    let test_data = vec![
        // Hierarchical tags: region > datacenter > rack > host
        (
            tags_from(&[
                ("region", "us-east"),
                ("datacenter", "dc1"),
                ("rack", "r1"),
                ("host", "h1"),
                ("service", "api"),
            ]),
            100.0,
        ),
        (
            tags_from(&[
                ("region", "us-east"),
                ("datacenter", "dc1"),
                ("rack", "r1"),
                ("host", "h2"),
                ("service", "db"),
            ]),
            200.0,
        ),
        (
            tags_from(&[
                ("region", "us-east"),
                ("datacenter", "dc1"),
                ("rack", "r2"),
                ("host", "h3"),
                ("service", "api"),
            ]),
            300.0,
        ),
        (
            tags_from(&[
                ("region", "us-east"),
                ("datacenter", "dc2"),
                ("rack", "r3"),
                ("host", "h4"),
                ("service", "cache"),
            ]),
            400.0,
        ),
        (
            tags_from(&[
                ("region", "us-west"),
                ("datacenter", "dc3"),
                ("rack", "r4"),
                ("host", "h5"),
                ("service", "api"),
            ]),
            500.0,
        ),
        (
            tags_from(&[
                ("region", "us-west"),
                ("datacenter", "dc3"),
                ("rack", "r4"),
                ("host", "h6"),
                ("service", "db"),
            ]),
            600.0,
        ),
        // Multiple values for the same keys (different points)
        (
            tags_from(&[("os", "linux"), ("version", "ubuntu"), ("kernel", "5.4")]),
            700.0,
        ),
        (
            tags_from(&[("os", "linux"), ("version", "centos"), ("kernel", "4.18")]),
            800.0,
        ),
        (
            tags_from(&[
                ("os", "windows"),
                ("version", "server2019"),
                ("kernel", "10.0"),
            ]),
            900.0,
        ),
        // Special characters in tags
        (
            tags_from(&[
                ("user-agent", "Mozilla/5.0"),
                ("path", "/api/v1/users"),
                ("status", "200"),
            ]),
            1000.0,
        ),
        // Empty tag values and unicode
        (
            tags_from(&[("tag_with_empty_value", ""), ("unicode", "你好世界")]),
            1100.0,
        ),
        // Many tags on a single point
        (
            tags_from(&[
                ("t1", "v1"),
                ("t2", "v2"),
                ("t3", "v3"),
                ("t4", "v4"),
                ("t5", "v5"),
                ("t6", "v6"),
                ("t7", "v7"),
                ("t8", "v8"),
                ("t9", "v9"),
                ("t10", "v10"),
            ]),
            1200.0,
        ),
    ];

    // Insert all test data with real timestamps
    for (i, (tags, value)) in test_data.iter().enumerate() {
        let timestamp = SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64
            + i as u64;

        db.insert(series_name, timestamp, *value, tags.clone())
            .unwrap();

        // Small sleep to ensure unique timestamps
        thread::sleep(Duration::from_nanos(1));
    }

    // Flush to ensure all data is persisted
    db.flush().unwrap();

    // Query with various tag filters

    // 1. Hierarchical query (region + datacenter)
    let region_dc_filter = tags_from(&[("region", "us-east"), ("datacenter", "dc1")]);
    let region_dc_results = db
        .query(series_name, 0..u64::MAX, Some(&region_dc_filter))
        .unwrap();
    assert_eq!(
        region_dc_results.len(),
        3,
        "Expected 3 points matching us-east + dc1"
    );

    // 2. Query for a specific service across all regions
    let service_filter = tags_from(&[("service", "api")]);
    let service_results = db
        .query(series_name, 0..u64::MAX, Some(&service_filter))
        .unwrap();
    assert_eq!(
        service_results.len(),
        3,
        "Expected 3 points with service=api"
    );

    // 3. Query with OS + kernel version filter
    let os_kernel_filter = tags_from(&[("os", "linux"), ("kernel", "5.4")]);
    let os_kernel_results = db
        .query(series_name, 0..u64::MAX, Some(&os_kernel_filter))
        .unwrap();
    assert_eq!(
        os_kernel_results.len(),
        1,
        "Expected 1 point with os=linux + kernel=5.4"
    );

    // 4. Query with special characters
    let special_filter = tags_from(&[("status", "200")]);
    let special_results = db
        .query(series_name, 0..u64::MAX, Some(&special_filter))
        .unwrap();
    assert_eq!(special_results.len(), 1, "Expected 1 point with status=200");

    // 5. Query with empty tag value
    let empty_value_filter = tags_from(&[("tag_with_empty_value", "")]);
    let empty_value_results = db
        .query(series_name, 0..u64::MAX, Some(&empty_value_filter))
        .unwrap();
    assert_eq!(
        empty_value_results.len(),
        1,
        "Expected 1 point with empty tag value"
    );

    // 6. Query with multiple specific tags that should match only one point
    let complex_filter = tags_from(&[("t1", "v1"), ("t5", "v5"), ("t10", "v10")]);
    let complex_results = db
        .query(series_name, 0..u64::MAX, Some(&complex_filter))
        .unwrap();
    assert_eq!(
        complex_results.len(),
        1,
        "Expected 1 point with multiple specific tags"
    );

    // 7. Query with non-existent tag should return empty results
    let nonexistent_filter = tags_from(&[("nonexistent", "value")]);
    let nonexistent_results = db
        .query(series_name, 0..u64::MAX, Some(&nonexistent_filter))
        .unwrap();
    assert_eq!(
        nonexistent_results.len(),
        0,
        "Expected 0 points with non-existent tag"
    );
}

// NOTE: tests use per-test directories; no global cleanup required.