use crate::support::{TestContextBuilder, register_command};
use std::sync::Arc;

use domain::{
    errors::DomainError,
    events::DomainEvent,
    ports::UserRepository,
    testing::{InMemoryStore, NoopEventPublisher, RefusingEventPublisher},
    value_objects::{Email, UserId},
};
use uuid::Uuid;

use application::{
    auth::{deps::RegisterDeps, register},
    users::{delete_account, deps::DeleteAccountDeps},
};

async fn register_user(b: &TestContextBuilder, users: &Arc<InMemoryStore>) -> Uuid {
    let reg_deps = RegisterDeps {
        user: b.user_repo.clone(),
        password_hasher: b.password_hasher.clone(),
        config: b.config.clone(),
    };
    register::execute(&reg_deps, register_command("alice@example.com", "alice"))
        .await
        .unwrap();
    users
        .find_by_email(&Email::new("alice@example.com".into()).unwrap())
        .await
        .unwrap()
        .unwrap()
        .id()
        .value()
}

#[tokio::test]
async fn deleting_an_unknown_user_is_not_found() {
    let events = NoopEventPublisher::new();
    let b = TestContextBuilder::new();
    let deps = DeleteAccountDeps {
        user: b.user_repo.clone(),
        event_publisher: Arc::clone(&events) as _,
    };

    let err = delete_account::execute(&deps, Uuid::new_v4())
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::NotFound(_)));
    assert!(events.published().is_empty());
}

#[tokio::test]
async fn deleting_an_existing_user_publishes_user_deleted() {
    let users = InMemoryStore::new();
    let events = NoopEventPublisher::new();
    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
    let deps = DeleteAccountDeps {
        user: b.user_repo.clone(),
        event_publisher: Arc::clone(&events) as _,
    };
    let uid = register_user(&b, &users).await;

    delete_account::execute(&deps, uid).await.unwrap();

    let published = events.published();
    assert!(
        matches!(
            published.as_slice(),
            [DomainEvent::UserDeleted { user_id }] if *user_id == UserId::from_uuid(uid)
        ),
        "published: {published:?}"
    );
}

#[tokio::test]
async fn deleting_fails_when_the_publisher_refuses() {
    let users = InMemoryStore::new();
    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
    let deps = DeleteAccountDeps {
        user: b.user_repo.clone(),
        event_publisher: Arc::new(RefusingEventPublisher),
    };
    let uid = register_user(&b, &users).await;

    assert!(delete_account::execute(&deps, uid).await.is_err());
}