"""Event log: every data-changing OCR route needs X-Username and records who did what (GET /ocr/events)."""
import time

import pytest
from fastapi.routing import APIRoute

from app.ocr import database
from app.ocr import router as ocr_router
from app.ocr.events import require_username
from app.ocr.services import extraction_service, merge_service
from tests.test_ocr import _MD, _concrete, _item, _seed_page, ocr  # noqa: F401  (fixture)

APIKEY = {"X-API-Key": "k3y"}
ALICE = {**APIKEY, "X-Username": "alice"}


def _depends_on_username(dependant) -> bool:
    return any(d.call is require_username or _depends_on_username(d) for d in dependant.dependencies)


def _changing_routes():
    """(method, path) of every /ocr route that changes data: any non-GET route, and GET /ocr/sync-ocr-md."""
    out = []
    for route in ocr_router.router.routes:
        if not isinstance(route, APIRoute):
            continue
        for method in sorted(route.methods - {"HEAD", "OPTIONS"}):
            if method != "GET" or route.path == "/ocr/sync-ocr-md":
                out.append((method, route.path))
    return out


def _events(ocr, **params):
    r = ocr.get("/ocr/events", headers=APIKEY, params=params)
    assert r.status_code == 200, r.text
    return r.json()


# ---------------------------------------------------------------- the header is required
def test_every_changing_route_depends_on_the_username():
    routes = {(m, r.path): r for r in ocr_router.router.routes if isinstance(r, APIRoute) for m in r.methods}
    missing = [(m, p) for m, p in _changing_routes() if not _depends_on_username(routes[(m, p)].dependant)]
    assert not missing, f"data-changing routes without the X-Username dependency: {missing}"
    assert len(_changing_routes()) >= 15


def test_reading_routes_do_not_need_a_username():
    routes = {(m, r.path): r for r in ocr_router.router.routes if isinstance(r, APIRoute) for m in r.methods}
    reads = [(m, p) for (m, p), r in routes.items() if m == "GET" and p != "/ocr/sync-ocr-md"]
    assert reads and not [k for k in reads if _depends_on_username(routes[k].dependant)]


@pytest.mark.parametrize("method,path", _changing_routes())
@pytest.mark.parametrize("headers", [APIKEY, {**APIKEY, "X-Username": "   "}, {**APIKEY, "X-Username": "x" * 65}])
def test_changing_routes_refuse_a_missing_or_bad_username(ocr, method, path, headers):
    r = ocr.request(method, _concrete(path), headers=headers, json={})
    assert r.status_code == 400, (method, path, r.status_code, r.text)
    assert "X-Username" in r.json()["detail"]


def test_api_key_is_checked_before_the_username(ocr):
    assert ocr.post("/ocr/pipeline/merge", json={"instrument_code": "AAA"}).status_code == 401


# ---------------------------------------------------------------- recording
def test_override_create_and_remove_are_recorded(ocr):
    body = {"kind": "RENAME", "statement_type": "BALANCE_SHEET", "scope": "CONSOLIDATED", "a_label": "Trade payables",
            "new_label": "Payables", "note": "same thing"}
    oid = ocr.post("/ocr/company/EVCO/merge/override", headers=ALICE, json=body).json()["id"]
    assert ocr.delete(f"/ocr/company/EVCO/merge/override/{oid}", headers={**APIKEY, "X-Username": "bob"}).status_code == 200

    got = _events(ocr, instrument_code="EVCO")
    assert got["total"] == 2
    remove, create = got["events"]                      # newest first
    assert (create["action"], create["username"], create["status"]) == ("OVERRIDE_RENAME", "alice", "SUCCEEDED")
    assert (create["target_type"], create["target_id"]) == ("merge_override", str(oid))
    assert create["details"]["new_label"] == "Payables" and create["finished_at"] and create["source"] == "api"
    assert (remove["action"], remove["username"]) == ("OVERRIDE_REMOVE", "bob")
    assert remove["details"] == {}


def test_a_refused_action_is_recorded_as_failed_with_the_reason(ocr):
    assert ocr.delete("/ocr/company/EVCO2/merge/override/999", headers=ALICE).status_code == 404
    (ev,) = _events(ocr, instrument_code="EVCO2")["events"]
    assert (ev["action"], ev["status"], ev["username"]) == ("OVERRIDE_REMOVE", "FAILED", "alice")
    assert ev["details"]["status_code"] == 404 and "not found" in ev["details"]["error"]


def test_review_decision_is_recorded_with_item_and_override(ocr):
    with database.get_connection() as conn:
        cur = conn.execute("""INSERT INTO merge_review_item (instrument_code, kind, dedupe_key, payload_json, created_at, updated_at)
                              VALUES ('EVCO3', 'SPLIT_DETECTED', 'k', '{}', '2025-01-01T00:00:00', '2025-01-01T00:00:00')""")
        conn.commit()
        item_id = cur.lastrowid
    r = ocr.post(f"/ocr/company/EVCO3/merge/review/{item_id}/resolve", headers=ALICE, json={"action": "accept", "note": "ok"})
    assert r.status_code == 200
    (ev,) = _events(ocr, instrument_code="EVCO3")["events"]
    assert ev["action"] == "REVIEW_ACCEPT" and ev["status"] == "SUCCEEDED"
    assert (ev["target_type"], ev["target_id"]) == ("review_item", str(item_id))
    assert ev["details"]["review_kind"] == "SPLIT_DETECTED" and ev["details"]["note"] == "ok"


def test_line_name_set_and_remove(ocr):
    item = {"concept": {"name": "Total", "statement": "NOTES_AND_FOOTNOTES", "category": "", "level": "GRAND_TOTAL"},
            "scope": {"type": "CONSOLIDATED", "entity": None, "segment": None},
            "behavior": {"temporal": "PERIOD_FLOW", "action": None, "metric_type": "CURRENCY", "qualifier": None},
            "tag": "FINANCIAL_METRIC", "verification_flag": "FIELD_UNIDENTIFIED", "flag_reason": "x", "raw_field": "Total",
            "notes": [], "data": [{"year": 2021, "date": None, "numeric_value": 5.0, "unit": None, "multiplier": 1.0,
                                   "table_num": 1, "table_row": 8, "table_col": 3}]}
    database.save_extracted_metrics("EVCO4", "2024-25", 1, [item])
    miss = ocr.post("/ocr/company/EVCO4/line-overrides", headers=ALICE,
                    json={"fiscal_year": "2024-25", "page_number": 1, "table_row": 99, "field": "X"})
    assert miss.status_code == 404                        # no line at that row: nothing changed, the event is FAILED
    ok = ocr.post("/ocr/company/EVCO4/line-overrides", headers=ALICE,
                  json={"fiscal_year": "2024-25", "page_number": 1, "table_row": 8, "field": "Other assets total"})
    assert ok.status_code == 200
    oid = ok.json()["id"]
    assert ocr.delete(f"/ocr/company/EVCO4/line-overrides/{oid}", headers=ALICE).status_code == 200

    failed, = _events(ocr, instrument_code="EVCO4", status="FAILED")["events"]
    assert failed["action"] == "LINE_NAME_SET" and failed["details"]["table_row"] == 99
    done = _events(ocr, instrument_code="EVCO4", status="SUCCEEDED")["events"]
    removed, named = done
    assert (named["action"], named["target_type"], named["target_id"]) == ("LINE_NAME_SET", "line_override", str(oid))
    assert named["details"]["field"] == "Other assets total" and named["details"]["updated_metrics"] == 1
    assert removed["action"] == "LINE_NAME_REMOVE" and removed["target_id"] == str(oid)


def test_extract_with_a_failing_page_is_succeeded_with_the_failed_pages_listed(ocr, monkeypatch):
    _seed_page("EVCO5", "2024-25", 1, _MD, [])

    def boom(*_a, **_k):
        raise RuntimeError("gemini down")

    monkeypatch.setattr(extraction_service, "extract_financial_data_from_markdown", boom)
    r = ocr.post("/ocr/pipeline/extract", headers=ALICE,
                 json={"instrument_code": "EVCO5", "fiscal_year": "2024-25", "page_numbers": [1]})
    assert r.status_code == 200
    (ev,) = _events(ocr, instrument_code="EVCO5")["events"]
    assert (ev["action"], ev["status"], ev["fiscal_year"]) == ("PAGES_EXTRACT", "SUCCEEDED", "2024-25")
    assert ev["details"]["pages"] == [1] and ev["details"]["failed_pages"] == [1]


def test_extract_job_event_starts_with_the_job_id_and_is_finished_by_the_worker(ocr, monkeypatch):
    _seed_page("EVCO6", "2024-25", 1, _MD, [])
    monkeypatch.setattr(extraction_service, "extract_financial_data_from_markdown",
                        lambda *a, **k: {"items": [_item("Total assets", [(2025, 1000), (2024, 900)])],
                                         "tokens": 7, "duration_sec": 0.0})
    r = ocr.post("/ocr/jobs/extract", headers=ALICE,
                 json={"instrument_code": "EVCO6", "fiscal_year": "2024-25", "page_number": 1})
    assert r.status_code == 202
    job_id = r.json()["job_id"]
    for _ in range(100):
        if ocr.get(f"/ocr/jobs/{job_id}", headers=APIKEY).json()["status"] in ("done", "error"):
            break
        time.sleep(0.05)
    for _ in range(100):                                  # the worker finishes the event just after the job state
        (ev,) = _events(ocr, instrument_code="EVCO6")["events"]
        if ev["status"] != "STARTED":
            break
        time.sleep(0.05)
    assert (ev["action"], ev["status"], ev["job_id"], ev["username"]) == ("PAGES_EXTRACT", "SUCCEEDED", job_id, "alice")
    assert ev["details"]["job"] == "extract" and ev["details"]["total_tokens"] == 7


def test_job_that_fails_is_recorded_as_failed(ocr):
    r = ocr.post("/ocr/jobs/ocr", headers=ALICE,
                 json={"instrument_code": "EVCO7", "fiscal_year": "2024-25", "page_number": 1})
    job_id = r.json()["job_id"]
    for _ in range(100):
        ev = _events(ocr, instrument_code="EVCO7")["events"][0]
        if ev["status"] != "STARTED":
            break
        time.sleep(0.05)
    assert ev["status"] == "FAILED" and ev["job_id"] == job_id and ev["details"]["status_code"] == 404


def test_cancelled_merge_is_recorded_as_cancelled(ocr, monkeypatch):
    def cancelled(*_a, **_k):
        raise merge_service.MergeCancelled()

    monkeypatch.setattr(ocr_router, "_execute_merge", cancelled)
    ocr.post("/ocr/pipeline/merge", headers=ALICE, json={"instrument_code": "EVCO8"})
    (ev,) = _events(ocr, instrument_code="EVCO8")["events"]
    assert (ev["action"], ev["status"], ev["username"]) == ("MERGE_RUN", "CANCELLED", "alice")


def test_successful_merge_records_counts(ocr, monkeypatch):
    merged = {"rows": [1, 2], "merge_report": [1], "conflicts": [], "total_pairs": 3}
    monkeypatch.setattr(ocr_router, "_execute_merge",
                        lambda *a, **k: {"merged_res": merged, "token_usage": {"total_tokens": 5}})
    r = ocr.post("/ocr/pipeline/merge", headers=ALICE, json={"instrument_code": "EVCO9"})
    assert r.status_code == 200 and r.json()["merged_rows_count"] == 2          # the response is unchanged
    (ev,) = _events(ocr, instrument_code="EVCO9")["events"]
    assert ev["status"] == "SUCCEEDED"
    assert ev["details"] == {"merged_rows_count": 2, "merge_count": 1, "conflicts_count": 0, "total_pairs": 3,
                             "total_tokens": 5}


def test_a_merge_refused_with_409_is_not_an_event(ocr):
    lock = ocr_router._acquire_merge_lock("EVCO10")
    try:
        assert ocr.post("/ocr/pipeline/merge", headers=ALICE, json={"instrument_code": "EVCO10"}).status_code == 409
    finally:
        lock.release()
    assert _events(ocr, instrument_code="EVCO10")["total"] == 0


# ---------------------------------------------------------------- reading
def test_event_list_filters_and_paging(ocr):
    body = {"kind": "RENAME", "statement_type": "BALANCE_SHEET", "scope": "CONSOLIDATED", "a_label": "A", "new_label": "B"}
    for who in ("carol", "carol", "dave"):
        ocr.post("/ocr/company/PAGECO/merge/override", headers={**APIKEY, "X-Username": who}, json=body)
    assert _events(ocr, instrument_code="PAGECO")["total"] == 3
    assert _events(ocr, instrument_code="PAGECO", username="carol")["total"] == 2
    assert _events(ocr, instrument_code="PAGECO", action="OVERRIDE_REMOVE")["total"] == 0
    assert _events(ocr, instrument_code="PAGECO", status="SUCCEEDED")["total"] == 3
    page = _events(ocr, instrument_code="PAGECO", limit=2, offset=1)
    assert page["total"] == 3 and len(page["events"]) == 2
    today = time.strftime("%Y-%m-%d", time.gmtime())
    assert _events(ocr, instrument_code="PAGECO", since=today, until=today)["total"] == 3
    assert _events(ocr, instrument_code="PAGECO", until="2000-01-01")["total"] == 0
    assert ocr.get("/ocr/events", headers=APIKEY, params={"limit": 501}).status_code == 422
    assert ocr.get("/ocr/events", headers=APIKEY, params={"status": "NOPE"}).status_code == 422
    first = _events(ocr, instrument_code="PAGECO")["events"][0]
    assert first["created_at"].endswith("Z") and first["details"]["kind"] == "RENAME"


# ---------------------------------------------------------------- backfill
def test_backfill_attributes_history_to_one_user_and_runs_once(tmp_path, monkeypatch):
    monkeypatch.setattr(database, "DB_PATH", tmp_path / "t.db")
    database.init_db()
    database.upsert_document("BFCO", "2024-25", "BFCO_2024-25.pdf", "x.pdf", 10)
    database.record_pipeline_run("BFCO", "2024-25", "OCR", [1, 2], 1.0, 50)
    database.record_pipeline_run("BFCO", "2024-25", "EXTRACTION", [1], 1.0, 70)
    oid = database.add_merge_override("BFCO", {"kind": "RENAME", "statement_type": "BALANCE_SHEET", "scope": "CONSOLIDATED",
                                               "a_label_key": "a", "new_label": "b"})
    database.deactivate_merge_override("BFCO", oid)
    with database.get_connection() as conn:
        conn.execute("""INSERT INTO merge_review_item (instrument_code, kind, dedupe_key, payload_json, status, resolution,
                            created_at, updated_at) VALUES ('BFCO', 'VALUE_CONFLICT', 'k', '{}', 'dismissed', 'dismiss', 't1', 't2')""")
        conn.commit()

    counts = database.backfill_events("Fin001")
    assert counts == {"REPORT_UPLOAD": 1, "PAGES_OCR": 1, "PAGES_EXTRACT": 1, "OVERRIDE_RENAME": 1, "OVERRIDE_REMOVE": 1,
                      "REVIEW_DISMISS": 1}
    assert database.backfill_events("Someone") == {}                          # idempotent
    got = database.list_events(instrument_code="BFCO")
    assert got["total"] == 6
    assert {e["username"] for e in got["events"]} == {"Fin001"}
    assert {e["source"] for e in got["events"]} == {"backfill"} and {e["status"] for e in got["events"]} == {"SUCCEEDED"}
    ocr_run = next(e for e in got["events"] if e["action"] == "PAGES_OCR")
    assert ocr_run["details"]["pages"] == [1, 2] and ocr_run["target_type"] == "pipeline_run"
