use std::sync::Arc;

use domain::activity::ActivityId;
use domain::ports::ActivityCommandPort;
use domain::testing::{InMemoryStore, test_activity, test_user};
use domain::user::UserId;

use application::entry::use_cases::replace_activity;

#[tokio::test]
async fn replaces_activity_on_entries() {
    let store = Arc::new(InMemoryStore::new());
    let user = test_user("alice");
    let old = test_activity(user.id().clone(), "gaming");
    let new = test_activity(user.id().clone(), "video games");
    store.save(&old).await.unwrap();
    store.save(&new).await.unwrap();

    let deps = replace_activity::Deps {
        entry_command: store.clone(),
        activity_query: store.clone(),
    };

    let result =
        replace_activity::execute(user.id().clone(), old.id().clone(), new.id().clone(), &deps)
            .await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn rejects_nonexistent_target_activity() {
    let store = Arc::new(InMemoryStore::new());
    let user = test_user("alice");

    let deps = replace_activity::Deps {
        entry_command: store.clone(),
        activity_query: store.clone(),
    };

    let result = replace_activity::execute(
        user.id().clone(),
        ActivityId::generate(),
        ActivityId::generate(),
        &deps,
    )
    .await;
    assert!(result.is_err());
}

#[tokio::test]
async fn rejects_target_owned_by_different_user() {
    let store = Arc::new(InMemoryStore::new());
    let alice = test_user("alice");
    let bob = test_user("bob");
    let bobs_activity = test_activity(bob.id().clone(), "gaming");
    store.save(&bobs_activity).await.unwrap();

    let deps = replace_activity::Deps {
        entry_command: store.clone(),
        activity_query: store.clone(),
    };

    let result = replace_activity::execute(
        alice.id().clone(),
        ActivityId::generate(),
        bobs_activity.id().clone(),
        &deps,
    )
    .await;
    assert!(result.is_err());
}