pinakes/crates/pinakes-core/tests/integrity.rs

use std::fs;

use pinakes_core::integrity::detect_orphans;

mod common;
use common::{create_test_media_item, setup_test_storage};

#[tokio::test]
async fn test_detect_orphaned_files() {
  let (storage, temp_dir) = setup_test_storage().await;

  let nonexistent_path = temp_dir.path().join("nonexistent.mp3");
  let orphaned_item = create_test_media_item(nonexistent_path, "hash1");

  storage.insert_media(&orphaned_item).await.unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert_eq!(report.orphaned_ids.len(), 1);
  assert_eq!(report.orphaned_ids[0], orphaned_item.id);
}

#[tokio::test]
async fn test_detect_untracked_files() {
  let (storage, temp_dir) = setup_test_storage().await;

  let root_dir = temp_dir.path().join("media");
  fs::create_dir(&root_dir).unwrap();
  storage.add_root_dir(root_dir.clone()).await.unwrap();

  let tracked_file = root_dir.join("tracked.mp3");
  let untracked_file = root_dir.join("untracked.mp3");

  fs::write(&tracked_file, b"tracked content").unwrap();
  fs::write(&untracked_file, b"untracked content").unwrap();

  let tracked_item =
    create_test_media_item(tracked_file.clone(), "hash_tracked");
  storage.insert_media(&tracked_item).await.unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert_eq!(report.untracked_paths.len(), 1);
  assert!(report.untracked_paths.contains(&untracked_file));
}

#[tokio::test]
async fn test_detect_moved_files() {
  let (storage, temp_dir) = setup_test_storage().await;

  let old_path = temp_dir.path().join("old_location.mp3");

  fs::write(&old_path, b"content").unwrap();

  let old_item = create_test_media_item(old_path.clone(), "hash_unique");
  storage.insert_media(&old_item).await.unwrap();

  fs::remove_file(&old_path).unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert_eq!(report.orphaned_ids.len(), 1);
  assert_eq!(report.moved_files.len(), 0);
}

#[tokio::test]
async fn test_ignore_patterns_respected() {
  let (storage, temp_dir) = setup_test_storage().await;

  let root_dir = temp_dir.path().join("media");
  fs::create_dir(&root_dir).unwrap();
  storage.add_root_dir(root_dir.clone()).await.unwrap();

  let hidden_dir = root_dir.join(".hidden");
  fs::create_dir(&hidden_dir).unwrap();

  let hidden_file = hidden_dir.join("hidden.mp3");
  fs::write(&hidden_file, b"hidden content").unwrap();

  let normal_file = root_dir.join("normal.mp3");
  fs::write(&normal_file, b"normal content").unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert_eq!(report.untracked_paths.len(), 1);
  assert!(report.untracked_paths.contains(&normal_file));
  assert!(!report.untracked_paths.contains(&hidden_file));
}

#[tokio::test]
async fn test_only_supported_media_types() {
  let (storage, temp_dir) = setup_test_storage().await;

  let root_dir = temp_dir.path().join("media");
  fs::create_dir(&root_dir).unwrap();
  storage.add_root_dir(root_dir.clone()).await.unwrap();

  let mp3_file = root_dir.join("audio.mp3");
  let txt_file = root_dir.join("readme.txt");
  let exe_file = root_dir.join("program.exe");

  fs::write(&mp3_file, b"audio").unwrap();
  fs::write(&txt_file, b"text").unwrap();
  fs::write(&exe_file, b"binary").unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert!(report.untracked_paths.len() <= 2);
  assert!(!report.untracked_paths.contains(&exe_file));
}

#[tokio::test]
async fn test_complete_orphan_workflow() {
  let (storage, temp_dir) = setup_test_storage().await;

  let root_dir = temp_dir.path().join("media");
  fs::create_dir(&root_dir).unwrap();
  storage.add_root_dir(root_dir.clone()).await.unwrap();

  let orphaned_path = root_dir.join("orphaned.mp3");
  let orphaned_item =
    create_test_media_item(orphaned_path.clone(), "hash_orphaned");
  storage.insert_media(&orphaned_item).await.unwrap();

  let untracked_path = root_dir.join("untracked.mp3");
  fs::write(&untracked_path, b"untracked").unwrap();

  let another_orphaned = root_dir.join("another_orphaned.mp3");
  let another_item =
    create_test_media_item(another_orphaned.clone(), "hash_another");
  storage.insert_media(&another_item).await.unwrap();

  let tracked_path = root_dir.join("tracked.mp3");
  fs::write(&tracked_path, b"tracked").unwrap();

  let tracked_item =
    create_test_media_item(tracked_path.clone(), "hash_tracked");
  storage.insert_media(&tracked_item).await.unwrap();

  let report = detect_orphans(&storage).await.unwrap();

  assert_eq!(report.orphaned_ids.len(), 2);
  assert!(report.orphaned_ids.contains(&orphaned_item.id));
  assert!(report.orphaned_ids.contains(&another_item.id));

  assert_eq!(report.untracked_paths.len(), 1);
  assert!(report.untracked_paths.contains(&untracked_path));

  assert_eq!(report.moved_files.len(), 0);
}

#[tokio::test]
async fn test_large_directory_performance() {
  let (storage, temp_dir) = setup_test_storage().await;

  let root_dir = temp_dir.path().join("media");
  fs::create_dir(&root_dir).unwrap();
  storage.add_root_dir(root_dir.clone()).await.unwrap();

  for i in 0..1000 {
    let file_path = root_dir.join(format!("file_{}.mp3", i));
    fs::write(&file_path, format!("content {}", i)).unwrap();
  }

  for i in 0..500 {
    let file_path = root_dir.join(format!("file_{}.mp3", i));
    let item = create_test_media_item(file_path, &format!("hash_{}", i));
    storage.insert_media(&item).await.unwrap();
  }

  let start = std::time::Instant::now();
  let report = detect_orphans(&storage).await.unwrap();
  let elapsed = start.elapsed();

  assert!(
    elapsed.as_secs() < 5,
    "Detection took too long: {:?}",
    elapsed
  );

  assert_eq!(report.untracked_paths.len(), 500);
}