"""The merged table: slim rows, the type of every restatement, the detail endpoints, and review items only for HIGH variances."""
import pytest

from app.ocr import database
from app.ocr.services import series_keys as sk
from tests.test_ocr import KEY, _MD, _item, _seed_page, merge_and_find, ocr  # noqa: F401  (fixture)

BODY = "/ocr/company/SLIMCO"


@pytest.mark.parametrize("first,later,kind,expected,pct", [
    (1000.0, 1000.0, sk.CURRENCY, sk.RESTATED_IDENTICAL, 0.0),
    (13.98, 13.99, sk.PER_SHARE, sk.RESTATED_MICRO, None),
    (100.0, 125.0, sk.CURRENCY, sk.RESTATED_LOW, 25.0),                  # up to 25 %
    (100.0, 80.0, sk.CURRENCY, sk.RESTATED_LOW, -20.0),
    (100.0, 125.5, sk.CURRENCY, sk.RESTATED_MID, 25.5),                  # more than 25 %, up to 100 %
    (100.0, 200.0, sk.CURRENCY, sk.RESTATED_MID, 100.0),
    (100.0, 200.5, sk.CURRENCY, sk.RESTATED_HIGH, 100.5),                # more than 100 %
    (100.0, -50.0, sk.CURRENCY, sk.RESTATED_HIGH, -150.0),               # a sign flip is more than 100 %
    (0.0, 50.0, sk.CURRENCY, sk.RESTATED_HIGH, None),                    # from 0: no percentage, HIGH
])
def test_restatement_types(first, later, kind, expected, pct):
    typ, diff, got = sk.restatement_type(first, later, kind)
    assert typ == expected and diff == later - first
    if pct is not None:
        assert got == pytest.approx(pct)


def test_a_difference_below_one_printed_unit_is_micro():
    assert sk.restatement_type(1000.0, 1000.4, sk.CURRENCY)[0] == sk.RESTATED_MICRO
    assert sk.restatement_type(1_000_000.0, 1_001_000.0, sk.CURRENCY, 1.0, 1000.0)[0] == sk.RESTATED_MICRO     # one 'thousand' unit


@pytest.fixture
def slim(ocr):  # noqa: F811
    """Two reports: total assets restated 950 -> 900 (5 %), a line printed 100 then 400 (HIGH), a line printed twice the same."""
    with database.get_connection() as conn:
        for table in ("cell_disclosure", "cell_current"):
            conn.execute(f"DELETE FROM {table} WHERE instrument_code = 'SLIMCO'")
        conn.commit()
    _seed_page("SLIMCO", "2024-25", 5, _MD, [_item("Total assets", [(2025, 1000), (2024, 900)]),
                                             _item("Provisions", [(2025, 7), (2024, 400)]),
                                             _item("Cash", [(2025, 50), (2024, 40)])])
    _seed_page("SLIMCO", "2023-24", 7, _MD, [_item("Total assets", [(2024, 950), (2023, 800)]),
                                             _item("Provisions", [(2024, 100), (2023, 90)]),
                                             _item("Cash", [(2024, 40), (2023, 30)])])
    assert ocr.post("/ocr/pipeline/merge", headers=KEY, json={"instrument_code": "SLIMCO"}).status_code == 200
    return ocr


def _rows(client, **params):
    return {r["field"]: r for r in client.get(f"{BODY}/results/merged", headers=KEY, params=params).json()["merged_rows"]}


def test_the_table_rows_are_slim_and_carry_the_values_behind_the_dots(slim):  # noqa: F811
    rows = _rows(slim)
    ta = rows["Total assets"]
    assert set(ta) == {"series_id", "field", "scope", "statement_type", "unit", "metric_type", "level", "active", "values", "flags",
                       "breakdown", "breakdown_of", "merged_from_count", "mismatch_years"}
    assert ta["values"]["2024"] == 900.0 and ta["series_id"] and ta["active"] is True
    (entry,) = ta["flags"]["2024"]
    assert entry == {"type": "RESTATED_LOW", "report": "2024-25", "date": entry["date"], "value": 900.0, "original_value": 950.0,
                     "original_report": "2023-24", "difference": -50.0, "percent_change": -5.26}
    assert rows["Provisions"]["flags"]["2024"][0]["type"] == "RESTATED_HIGH"
    assert rows["Cash"]["flags"]["2024"][0]["type"] == "RESTATED_IDENTICAL"
    assert "2025" not in ta["flags"] and "restatement_dots" not in ta and "constituent_details" not in ta
    body = slim.get(f"{BODY}/results/merged", headers=KEY).json()
    assert "merge_report" not in body and "value_mismatch_conflicts" not in body
    assert isinstance(body["value_conflicts_count"], int) and isinstance(body["value_merge_count"], int)
    # the former rows are still there on request, and one row in full
    full = {r["field"]: r for r in slim.get(f"{BODY}/results/merged", headers=KEY, params={"view": "full"}).json()["merged_rows"]}
    assert "restatement_dots" in full["Total assets"] and len(str(full)) > len(str(rows))
    assert full["Total assets"]["flags"] == ta["flags"]


def test_a_chosen_disclosure_is_a_user_defined_flag(slim):  # noqa: F811
    sid = merge_and_find(slim, "SLIMCO", "Total assets")["series_id"]
    made = slim.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 5, "note": "x"}).json()
    slim.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": made["record_key"]})
    ta = _rows(slim)["Total assets"]
    assert ta["values"]["2024"] == 5.0
    assert [e["type"] for e in ta["flags"]["2024"]] == ["RESTATED_LOW", "USER_DEFINED"]
    user = ta["flags"]["2024"][-1]
    assert (user["value"], user["origin"], user["set_by"], user["record_key"]) == (5.0, "USER_ADDED", "tester", made["record_key"])
    slim.delete(f"{BODY}/cell-current", headers=KEY, params={"series_id": sid, "year": 2024})
    assert [e["type"] for e in _rows(slim)["Total assets"]["flags"]["2024"]] == ["RESTATED_LOW"]


def test_the_detail_endpoints_give_what_the_slim_table_leaves_out(slim):  # noqa: F811
    sid = _rows(slim)["Total assets"]["series_id"]
    row = slim.get(f"{BODY}/results/merged/row/{sid}", headers=KEY).json()
    assert row["series_id"] == sid and "constituent_details" in row and "restatement_dots" in row and row["flags"]["2024"]
    assert slim.get(f"{BODY}/results/merged/row/999999", headers=KEY).status_code == 404
    conflicts = slim.get(f"{BODY}/results/merged/conflicts", headers=KEY).json()
    assert conflicts["count"] == len(conflicts["value_mismatch_conflicts"])
    report = slim.get(f"{BODY}/results/merged/report", headers=KEY).json()
    assert report["count"] == len(report["merge_report"])
    counts = slim.get(f"{BODY}/results/merged", headers=KEY).json()
    assert (counts["value_conflicts_count"], counts["value_merge_count"]) == (conflicts["count"], report["count"])
