"""

Unit tests for the bill diff classifier and rider detection regex.

All tests are pure-Python / no network / no DB.

"""

import pytest

from ingest.diff import (

    Section,

    classify_change,

    align_sections,

    _fuzzy_score,

    parse_sections,

    _make_snippet,

)

from ingest.rider_detect import (

    is_rider_signal,

    is_rider_signal_strong,

    matched_signals,

)

class TestClassifyChange:

    def test_added_when_old_empty(self):

        assert classify_change(None, "new text here") == "added"

    def test_added_when_old_blank(self):

        assert classify_change("", "new text here") == "added"

    def test_removed_when_new_empty(self):

        assert classify_change("old text", None) == "removed"

    def test_removed_when_new_blank(self):

        assert classify_change("old text", "") == "removed"

    def test_amended_when_both_differ(self):

        assert classify_change("original language", "revised language") == "amended"

    def test_no_change_when_identical(self):

        assert classify_change("same text", "same text") is None

    def test_no_change_whitespace_stripped(self):

        assert classify_change("  same  ", "same") is None

    def test_added_short(self):

        assert classify_change("", "x") == "added"

    def test_removed_short(self):

        assert classify_change("x", "") == "removed"

def _sec(sec_id="", enum="", header="", text=""):

    return Section(sec_id=sec_id, enum=enum, header=header, text=text)

class TestAlignSections:

    def test_exact_id_match(self):

        old = [_sec(sec_id="H001", header="Short Title", text="old")]

        new = [_sec(sec_id="H001", header="Short Title", text="new")]

        pairs = align_sections(old, new)

        assert len(pairs) == 1

        assert pairs[0][0] is old[0]

        assert pairs[0][1] is new[0]

    def test_added_section_no_id(self):

        old = [_sec(sec_id="H001", header="Definitions", text="some defs")]

        new = [

            _sec(sec_id="H001", header="Definitions", text="some defs"),

            _sec(sec_id="",     header="New Provision", text="brand new"),

        ]

        pairs = align_sections(old, new)

        matched = [(o, n) for o, n in pairs if o and n]

        added   = [(o, n) for o, n in pairs if o is None]

        assert len(matched) == 1

        assert len(added) == 1

    def test_removed_section(self):

        old = [

            _sec(sec_id="H001", header="Authorization", text="text"),

            _sec(sec_id="H002", header="Definitions",   text="defs"),

        ]

        new = [_sec(sec_id="H001", header="Authorization", text="text")]

        pairs = align_sections(old, new)

        removed = [(o, n) for o, n in pairs if n is None]

        assert len(removed) == 1

        assert removed[0][0].sec_id == "H002"

    def test_fuzzy_header_match(self):

        old = [_sec(sec_id="",  enum="1.", header="Authorization of Appropriations")]

        new = [_sec(sec_id="",  enum="1.", header="Authorization of Appropriationz")]

        pairs = align_sections(old, new)

        matched = [(o, n) for o, n in pairs if o and n]

        assert len(matched) == 1

    def test_fuzzy_below_threshold_not_matched(self):

        old = [_sec(sec_id="", enum="1.", header="Authorization of Appropriations")]

        new = [_sec(sec_id="", enum="9.", header="Entirely Different Section")]

        pairs = align_sections(old, new)

        added   = [(o, n) for o, n in pairs if o is None]

        removed = [(o, n) for o, n in pairs if n is None]

        assert len(added) == 1

        assert len(removed) == 1

    def test_empty_old(self):

        new = [_sec(sec_id="H001", text="all new")]

        pairs = align_sections([], new)

        added = [(o, n) for o, n in pairs if o is None]

        assert len(added) == 1

    def test_empty_new(self):

        old = [_sec(sec_id="H001", text="was here")]

        pairs = align_sections(old, [])

        removed = [(o, n) for o, n in pairs if n is None]

        assert len(removed) == 1

    def test_both_empty(self):

        assert align_sections([], []) == []

class TestMakeSnippet:

    def test_added_snippet_length(self):

        long_text = "X" * 1000

        s = _make_snippet(None, long_text, "added")

        assert len(s) <= 510

        assert s.endswith("…")

    def test_removed_snippet_short(self):

        s = _make_snippet("short", None, "removed")

        assert s == "short"

    def test_amended_has_diff_markers(self):

        s = _make_snippet("line one\nline two", "line one\nline three", "amended")

        assert "+" in s or "-" in s or "@@" in s

SIMPLE_BILL_XML = """<?xml version="1.0"?>

<bill>

  <body>

    <section id="H001">

      <enum>1.</enum>

      <header>Short Title</header>

      <text>This Act may be cited as the Test Act.</text>

    </section>

    <section id="H002">

      <enum>2.</enum>

      <header>Definitions</header>

      <text>In this Act-</text>

      <subsection>

        <enum>(a)</enum>

        <header>Term</header>

        <text>The term "widget" means any gizmo.</text>

      </subsection>

    </section>

  </body>

</bill>

"""

NAMESPACED_BILL_XML = """<?xml version="1.0"?>

<bill xmlns:ns="http://xml.house.gov/schemas/uslm/1.0">

  <ns:body>

    <ns:section id="S001">

      <ns:enum>1.</ns:enum>

      <ns:header>Purpose</ns:header>

      <ns:text>The purpose of this Act is to test parsing.</ns:text>

    </ns:section>

  </ns:body>

</bill>

"""

class TestParseSections:

    def test_simple_xml_two_sections(self):

        sections = parse_sections(SIMPLE_BILL_XML)

        assert len(sections) == 2

        assert sections[0].sec_id == "H001"

        assert "Short Title" in sections[0].header

        assert "Test Act" in sections[0].text

    def test_section_enum_captured(self):

        sections = parse_sections(SIMPLE_BILL_XML)

        assert sections[1].enum == "2."

    def test_subsection_text_flattened(self):

        sections = parse_sections(SIMPLE_BILL_XML)

        assert "widget" in sections[1].text or "widget" in sections[1].text

    def test_invalid_xml_returns_empty(self):

        sections = parse_sections("<not valid xml <<>>")

        assert sections == []

    def test_empty_xml_returns_empty(self):

        sections = parse_sections("")

        assert sections == []

    def test_namespaced_xml_parsed(self):

        sections = parse_sections(NAMESPACED_BILL_XML)

        assert isinstance(sections, list)

class TestRiderDetect:

    def test_notwithstanding_triggers(self):

        assert is_rider_signal(

            "Notwithstanding any other provision of law, the Secretary shall..."

        )

    def test_provided_comma_triggers(self):

        assert is_rider_signal(

            "Provided, That no funds shall be used for..."

        )

    def test_provided_further_triggers(self):

        assert is_rider_signal(

            "Provided Further, That the Director may waive..."

        )

    def test_is_amended_triggers(self):

        assert is_rider_signal(

            "Section 401(a) of the XYZ Act Is Amended by inserting..."

        )

    def test_are_authorized_triggers(self):

        assert is_rider_signal(

            "There Are Authorized to be appropriated $5,000,000 for each..."

        )

    def test_unless_triggers(self):

        assert is_rider_signal(

            "Unless the Secretary determines otherwise, the grant shall..."

        )

    def test_until_triggers(self):

        assert is_rider_signal(

            "No action shall be taken Until the report is submitted."

        )

    def test_determines_triggers(self):

        assert is_rider_signal(

            "The Administrator Determines that the standard is met."

        )

    def test_in_general_triggers(self):

        assert is_rider_signal("In General.  -  The Secretary shall...")

    def test_clean_text_no_trigger(self):

        assert not is_rider_signal(

            "This Act establishes a new national park in Colorado."

        )

    def test_case_insensitive_notwithstanding(self):

        assert is_rider_signal("NOTWITHSTANDING section 4 of the prior Act,")

    def test_case_insensitive_provided(self):

        assert is_rider_signal("provided, that all funds shall be...")

    def test_strong_check_no_funds(self):

        assert is_rider_signal_strong(

            "None of the funds appropriated under this Act shall be..."

        )

    def test_strong_check_no_funds_variant(self):

        assert is_rider_signal_strong(

            "No funds appropriated herein may be used to..."

        )

    def test_matched_signals_returns_list(self):

        signals = matched_signals(

            "Notwithstanding other provisions, Provided, That the Secretary..."

        )

        assert len(signals) >= 2

    def test_no_false_positive_normal_text(self):

        text = (

            "The Secretary of Defense shall submit a report to Congress "

            "within 90 days of the date of enactment of this Act "

            "describing the status of the program."

        )

        assert not is_rider_signal(text)

    def test_notwithstanding_inline(self):

        text = (

            "Notwithstanding section 1341 of title 31, United States Code, "

            "the Secretary may transfer amounts between appropriation accounts."

        )

        assert is_rider_signal(text)

    def test_provided_further_complex(self):

        text = (

            "Provided, That the amount made available shall be $10,000,000: "

            "Provided Further, That not less than $2,000,000 shall be for..."

        )

        assert is_rider_signal(text)

        signals = matched_signals(text)

        assert len(signals) >= 2

    def test_empty_text_no_trigger(self):

        assert not is_rider_signal("")

        assert not is_rider_signal_strong("")

OLD_BILL_XML = """<?xml version="1.0"?>

<bill>

  <body>

    <section id="H001">

      <enum>1.</enum>

      <header>Short Title</header>

      <text>This Act may be cited as the Widget Act of 2024.</text>

    </section>

    <section id="H002">

      <enum>2.</enum>

      <header>Authorization</header>

      <text>There is authorized to be appropriated $5,000,000.</text>

    </section>

  </body>

</bill>

"""

NEW_BILL_XML = """<?xml version="1.0"?>

<bill>

  <body>

    <section id="H001">

      <enum>1.</enum>

      <header>Short Title</header>

      <text>This Act may be cited as the Widget Act of 2025.</text>

    </section>

    <section id="H002">

      <enum>2.</enum>

      <header>Authorization</header>

      <text>There is authorized to be appropriated $10,000,000.</text>

    </section>

    <section id="H003">

      <enum>3.</enum>

      <header>Notwithstanding Provision</header>

      <text>Notwithstanding any other provision of law, no funds appropriated

            under this Act shall be used to implement section 404.</text>

    </section>

  </body>

</bill>

"""

class TestFullDiffPipeline:

    def test_changed_section_is_amended(self):

        old_secs = parse_sections(OLD_BILL_XML)

        new_secs = parse_sections(NEW_BILL_XML)

        pairs = align_sections(old_secs, new_secs)

        changes = {}

        for o, n in pairs:

            change = classify_change(

                o.text if o else None,

                n.text if n else None,

            )

            sec = (n or o)

            if change:

                changes[sec.sec_id] = change

        assert changes.get("H001") == "amended"

        assert changes.get("H002") == "amended"

        assert changes.get("H003") == "added"

    def test_added_section_rider_flag(self):

        old_secs = parse_sections(OLD_BILL_XML)

        new_secs = parse_sections(NEW_BILL_XML)

        pairs    = align_sections(old_secs, new_secs)

        for o, n in pairs:

            if o is None and n is not None:

                assert is_rider_signal(n.text), (

                    f"Expected rider signal in added section: {n.text!r}"

                )