path: root/data/tests/src/test_sheet_creation_management_and_persistence.rs

use std::io::Error;

use cfg_file::config::ConfigFile;
use vcs_data::{
    constants::{SERVER_FILE_SHEET, SERVER_FILE_VAULT},
    data::{
        member::{Member, MemberId},
        sheet::SheetName,
        vault::{Vault, vault_config::VaultConfig, virtual_file::VirtualFileId},
    },
};

use crate::get_test_dir;

#[tokio::test]
async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io::Error> {
    let dir = get_test_dir("sheet_management").await?;

    // Setup vault
    Vault::setup_vault(dir.clone(), "TestVault").await?;

    // Get vault
    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
    let Some(vault) = Vault::init(config, &dir) else {
        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
    };

    // Add a member to use as sheet holder
    let member_id: MemberId = "test_member".to_string();
    vault
        .register_member_to_vault(Member::new(&member_id))
        .await?;

    // Test 1: Create a new sheet
    let sheet_name: SheetName = "test_sheet".to_string();
    let sheet = vault.create_sheet(&sheet_name, &member_id).await?;

    // Verify sheet properties
    assert_eq!(sheet.holder(), Some(&member_id));
    assert_eq!(sheet.holder(), Some(&member_id));
    assert!(sheet.mapping().is_empty());

    // Verify sheet file was created
    let sheet_path = dir.join(SERVER_FILE_SHEET.replace("{sheet_name}", &sheet_name));
    assert!(sheet_path.exists());

    // Test 2: Add mapping entries to the sheet
    let mut sheet = vault.sheet(&sheet_name).await?;

    // Add mapping entries for the files
    let main_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/main.rs");
    let lib_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/lib.rs");
    let main_rs_id = VirtualFileId::new();
    let lib_rs_id = VirtualFileId::new();

    sheet
        .add_mapping(
            main_rs_path.clone(),
            main_rs_id.clone(),
            "1.0.0".to_string(),
        )
        .await?;
    sheet
        .add_mapping(lib_rs_path.clone(), lib_rs_id.clone(), "1.0.0".to_string())
        .await?;

    // Verify mappings were added
    assert_eq!(sheet.mapping().len(), 2);

    // Test 3: Add more mapping entries
    let mapping_path = vcs_data::data::sheet::SheetPathBuf::from("output/build.exe");
    let virtual_file_id = VirtualFileId::new();

    sheet
        .add_mapping(
            mapping_path.clone(),
            virtual_file_id.clone(),
            "1.0.0".to_string(),
        )
        .await?;

    // Verify mapping was added
    assert_eq!(sheet.mapping().len(), 3);
    assert_eq!(
        sheet.mapping().get(&mapping_path).map(|meta| &meta.id),
        Some(&virtual_file_id)
    );

    // Test 4: Persist sheet to disk
    sheet.persist().await?;

    // Verify persistence by reloading the sheet
    let reloaded_sheet = vault.sheet(&sheet_name).await?;
    assert_eq!(reloaded_sheet.holder(), Some(&member_id));
    assert_eq!(reloaded_sheet.mapping().len(), 3);

    // Test 5: Remove mapping entry
    let mut sheet_for_removal = vault.sheet(&sheet_name).await?;
    let _removed_virtual_file_id = sheet_for_removal.remove_mapping(&mapping_path).await;
    // Don't check the return value since it depends on virtual file existence
    assert_eq!(sheet_for_removal.mapping().len(), 2);

    // Test 6: List all sheets in vault
    let sheet_names = vault.sheet_names()?;
    assert_eq!(sheet_names.len(), 2);
    assert!(sheet_names.contains(&sheet_name));
    assert!(sheet_names.contains(&"ref".to_string()));

    let all_sheets = vault.sheets().await?;
    assert_eq!(all_sheets.len(), 2);
    // One sheet should be the test sheet, the other should be the ref sheet with host as holder
    let test_sheet_holder = all_sheets
        .iter()
        .find(|s| s.holder() == Some(&member_id))
        .map(|s| s.holder())
        .unwrap();
    let ref_sheet_holder = all_sheets
        .iter()
        .find(|s| s.holder() == Some(&"host".to_string()))
        .map(|s| s.holder())
        .unwrap();
    assert_eq!(test_sheet_holder, Some(&member_id));
    assert_eq!(ref_sheet_holder, Some(&"host".to_string()));

    // Test 7: Safe deletion (move to trash)
    vault.delete_sheet_safely(&sheet_name).await?;

    // Verify sheet is not in normal listing but can be restored
    let sheet_names_after_deletion = vault.sheet_names()?;
    assert_eq!(sheet_names_after_deletion.len(), 1);
    assert_eq!(sheet_names_after_deletion[0], "ref");

    // Test 8: Restore sheet from trash
    let restored_sheet = vault.sheet(&sheet_name).await?;
    assert_eq!(restored_sheet.holder(), Some(&member_id));
    assert_eq!(restored_sheet.holder(), Some(&member_id));

    // Verify sheet is back in normal listing
    let sheet_names_after_restore = vault.sheet_names()?;
    assert_eq!(sheet_names_after_restore.len(), 2);
    assert!(sheet_names_after_restore.contains(&sheet_name));
    assert!(sheet_names_after_restore.contains(&"ref".to_string()));

    // Test 9: Permanent deletion
    vault.delete_sheet(&sheet_name).await?;

    // Verify sheet is permanently gone
    let sheet_names_final = vault.sheet_names()?;
    assert_eq!(sheet_names_final.len(), 1);
    assert_eq!(sheet_names_final[0], "ref");

    // Attempt to access deleted sheet should fail
    let result = vault.sheet(&sheet_name).await;
    assert!(result.is_err());

    // Clean up: Remove member
    vault.remove_member_from_vault(&member_id)?;

    Ok(())
}

#[tokio::test]
async fn test_sheet_error_conditions() -> Result<(), std::io::Error> {
    let dir = get_test_dir("sheet_error_conditions").await?;

    // Setup vault
    Vault::setup_vault(dir.clone(), "TestVault").await?;

    // Get vault
    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
    let Some(vault) = Vault::init(config, &dir) else {
        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
    };

    // Test 1: Create sheet with non-existent member should fail
    let non_existent_member: MemberId = "non_existent_member".to_string();
    let sheet_name: SheetName = "test_sheet".to_string();

    let result = vault.create_sheet(&sheet_name, &non_existent_member).await;
    assert!(result.is_err());

    // Add a member first
    let member_id: MemberId = "test_member".to_string();
    vault
        .register_member_to_vault(Member::new(&member_id))
        .await?;

    // Test 2: Create duplicate sheet should fail
    vault.create_sheet(&sheet_name, &member_id).await?;
    let result = vault.create_sheet(&sheet_name, &member_id).await;
    assert!(result.is_err());

    // Test 3: Delete non-existent sheet should fail
    let non_existent_sheet: SheetName = "non_existent_sheet".to_string();
    let result = vault.delete_sheet(&non_existent_sheet).await;
    assert!(result.is_err());

    // Test 4: Safe delete non-existent sheet should fail
    let result = vault.delete_sheet_safely(&non_existent_sheet).await;
    assert!(result.is_err());

    // Test 5: Restore non-existent sheet from trash should fail
    let result = vault.restore_sheet(&non_existent_sheet).await;
    assert!(result.is_err());

    // Clean up
    vault.remove_member_from_vault(&member_id)?;

    Ok(())
}

#[tokio::test]
async fn test_sheet_data_serialization() -> Result<(), std::io::Error> {
    let dir = get_test_dir("sheet_serialization").await?;

    // Test serialization by creating a sheet through the vault
    // Setup vault
    Vault::setup_vault(dir.clone(), "TestVault").await?;

    // Get vault
    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
    let Some(vault) = Vault::init(config, &dir) else {
        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
    };

    // Add a member
    let member_id: MemberId = "test_member".to_string();
    vault
        .register_member_to_vault(Member::new(&member_id))
        .await?;

    // Create a sheet
    let sheet_name: SheetName = "test_serialization_sheet".to_string();
    let mut sheet = vault.create_sheet(&sheet_name, &member_id).await?;

    // Add some mappings
    let main_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/main.rs");
    let lib_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/lib.rs");
    let main_rs_id = VirtualFileId::new();
    let lib_rs_id = VirtualFileId::new();

    sheet
        .add_mapping(
            main_rs_path.clone(),
            main_rs_id.clone(),
            "1.0.0".to_string(),
        )
        .await?;
    sheet
        .add_mapping(lib_rs_path.clone(), lib_rs_id.clone(), "1.0.0".to_string())
        .await?;

    // Add more mappings
    let build_exe_id = VirtualFileId::new();

    sheet
        .add_mapping(
            vcs_data::data::sheet::SheetPathBuf::from("output/build.exe"),
            build_exe_id,
            "1.0.0".to_string(),
        )
        .await?;

    // Persist the sheet
    sheet.persist().await?;

    // Verify the sheet file was created
    let sheet_path = dir.join(SERVER_FILE_SHEET.replace("{sheet_name}", &sheet_name));
    assert!(sheet_path.exists());

    // Clean up
    vault.remove_member_from_vault(&member_id)?;

    Ok(())
}