"""Bounded task worker outcome tests."""

import uuid
from typing import cast

from app.tasks.repository import Task, TaskRepository
from app.tasks.worker import TaskWorker


class FakeRepository:
    def __init__(self, task: Task) -> None:
        self.task = task
        self.finishes: list[tuple[str, str | None]] = []

    async def get(self, _task_id: uuid.UUID) -> Task:
        return self.task

    async def finish(
        self,
        _task_id: uuid.UUID,
        _worker_id: str,
        *,
        status: str,
        result: dict[str, object] | None = None,
        error: str | None = None,
    ) -> None:
        del result
        self.finishes.append((status, error))


def make_task(*, task_type: str = "test", cancelled: bool = False) -> Task:
    return Task(uuid.uuid4(), "UPID:test", task_type, "running", {}, 0, cancelled, 1)


async def test_worker_persists_success_error_and_unsupported() -> None:
    task = make_task()
    repository = FakeRepository(task)

    async def success(_task: Task) -> dict[str, object]:
        return {"ok": True}

    worker = TaskWorker(cast(TaskRepository, repository), "worker", {"test": success})
    await worker._execute(task)
    assert repository.finishes == [("success", None)]

    unsupported = make_task(task_type="missing")
    repository.task = unsupported
    await worker._execute(unsupported)
    assert repository.finishes[-1] == ("error", "unsupported task type")

    async def failure(_task: Task) -> None:
        raise RuntimeError("private detail")

    failed = make_task()
    repository.task = failed
    worker.handlers["test"] = failure
    await worker._execute(failed)
    assert repository.finishes[-1] == ("error", "RuntimeError")


async def test_worker_honors_persisted_cancellation() -> None:
    task = make_task(cancelled=True)
    repository = FakeRepository(task)
    called = False

    async def handler(_task: Task) -> None:
        nonlocal called
        called = True

    worker = TaskWorker(cast(TaskRepository, repository), "worker", {"test": handler})
    await worker._execute(task)

    assert not called
    assert repository.finishes == [("cancelled", None)]