use application::sidecar::{ImportSidecarCommand, ImportSidecarHandler};
use application::testing::{
    InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter,
};
use domain::catalog::entities::MetadataSource;
use domain::entities::{SidecarRecord, SyncStatus};
use domain::errors::DomainError;
use domain::ports::{SidecarRepository, SidecarWriterPort};
use domain::value_objects::{MetadataValue, StructuredData, SystemId};
use std::sync::Arc;

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

    let asset_id = SystemId::new();
    let path = format!("sidecars/{}.xmp", asset_id);

    // Create PendingRead record
    let mut record = SidecarRecord::new(asset_id, &path);
    record.mark_pending_read();
    sidecar_repo.save(&record).await.unwrap();

    // Write sidecar file data
    let mut data = StructuredData::new();
    data.insert("camera", MetadataValue::String("Canon".into()));
    writer.write_sidecar(&data, &path).await.unwrap();

    let handler = ImportSidecarHandler::new(sidecar_repo.clone(), writer, meta_repo);
    let metadata = handler
        .execute(ImportSidecarCommand { asset_id })
        .await
        .unwrap();

    assert_eq!(metadata.metadata_source, MetadataSource::ExifExtracted);
    assert_eq!(metadata.data.get_string("camera"), Some("Canon"));

    let updated = sidecar_repo
        .find_by_asset(&asset_id)
        .await
        .unwrap()
        .unwrap();
    assert_eq!(updated.sync_status, SyncStatus::InSync);
}

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

    let asset_id = SystemId::new();
    let record = SidecarRecord::new(asset_id, "sidecars/x.xmp");
    // Default status is PendingWrite, not PendingRead
    sidecar_repo.save(&record).await.unwrap();

    let handler = ImportSidecarHandler::new(sidecar_repo, writer, meta_repo);
    let result = handler.execute(ImportSidecarCommand { asset_id }).await;

    assert!(matches!(result, Err(DomainError::Validation(_))));
}