"""Job queue: one job per page (OCR, extraction) or company (merge), queued in order, waiting for earlier jobs on the
same target, deduplicated while queued, cancellable."""
import threading
import time

import pytest
from fastapi import HTTPException

from app.ocr import jobs
from app.ocr import router as ocr_router
from app.ocr.services import extraction_service, merge_service
from tests.test_ocr import _MD, _item, _seed_page, ocr  # noqa: F401  (fixture)

APIKEY = {"X-API-Key": "k3y"}
ALICE = {**APIKEY, "X-Username": "alice"}


def _wait(cond, timeout=5.0):
    end = time.monotonic() + timeout
    while time.monotonic() < end:
        if cond():
            return True
        time.sleep(0.01)
    return False


def _status(job_id):
    return jobs.get(job_id)["status"]


def _gate():
    """A job function that blocks until released, and records that it ran."""
    started, release, ran = threading.Event(), threading.Event(), []

    def fn(tag):
        started.set()
        release.wait(5)
        ran.append(tag)
        return {"tag": tag}
    return fn, started, release, ran


# ---------------------------------------------------------------- ordering
def test_extraction_of_a_page_waits_for_its_ocr_and_other_pages_do_not():
    ocr_fn, ocr_started, release, _ = _gate()
    o1 = jobs.submit("ocr", "ocr", ocr_fn, "ocr p1", instrument_code="QA1", fiscal_year="2024", page_number=1)
    assert ocr_started.wait(5)
    e1 = jobs.submit("extract", "extract", lambda t: {"tag": t}, "ext p1", instrument_code="QA1", fiscal_year="2024", page_number=1)
    e2 = jobs.submit("extract", "extract", lambda t: {"tag": t}, "ext p2", instrument_code="QA1", fiscal_year="2024", page_number=2)
    assert _wait(lambda: _status(e2["job_id"]) == "done")              # another page is not held up
    view = jobs.get(e1["job_id"])
    assert view["status"] == "queued" and view["waiting_for_earlier_job"] is True
    release.set()
    assert _wait(lambda: _status(e1["job_id"]) == "done")
    assert jobs.get(o1["job_id"])["status"] == "done"
    assert jobs.get(e1["job_id"])["started_at"] >= jobs.get(o1["job_id"])["finished_at"]


def test_merge_waits_for_earlier_company_jobs_and_later_page_jobs_wait_for_the_merge():
    order = []
    ocr_fn, ocr_started, release_ocr, _ = _gate()
    jobs.submit("ocr", "ocr", ocr_fn, "ocr", instrument_code="QA2", fiscal_year="2024", page_number=1)
    assert ocr_started.wait(5)
    merge_release = threading.Event()

    def merge_fn(job):
        order.append("merge start")
        merge_release.wait(5)
        order.append("merge end")
        return {}
    m = jobs.submit("merge", "merge", merge_fn, instrument_code="QA2", takes_job=True)
    later = jobs.submit("extract", "extract", lambda: order.append("later extract") or {},
                        instrument_code="QA2", fiscal_year="2024", page_number=9)
    other = jobs.submit("extract", "extract", lambda: {}, instrument_code="QA2OTHER", fiscal_year="2024", page_number=9)
    assert _wait(lambda: _status(other["job_id"]) == "done")           # other companies are not held up
    time.sleep(0.1)
    assert _status(m["job_id"]) == "queued" and jobs.get(m["job_id"])["waiting_for_earlier_job"]
    release_ocr.set()
    assert _wait(lambda: order == ["merge start"])
    assert _status(later["job_id"]) == "queued"
    merge_release.set()
    assert _wait(lambda: _status(later["job_id"]) == "done")
    assert order == ["merge start", "merge end", "later extract"]


def test_queued_jobs_have_a_position_in_their_step_queue():
    fn, started, release, _ = _gate()
    first = jobs.submit("merge", "merge", lambda job: fn("a"), instrument_code="QA3", takes_job=True)
    assert started.wait(5)
    second = jobs.submit("merge", "merge", lambda job: {}, instrument_code="QA3B", takes_job=True)
    third = jobs.submit("merge", "merge", lambda job: {}, instrument_code="QA3C", takes_job=True)
    assert (jobs.get(second["job_id"])["position"], jobs.get(third["job_id"])["position"]) == (1, 2)
    assert jobs.get(first["job_id"])["position"] is None and jobs.counts()["merge"]["running"] >= 1
    release.set()
    assert _wait(lambda: _status(third["job_id"]) == "done")


# ---------------------------------------------------------------- dedupe, cancel, limits
def test_the_same_work_still_queued_is_not_queued_twice():
    fn, started, release, ran = _gate()
    jobs.submit("ocr", "ocr", fn, "first", instrument_code="QA4", fiscal_year="2024", page_number=1)
    assert started.wait(5)
    queued = []
    a = jobs.submit("extract", "extract", lambda: {}, instrument_code="QA4", fiscal_year="2024", page_number=1,
                    on_queued=queued.append)
    b = jobs.submit("extract", "extract", lambda: {}, instrument_code="QA4", fiscal_year="2024", page_number=1,
                    on_queued=queued.append)
    assert b["job_id"] == a["job_id"] and b["deduplicated"] is True and queued == [a["job_id"]]
    release.set()
    assert _wait(lambda: _status(a["job_id"]) == "done")


def test_cancel_a_queued_job_runs_its_on_cancel_and_it_never_runs():
    fn, started, release, ran = _gate()
    jobs.submit("ocr", "ocr", fn, "blocker", instrument_code="QA5", fiscal_year="2024", page_number=1)
    assert started.wait(5)
    cancelled = []
    j = jobs.submit("extract", "extract", lambda: ran.append("must not run") or {}, instrument_code="QA5",
                    fiscal_year="2024", page_number=1, on_cancel=lambda: cancelled.append(True))
    out = jobs.cancel(j["job_id"])
    assert out["status"] == "cancelled" and cancelled == [True]
    release.set()
    time.sleep(0.2)
    assert "must not run" not in ran
    with pytest.raises(HTTPException) as e:
        jobs.cancel(j["job_id"])
    assert e.value.status_code == 409


def test_a_running_page_job_cannot_be_cancelled_but_a_running_merge_stops():
    fn, started, release, _ = _gate()
    page = jobs.submit("ocr", "ocr", fn, "x", instrument_code="QA6", fiscal_year="2024", page_number=1)
    assert started.wait(5)
    with pytest.raises(HTTPException) as e:
        jobs.cancel(page["job_id"])
    assert e.value.status_code == 409
    release.set()

    def merge_fn(job):
        while not job.cancelled():
            time.sleep(0.01)
        raise jobs.JobCancelled()
    m = jobs.submit("merge", "merge", merge_fn, instrument_code="QA6B", takes_job=True)
    assert _wait(lambda: _status(m["job_id"]) == "running")
    assert jobs.cancel(m["job_id"])["cancel_requested"] is True
    assert _wait(lambda: _status(m["job_id"]) == "cancelled")


def test_a_full_queue_refuses_new_jobs(monkeypatch):
    from app.ocr import config
    fn, started, release, _ = _gate()
    jobs.submit("merge", "merge", lambda job: fn(1), instrument_code="QA7", takes_job=True)
    assert started.wait(5)
    queued_now = sum(1 for j in jobs.list_jobs() if j["status"] == "queued")
    monkeypatch.setattr(config, "JOB_QUEUE_MAX", queued_now + 1)
    jobs.submit("merge", "merge", lambda job: {}, instrument_code="QA7B", takes_job=True)
    with pytest.raises(HTTPException) as e:
        jobs.submit("merge", "merge", lambda job: {}, instrument_code="QA7C", takes_job=True)
    assert e.value.status_code == 429
    release.set()


# ---------------------------------------------------------------- endpoints
def test_page_jobs_take_one_page_and_refuse_the_old_list_body(ocr):
    r = ocr.post("/ocr/jobs/ocr", headers=ALICE, json={"instrument_code": "QB1", "fiscal_year": "2024", "page_numbers": [1, 2]})
    assert r.status_code == 422
    r = ocr.post("/ocr/jobs/extract", headers=ALICE, json={"instrument_code": "QB1", "fiscal_year": "2024", "page_numbers": [1]})
    assert r.status_code == 422


def test_many_page_requests_at_once_each_become_a_job(ocr, monkeypatch):
    for p in (1, 2, 3):
        _seed_page("QB2", "2024-25", p, _MD, [])
    monkeypatch.setattr(extraction_service, "extract_financial_data_from_markdown",
                        lambda *a, **k: {"items": [_item("Total assets", [(2025, 1000), (2024, 900)])],
                                         "tokens": 1, "duration_sec": 0.0})
    ids = [ocr.post("/ocr/jobs/extract", headers=ALICE,
                    json={"instrument_code": "QB2", "fiscal_year": "2024-25", "page_number": p}).json()["job_id"]
           for p in (1, 2, 3)]
    assert len(set(ids)) == 3
    assert _wait(lambda: all(ocr.get(f"/ocr/jobs/{i}", headers=APIKEY).json()["status"] == "done" for i in ids))
    job = ocr.get(f"/ocr/jobs/{ids[1]}", headers=APIKEY).json()
    assert (job["kind"], job["stage"], job["page_number"]) == ("extract", "extract", 2)
    assert [r["page_number"] for r in job["result"]["verification_results"]] == [2]
    listed = ocr.get("/ocr/jobs", headers=APIKEY, params={"instrument_code": "QB2"}).json()
    assert [j["job_id"] for j in listed["jobs"]] == ids and "result" not in listed["jobs"][0]
    assert set(listed["queues"]) == {"ocr", "extract", "merge"} and listed["limits"]["rate_limit_rpm"] > 0
    evs = ocr.get("/ocr/events", headers=APIKEY, params={"instrument_code": "QB2"}).json()["events"]
    assert sorted(e["details"]["pages"][0] for e in evs) == [1, 2, 3] and {e["job_id"] for e in evs} == set(ids)


def test_merge_job_reports_progress_and_a_summary(ocr, monkeypatch):
    _seed_page("QB3", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000), (2024, 900)])])
    seen = []

    def fake_merge(code, metrics, progress_callback=None, should_cancel=None):
        progress_callback({"type": "progress", "percent": 40, "stage": "linking", "gemini_calls_done": 2, "gemini_calls_total": 5})
        progress_callback({"type": "progress", "percent": 30})            # never goes backwards
        seen.append(dict(jobs.get(job_id)["progress"]))
        return {"merged_res": {"rows": [1, 2], "merge_report": [1], "conflicts": [], "total_pairs": 4},
                "token_usage": {"total_tokens": 9, "batches_count": 5}}
    monkeypatch.setattr(ocr_router, "_execute_merge", fake_merge)
    r = ocr.post("/ocr/jobs/merge", headers=ALICE, json={"instrument_code": "QB3"})
    assert r.status_code == 202
    job_id = r.json()["job_id"]
    assert _wait(lambda: ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status"] == "done")
    job = ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()
    assert seen[0]["percent"] == 40
    assert job["progress"]["percent"] == 100 and job["progress"]["gemini_calls_total"] == 5
    assert job["result"]["merged_rows_count"] == 2 and "merged_csv_data" not in job["result"]
    (ev,) = ocr.get("/ocr/events", headers=APIKEY, params={"instrument_code": "QB3"}).json()["events"]
    assert (ev["action"], ev["status"], ev["job_id"]) == ("MERGE_RUN", "SUCCEEDED", job_id)
    assert ev["details"]["total_tokens"] == 9 and ev["details"]["merged_rows_count"] == 2


def test_cancel_endpoint_stops_a_running_merge_and_logs_who(ocr, monkeypatch):
    _seed_page("QB4", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000), (2024, 900)])])

    def slow_merge(code, metrics, progress_callback=None, should_cancel=None):
        while not should_cancel():
            time.sleep(0.01)
        raise merge_service.MergeCancelled()
    monkeypatch.setattr(ocr_router, "_execute_merge", slow_merge)
    job_id = ocr.post("/ocr/jobs/merge", headers=ALICE, json={"instrument_code": "QB4"}).json()["job_id"]
    assert _wait(lambda: ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status"] == "running")
    assert ocr.delete(f"/ocr/jobs/{job_id}", headers=APIKEY).status_code == 400          # X-Username needed
    r = ocr.delete(f"/ocr/jobs/{job_id}", headers=ALICE)
    assert r.status_code == 200 and r.json()["cancel_requested"] is True
    assert _wait(lambda: ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status"] == "cancelled")
    assert _wait(lambda: {e["action"]: e["status"] for e in ocr.get(
        "/ocr/events", headers=APIKEY, params={"instrument_code": "QB4"}).json()["events"]}
        == {"MERGE_RUN": "CANCELLED", "JOB_CANCEL": "SUCCEEDED"})
    assert ocr.delete(f"/ocr/jobs/{job_id}", headers=ALICE).status_code == 409
    assert ocr.delete("/ocr/jobs/" + "a" * 32, headers=ALICE).status_code == 404


def test_merge_job_without_metrics_fails_with_404(ocr):
    job_id = ocr.post("/ocr/jobs/merge", headers=ALICE, json={"instrument_code": "QB5EMPTY"}).json()["job_id"]
    assert _wait(lambda: ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status"] == "error")
    assert ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status_code"] == 404


def test_client_page_job_takes_one_image(ocr, monkeypatch):
    from app.ocr.services import ocr_service
    monkeypatch.setattr(ocr_service, "ocr_image_with_gemini", lambda *a, **k: {"markdown": "# x", "tokens": 1, "duration_sec": 0.0},
                        raising=False)
    png = b"\x89PNG\r\n\x1a\n" + b"0" * 32
    r = ocr.post("/ocr/jobs/ocr-client-pages", headers=ALICE,
                 data={"instrument_code": "QB6", "fiscal_year": "2024", "page_number": "7"},
                 files={"file": ("page.png", png, "image/png")})
    assert r.status_code == 202, r.text
    job = r.json()
    assert (job["kind"], job["stage"], job["page_number"], job["fiscal_year"]) == ("ocr-client-pages", "ocr", 7, "2024")
