use std::sync::Arc;
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};

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")));
}