"""Users add disclosures to a cell (never edit one) and choose which disclosure of a cell is the current one."""
import io

from openpyxl import load_workbook

import pytest

from tests.test_ocr import KEY, _MD, _item, _seed_page, full_results, merge_and_find, ocr  # noqa: F401  (fixture)

BODY = "/ocr/company/DISCCO"


@pytest.fixture
def seeded(ocr):  # noqa: F811
    """Two reports; the 2023-24 report states 2024 total assets differently from the 2024-25 one (a restatement). Its own company,
    because the tests add user data that must not leak into other tests."""
    from app.ocr import database
    with database.get_connection() as conn:
        for table in ("cell_disclosure", "cell_current"):
            conn.execute(f"DELETE FROM {table} WHERE instrument_code = 'DISCCO'")
        conn.commit()
    _seed_page("DISCCO", "2024-25", 5, _MD, [_item("Total assets", [(2025, 1000), (2024, 900)])])
    _seed_page("DISCCO", "2023-24", 7, _MD, [_item("Total assets", [(2024, 950), (2023, 800)])])
    return ocr


def _details(client, sid, year):
    return client.get(f"{BODY}/cell-details", headers=KEY, params={"series_id": sid, "year": year}).json()


def _merged_value(client, year="2024"):
    row = next(r for r in full_results(client, "DISCCO")["merged_rows"] if r["base_field"].lower() == "total assets")
    return row["values"][year], row


def test_extracted_records_say_where_they_came_from_and_one_is_current(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    d = _details(seeded, sid, 2024)
    recs = d["cell_records"]
    assert [r["origin"] for r in recs] == ["AI_EXTRACTED", "AI_EXTRACTED"] and all(r["disclosure_id"] is None for r in recs)
    assert all(r["record_key"].startswith("ai:") for r in recs)
    # the latest extracted record is current until a user chooses
    assert [r["is_current"] for r in recs] == [False, True]
    assert d["current_record_key"] == recs[-1]["record_key"] and d["current_is_override"] is False
    assert d["current_selection"] is None and d["user_added_count"] == 0


def test_entering_a_disclosure_changes_nothing_until_chosen(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    before, _ = _merged_value(seeded)
    r = seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={
        "series_id": sid, "year": 2024, "value": 1234.0, "note": "Corrected from the audited accounts",
        "reference": "ignored: not a field any more", "date": "2024-06-30"})
    assert r.status_code == 200
    made = r.json()
    assert made["replaced"] is False
    assert made["record_key"] == f"user:{made['disclosure_id']}" and made["created_by"] == "tester" and made["value"] == 1234.0

    d = _details(seeded, sid, 2024)
    user = [x for x in d["cell_records"] if x["origin"] == "USER_ADDED"]
    assert len(user) == 1 and d["user_added_count"] == 1 and len(d["cell_records"]) == 3
    u = user[0]
    assert (u["status"], u["effective_value"], u["created_by"], u["user_note"], u["date"]) ==         ("USER_ADDED", 1234.0, "tester", "Corrected from the audited accounts", "2024-06-30")
    assert "reference" not in made and "reference" not in u and "user_reference" not in u   # not taken, saved or returned
    assert u["restatement_type"] is None and u["is_current"] is False and u["page_number"] is None
    # not an overwrite: the extracted disclosures, the dots and the merged value are as before
    assert d["current_is_override"] is False and [e["type"] for e in d["flags"]] == ["RESTATED_LOW"]
    assert _merged_value(seeded)[0] == before
    # one endpoint adds and edits: there is no route per disclosure
    assert seeded.put(f"{BODY}/enter-disclosure/{made['disclosure_id']}", headers=KEY, json={"value": 1}).status_code in (404, 405)
    assert seeded.patch(f"{BODY}/enter-disclosure/{made['disclosure_id']}", headers=KEY, json={"value": 1}).status_code in (404, 405)


def test_choosing_the_current_disclosure_overwrites_the_merged_value_and_can_be_reset(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    auto, _ = _merged_value(seeded)
    made = seeded.post(f"{BODY}/enter-disclosure", headers=KEY,
                       json={"series_id": sid, "year": 2024, "value": 1234.0, "note": "audited"}).json()
    first = _details(seeded, sid, 2024)["cell_records"][0]            # the originally stated extracted record

    # choose the user's disclosure
    r = seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": made["record_key"]})
    assert r.status_code == 200 and r.json()["current_is_override"] is True
    value, row = _merged_value(seeded)
    assert value == 1234.0 and row["stating_years"]["2024"] == "USER"
    assert row["overrides"]["2024"]["origin"] == "USER_ADDED" and row["overrides"]["2024"]["set_by"] == "tester"
    d = _details(seeded, sid, 2024)
    assert d["current_is_override"] is True and d["current_record_key"] == made["record_key"]
    assert [x["origin"] for x in d["cell_records"] if x["is_current"]] == ["USER_ADDED"]
    assert d["current_selection"]["set_by"] == "tester" and d["current_selection"]["missing"] is False
    assert [e["type"] for e in d["flags"]] == ["RESTATED_LOW", "USER_DEFINED"] and d["flags"][-1]["value"] == 1234.0
    assert "timeline_summary" not in d and "restatement_dots" not in d

    # choosing is an overwrite: one choice per cell, replaced by the next (an extracted disclosure this time)
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": first["record_key"]})
    value, row = _merged_value(seeded)
    assert value == first["effective_value"] and row["overrides"]["2024"]["origin"] == "AI_EXTRACTED"
    assert [x["record_key"] for x in _details(seeded, sid, 2024)["cell_records"] if x["is_current"]] == [first["record_key"]]

    # the choice survives a re-merge, and the Excel download follows it
    merge_and_find(seeded, "DISCCO", "Total assets")
    assert _merged_value(seeded)[0] == first["effective_value"]
    wb = load_workbook(io.BytesIO(seeded.get(f"{BODY}/download/merged.xlsx", headers=KEY).content))
    ws = wb["Balance Sheet"]
    years = [c.value for c in ws[1]]
    line = next(r for r in range(2, ws.max_row + 1) if ws.cell(row=r, column=1).value == "Total assets")
    assert ws.cell(row=line, column=years.index("2024") + 1).value == first["effective_value"]
    assert "Chosen by tester" in ws.cell(row=line, column=years.index("2024") + 1).comment.text

    # back to automatic
    r = seeded.delete(f"{BODY}/cell-current", headers=KEY, params={"series_id": sid, "year": 2024})
    assert r.json()["reset"] is True and _merged_value(seeded)[0] == auto
    assert seeded.delete(f"{BODY}/cell-current", headers=KEY, params={"series_id": sid, "year": 2024}).json()["reset"] is False
    assert _details(seeded, sid, 2024)["current_is_override"] is False


def test_an_empty_cell_can_be_given_a_value(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    assert _details(seeded, sid, 2019)["cell_records"] == []
    made = seeded.post(f"{BODY}/enter-disclosure", headers=KEY,
                       json={"series_id": sid, "year": 2019, "value": 777, "note": "from the 2019 report"}).json()
    d = _details(seeded, sid, 2019)
    assert [x["origin"] for x in d["cell_records"]] == ["USER_ADDED"] and d["current_record_key"] is None
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2019, "record_key": made["record_key"]})
    assert _merged_value(seeded, "2019")[0] == 777.0


def test_validation_and_unknown_things(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    ok = {"series_id": sid, "year": 2024, "value": 5, "note": "x"}
    assert seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={**ok, "series_id": 999999}).status_code == 404
    assert seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={**ok, "note": ""}).status_code == 422
    assert seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={**ok, "value": "abc"}).status_code == 422
    assert seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={**ok, "date": "30 June"}).status_code == 422
    # a record key must belong to the cell
    bad = seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": "user:999"})
    assert bad.status_code == 422
    other_year = seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2023, "record_key":
                            _details(seeded, sid, 2024)["cell_records"][0]["record_key"]})
    assert other_year.status_code == 422
    assert seeded.put(f"{BODY}/cell-current", headers=KEY,
                      json={"series_id": 999999, "year": 2024, "record_key": "user:1"}).status_code == 404
    # a username is needed on every change
    no_user = {"X-API-Key": KEY["X-API-Key"]}
    assert seeded.post(f"{BODY}/enter-disclosure", headers=no_user, json=ok).status_code == 400
    assert seeded.put(f"{BODY}/cell-current", headers=no_user, json={"series_id": sid, "year": 2024, "record_key": "user:1"}).status_code == 400
    assert seeded.delete(f"{BODY}/cell-current", headers=no_user, params={"series_id": sid, "year": 2024}).status_code == 400


def test_the_actions_are_in_the_event_log(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    made = seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 5, "note": "x"}).json()
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": made["record_key"]})
    seeded.delete(f"{BODY}/cell-current", headers=KEY, params={"series_id": sid, "year": 2024})
    events = seeded.get("/ocr/events", headers=KEY, params={"instrument_code": "DISCCO"}).json()["events"]
    assert {"DISCLOSURE_ENTER", "CELL_CURRENT_SET", "CELL_CURRENT_RESET"} <= {e["action"] for e in events}


def test_a_cell_has_one_user_disclosure_and_entering_again_replaces_it(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    first = seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 111, "note": "first"}).json()
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": first["record_key"]})
    assert _merged_value(seeded)[0] == 111.0

    again = seeded.post(f"{BODY}/enter-disclosure", headers={**KEY, "X-Username": "second"},
                        json={"series_id": sid, "year": 2024, "value": 222, "note": "second", "date": "2024-06-30"}).json()
    assert again["replaced"] is True and again["disclosure_id"] == first["disclosure_id"] and again["record_key"] == first["record_key"]
    assert (again["value"], again["note"], again["created_by"], again["date"]) == (222.0, "second", "second", "2024-06-30")
    d = _details(seeded, sid, 2024)
    user = [x for x in d["cell_records"] if x["origin"] == "USER_ADDED"]
    assert len(user) == 1 and d["user_added_count"] == 1                          # still one
    assert (user[0]["effective_value"], user[0]["user_note"], user[0]["created_by"]) == (222.0, "second", "second")
    # it was the current disclosure and stays it, with the new figure; the extracted ones are untouched
    assert d["current_record_key"] == first["record_key"] and user[0]["is_current"] and _merged_value(seeded)[0] == 222.0
    assert [x["effective_value"] for x in d["cell_records"] if x["origin"] == "AI_EXTRACTED"] == [950.0, 900.0]
    # another year of the same row is its own cell
    other = seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2023, "value": 5, "note": "x"}).json()
    assert other["replaced"] is False and other["disclosure_id"] != first["disclosure_id"]
    # the replaced figure stays in the event log
    events = seeded.get("/ocr/events", headers=KEY, params={"instrument_code": "DISCCO"}).json()["events"]
    entered = [e for e in events if e["action"] == "DISCLOSURE_ENTER" and e["details"].get("replaced")]
    assert entered and entered[0]["details"]["previous"]["value"] == 111.0 and entered[0]["details"]["previous"]["created_by"] == "tester"


def test_a_user_disclosure_can_be_deleted_and_its_choice_goes_with_it(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    auto, _ = _merged_value(seeded)
    made = seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 111, "note": "x"}).json()
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": made["record_key"]})
    assert _merged_value(seeded)[0] == 111.0

    r = seeded.delete(f"{BODY}/enter-disclosure", headers=KEY, params={"series_id": sid, "year": 2024})
    assert r.status_code == 200 and r.json() == {"series_id": sid, "year": 2024, "deleted": True, "current_reset": True}
    d = _details(seeded, sid, 2024)
    assert d["user_added_count"] == 0 and [x["origin"] for x in d["cell_records"]] == ["AI_EXTRACTED", "AI_EXTRACTED"]
    assert d["current_is_override"] is False and d["current_selection"] is None and _merged_value(seeded)[0] == auto
    assert "USER_DEFINED" not in [e["type"] for e in d["flags"]]

    # nothing to delete the second time; the extracted disclosures are never deleted
    again = seeded.delete(f"{BODY}/enter-disclosure", headers=KEY, params={"series_id": sid, "year": 2024}).json()
    assert again == {"series_id": sid, "year": 2024, "deleted": False, "current_reset": False}
    assert len(_details(seeded, sid, 2024)["cell_records"]) == 2
    assert seeded.delete(f"{BODY}/enter-disclosure", headers=KEY, params={"series_id": 999999, "year": 2024}).status_code == 404
    assert seeded.delete(f"{BODY}/enter-disclosure", headers={"X-API-Key": KEY["X-API-Key"]},
                         params={"series_id": sid, "year": 2024}).status_code == 400

    # a disclosure that was NOT the current one: deleting keeps another choice (an extracted record) as it is
    first = _details(seeded, sid, 2024)["cell_records"][0]
    seeded.put(f"{BODY}/cell-current", headers=KEY, json={"series_id": sid, "year": 2024, "record_key": first["record_key"]})
    seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 5, "note": "y"})
    r = seeded.delete(f"{BODY}/enter-disclosure", headers=KEY, params={"series_id": sid, "year": 2024}).json()
    assert r["deleted"] is True and r["current_reset"] is False
    assert _details(seeded, sid, 2024)["current_record_key"] == first["record_key"]
    # the deleted figure stays in the event log, and the cell can be entered again
    events = seeded.get("/ocr/events", headers=KEY, params={"instrument_code": "DISCCO"}).json()["events"]
    deleted = [e for e in events if e["action"] == "DISCLOSURE_DELETE" and e["details"].get("deleted")]
    assert {e["details"]["previous"]["value"] for e in deleted} == {111.0, 5.0}
    assert seeded.post(f"{BODY}/enter-disclosure", headers=KEY, json={"series_id": sid, "year": 2024, "value": 7, "note": "z"}).json()["replaced"] is False


def test_series_formation_lists_members_metrics_and_values(seeded):  # noqa: F811
    sid = merge_and_find(seeded, "DISCCO", "Total assets")["series_id"]
    r = seeded.get(f"{BODY}/series-formation", headers=KEY, params={"series_id": sid})
    assert r.status_code == 200, r.text
    f = r.json()
    assert f["series_id"] == sid and f["merged_values"]["2024"] and f["unmatched_metrics"] == []
    assert [m["report"] for m in f["members"]] == ["2023-24", "2024-25"]
    assert f["members"][0]["link_rule"] is None and f["members"][1]["link_rule"]
    for m in f["members"]:
        assert len(m["metrics"]) == 1
        met = m["metrics"][0]
        assert met["metric_id"] and met["field"] and met["metric_type"] and met["page_number"]
        assert {v["year"] for v in met["values"]} == ({2024, 2023} if m["report"] == "2023-24" else {2025, 2024})
        assert all({"data_id", "value", "unit", "date", "restated", "table_row", "table_col"} <= set(v) for v in met["values"])
    assert seeded.get(f"{BODY}/series-formation", headers=KEY, params={"series_id": 999999}).status_code == 404
