use crate::support::edit_review_command;
use std::sync::Arc;

use domain::{
    models::ReviewEdit,
    ports::ReviewRepository,
    testing::{InMemoryStore, NoopEventPublisher, test_review},
    value_objects::{Comment, MovieId, ReviewId, UserId, WatchMedium},
};

use application::diary::{commands::EditReviewCommand, deps::EditReviewDeps, edit_review};

async fn setup() -> (
    Arc<InMemoryStore>,
    Arc<NoopEventPublisher>,
    ReviewId,
    UserId,
) {
    let reviews = InMemoryStore::new();
    let events = NoopEventPublisher::new();
    let user_id = UserId::generate();
    let review = test_review(&MovieId::generate(), &user_id, 3).apply_edit(ReviewEdit {
        comment: Some(Some(Comment::new("original comment".into()).unwrap())),
        watch_medium: Some(Some(WatchMedium::Streaming)),
        ..Default::default()
    });
    let review_id = review.id().clone();
    reviews.save_review(&review).await.unwrap();
    (reviews, events, review_id, user_id)
}

fn deps(reviews: &Arc<InMemoryStore>, events: &Arc<NoopEventPublisher>) -> EditReviewDeps {
    EditReviewDeps {
        review: Arc::clone(reviews) as _,
        event_publisher: Arc::clone(events) as _,
    }
}

#[tokio::test]
async fn edit_own_review_updates_rating() {
    let (reviews, events, review_id, user_id) = setup().await;

    edit_review::execute(
        &deps(&reviews, &events),
        EditReviewCommand {
            review_id: review_id.value(),
            requesting_user_id: user_id.value(),
            ..edit_review_command(5)
        },
    )
    .await
    .unwrap();

    let updated = reviews.get_review_by_id(&review_id).await.unwrap().unwrap();
    assert_eq!(updated.rating().value(), 5);
    assert_eq!(updated.comment().unwrap().value(), "original comment");
    assert_eq!(updated.watch_medium(), Some(&WatchMedium::Streaming));
}

#[tokio::test]
async fn edit_nonexistent_review_returns_not_found() {
    let reviews = InMemoryStore::new();
    let events = NoopEventPublisher::new();

    let err = edit_review::execute(&deps(&reviews, &events), edit_review_command(5))
        .await
        .unwrap_err();

    assert!(matches!(err, domain::errors::DomainError::NotFound(_)));
}

#[tokio::test]
async fn edit_other_users_review_returns_forbidden() {
    let (reviews, events, review_id, _user_id) = setup().await;

    let err = edit_review::execute(
        &deps(&reviews, &events),
        EditReviewCommand {
            review_id: review_id.value(),
            ..edit_review_command(5)
        },
    )
    .await
    .unwrap_err();

    assert!(matches!(err, domain::errors::DomainError::Forbidden(_)));
}

#[tokio::test]
async fn edit_publishes_review_updated_event() {
    let (reviews, events, review_id, user_id) = setup().await;

    edit_review::execute(
        &deps(&reviews, &events),
        EditReviewCommand {
            review_id: review_id.value(),
            requesting_user_id: user_id.value(),
            ..edit_review_command(1)
        },
    )
    .await
    .unwrap();

    let published = events.published();
    assert_eq!(published.len(), 1);
    assert!(matches!(
        published[0],
        domain::events::DomainEvent::ReviewUpdated { .. }
    ));
}

#[tokio::test]
async fn edit_sets_watch_medium() {
    let (reviews, events, review_id, user_id) = setup().await;

    edit_review::execute(
        &deps(&reviews, &events),
        EditReviewCommand {
            rating: None,
            review_id: review_id.value(),
            requesting_user_id: user_id.value(),
            watch_medium: Some(Some(WatchMedium::Cinema)),
            ..edit_review_command(1)
        },
    )
    .await
    .unwrap();

    let updated = reviews.get_review_by_id(&review_id).await.unwrap().unwrap();
    assert_eq!(updated.watch_medium(), Some(&WatchMedium::Cinema));
}

#[tokio::test]
async fn editing_a_review_fails_when_the_store_refuses() {
    let (_, events, review_id, user_id) = setup().await;
    let deps = EditReviewDeps {
        review: Arc::new(domain::testing::RefusingReviewRepository),
        event_publisher: Arc::clone(&events) as _,
    };

    let result = edit_review::execute(
        &deps,
        EditReviewCommand {
            review_id: review_id.value(),
            requesting_user_id: user_id.value(),
            ..edit_review_command(5)
        },
    )
    .await;

    assert!(matches!(
        result,
        Err(domain::errors::DomainError::InfrastructureError(m)) if m == "refused"
    ));
}