/// Integration tests for AI/NPU functionality
use activity_tracker::ai::{NpuDevice, NpuClassifier};

#[test]
fn test_npu_detection() {
    let npu = NpuDevice::detect();

    // Should detect NPU on Intel Core Ultra
    println!("NPU Device: {}", npu.device_name());
    println!("NPU Available: {}", npu.is_available());

    // On Windows with compatible hardware, this should be true
    #[cfg(windows)]
    assert!(npu.is_available(), "NPU should be available on Intel Core Ultra 7 155U");

    println!("✅ NPU detection test passed");
}

#[test]
fn test_classifier_creation() {
    let classifier = NpuClassifier::new();

    // Should create without error
    assert!(!classifier.is_model_loaded(), "No model should be loaded initially");
    println!("✅ Classifier creation test passed");
}

#[test]
fn test_rule_based_classification() {
    let classifier = NpuClassifier::new();

    // Test classification without model (fallback to rules)
    let result = classifier.classify("VSCode - main.rs", "code.exe");
    assert!(result.is_ok(), "Classification should succeed");

    let (category, confidence, entities) = result.unwrap();
    println!("Category: {:?}", category);
    println!("Confidence: {}", confidence);
    println!("Entities: {:?}", entities);

    // Should classify as Development
    assert!(matches!(category, activity_tracker::analysis::ActivityCategory::Development));
    assert!(confidence > 0.0);

    println!("✅ Rule-based classification test passed");
}

#[test]
fn test_multiple_classifications() {
    let classifier = NpuClassifier::new();

    let test_cases = vec![
        ("Chrome - Google Search", "chrome.exe", "Research"),
        ("Zoom Meeting", "zoom.exe", "Meeting"),
        ("Figma - Design", "figma.exe", "Design"),
        ("Terminal - bash", "terminal.exe", "Development"),
    ];

    for (title, process, expected_category) in test_cases {
        let result = classifier.classify(title, process);
        assert!(result.is_ok(), "Classification should succeed for: {}", title);

        let (category, confidence, _) = result.unwrap();
        println!("{} -> {:?} (confidence: {})", title, category, confidence);

        let category_str = match category {
            activity_tracker::analysis::ActivityCategory::Development => "Development",
            activity_tracker::analysis::ActivityCategory::Meeting => "Meeting",
            activity_tracker::analysis::ActivityCategory::Research => "Research",
            activity_tracker::analysis::ActivityCategory::Design => "Design",
            activity_tracker::analysis::ActivityCategory::Other => "Other",
        };

        assert_eq!(category_str, expected_category, "Expected {} for {}", expected_category, title);
    }

    println!("✅ Multiple classifications test passed");
}

#[test]
fn test_npu_info() {
    let npu = NpuDevice::detect();

    println!("\n=== NPU Information ===");
    println!("Device: {}", npu.device_name());
    println!("Available: {}", npu.is_available());

    #[cfg(windows)]
    {
        println!("DirectML: Enabled");
        println!("Expected performance: ~10x faster than CPU");
    }

    println!("✅ NPU info test passed");
}