"""

Tests for votes_house XML parser and votes_enrich Senate parser.

Coverage:

  • parse_house_vote_xml()  -  position enum, bill linkage, aggregate counts

  • _normalize_position()   -  canonical mapping including edge cases

  • _parse_legis_num()      -  bill-type normalization

  • parse_senate_vote_positions()  -  lis_member_id extraction, position mapping

  • Integration: schema setup + position insertion via temp DB

"""

import os

import sqlite3

import tempfile

import pytest

from ingest.db import get_connection, init_schema

from ingest.pollers.members import ensure_votes_schema

from ingest.pollers.votes_house import (

    _normalize_position,

    _parse_legis_num,

    parse_house_vote_xml,

)

from ingest.pollers.votes_enrich import parse_senate_vote_positions

SAMPLE_HOUSE_XML = """\

<?xml version="1.0" encoding="UTF-8"?>

<rollcall-vote>

  <vote-metadata>

    <majority>Republican</majority>

    <congress>119</congress>

    <session>1</session>

    <chamber>U.S. House of Representatives</chamber>

    <rollcall-num>42</rollcall-num>

    <legis-num>H R 1000</legis-num>

    <vote-question>On Passage</vote-question>

    <vote-type>YEA-AND-NAY</vote-type>

    <vote-result>Passed</vote-result>

    <action-date>15-Mar-2025</action-date>

    <action-time time-etz="2:30 PM">2:30 PM</action-time>

    <vote-desc>Some bill</vote-desc>

    <vote-totals>

      <totals-by-party>

        <party>Republican</party>

        <yea-total>210</yea-total>

        <nay-total>5</nay-total>

        <present-total>0</present-total>

        <not-voting-total>2</not-voting-total>

      </totals-by-party>

      <totals-by-party>

        <party>Democratic</party>

        <yea-total>3</yea-total>

        <nay-total>195</nay-total>

        <present-total>1</present-total>

        <not-voting-total>1</not-voting-total>

      </totals-by-party>

      <totals-by-vote>

        <yea-total>213</yea-total>

        <nay-total>200</nay-total>

        <present-total>1</present-total>

        <not-voting-total>3</not-voting-total>

      </totals-by-vote>

    </vote-totals>

  </vote-metadata>

  <vote-data>

    <recorded-vote>

      <legislator name-id="A000055" sort-field="Aderholt" party="R" state="AL" role="Member">Aderholt</legislator>

      <vote>Yea</vote>

    </recorded-vote>

    <recorded-vote>

      <legislator name-id="B000574" sort-field="Blumenauer" party="D" state="OR" role="Member">Blumenauer</legislator>

      <vote>Nay</vote>

    </recorded-vote>

    <recorded-vote>

      <legislator name-id="C000537" sort-field="Clyburn" party="D" state="SC" role="Member">Clyburn</legislator>

      <vote>Present</vote>

    </recorded-vote>

    <recorded-vote>

      <legislator name-id="D000617" sort-field="DelBene" party="D" state="WA" role="Member">DelBene</legislator>

      <vote>Not Voting</vote>

    </recorded-vote>

  </vote-data>

</rollcall-vote>

"""

VOICE_VOTE_XML = """\

<?xml version="1.0" encoding="UTF-8"?>

<rollcall-vote>

  <vote-metadata>

    <congress>119</congress>

    <rollcall-num>10</rollcall-num>

    <vote-type>VOICE VOTE</vote-type>

    <vote-result>Passed</vote-result>

    <action-date>10-Jan-2025</action-date>

    <vote-totals>

      <totals-by-vote>

        <yea-total>0</yea-total>

        <nay-total>0</nay-total>

        <present-total>0</present-total>

        <not-voting-total>0</not-voting-total>

      </totals-by-vote>

    </vote-totals>

  </vote-metadata>

</rollcall-vote>

"""

SAMPLE_SENATE_XML = """\

<?xml version="1.0" encoding="UTF-8"?>

<roll_call_vote>

  <congress>119</congress>

  <session>1</session>

  <congress_year>2025</congress_year>

  <vote_number>100</vote_number>

  <vote_date>March 15, 2025, 02:00 PM</vote_date>

  <vote_question_text>On Passage of the Bill</vote_question_text>

  <vote_result_text>Passed</vote_result_text>

  <count>

    <yeas>51</yeas>

    <nays>49</nays>

    <abstains>0</abstains>

    <present>0</present>

  </count>

  <members>

    <member>

      <lis_member_id>S000148</lis_member_id>

      <member_full>Schumer, Charles E.</member_full>

      <last_name>Schumer</last_name>

      <first_name>Charles</first_name>

      <party>D</party>

      <state>NY</state>

      <vote_cast>Yea</vote_cast>

    </member>

    <member>

      <lis_member_id>S001217</lis_member_id>

      <member_full>Scott, Rick</member_full>

      <last_name>Scott</last_name>

      <first_name>Rick</first_name>

      <party>R</party>

      <state>FL</state>

      <vote_cast>Nay</vote_cast>

    </member>

    <member>

      <lis_member_id>S001181</lis_member_id>

      <member_full>Shaheen, Jeanne</member_full>

      <last_name>Shaheen</last_name>

      <first_name>Jeanne</first_name>

      <party>D</party>

      <state>NH</state>

      <vote_cast>Not Voting</vote_cast>

    </member>

    <member>

      <lis_member_id>S001184</lis_member_id>

      <member_full>Scott, Tim</member_full>

      <last_name>Scott</last_name>

      <first_name>Tim</first_name>

      <party>R</party>

      <state>SC</state>

      <vote_cast>Present</vote_cast>

    </member>

  </members>

</roll_call_vote>

"""

class TestNormalizePosition:

    def test_yea_variants(self):

        assert _normalize_position("Yea") == "Yea"

        assert _normalize_position("YEA") == "Yea"

        assert _normalize_position("yea") == "Yea"

        assert _normalize_position("Aye") == "Yea"

        assert _normalize_position("aye") == "Yea"

    def test_nay_variants(self):

        assert _normalize_position("Nay") == "Nay"

        assert _normalize_position("NAY") == "Nay"

        assert _normalize_position("No") == "Nay"

        assert _normalize_position("no") == "Nay"

    def test_present(self):

        assert _normalize_position("Present") == "Present"

        assert _normalize_position("present") == "Present"

        assert _normalize_position("PRESENT") == "Present"

    def test_not_voting(self):

        assert _normalize_position("Not Voting") == "Not Voting"

        assert _normalize_position("not voting") == "Not Voting"

        assert _normalize_position("not-voting") == "Not Voting"

    def test_unknown_returns_none(self):

        assert _normalize_position("Abstain") is None

        assert _normalize_position("") is None

        assert _normalize_position("Pass") is None

    def test_positions_are_in_valid_set(self):

        valid = {"Yea", "Nay", "Present", "Not Voting"}

        for raw in ["Yea", "Nay", "Present", "Not Voting", "Aye", "No"]:

            result = _normalize_position(raw)

            assert result in valid, f"Got unexpected position {result!r} for {raw!r}"

class TestParseLegisNum:

    def test_house_bill(self):

        bt, num, ext = _parse_legis_num("H R 1234", 119)

        assert bt == "hr"

        assert num == "1234"

        assert ext == "119-hr-1234"

    def test_house_resolution(self):

        bt, num, ext = _parse_legis_num("H RES 50", 119)

        assert bt == "hres"

        assert num == "50"

        assert ext == "119-hres-50"

    def test_house_joint_resolution(self):

        bt, num, ext = _parse_legis_num("H J RES 88", 119)

        assert bt == "hjres"

        assert num == "88"

        assert ext == "119-hjres-88"

    def test_house_concurrent_resolution(self):

        bt, num, ext = _parse_legis_num("H CON RES 3", 119)

        assert bt == "hconres"

        assert num == "3"

        assert ext == "119-hconres-3"

    def test_senate_bill(self):

        bt, num, ext = _parse_legis_num("S 500", 119)

        assert bt == "s"

        assert num == "500"

        assert ext == "119-s-500"

    def test_senate_resolution(self):

        bt, num, ext = _parse_legis_num("S RES 22", 119)

        assert bt == "sres"

        assert num == "22"

        assert ext == "119-sres-22"

    def test_unparseable_returns_none_triple(self):

        bt, num, ext = _parse_legis_num("QUORUM CALL", 119)

        assert bt is None and num is None and ext is None

    def test_empty_returns_none_triple(self):

        bt, num, ext = _parse_legis_num("", 119)

        assert bt is None and num is None and ext is None

    def test_case_insensitive_prefix(self):

        bt, num, ext = _parse_legis_num("h r 999", 119)

        assert bt == "hr"

        assert num == "999"

class TestParseHouseVoteXml:

    SOURCE_URL = "https://clerk.house.gov/evs/2025/roll042.xml"

    def test_basic_fields(self):

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        assert result["congress"]     == 119

        assert result["session"]      == 1

        assert result["roll_number"]  == 42

        assert result["action_date"]  == "2025-03-15"

        assert result["question"]     == "On Passage"

        assert result["result"]       == "Passed"

        assert result["source_url"]   == self.SOURCE_URL

    def test_aggregate_counts(self):

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        assert result["yea"]        == 213

        assert result["nay"]        == 200

        assert result["present"]    == 1

        assert result["not_voting"] == 3

    def test_bill_linkage_parsed(self):

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        assert result["bill_text_ref"]     == "H R 1000"

        assert result["legis_external_id"] == "119-hr-1000"

    def test_positions_extracted(self):

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        positions = result["positions"]

        assert len(positions) == 4

    def test_position_bioguides(self):

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        pos_by_bio = {p["bioguide"]: p["position"] for p in result["positions"]}

        assert pos_by_bio["A000055"] == "Yea"

        assert pos_by_bio["B000574"] == "Nay"

        assert pos_by_bio["C000537"] == "Present"

        assert pos_by_bio["D000617"] == "Not Voting"

    def test_all_positions_in_valid_enum(self):

        valid = {"Yea", "Nay", "Present", "Not Voting"}

        result = parse_house_vote_xml(SAMPLE_HOUSE_XML, self.SOURCE_URL)

        assert result is not None

        for p in result["positions"]:

            assert p["position"] in valid, f"Invalid position: {p['position']!r}"

    def test_voice_vote_returns_none(self):

        """Voice votes must be skipped  -  no individual record exists."""

        result = parse_house_vote_xml(VOICE_VOTE_XML, self.SOURCE_URL)

        assert result is None, "Voice vote should not produce position data"

    def test_malformed_xml_returns_none(self):

        result = parse_house_vote_xml("<broken>", self.SOURCE_URL)

        assert result is None

    def test_empty_xml_returns_none(self):

        result = parse_house_vote_xml("", self.SOURCE_URL)

        assert result is None

class TestParseSenateVotePositions:

    def test_member_count(self):

        positions = parse_senate_vote_positions(SAMPLE_SENATE_XML)

        assert len(positions) == 4

    def test_all_positions_valid(self):

        valid = {"Yea", "Nay", "Present", "Not Voting"}

        for p in parse_senate_vote_positions(SAMPLE_SENATE_XML):

            assert p["position"] in valid

    def test_yea_member(self):

        positions = parse_senate_vote_positions(SAMPLE_SENATE_XML)

        schumer = next(p for p in positions if p["lis_member_id"] == "S000148")

        assert schumer["position"] == "Yea"

        assert schumer["state"] == "NY"

    def test_nay_member(self):

        positions = parse_senate_vote_positions(SAMPLE_SENATE_XML)

        scott = next(p for p in positions if p["lis_member_id"] == "S001217")

        assert scott["position"] == "Nay"

    def test_not_voting_member(self):

        positions = parse_senate_vote_positions(SAMPLE_SENATE_XML)

        shaheen = next(p for p in positions if p["lis_member_id"] == "S001181")

        assert shaheen["position"] == "Not Voting"

    def test_present_member(self):

        positions = parse_senate_vote_positions(SAMPLE_SENATE_XML)

        tim_scott = next(p for p in positions if p["lis_member_id"] == "S001184")

        assert tim_scott["position"] == "Present"

    def test_malformed_xml_returns_empty(self):

        assert parse_senate_vote_positions("<broken>") == []

    def test_empty_xml_returns_empty(self):

        assert parse_senate_vote_positions("") == []

    def test_no_members_element_returns_empty(self):

        xml = "<roll_call_vote><congress>119</congress></roll_call_vote>"

        assert parse_senate_vote_positions(xml) == []

class TestSchemaAndInsertion:

    """Verify that the schema setup and actual DB writes work end-to-end."""

    def _make_db(self):

        tmp = tempfile.mktemp(suffix=".db")

        conn = get_connection(tmp)

        init_schema(conn)

        ensure_votes_schema(conn)

        return conn, tmp

    def test_members_table_created(self):

        conn, tmp = self._make_db()

        tables = {

            row[0]

            for row in conn.execute(

                "SELECT name FROM sqlite_master WHERE type='table'"

            )

        }

        assert "members" in tables

        assert "vote_positions" in tables

        conn.close()

        os.unlink(tmp)

    def test_votes_extended_columns_present(self):

        conn, tmp = self._make_db()

        info = {

            row[1]

            for row in conn.execute("PRAGMA table_info(votes)")

        }

        for col in ["congress", "session", "roll_number", "question",

                    "not_voting", "recorded", "vote_external_id", "bill_text_ref"]:

            assert col in info, f"Expected column {col!r} in votes"

        conn.close()

        os.unlink(tmp)

    def test_vote_positions_indexes_exist(self):

        conn, tmp = self._make_db()

        indexes = {

            row[0]

            for row in conn.execute(

                "SELECT name FROM sqlite_master WHERE type='index'"

            )

        }

        assert "idx_vote_positions_vote_id"   in indexes

        assert "idx_vote_positions_member_id"  in indexes

        conn.close()

        os.unlink(tmp)

    def test_insert_position_row(self):

        conn, tmp = self._make_db()

        conn.execute(

            "INSERT INTO votes (chamber, date, yea, nay, present, result, source_url) "

            "VALUES (?, ?, ?, ?, ?, ?, ?)",

            ("house", "2025-03-15", 213, 200, 1, "Passed",

             "https://clerk.house.gov/evs/2025/ROLL_042.xml"),

        )

        vote_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]

        conn.execute(

            "INSERT INTO vote_positions (vote_id, member_bioguide, member_id, position) "

            "VALUES (?, ?, ?, ?)",

            (vote_id, "A000055", None, "Yea"),

        )

        conn.commit()

        row = conn.execute(

            "SELECT * FROM vote_positions WHERE vote_id=?", (vote_id,)

        ).fetchone()

        assert row is not None

        assert row["member_bioguide"] == "A000055"

        assert row["position"] == "Yea"

        conn.close()

        os.unlink(tmp)

    def test_position_enum_enforced(self):

        """SQLite CHECK constraint must reject invalid position values."""

        conn, tmp = self._make_db()

        conn.execute(

            "INSERT INTO votes (chamber, date, yea, nay, present, result, source_url) "

            "VALUES (?, ?, ?, ?, ?, ?, ?)",

            ("house", "2025-03-15", 1, 0, 0, "Passed",

             "https://clerk.house.gov/evs/2025/roll001.xml"),

        )

        vote_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]

        conn.execute("PRAGMA foreign_keys=ON")

        with pytest.raises(sqlite3.IntegrityError):

            conn.execute(

                "INSERT INTO vote_positions (vote_id, member_bioguide, position) "

                "VALUES (?, ?, ?)",

                (vote_id, "A000055", "Abstain"),

            )

            conn.commit()

        conn.close()

        os.unlink(tmp)

    def test_both_pivots_queryable(self):

        """

        Confirm that both query directions are supported:

          - all positions for a vote  (vote_id → vote_positions → members)

          - all votes for a member   (bioguide → vote_positions → votes)

        """

        conn, tmp = self._make_db()

        conn.execute(

            "INSERT INTO members (bioguide_id, full_name, party, state, chamber, source_url) "

            "VALUES (?, ?, ?, ?, ?, ?)",

            ("A000055", "Robert Aderholt", "Republican", "AL", "house",

             "https://bioguide.congress.gov/search/bio/A000055"),

        )

        member_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]

        for roll in [42, 43]:

            conn.execute(

                "INSERT INTO votes (chamber, date, yea, nay, present, result, source_url, roll_number) "

                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",

                ("house", "2025-03-15", 213, 200, 1, "Passed",

                 f"https://clerk.house.gov/evs/2025/ROLL_{roll:03d}.xml", roll),

            )

            vid = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]

            conn.execute(

                "INSERT INTO vote_positions (vote_id, member_bioguide, member_id, position) "

                "VALUES (?, ?, ?, ?)",

                (vid, "A000055", member_id, "Yea"),

            )

        conn.commit()

        vote_id_42 = conn.execute(

            "SELECT id FROM votes WHERE roll_number=42"

        ).fetchone()["id"]

        pos_rows = conn.execute(

            """

            SELECT vp.position, m.full_name, m.state

            FROM   vote_positions vp

            JOIN   members m ON m.id = vp.member_id

            WHERE  vp.vote_id = ?

            """,

            (vote_id_42,),

        ).fetchall()

        assert len(pos_rows) == 1

        assert pos_rows[0]["full_name"] == "Robert Aderholt"

        assert pos_rows[0]["position"]  == "Yea"

        member_votes = conn.execute(

            """

            SELECT v.roll_number, vp.position

            FROM   vote_positions vp

            JOIN   votes v ON v.id = vp.vote_id

            WHERE  vp.member_bioguide = 'A000055'

            ORDER  BY v.roll_number

            """,

        ).fetchall()

        assert len(member_votes) == 2

        assert member_votes[0]["roll_number"] == 42

        assert member_votes[1]["roll_number"] == 43

        conn.close()

        os.unlink(tmp)