use std::sync::Arc;
use application::testing::{InMemoryJobRepository, StubEventPublisher};
use application::processing::{EnqueueJobCommand, EnqueueJobHandler};
use domain::entities::{JobStatus, JobType};
use domain::events::DomainEvent;
use domain::value_objects::{StructuredData, SystemId};

#[tokio::test]
async fn enqueues_job() {
    let job_repo = Arc::new(InMemoryJobRepository::new());
    let event_pub = Arc::new(StubEventPublisher::new());
    let handler = EnqueueJobHandler::new(job_repo.clone(), event_pub.clone());

    let job = handler.execute(EnqueueJobCommand {
        job_type: JobType::ExtractMetadata,
        priority: 5,
        payload: StructuredData::new(),
        target_asset_id: None,
        batch_id: None,
    }).await.unwrap();

    assert_eq!(job.status, JobStatus::Queued);
    assert_eq!(job.priority, 5);
    assert!(job.target_asset_id.is_none());
    assert!(job.batch_id.is_none());
}

#[tokio::test]
async fn enqueues_with_target_and_batch() {
    let job_repo = Arc::new(InMemoryJobRepository::new());
    let event_pub = Arc::new(StubEventPublisher::new());
    let handler = EnqueueJobHandler::new(job_repo.clone(), event_pub.clone());

    let target = SystemId::new();
    let batch = SystemId::new();
    let job = handler.execute(EnqueueJobCommand {
        job_type: JobType::GenerateDerivative,
        priority: 10,
        payload: StructuredData::new(),
        target_asset_id: Some(target),
        batch_id: Some(batch),
    }).await.unwrap();

    assert_eq!(job.target_asset_id, Some(target));
    assert_eq!(job.batch_id, Some(batch));
}

#[tokio::test]
async fn publishes_event() {
    let job_repo = Arc::new(InMemoryJobRepository::new());
    let event_pub = Arc::new(StubEventPublisher::new());
    let handler = EnqueueJobHandler::new(job_repo.clone(), event_pub.clone());

    let job = handler.execute(EnqueueJobCommand {
        job_type: JobType::ScanDirectory,
        priority: 1,
        payload: StructuredData::new(),
        target_asset_id: None,
        batch_id: None,
    }).await.unwrap();

    let events = event_pub.published().await;
    assert_eq!(events.len(), 1);
    assert!(matches!(&events[0], DomainEvent::JobEnqueued { job_id, .. } if *job_id == job.job_id));
}