vipune 0.8.0

//! Batch ingest tests for the memory store.

use super::*;
use crate::memory_types::{BatchIngestItemResult, IngestPolicy};

use super::crud::test_fake_embedder;

#[test]
fn test_batch_ingest_empty_batch() {
    let mut store = MemoryStore::test_store();

    let result = store
        .batch_ingest("test-project", vec![], IngestPolicy::ConflictAware)
        .unwrap();

    assert_eq!(result.results.len(), 0);
}

#[test]
fn test_batch_ingest_mixed_outcomes() {
    let path = MemoryStore::test_db_path();
    let db = crate::sqlite::Database::open(&path).unwrap();

    // Pre-populate with a memory that will cause conflicts
    let embedding = test_fake_embedder("Alice works at Microsoft").unwrap();
    db.insert(
        "test-project",
        "Alice works at Microsoft",
        &embedding,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let mut store = MemoryStore::from_db_with_test_embedder(db);

    // Create a batch with mixed outcomes:
    // 0: empty -> Error
    // 1: valid unique -> Added
    // 2: conflict -> Conflicts
    // 3: valid unique -> Added
    let items = vec![
        ("", None),                         // Empty input -> Error
        ("Bob works at Google", None),      // Should add (unique)
        ("Alice works at Microsoft", None), // Should conflict with existing
        ("Charlie works at Amazon", None),  // Should add (unique)
    ];

    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::ConflictAware)
        .unwrap();

    // Verify we have 4 results (one per input)
    assert_eq!(result.results.len(), 4);

    // Check item 0: Error (empty input)
    match &result.results[0] {
        BatchIngestItemResult::Error { message } => {
            assert!(message.contains("empty") || message.contains("EmptyInput"));
        }
        _ => panic!("Expected Error for item 0, got {:?}", result.results[0]),
    }

    // Check item 1: Added (unique content)
    match &result.results[1] {
        BatchIngestItemResult::Added { id } => {
            assert!(!id.is_empty());
            // Verify it was actually stored
            let memory = store.get(id, "test-project").unwrap().unwrap();
            assert_eq!(memory.content, "Bob works at Google");
        }
        _ => panic!("Expected Added for item 1, got {:?}", result.results[1]),
    }

    // Check item 2: Conflicts (similar to existing memory)
    match &result.results[2] {
        BatchIngestItemResult::Conflicts {
            proposed,
            conflicts,
        } => {
            assert_eq!(proposed, "Alice works at Microsoft");
            assert!(!conflicts.is_empty());
            assert!(conflicts.iter().any(|c| c.content.contains("Alice")));
        }
        _ => panic!("Expected Conflicts for item 2, got {:?}", result.results[2]),
    }

    // Check item 3: Added (unique content)
    match &result.results[3] {
        BatchIngestItemResult::Added { id } => {
            assert!(!id.is_empty());
            // Verify it was actually stored
            let memory = store.get(id, "test-project").unwrap().unwrap();
            assert_eq!(memory.content, "Charlie works at Amazon");
        }
        _ => panic!("Expected Added for item 3, got {:?}", result.results[3]),
    }
}

#[test]
fn test_batch_ingest_deterministic_index_mapping() {
    let path = MemoryStore::test_db_path();
    let db = crate::sqlite::Database::open(&path).unwrap();

    // Pre-populate with conflicting content
    let embedding = test_fake_embedder("conflict with item 1").unwrap();
    db.insert(
        "test-project",
        "conflict with item 1",
        &embedding,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let mut store = MemoryStore::from_db_with_test_embedder(db);

    // Create batch with specific ordering
    let items = vec![
        ("unique item 0", None),
        ("conflict with item 1", None), // Will conflict
        ("", None),                     // Will error
        ("unique item 3", Some("metadata")),
    ];

    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::ConflictAware)
        .unwrap();

    assert_eq!(result.results.len(), 4);

    // Verify index 0 is Added (unique)
    assert!(matches!(
        &result.results[0],
        BatchIngestItemResult::Added { .. }
    ));

    // Verify index 1 is Conflicts (we pre-populated a conflict)
    assert!(matches!(
        &result.results[1],
        BatchIngestItemResult::Conflicts { .. }
    ));

    // Verify index 2 is Error (empty input)
    assert!(matches!(
        &result.results[2],
        BatchIngestItemResult::Error { .. }
    ));

    // Verify index 3 is Added (unique with metadata)
    if let BatchIngestItemResult::Added { id } = &result.results[3] {
        let memory = store.get(id, "test-project").unwrap().unwrap();
        assert_eq!(memory.content, "unique item 3");
        assert_eq!(memory.metadata, Some("metadata".to_string()));
    } else {
        panic!("Expected Added for index 3");
    }
}

#[test]
fn test_batch_ingest_policy_force() {
    let path = MemoryStore::test_db_path();
    let db = crate::sqlite::Database::open(&path).unwrap();

    // Pre-populate with conflicting content
    let embedding = test_fake_embedder("Alice works at Microsoft").unwrap();
    db.insert(
        "test-project",
        "Alice works at Microsoft",
        &embedding,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let mut store = MemoryStore::from_db_with_test_embedder(db);

    // Create batch with conflicts
    let items = vec![
        ("Alice works at Microsoft", None), // Would conflict under ConflictAware
        ("Bob works at Google", None),      // Unique
    ];

    // With Force policy, should add everything (except empty/invalid)
    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::Force)
        .unwrap();

    assert_eq!(result.results.len(), 2);

    // Both should be Added (no conflicts with Force policy)
    match &result.results[0] {
        BatchIngestItemResult::Added { id } => {
            assert!(!id.is_empty());
            // Verify it was actually stored despite potential similarity
            let memory = store.get(id, "test-project").unwrap().unwrap();
            assert_eq!(memory.content, "Alice works at Microsoft");
        }
        _ => panic!("Expected Added for item 0 with Force policy"),
    }

    match &result.results[1] {
        BatchIngestItemResult::Added { id } => {
            assert!(!id.is_empty());
            let memory = store.get(id, "test-project").unwrap().unwrap();
            assert_eq!(memory.content, "Bob works at Google");
        }
        _ => panic!("Expected Added for item 1 with Force policy"),
    }
}

#[test]
fn test_batch_ingest_invalid_inputs() {
    let mut store = MemoryStore::test_store();

    // Create oversized input (100,001 characters)
    let too_long = "a".repeat(100_001);

    // Create whitespace-only input
    let whitespace = "   \t\n  ";

    let items = vec![
        ("", None),            // Empty
        ("   ", None),         // Whitespace-only
        (&too_long, None),     // Too long
        ("valid input", None), // Valid
        (whitespace, None),    // Whitespace
    ];

    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::ConflictAware)
        .unwrap();

    assert_eq!(result.results.len(), 5);

    // All invalid inputs should return Error
    for &idx in &[0_usize, 1, 2, 4] {
        match &result.results[idx] {
            BatchIngestItemResult::Error { .. } => {
                // Expected error
            }
            other => panic!(
                "Expected Error for invalid input at index {}, got {:?}",
                idx, other
            ),
        }
    }

    // Only the valid input should succeed
    match &result.results[3] {
        BatchIngestItemResult::Added { id } => {
            assert!(!id.is_empty());
            let memory = store.get(id, "test-project").unwrap().unwrap();
            assert_eq!(memory.content, "valid input");
        }
        _ => panic!("Expected Added for valid input at index 3"),
    }
}

#[test]
fn test_batch_ingest_all_errors() {
    let mut store = MemoryStore::test_store();

    // Create a batch where every item fails validation
    let items = vec![
        ("", None),    // Empty
        ("   ", None), // Whitespace-only
    ];

    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::ConflictAware)
        .unwrap();

    assert_eq!(result.results.len(), 2);

    for (idx, item_result) in result.results.iter().enumerate() {
        match item_result {
            BatchIngestItemResult::Error { .. } => {
                // Expected error
            }
            _ => panic!("Expected Error for all items at index {}", idx),
        }
    }
}

#[test]
fn test_batch_ingest_metadata_preservation() {
    let mut store = MemoryStore::test_store();

    let items = vec![
        ("content with metadata", Some(r#"{"tag": "important"}"#)),
        ("content without metadata", None),
        (
            "json metadata",
            Some(r#"{"source": "user", "priority": 1}"#),
        ),
    ];

    let result = store
        .batch_ingest("test-project", items.clone(), IngestPolicy::ConflictAware)
        .unwrap();

    assert_eq!(result.results.len(), 3);

    // Verify metadata is preserved for items 0 and 2
    if let BatchIngestItemResult::Added { id } = &result.results[0] {
        let memory = store.get(id, "test-project").unwrap().unwrap();
        assert_eq!(memory.metadata, Some(r#"{"tag": "important"}"#.to_string()));
    } else {
        panic!("Expected Added for item 0");
    }

    if let BatchIngestItemResult::Added { id } = &result.results[1] {
        let memory = store.get(id, "test-project").unwrap().unwrap();
        assert_eq!(memory.metadata, None);
    } else {
        panic!("Expected Added for item 1");
    }

    if let BatchIngestItemResult::Added { id } = &result.results[2] {
        let memory = store.get(id, "test-project").unwrap().unwrap();
        assert_eq!(
            memory.metadata,
            Some(r#"{"source": "user", "priority": 1}"#.to_string())
        );
    } else {
        panic!("Expected Added for item 2");
    }
}