r"""
conditions/depression_dx_pointer.py — document condition #6.

    python tests\test_conditions_depression_dx_pointer.py

Uses hcfa_claim.html rather than ub_claim.html: the real live claim this
condition was built for (9103000) is the professional/HCFA screen, and that
fixture already carries the full scenario (a wrongly-tagged 99213, a
wrongly-tagged G8510, and an untouched J7298) — see its own comments.
test_telehealth_fix.py separately proves the underlying primitive
(`retag_cpt_icd_pointer`) against the UB form's own id scheme.

G8431 (positive depression) has no row of its own in that fixture — only
G8510 — so `_inject_g8431_row()` adds one the same way the
medicare_telehealth tests inject a G2025 row, rather than growing the
shared fixture and risking every other test's row-count assumptions
(`CPT/HCPCS (3)`, `len(cpt) == 3`, ...). G8431 shares the SAME Z13.31
pointer as G8510 — there is no separate ICD code for "positive" depression,
only for the underlying CPT/HCPCS code itself.
"""

import io
import sys
import pathlib
import inspect
import contextlib

ROOT = pathlib.Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT / "src"))

FIXTURE = pathlib.Path(__file__).resolve().parent / "fixtures" / "hcfa_claim.html"

from ecw_bot.conditions import depression_dx_pointer         # noqa: E402
from ecw_bot.conditions.base import ConditionResult, run_all  # noqa: E402
from ecw_bot.pages import claim_form                          # noqa: E402
from ecw_bot.selectors import claim_form as sel               # noqa: E402


CASES = []


def case(fn):
    CASES.append(fn)
    return fn


_ICD_WITH_DEPRESSION = [
    {"#": "1", "Code": "Z30.430", "Name": "Encounter for insertion..."},
    {"#": "2", "Code": "Z13.31", "Name": "Negative depression screening"},
]


def _inject_g8431_row(page, icd1="1", checked=False):
    """
    hcfa_claim.html has no G8431 row of its own (only G8510) — injected the
    same way the medicare_telehealth tests inject a G2025 row, rather than
    growing the shared fixture and risking every other test's row-count
    assumptions (`CPT/HCPCS (3)`, `len(cpt) == 3`, ...).
    """
    page.evaluate(
        """(args) => {
            const tbody = document.querySelector(
                '#claimCPTCodesTable8888888888888 tbody');
            const addRowTr = tbody.querySelector('tr:last-child');
            const tr = document.createElement('tr');
            tr.id = 'CPTROW_3';
            tr.innerHTML =
                '<td><input data-fieldname="claimCPTCode" value="G8431" readonly></td>'
              + '<td><input type="checkbox" ng-click="updateBillToIns(3)"'
              + (args.checked ? ' checked' : '') + '></td>'
              + '<td><input data-fieldname="ClaimCPTICD1" value="' + args.icd1 + '"></td>'
              + '<td><input data-fieldname="ClaimCPTICD2" value=""></td>'
              + '<td><input data-fieldname="ClaimCPTICD3" value=""></td>'
              + '<td><input data-fieldname="ClaimCPTICD4" value=""></td>';
            tbody.insertBefore(tr, addRowTr);
        }""", {"icd1": icd1, "checked": checked})


def _inject_duplicate_target_row(page, code, row_id="CPTROW_3",
                                  icd1="1", checked=True, fee="75.00"):
    """
    Injects a SECOND row for a code already on the fixture (G8510, at
    CPTROW_2) — or for G8431 alongside `_inject_g8431_row` — to prove the
    duplicate-row suppression step: whichever row is later in DOM order is
    the one that should get unchecked and fee-zeroed, the first left alone.
    Carries a Billed Fee field, unlike `_inject_g8431_row`, since that is
    exactly what this step targets.
    """
    page.evaluate(
        """(args) => {
            const tbody = document.querySelector(
                '#claimCPTCodesTable8888888888888 tbody');
            const addRowTr = tbody.querySelector('tr:last-child');
            const tr = document.createElement('tr');
            tr.id = args.rowId;
            tr.innerHTML =
                '<td><input data-fieldname="claimCPTCode" value="' + args.code + '" readonly></td>'
              + '<td><input type="checkbox" ng-click="updateBillToIns(3)"'
              + (args.checked ? ' checked' : '') + '></td>'
              + '<td><input data-fieldname="ClaimCPTICD1" value="' + args.icd1 + '"></td>'
              + '<td><input data-fieldname="ClaimCPTICD2" value=""></td>'
              + '<td><input data-fieldname="ClaimCPTICD3" value=""></td>'
              + '<td><input data-fieldname="ClaimCPTICD4" value=""></td>'
              + '<td><input data-fieldname="ClaimCPTBilledFee" value="' + args.fee + '"></td>';
            tbody.insertBefore(tr, addRowTr);
        }""", {"code": code, "rowId": row_id, "icd1": icd1,
                "checked": checked, "fee": fee})


def _make_claim_already_correct(page):
    """
    Puts the fixture into the state live claim 9131000 was already in
    before the bot touched it: the first G8510 (CPTROW_2) checked and
    carrying nothing but the Z13.31 pointer ("2"), and 99213 no longer
    carrying it — so the retag and check steps have nothing left to do on
    the fixture's own rows, and anything reported comes from whatever a
    test injects on top.
    """
    page.evaluate(
        """() => {
            const set = (rowId, field, value) => {
                document.querySelector(
                    '#' + rowId + ' [data-fieldname="' + field + '"]').value = value;
            };
            set('CPTROW_0', 'ClaimCPTICD2', '3');
            set('CPTROW_0', 'ClaimCPTICD3', '');
            set('CPTROW_2', 'ClaimCPTICD1', '2');
            document.querySelector(
                '#CPTROW_2 [ng-click*="updateBillToIns("]').checked = true;
        }""")


def _count_checkbox_clicks(page, row_id):
    """
    Counts clicks on one row's "Assign To Patient" checkbox, read back as
    `window.clicksOn[row_id]`. On the live screen that click is what fires
    eCW's own `updateBillToIns()`, so a row that must stay excluded should
    never receive one at all — not merely end up unchecked again.
    """
    page.evaluate(
        """(rowId) => {
            window.clicksOn = window.clicksOn || {};
            window.clicksOn[rowId] = 0;
            document.querySelector('#' + rowId + ' [ng-click*="updateBillToIns("]')
                .addEventListener('click', () => { window.clicksOn[rowId] += 1; });
        }""", row_id)


@case
def detect_true_when_z13_31_is_on_the_claim():
    data = {"icd": _ICD_WITH_DEPRESSION}
    assert depression_dx_pointer.detect("C1", data) is True


@case
def detect_false_when_z13_31_is_absent():
    data = {"icd": [{"#": "1", "Code": "Z30.430", "Name": "..."}]}
    assert depression_dx_pointer.detect("C1", data) is False


@case
def detect_false_with_no_icd_key_at_all():
    assert depression_dx_pointer.detect("C1", {}) is False


@case
def apply_retags_g8510_and_strips_99213_on_the_real_claim_shape(page):
    """
    The full real scenario (claim 9103000): the ICD-pointer fix on 99213
    and G8510, PLUS the separately-reported bug — G8510's checkbox sat
    unchecked and needed checking once its pointer was corrected. Three
    changes total: two ICD-pointer edits and one checkbox check, both
    against G8510's own row.
    """
    page.goto(FIXTURE.as_uri())
    data = {"icd": _ICD_WITH_DEPRESSION}
    result = depression_dx_pointer.apply(page, "9103000", data)
    assert isinstance(result, ConditionResult)
    assert result.condition_name == "depression_dx_pointer"
    assert result.changed is True
    assert len(result.changes) == 3, result.changes

    icd_changes = [c for c in result.changes if "before" in c]
    checkbox_changes = [c for c in result.changes if "before" not in c]

    by_code = {c["code"]: c for c in icd_changes}
    assert set(by_code) == {"99213", "G8510"}, icd_changes
    assert by_code["G8510"]["after"]["icd"] == ["2", "", "", ""]
    assert by_code["99213"]["after"]["icd"] == ["1", "3", "", ""]

    assert checkbox_changes == [{"row": 2, "code": "G8510"}], checkbox_changes


@case
def apply_retags_g8431_with_the_same_z13_31_pointer_as_g8510(page):
    """
    G8510 (negative depression) and G8431 (positive depression) are
    different CPT codes but share the SAME one ICD pointer, Z13.31 — there
    is no separate "positive depression" ICD code (an earlier attempt to
    use Z13.32 for this was the client's own uncertain guess and has been
    reverted; only Z13.31 was ever actually given). Both rows end up
    carrying pointer "2", and 99213 keeps carrying nothing but its own
    diagnosis once the pointer is retagged onto both target rows.
    """
    page.goto(FIXTURE.as_uri())
    _inject_g8431_row(page, icd1="1", checked=False)

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    assert result.changed is True

    icd_changes = [c for c in result.changes if "before" in c]
    checkbox_changes = [c for c in result.changes if "before" not in c]

    by_code = {c["code"]: c for c in icd_changes}
    assert set(by_code) == {"99213", "G8510", "G8431"}, icd_changes
    assert by_code["G8510"]["after"]["icd"] == ["2", "", "", ""], by_code
    assert by_code["G8431"]["after"]["icd"] == ["2", "", "", ""], by_code
    assert by_code["99213"]["after"]["icd"] == ["1", "3", "", ""], by_code

    checkbox_codes = {c["code"] for c in checkbox_changes}
    assert checkbox_codes == {"G8510", "G8431"}, checkbox_changes

    g8431_row = page.locator(sel.SEL_CPT_ROWS).nth(3)
    assert [g8431_row.locator(s).first.input_value() for s in sel.SEL_CPT_ICD] \
        == ["2", "", "", ""]
    assert g8431_row.locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is True


@case
def apply_suppresses_a_duplicate_g8510_row_keeping_the_first(page):
    """
    The client's follow-up: G8510 duplicated on the same claim, both
    checked. The first (CPTROW_2, from the fixture) is retagged and left
    billed exactly as the base scenario proves; the duplicate (injected,
    later in DOM order) gets its ICD pointer retagged too but is then
    unchecked and its Billed Fee zeroed — "only one is enough".
    """
    page.goto(FIXTURE.as_uri())
    _inject_duplicate_target_row(page, "G8510", icd1="1", checked=True, fee="75.00")

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    assert result.changed is True
    assert len(result.changes) == 5, result.changes

    icd_changes = [c for c in result.changes if "before" in c]
    checked_changes = [c for c in result.changes
                        if "before" not in c and "unchecked" not in c and "fee" not in c]
    duplicate_changes = [c for c in result.changes
                          if "before" not in c and ("unchecked" in c or "fee" in c)]

    assert {c["row"] for c in icd_changes} == {0, 2, 3}, icd_changes
    assert checked_changes == [{"row": 2, "code": "G8510"}], checked_changes
    assert duplicate_changes == [{
        "row": 3, "code": "G8510",
        "unchecked": True, "fee": {"before": "75.00", "after": "0.00"},
    }], duplicate_changes

    first_row = page.locator(sel.SEL_CPT_ROWS).nth(2)
    assert first_row.locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is True
    assert first_row.locator(sel.SEL_CPT_BILLED_FEE).first.input_value() == "65.00", \
        "the first G8510 row must keep its own fee — only the duplicate is zeroed"

    duplicate_row = page.locator(sel.SEL_CPT_ROWS).nth(3)
    assert duplicate_row.locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is False
    assert duplicate_row.locator(sel.SEL_CPT_BILLED_FEE).first.input_value() == "0.00"


@case
def apply_leaves_a_single_g8510_row_alone_no_duplicate_suppression(page):
    """
    No second G8510/G8431 row on the claim — the duplicate step must be a
    no-op, proven directly against the base fixture's change count (the
    same 3 changes the non-duplicate test already asserts).
    """
    page.goto(FIXTURE.as_uri())
    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    assert len(result.changes) == 3, result.changes
    assert not any("unchecked" in c or "fee" in c for c in result.changes), result.changes


@case
def apply_leaves_an_already_excluded_duplicate_g8510_alone(page):
    """
    Live claim 9131000 (Logs\\run_20260929_161613.log): the first G8510 was
    already checked and tagged with Z13.31 alone, and a second G8510 further
    down sat unchecked at 0.00 — already excluded. The check step used to
    check that duplicate and the duplicate step unchecked it again straight
    after: no net change to the claim, but it was reported as changed, and
    the review box listed "checkbox checked (was excluded from the claim)"
    and "checkbox unchecked (duplicate row)" for the same row. There is
    nothing to do on this claim at all.
    """
    page.goto(FIXTURE.as_uri())
    _make_claim_already_correct(page)
    _inject_duplicate_target_row(page, "G8510", icd1="2", checked=False, fee="0.00")
    _count_checkbox_clicks(page, "CPTROW_3")

    result = depression_dx_pointer.apply(page, "9131000", {"icd": _ICD_WITH_DEPRESSION})
    duplicate_changes = [c for c in result.changes if c["row"] == 3]
    assert duplicate_changes == [], duplicate_changes
    assert result.changed is False, result.changes
    assert result.changes == [], result.changes

    duplicate_row = page.locator(sel.SEL_CPT_ROWS).nth(3)
    assert duplicate_row.locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is False
    assert page.evaluate("window.clicksOn['CPTROW_3']") == 0, \
        "the excluded duplicate's checkbox was clicked — updateBillToIns() would fire"


@case
def apply_checks_only_the_first_g8510_not_an_excluded_duplicate(page):
    """
    The same already-excluded duplicate as above, but with the first G8510
    still unchecked (the fixture's own 9103000 shape): that first row is the
    one to re-include, and only it. The duplicate — unchecked at 0.00 and
    already carrying Z13.31 — is left exactly as it was.
    """
    page.goto(FIXTURE.as_uri())
    _inject_duplicate_target_row(page, "G8510", icd1="2", checked=False, fee="0.00")
    _count_checkbox_clicks(page, "CPTROW_3")

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    checked_changes = [c for c in result.changes
                        if "before" not in c and "unchecked" not in c and "fee" not in c]
    assert checked_changes == [{"row": 2, "code": "G8510"}], checked_changes
    assert [c for c in result.changes if c["row"] == 3] == [], result.changes

    rows = page.locator(sel.SEL_CPT_ROWS)
    assert rows.nth(2).locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is True
    assert rows.nth(3).locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked() is False
    assert rows.nth(3).locator(sel.SEL_CPT_BILLED_FEE).first.input_value() == "0.00"
    assert page.evaluate("window.clicksOn['CPTROW_3']") == 0, \
        "the excluded duplicate's checkbox was clicked — updateBillToIns() would fire"


# =============================================================================
# Which row is kept per code — the ONE shared helper both the re-include and
# the duplicate step use (operator ruling, 2026-09-30)
# =============================================================================

@case
def kept_row_is_the_first_row_for_a_code_when_it_is_priced():
    rows = [(2, "G8510", "65.00"), (3, "G8510", "75.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8510": 2}


@case
def kept_row_skips_zero_fee_copies_for_the_first_priced_one():
    rows = [(2, "G8510", "0.00"), (3, "G8510", ""), (4, "G8510", "65.00"),
            (5, "G8510", "75.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8510": 4}


@case
def kept_row_is_the_first_by_position_when_every_copy_is_zero_fee():
    rows = [(2, "G8510", "0.00"), (3, "G8510", ""), (4, "G8510", "$0.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8510": 2}


@case
def kept_row_counts_a_row_with_no_fee_input_as_eligible():
    # None: no Billed Fee input at all — unknown, not zero.
    rows = [(2, "G8510", "0.00"), (3, "G8510", None), (4, "G8510", "65.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8510": 3}


@case
def kept_row_counts_a_non_numeric_fee_as_eligible():
    # is_zero_fee("N/A") is False — an unreadable fee is not zero.
    rows = [(2, "G8510", "0.00"), (3, "G8510", "N/A"), (4, "G8510", "65.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8510": 3}


@case
def kept_row_is_chosen_per_code():
    rows = [(1, "G8431", "0.00"), (2, "G8510", "65.00"), (3, "G8431", "40.00"),
            (4, "G8510", "0.00")]
    assert claim_form.kept_cpt_row_per_code(rows) == {"G8431": 3, "G8510": 2}


@case
def kept_row_of_no_rows_is_empty():
    assert claim_form.kept_cpt_row_per_code([]) == {}


def _set_fixture_g8510(page, *, checked=None, fee=None):
    """Sets the fixture's own G8510 (CPTROW_2) checkbox and/or Billed Fee."""
    page.evaluate(
        """(a) => {
            const tr = document.getElementById('CPTROW_2');
            if (a.checked !== null)
                tr.querySelector('[ng-click*="updateBillToIns("]').checked = a.checked;
            if (a.fee !== null)
                tr.querySelector('[data-fieldname="ClaimCPTBilledFee"]').value = a.fee;
        }""", {"checked": checked, "fee": fee})


def _state(page, index):
    row = page.locator(sel.SEL_CPT_ROWS).nth(index)
    return (row.locator(sel.SEL_CPT_ASSIGN_TO_PATIENT).first.is_checked(),
            row.locator(sel.SEL_CPT_BILLED_FEE).first.input_value())


@case
def apply_keeps_the_priced_g8510_when_the_first_copy_is_zero_fee(page):
    """
    Operator ruling (2026-09-30): the G8510 kept is the first whose fee is
    not zero. The fixture's G8510 (unchecked) is set to 0.00 and a later
    G8510 sits unchecked at 65.00 — that one is re-included, and the 0.00
    copy is left exactly as it is: already unchecked, already 0.00, never
    clicked. Before, the re-include step skipped the 0.00 first copy and
    no G8510 was billed at all.
    """
    page.goto(FIXTURE.as_uri())
    _set_fixture_g8510(page, fee="0.00")
    _inject_duplicate_target_row(page, "G8510", icd1="1", checked=False, fee="65.00")
    _count_checkbox_clicks(page, "CPTROW_2")
    _count_checkbox_clicks(page, "CPTROW_3")

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    not_retags = [c for c in result.changes if "before" not in c]
    assert not_retags == [{"row": 3, "code": "G8510"}], result.changes
    assert (_state(page, 2), _state(page, 3)) == ((False, "0.00"), (True, "65.00"))
    assert page.evaluate("window.clicksOn") == {"CPTROW_2": 0, "CPTROW_3": 1}


@case
def apply_unchecks_a_checked_zero_fee_first_copy_as_the_duplicate(page):
    """
    The same ruling from the other side: the first G8510 checked at 0.00,
    a later one checked at 75.00. The 75.00 copy is kept and keeps its fee;
    the 0.00 first copy is now the duplicate, unchecked by the duplicate
    step (its fee is already 0.00, so it is not written). Called straight
    here — in a real run zero_fee_uncheck has unchecked it first
    (test_conditions_zero_fee_uncheck.py).
    """
    page.goto(FIXTURE.as_uri())
    _set_fixture_g8510(page, checked=True, fee="0.00")
    _inject_duplicate_target_row(page, "G8510", icd1="1", checked=True, fee="75.00")

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    not_retags = [c for c in result.changes if "before" not in c]
    assert not_retags == [{"row": 2, "code": "G8510", "unchecked": True}], result.changes
    assert (_state(page, 2), _state(page, 3)) == ((False, "0.00"), (True, "75.00"))


@case
def apply_never_checks_a_zero_fee_g8510_even_when_every_copy_is_zero_fee(page):
    # Every copy at zero: the first by position is the one kept, and it is
    # still never checked — a line billed at zero is never billed.
    page.goto(FIXTURE.as_uri())
    _set_fixture_g8510(page, fee="0.00")
    _inject_duplicate_target_row(page, "G8510", icd1="1", checked=False, fee="0.00")
    _count_checkbox_clicks(page, "CPTROW_2")
    _count_checkbox_clicks(page, "CPTROW_3")

    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    assert [c for c in result.changes if "before" not in c] == [], result.changes
    assert (_state(page, 2), _state(page, 3)) == ((False, "0.00"), (False, "0.00"))
    assert page.evaluate("window.clicksOn") == {"CPTROW_2": 0, "CPTROW_3": 0}


@case
def re_include_and_duplicate_steps_always_agree_on_the_kept_row(page):
    """
    `ensure_cpt_rows_checked()` and `zero_and_uncheck_duplicate_cpt_rows()`
    decide "which G8510 is kept" through the one shared helper, so across
    every shape the row the first may check is never a row the second
    unchecks — claim 9131000's toggle can not come back through them
    disagreeing. `(first checked, first fee, later checked, later fee)` ->
    the row kept.
    """
    shapes = [
        ((True, "65.00", False, "0.00"), 2),    # live claim 9131000
        ((False, "65.00", False, "0.00"), 2),
        ((False, "0.00", False, "65.00"), 3),
        ((True, "0.00", True, "65.00"), 3),
        ((False, "", True, "75.00"), 3),
        ((True, "65.00", True, "75.00"), 2),
        ((False, "0.00", False, "0.00"), 2),    # every copy zero: first by position
    ]
    for (first_checked, first_fee, later_checked, later_fee), kept in shapes:
        page.goto(FIXTURE.as_uri())
        _set_fixture_g8510(page, checked=first_checked, fee=first_fee)
        _inject_duplicate_target_row(page, "G8510", checked=later_checked,
                                     fee=later_fee)
        before = {2: _state(page, 2), 3: _state(page, 3)}
        shape = (first_checked, first_fee, later_checked, later_fee)

        checked = claim_form.ensure_cpt_rows_checked(page, {"G8510", "G8431"})
        duplicate = claim_form.zero_and_uncheck_duplicate_cpt_rows(
            page, {"G8510", "G8431"})

        assert {c["row"] for c in checked} <= {kept}, (shape, checked)
        assert kept not in {c["row"] for c in duplicate}, (shape, duplicate)
        other = 5 - kept
        other_checked, other_fee = _state(page, other)
        assert other_checked is False and claim_form.is_zero_fee(other_fee), \
            (shape, "the other copy must end excluded", _state(page, other))
        assert _state(page, kept)[1] == before[kept][1], \
            (shape, "the kept row's fee must never be written")


@case
def apply_logs_why_when_the_claim_is_already_correct(page):
    """
    Live claim 9132000: Z13.31 was already only on G8431, so apply()
    returned ConditionResult.none — but the log's last word on it was
    "1 condition(s) matched — about to apply: depression_dx_pointer", which
    reads as a silent failure. Other conditions name their own "nothing
    to ..." reason; this one does too, and only on that path — not when
    the claim did change, and not when there is no Z13.31 to act on.
    """
    page.goto(FIXTURE.as_uri())
    _make_claim_already_correct(page)
    out = io.StringIO()
    with contextlib.redirect_stdout(out):
        result = depression_dx_pointer.apply(page, "9132000", {"icd": _ICD_WITH_DEPRESSION})
    assert result.changed is False, result.changes
    logged = out.getvalue()
    assert "[COND depression_dx_pointer 9132000]" in logged, logged
    assert "nothing to change" in logged, logged

    page.goto(FIXTURE.as_uri())
    out = io.StringIO()
    with contextlib.redirect_stdout(out):
        result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    assert result.changed is True, result.changes
    assert "nothing to change" not in out.getvalue(), out.getvalue()

    page.goto(FIXTURE.as_uri())
    out = io.StringIO()
    with contextlib.redirect_stdout(out):
        depression_dx_pointer.apply(
            page, "9103000", {"icd": [{"#": "1", "Code": "Z30.430", "Name": "..."}]})
    assert "nothing to change" not in out.getvalue(), out.getvalue()


@case
def apply_is_a_no_op_when_the_claim_has_no_depression_dx(page):
    page.goto(FIXTURE.as_uri())
    data = {"icd": [{"#": "1", "Code": "Z30.430", "Name": "..."}]}
    result = depression_dx_pointer.apply(page, "9103000", data)
    assert result.changed is False
    assert result.changes == []


@case
def describe_names_each_retagged_row(page):
    page.goto(FIXTURE.as_uri())
    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    text = depression_dx_pointer.describe(result)
    assert "G8510" in text and "99213" in text, text


@case
def describe_names_g8431_too_when_it_is_on_the_claim(page):
    page.goto(FIXTURE.as_uri())
    _inject_g8431_row(page, icd1="1", checked=False)
    result = depression_dx_pointer.apply(page, "9103000", {"icd": _ICD_WITH_DEPRESSION})
    text = depression_dx_pointer.describe(result)
    assert "G8431" in text, text


@case
def run_all_fires_depression_dx_pointer_alongside_telehealth_independently(page):
    """
    Against the REAL registry, not fakes - proves this condition is wired
    into conditions.CONDITIONS and does not collide with the telehealth
    conditions, which key off progress_notes/insurance, not icd.
    """
    page.goto(FIXTURE.as_uri())
    data = {"icd": _ICD_WITH_DEPRESSION}
    results = run_all(page, "9103000", data)
    assert len(results) == 1, results
    assert results[0].condition_name == "depression_dx_pointer", results


def _run_cases() -> int:
    if not FIXTURE.exists():
        print(f"  FAIL  fixture missing: {FIXTURE}")
        return 1
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        print("  SKIP  playwright is not installed")
        return 0

    failures = 0
    with sync_playwright() as pw:
        browser = pw.chromium.launch(headless=True)
        page = browser.new_page()

        for fn in CASES:
            name = fn.__name__.replace("_", " ")
            try:
                if len(inspect.signature(fn).parameters) == 0:
                    fn()
                else:
                    fn(page)
                print(f"  ok    {name}")
            except AssertionError as exc:
                print(f"  FAIL  {name}: {exc}")
                failures += 1
            except Exception as exc:
                print(f"  ERROR {name}: {type(exc).__name__}: {exc}")
                failures += 1
        browser.close()

    print(f"\n{len(CASES) - failures}/{len(CASES)} passed")
    return 1 if failures else 0


def main() -> int:
    from ecw_bot import settings as _cfg
    # These cases exercise eCW's own click and Add flow, as a LIVE-WRITE run
    # does. VERIFY clicks no box and adds no row (eCW saves both at once,
    # 2026-10-16): that is tests/test_verify_no_live_writes.py.
    orig = _cfg.SAVE_CORRECTIONS
    _cfg.SAVE_CORRECTIONS = True
    try:
        return _run_cases()
    finally:
        _cfg.SAVE_CORRECTIONS = orig


if __name__ == "__main__":
    sys.exit(main())