use application::sidecar::{FullExportCommand, FullExportHandler};
use application::testing::{
    InMemoryAssetMetadataRepository, InMemoryAssetRepository, InMemorySidecarRepository,
    InMemorySidecarWriter,
};
use domain::catalog::entities::{Asset, AssetMetadata, AssetType, MetadataSource, SourceReference};
use domain::ports::AssetRepository;
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
use std::sync::Arc;

fn make_asset(owner: SystemId) -> Asset {
    let source = SourceReference {
        volume_id: SystemId::new(),
        relative_path: "photos/img.jpg".into(),
        checksum: Checksum::new("a".repeat(64)).unwrap(),
    };
    Asset::new(source, AssetType::Image, "image/jpeg", 1024, owner)
}

#[tokio::test]
async fn exports_all_user_assets() {
    let asset_repo = Arc::new(InMemoryAssetRepository::new());
    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
    let writer = Arc::new(InMemorySidecarWriter::new());

    let owner = SystemId::new();
    let a1 = make_asset(owner);
    let a2 = make_asset(owner);
    asset_repo.save(&a1).await.unwrap();
    asset_repo.save(&a2).await.unwrap();

    let mut data = StructuredData::new();
    data.insert("title", MetadataValue::String("Sunset".into()));
    use domain::ports::AssetMetadataRepository;
    meta_repo
        .save(&AssetMetadata::new(
            a1.asset_id,
            MetadataSource::UserEdited,
            data,
        ))
        .await
        .unwrap();

    let handler = FullExportHandler::new(asset_repo, meta_repo, sidecar_repo, writer.clone());
    let count = handler
        .execute(FullExportCommand { owner_id: owner })
        .await
        .unwrap();

    assert_eq!(count, 2);

    let written = writer.get(&format!("sidecars/{}.xmp", a1.asset_id)).await;
    assert!(written.is_some());
}