import json
from unittest.mock import AsyncMock, MagicMock

import pytest

import worker


def test_dispatch_routes_to_provider(monkeypatch):
    called = {}
    monkeypatch.setattr(worker, "run_gpt_image_generation", lambda tid, p: called.setdefault("gpt", (tid, p)))
    worker._dispatch({"job_type": "gpt_image_generation", "task_id": "t1", "params": {"prompt": "x"}})
    assert called["gpt"][0] == "t1"


def test_dispatch_unknown_job_type_reports_failed(monkeypatch):
    calls = []
    monkeypatch.setattr(worker, "webhook_update_task", lambda *a, **k: calls.append((a, k)))
    worker._dispatch({"job_type": "midjourney_generation", "task_id": "t9", "params": {}})
    assert calls[-1][0][1] == "failed"


# ----- F6: ReliableQueue poll_once -----

@pytest.mark.asyncio
async def test_poll_once_acks_on_success(monkeypatch):
    payload = {"task_id": "t1", "job_type": "gpt_image_generation", "params": {}}
    raw = json.dumps(payload).encode()
    fake_queue = AsyncMock()
    fake_queue.dequeue = AsyncMock(return_value=(payload, raw))
    fake_queue.ack = AsyncMock()
    fake_queue.fail = AsyncMock()
    monkeypatch.setattr(worker, "_dispatch", MagicMock())
    handled = await worker.poll_once(fake_queue)
    assert handled is True
    fake_queue.ack.assert_awaited_once_with(raw)
    fake_queue.fail.assert_not_awaited()


@pytest.mark.asyncio
async def test_poll_once_calls_fail_on_dispatch_exception(monkeypatch):
    payload = {"task_id": "t2", "job_type": "gpt_image_generation", "params": {}}
    raw = json.dumps(payload).encode()
    fake_queue = AsyncMock()
    fake_queue.dequeue = AsyncMock(return_value=(payload, raw))
    fake_queue.ack = AsyncMock()
    fake_queue.fail = AsyncMock()

    def _boom(p):
        raise RuntimeError("dispatch crash")

    monkeypatch.setattr(worker, "_dispatch", _boom)
    handled = await worker.poll_once(fake_queue)
    assert handled is True
    fake_queue.fail.assert_awaited_once_with(raw, payload)
    fake_queue.ack.assert_not_awaited()


@pytest.mark.asyncio
async def test_poll_once_returns_false_on_timeout(monkeypatch):
    fake_queue = AsyncMock()
    fake_queue.dequeue = AsyncMock(return_value=None)
    fake_queue.ack = AsyncMock()
    fake_queue.fail = AsyncMock()
    monkeypatch.setattr(worker, "_dispatch", MagicMock())
    handled = await worker.poll_once(fake_queue)
    assert handled is False
    fake_queue.ack.assert_not_awaited()
    fake_queue.fail.assert_not_awaited()


# ----- heartbeat stats 카운터 -----

class _OneJobQueue:
    def __init__(self): self.acked = False
    async def dequeue(self, timeout=5):
        if self.acked: return None
        return ({"job_type": "flux_generation", "task_id": "t1", "params": {}}, b"raw")
    async def ack(self, raw): self.acked = True
    async def fail(self, raw, payload): pass


@pytest.mark.asyncio
async def test_poll_once_increments_jobs_done(monkeypatch):
    worker.stats.jobs_done = 0
    monkeypatch.setattr(worker, "run_flux_generation", lambda task_id, params: None)
    handled = await worker.poll_once(_OneJobQueue())
    assert handled is True
    assert worker.stats.jobs_done == 1
    assert worker.stats.busy is False
    assert worker.stats.last_job_at is not None
