"""Backend guarantees the frontend relies on: API-key auth, error shape, merge stream,
stale merges, CSV escaping, usage report, cell details, page listing, registration, jobs."""
import json
import time

import pytest

from app.ocr import database
from app.ocr import router as ocr_router
from app.ocr.services import csv_service, extraction_service, merge_service
from tests.test_ocr import _MD, KEY, _item, _seed_page, full_results, merge_and_find, ocr  # noqa: F401  (fixture)


# ---------------------------------------------------------------- auth
@pytest.mark.parametrize("headers", [
    {}, {"X-API-Key": "nope"}, {"Authorization": "Bearer k3y"}, {"Authorization": "Bearer 123.abc"},
])
def test_missing_or_bad_api_key_is_401(ocr, headers):
    r = ocr.get("/ocr/company/X/status", headers=headers)
    assert r.status_code == 401
    assert r.json() == {"detail": "Not authenticated"}
    assert "www-authenticate" not in r.headers


def test_api_key_accepted(ocr):
    assert ocr.get("/ocr/company/X/status", headers=KEY).status_code == 200


def test_health_needs_no_key(ocr):
    assert ocr.get("/ocr/health").json()["status"] in ("pass", "warn")


# ---------------------------------------------------------------- error shape
def test_validation_error_detail_is_a_string(ocr):
    r = ocr.post("/ocr/pipeline/ocr", headers=KEY, json={"instrument_code": "AAA"})
    body = r.json()
    assert r.status_code == 422
    assert isinstance(body["detail"], str) and "fiscal_year" in body["detail"]
    assert isinstance(body["errors"], list)


def test_unknown_route_is_json_404(ocr):
    r = ocr.get("/ocr/nope", headers=KEY)
    assert r.status_code == 404 and r.json() == {"detail": "Not Found"}


# ---------------------------------------------------------------- CSV escaping
@pytest.mark.parametrize("value,expected", [
    ("=SUM(A1)", "'=SUM(A1)"), ("+cmd", "'+cmd"), ("-abc", "'-abc"), ("@x", "'@x"),
    ("\tx", "'\tx"), ("-5", "-5"), ("-1.5e3", "-1.5e3"), ("Total assets", "Total assets"), ("", ""), (12, 12),
])
def test_csv_safe_cell(value, expected):
    assert csv_service.csv_safe_cell(value) == expected


@pytest.mark.parametrize("value,expected", [
    # Dates are read before fiscal-year ranges ("2023-06-30" was once parsed as "2023-06" -> 2006).
    ("2023-06-30", 2023), ("2014-12-31", 2014), ("2024-03-31", 2024), ("30.06.2023", 2023),
    ("2023-24", 2024), ("2023-2024", 2024), ("FY 2023-24", 2024), ("1999-00", 2000),
    ("July 01, 2020 to June 30, 2021", 2021), ("30 June 2025", 2025), ("2024", 2024), (2024, 2024),
    (None, None), ("", None), ("n/a", None),
])
def test_extract_year_int(value, expected):
    assert csv_service.extract_year_int(value) == expected


def test_csv_escaping_round_trips_through_parser():
    _seed_page("CSVCO", "2024-25", 1, _MD, [_item("=HYPERLINK(evil)", [(2025, -5)])])
    raw = csv_service.build_raw_csv_from_metrics(database.get_all_metrics_for_company("CSVCO"))
    assert "'=HYPERLINK(evil)" in raw["csv_text"]
    assert ",-5" in raw["csv_text"]
    (row,) = csv_service.parse_csv_text_to_rows(raw["csv_text"])
    assert row["field"] == "=HYPERLINK(evil)" and row["values"]["2025"] == -5


def test_download_has_bom(ocr):
    _seed_page("BOMCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    r = ocr.get("/ocr/company/BOMCO/download/raw", headers=KEY)
    assert r.status_code == 200 and r.content.startswith(b"\xef\xbb\xbf")


# ---------------------------------------------------------------- merge stream
# Single-report companies have nothing ambiguous to link, so these merges never call Gemini.
def _events(r):
    return [json.loads(line) for line in r.text.splitlines() if line.strip()]


def test_merge_stream_ends_with_complete(ocr):
    _seed_page("MRGCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    events = _events(ocr.post("/ocr/pipeline/merge/stream", headers=KEY, json={"instrument_code": "MRGCO"}))
    terminal = [e for e in events if e["type"] in ("complete", "error")]
    assert [e["type"] for e in terminal] == ["complete"] and events[-1] is terminal[0]
    assert "csv_text" in events[-1]["merged_csv_data"]
    assert events[0]["type"] == "init"


def test_merge_stream_tells_how_many_gemini_calls_to_expect(ocr):
    _seed_page("PRGCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    events = _events(ocr.post("/ocr/pipeline/merge/stream", headers=KEY, json={"instrument_code": "PRGCO"}))
    init, finalize, complete = events[0], next(e for e in events if e["type"] == "finalize"), events[-1]
    assert init["stage"] == "init" and init["gemini_calls_total"] == 0 and init["gemini_calls_done"] == 0
    assert init["estimate_exact"] is False and init["rounds_total"] == 0 and init["eta_sec"] is None
    assert finalize["stage"] == "saving" and finalize["estimate_exact"] is True and finalize["gemini_calls_total"] == 0
    assert complete["stage"] == "complete" and complete["gemini_calls_done"] == complete["gemini_calls_total"] == 0
    assert complete["estimate_exact"] is True


def test_merge_stream_exception_ends_with_error(ocr, monkeypatch):
    from app.ocr.services import series_linker
    _seed_page("ERRCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    real = series_linker.link_company

    def boom(*_a, **_k):
        raise ValueError("secret detail")

    monkeypatch.setattr(series_linker, "link_company", boom)
    events = _events(ocr.post("/ocr/pipeline/merge/stream", headers=KEY, json={"instrument_code": "ERRCO"}))
    assert [e["type"] for e in events if e["type"] != "init"] == ["error"]
    assert events[-1]["error"] == "Merge failed (ValueError)"
    # The lock was released: the next merge is not rejected.
    monkeypatch.setattr(series_linker, "link_company", real)
    events = _events(ocr.post("/ocr/pipeline/merge/stream", headers=KEY, json={"instrument_code": "ERRCO"}))
    assert events[-1]["type"] == "complete"


def test_concurrent_merge_is_409(ocr):
    _seed_page("LOCKCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    lock = ocr_router._acquire_merge_lock("LOCKCO")
    try:
        for path in ("/ocr/pipeline/merge/stream", "/ocr/pipeline/merge"):
            r = ocr.post(path, headers=KEY, json={"instrument_code": "LOCKCO"})
            assert r.status_code == 409 and "already running" in r.json()["detail"]
    finally:
        lock.release()


def test_cancelled_merge_saves_nothing(ocr):
    _seed_page("CANCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    metrics = database.get_all_metrics_for_company("CANCO")
    with pytest.raises(merge_service.MergeCancelled):
        ocr_router._execute_merge("CANCO", metrics, should_cancel=lambda: True)
    assert not (database.get_company_results("CANCO") or {}).get("merged_csv_text")


# ---------------------------------------------------------------- stale merge + results shape
def test_merged_stale_flag(ocr):
    _seed_page("STALECO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    assert ocr.post("/ocr/pipeline/merge", headers=KEY, json={"instrument_code": "STALECO"}).status_code == 200

    body = full_results(ocr, "STALECO")
    assert body["has_merged_csv"] and body["merged_stale"] is False
    assert body["updated_at"].endswith("Z")

    database.record_pipeline_run("STALECO", "2024-25", "EXTRACTION", [1], 0.0, 0)
    assert full_results(ocr, "STALECO")["merged_stale"] is True


def test_results_always_has_arrays_and_strings(ocr):
    _seed_page("EMPTYCO", "2024-25", 1, _MD, [_item("Total assets", [(2025, 1000)])])
    body = full_results(ocr, "EMPTYCO")
    assert body["merged_rows"] == [] and "merged_csv_text" not in body and body["merged_stale"] is False
    assert isinstance(body["raw_rows"], list) and "raw_csv_text" not in body


# ---------------------------------------------------------------- usage report
def test_usage_report_merge_runs(ocr):
    _seed_page("USECO", "2024-25", 1, _MD, [])
    database.record_pipeline_run("USECO", "2023-24-2024-25", "MERGE", [], 2.0, 100,
                                 details=[{"analyzed_years": ["2023-24", "2024-25"]}])
    body = ocr.get("/ocr/company/USECO/usage-report", headers=KEY).json()
    (run,) = [r for r in body["recent_runs"] if r["process_type"] == "MERGE"]
    assert run["fiscal_year"] is None and run["fiscal_year_label"] == "2023-24-2024-25"
    assert run["created_at"].endswith("Z")
    assert {y["fiscal_year"]: y["merge_tokens"] for y in body["by_year"]} == {"2023-24": 50, "2024-25": 50}

    year = ocr.get("/ocr/company/USECO/year/2024-25/usage-report", headers=KEY).json()
    assert year["summary"]["merge"]["total_tokens"] == 50
    assert any(r["process_type"] == "MERGE" for r in year["recent_runs"])


# ---------------------------------------------------------------- cell details
def test_cell_details_partial_micro_variance_is_null(seeded):
    row = merge_and_find(seeded, "SEEDCO", "Total assets")
    with database.get_connection() as conn:
        rows = json.loads(conn.execute("SELECT merged_rows_json FROM company_results WHERE instrument_code = 'SEEDCO'").fetchone()[0])
        for r in rows:
            if r["series_id"] == row["series_id"]:
                r["micro_variances"] = {"2024": {"val_a": 1}}
        conn.execute("UPDATE company_results SET merged_rows_json = ? WHERE instrument_code = 'SEEDCO'", (json.dumps(rows),))
        conn.commit()
    body = seeded.get("/ocr/company/SEEDCO/cell-details", headers=KEY,
                      params={"series_id": row["series_id"], "year": 2024}).json()
    assert body["micro_variance"] is None and body["has_micro_variance"] is False
    rv = body["restatement_variance"]
    assert set(rv) == {"original_value", "restated_value", "difference", "percent_change"}
    assert "timeline_summary" not in body and isinstance(body["flags"], list)




@pytest.fixture
def seeded(ocr):
    _seed_page("SEEDCO", "2024-25", 5, _MD, [_item("Total assets", [(2025, 1000), (2024, 900)])])
    _seed_page("SEEDCO", "2023-24", 7, _MD, [_item("Total assets", [(2024, 950), (2023, 800)])])
    return ocr


# ---------------------------------------------------------------- pages
def test_pages_without_markdown_and_single_page_markdown(ocr):
    _seed_page("MDCO", "2024-25", 2, _MD, [])
    pages = ocr.get("/ocr/company/MDCO/year/2024-25/pages", headers=KEY,
                    params={"include_markdown": "false"}).json()["pages"]
    assert pages and all(p["ocr_markdown"] is None for p in pages)
    assert pages[0]["has_markdown"] is True and "image_url" in pages[0]

    r = ocr.get("/ocr/company/MDCO/year/2024-25/page/2/markdown", headers=KEY)
    assert r.json() == {"page": 2, "ocr_markdown": _MD}
    assert ocr.get("/ocr/company/MDCO/year/2024-25/page/9/markdown", headers=KEY).status_code == 404


# ---------------------------------------------------------------- registration
def test_register_document_replace_keeps_filepath(ocr):
    pdf = ("file", ("a.pdf", b"%PDF-1.4\n%%EOF\n", "application/pdf"))
    form = {"instrument_code": "REGCO", "fiscal_year": "2024-25", "filename": "a.pdf", "total_pages": "3"}
    first = ocr.post("/ocr/register-document", headers=KEY, data=form, files=[pdf]).json()
    assert first["replaced"] is False
    path = database.get_document_by_year("REGCO", "2024-25")["filepath"]

    from app.ocr import config as ocr_config
    (ocr_config.UPLOADS_DIR / "REGCO_2024-25.pdf").unlink()
    second = ocr.post("/ocr/register-document", headers=KEY, data={**form, "total_pages": "4"}).json()
    assert second["replaced"] is True
    doc = database.get_document_by_year("REGCO", "2024-25")
    assert doc["filepath"] == path and doc["total_pages"] == 4


def test_upload_413_detail_names_limit(ocr, monkeypatch):
    from app.ocr import config as ocr_config
    monkeypatch.setattr(ocr_config, "MAX_UPLOAD_BYTES", 10)
    pdf = ("file", ("a.pdf", b"%PDF-" + b"x" * 100, "application/pdf"))
    r = ocr.post("/ocr/register-document", headers=KEY, data={
        "instrument_code": "BIGCO", "fiscal_year": "2024-25", "filename": "a.pdf", "total_pages": "1"}, files=[pdf])
    assert r.status_code == 413 and "MB" in r.json()["detail"]


# ---------------------------------------------------------------- extraction + jobs
def test_extract_failed_page_still_reported(ocr, monkeypatch):
    _seed_page("EXTCO", "2024-25", 1, _MD, [])

    def boom(*_a, **_k):
        raise RuntimeError("gemini down")

    monkeypatch.setattr(extraction_service, "extract_financial_data_from_markdown", boom)
    body = ocr.post("/ocr/pipeline/extract", headers=KEY, json={
        "instrument_code": "EXTCO", "fiscal_year": "2024-25", "page_numbers": [1]}).json()
    (res,) = body["verification_results"]
    assert res["page_number"] == 1 and res["is_success"] is False and res["extraction_status"] == "FAILED"


def test_extract_job_lifecycle(ocr, monkeypatch):
    _seed_page("JOBCO", "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": 1, "duration_sec": 0.0})
    r = ocr.post("/ocr/jobs/extract", headers=KEY, json={
        "instrument_code": "JOBCO", "fiscal_year": "2024-25", "page_number": 1})
    assert r.status_code == 202
    job_id = r.json()["job_id"]
    for _ in range(100):
        job = ocr.get(f"/ocr/jobs/{job_id}", headers=KEY).json()
        if job["status"] in ("done", "error"):
            break
        time.sleep(0.05)
    assert job["status"] == "done", job
    assert job["result"]["verification_results"][0]["page_number"] == 1
    assert ocr.get("/ocr/jobs/" + "f" * 32, headers=KEY).status_code == 404


def test_companies_basic(ocr):
    rows = ocr.get("/ocr/companies", headers=KEY, params={"fields": "basic"}).json()
    assert len(rows) > 100 and set(rows[0]) == {"security_code", "company_name", "sector"}
