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

fn conflict_record(asset_id: SystemId, path: &str) -> SidecarRecord {
    let mut r = SidecarRecord::new(asset_id, path);
    r.mark_conflict();
    r
}

#[tokio::test]
async fn db_wins_re_exports() {
    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);

    sidecar_repo
        .save(&conflict_record(asset_id, &path))
        .await
        .unwrap();

    let mut data = StructuredData::new();
    data.insert("title", MetadataValue::String("DB Value".into()));
    meta_repo
        .save(&AssetMetadata::new(
            asset_id,
            MetadataSource::UserEdited,
            data,
        ))
        .await
        .unwrap();

    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer.clone(), meta_repo);
    let record = handler
        .execute(ResolveConflictCommand {
            asset_id,
            policy: ConflictPolicy::DbWins,
        })
        .await
        .unwrap();

    assert_eq!(record.sync_status, SyncStatus::InSync);
    let written = writer.get(&path).await.unwrap();
    assert_eq!(written.get_string("title"), Some("DB Value"));
}

#[tokio::test]
async fn file_wins_re_imports() {
    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);

    sidecar_repo
        .save(&conflict_record(asset_id, &path))
        .await
        .unwrap();

    let mut file_data = StructuredData::new();
    file_data.insert("title", MetadataValue::String("File Value".into()));
    writer.write_sidecar(&file_data, &path).await.unwrap();

    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer, meta_repo.clone());
    let record = handler
        .execute(ResolveConflictCommand {
            asset_id,
            policy: ConflictPolicy::FileWins,
        })
        .await
        .unwrap();

    assert_eq!(record.sync_status, SyncStatus::InSync);
    let imported = meta_repo
        .find_by_asset_and_source(&asset_id, MetadataSource::ExifExtracted)
        .await
        .unwrap();
    assert!(imported.is_some());
    assert_eq!(
        imported.unwrap().data.get_string("title"),
        Some("File Value")
    );
}

#[tokio::test]
async fn user_decision_returns_error() {
    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();
    sidecar_repo
        .save(&conflict_record(asset_id, "sidecars/x.xmp"))
        .await
        .unwrap();

    let handler = ResolveConflictHandler::new(sidecar_repo, writer, meta_repo);
    let result = handler
        .execute(ResolveConflictCommand {
            asset_id,
            policy: ConflictPolicy::RequireUserDecision,
        })
        .await;

    assert!(matches!(result, Err(DomainError::Validation(msg)) if msg.contains("Manual")));
}