//! Integration tests for status-token methods on SqliteTaskRepository.

mod common;

use goingson_core::{
    StatusToken, TOKEN_KIND_COMMIT, TaskAnnotations, TaskCrud, TaskId, TaskStatus, TokenState,
};
use goingson_db_sqlite::SqliteTaskRepository;

const COMMIT: &str = TOKEN_KIND_COMMIT;

#[tokio::test]
async fn record_token_appends_and_reads_back() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    let t = repo
        .record_status_token(
            task_id,
            user_id,
            COMMIT,
            "deox@7c236fca8",
            TokenState::Pending,
            false,
        )
        .await
        .expect("record")
        .expect("some");
    assert_eq!(t.task_id, task_id);
    assert_eq!(t.kind, COMMIT);
    assert_eq!(t.reference, "deox@7c236fca8");
    assert_eq!(t.state, TokenState::Pending);
    assert!(!t.is_primary);
    assert_eq!(t.position, 0);

    let tokens = repo.get_status_tokens_for_task(task_id).await.expect("get");
    assert_eq!(tokens.len(), 1);
    assert_eq!(tokens[0].id, t.id);
}

#[tokio::test]
async fn record_token_is_idempotent_in_task_kind_ref() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    let a = repo
        .record_status_token(
            task_id,
            user_id,
            COMMIT,
            "deox@aaa",
            TokenState::Pending,
            false,
        )
        .await
        .unwrap()
        .unwrap();
    // Re-record the same token, flipping state to Complete (e.g. it was pushed).
    let b = repo
        .record_status_token(
            task_id,
            user_id,
            COMMIT,
            "deox@aaa",
            TokenState::Complete,
            false,
        )
        .await
        .unwrap()
        .unwrap();
    assert_eq!(
        a.id, b.id,
        "same (task, kind, ref) collapses to one deterministic id"
    );

    let tokens = repo.get_status_tokens_for_task(task_id).await.unwrap();
    assert_eq!(tokens.len(), 1, "no duplicate row on re-record");
    assert_eq!(
        tokens[0].state,
        TokenState::Complete,
        "state updated in place"
    );
    assert_eq!(tokens[0].position, 0);
}

#[tokio::test]
async fn record_token_preserves_append_order() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@one",
        TokenState::Pending,
        false,
    )
    .await
    .unwrap();
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@two",
        TokenState::Pending,
        false,
    )
    .await
    .unwrap();
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@three",
        TokenState::Pending,
        false,
    )
    .await
    .unwrap();

    let tokens = repo.get_status_tokens_for_task(task_id).await.unwrap();
    let refs: Vec<&str> = tokens.iter().map(|t| t.reference.as_str()).collect();
    assert_eq!(refs, vec!["deox@one", "deox@two", "deox@three"]);
}

#[tokio::test]
async fn primary_flag_is_exclusive_and_can_promote_existing() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@one",
        TokenState::Pending,
        false,
    )
    .await
    .unwrap();
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@two",
        TokenState::Pending,
        false,
    )
    .await
    .unwrap();
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@three",
        TokenState::Complete,
        true,
    )
    .await
    .unwrap();

    let commits = repo.get_status_tokens_for_task(task_id).await.unwrap();
    let primaries: Vec<&str> = commits
        .iter()
        .filter(|t| t.is_primary)
        .map(|t| t.reference.as_str())
        .collect();
    assert_eq!(primaries, vec!["deox@three"], "exactly one primary");

    // Promote an existing token to primary; the prior primary flag clears.
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@one",
        TokenState::Pending,
        true,
    )
    .await
    .unwrap();
    let commits = repo.get_status_tokens_for_task(task_id).await.unwrap();
    let primary_refs: Vec<&str> = commits
        .iter()
        .filter(|t| t.is_primary)
        .map(|t| t.reference.as_str())
        .collect();
    assert_eq!(
        primary_refs,
        vec!["deox@one"],
        "primary moved, still exactly one"
    );
    assert_eq!(commits.len(), 3, "promotion did not add a row");
}

#[tokio::test]
async fn delete_token_removes_only_that_token() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    let keep = repo
        .record_status_token(
            task_id,
            user_id,
            COMMIT,
            "deox@keep",
            TokenState::Pending,
            false,
        )
        .await
        .unwrap()
        .unwrap();
    let drop = repo
        .record_status_token(
            task_id,
            user_id,
            COMMIT,
            "deox@drop",
            TokenState::Pending,
            false,
        )
        .await
        .unwrap()
        .unwrap();

    let removed = repo.delete_status_token(drop.id, user_id).await.unwrap();
    assert!(removed);

    let tokens = repo.get_status_tokens_for_task(task_id).await.unwrap();
    assert_eq!(tokens.len(), 1);
    assert_eq!(tokens[0].id, keep.id);

    // Deleting an unknown token is a no-op, not an error.
    assert!(
        !repo
            .delete_status_token(
                StatusToken::deterministic_id(task_id, COMMIT, "deox@nope"),
                user_id
            )
            .await
            .unwrap()
    );
}

#[tokio::test]
async fn record_token_rejects_unknown_or_unowned_task() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let missing = repo
        .record_status_token(
            TaskId::new(),
            user_id,
            COMMIT,
            "deox@x",
            TokenState::Pending,
            false,
        )
        .await
        .expect("no error");
    assert!(
        missing.is_none(),
        "recording against a missing task returns None"
    );
}

#[tokio::test]
async fn tokens_load_onto_the_task_with_rollup() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let task_id = common::create_test_task(&pool, user_id).await;
    let repo = SqliteTaskRepository::new(pool);

    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@one",
        TokenState::Complete,
        false,
    )
    .await
    .unwrap();
    repo.record_status_token(
        task_id,
        user_id,
        COMMIT,
        "deox@two",
        TokenState::Pending,
        true,
    )
    .await
    .unwrap();

    let task = repo.get_by_id(task_id, user_id).await.unwrap().unwrap();
    assert_eq!(task.status_tokens.len(), 2);
    assert_eq!(
        task.primary_token().map(|t| t.reference.as_str()),
        Some("deox@two")
    );
    assert_eq!(
        task.status_token_summary(),
        "pending",
        "a pending token keeps rollup pending"
    );
    // status is unaffected by recording tokens
    assert_ne!(task.status, TaskStatus::Completed);
}