"""

Tests for state coverage and the STATE_LEG_HOSTS allowlist.

Covers:

  1. STATE_LEG_HOSTS  -  explicit non-.gov state legislature hosts

  2. *.state.<XX>.us pattern matching

  3. state_coverage.compute() populates all 52 jurisdictions as "missing"

     when the DB is empty (keys absent scenario)

  4. state_coverage.compute() flips to "ok" after log_scrape() is called

  5. state_coverage.compute() correctly marks "stale" for old timestamps

  6. Helper functions: _confidence(), _infer_state_from_ocd(),

     _infer_state_from_legiscan_id()

"""

import os

import sqlite3

import tempfile

from datetime import datetime, timedelta, timezone

import pytest

from ingest.source_validator import (

    STATE_LEG_HOSTS,

    _is_state_leg_pattern,

    is_allowlisted,

    validate_source_url,

    SourceURLError,

)

from ingest.state_coverage import (

    ALL_STATES,

    SOURCES,

    DATA_TYPES,

    STALE_HOURS,

    _confidence,

    _infer_state_from_ocd,

    _infer_state_from_legiscan_id,

    compute,

    log_scrape,

)

from ingest.db import get_connection, init_schema

def _make_db():

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

    conn = get_connection(tmp)

    init_schema(conn)

    return conn, tmp

class TestStateLegHosts:

    def test_state_leg_hosts_is_non_empty(self):

        assert len(STATE_LEG_HOSTS) > 0

    def test_explicit_pa_host_is_allowed(self):

        assert is_allowlisted("https://www.legis.state.pa.us/CFDOCS/billInfo/billInfo.cfm?sYear=2025&sInd=0&body=H&type=B&bn=1")

    def test_explicit_nj_host_is_allowed(self):

        assert is_allowlisted("https://www.njleg.state.nj.us/Bills/2025/A0500/499_I1.HTM")

    def test_ks_org_host_is_allowed(self):

        assert is_allowlisted("https://www.kslegislature.org/li/b2025_26/measures/hb2001/")

    def test_tx_capitol_host_is_allowed(self):

        assert is_allowlisted("https://capitol.state.tx.us/BillLookup/History.aspx?LegSess=89R&Bill=HB1")

    def test_mn_leg_host_is_allowed(self):

        assert is_allowlisted("https://www.leg.state.mn.us/cgi-bin/bi?mode=1&session=91")

    def test_ms_billstatus_host_is_allowed(self):

        assert is_allowlisted("https://billstatus.ls.state.ms.us/2025/pdf/history/SB/SB2001.xml")

    def test_nh_gencourt_host_is_allowed(self):

        assert is_allowlisted("https://www.gencourt.state.nh.us/legislation/2025/SB0001.html")

    def test_ak_legis_host_is_allowed(self):

        assert is_allowlisted("https://www.legis.state.ak.us/basis/bill_status.asp?session=34&bill=SB1")

    def test_ar_arkleg_host_is_allowed(self):

        assert is_allowlisted("https://www.arkleg.state.ar.us/Bills/Detail?id=SB1&ddBienniumSession=2025%2F2025R")

    def test_dotgov_still_passes(self):

        """Existing .gov URLs must still pass after the STATE_LEG_HOSTS addition."""

        gov_urls = [

            "https://leginfo.legislature.ca.gov/faces/billStatusClient.xhtml?bill_id=202520260AB1",

            "https://leg.colorado.gov/bills/hb25-1001",

            "https://legislature.mi.gov/documents/2025-2026/billengrossed/House/htm/2025-HEB-0001.htm",

            "https://malegislature.gov/Bills/194/H1",

            "https://www.congress.gov/bill/119th-congress/house-bill/1",

        ]

        for url in gov_urls:

            assert is_allowlisted(url), f"Expected .gov URL to pass: {url}"

    def test_aggregator_hosts_rejected(self):

        """OpenStates and LegiScan URLs must NOT be accepted as source_url."""

        bad_urls = [

            "https://openstates.org/ca/bills/20252026/AB1/",

            "https://legiscan.com/CA/bill/AB1/2025",

            "https://api.legiscan.com/",

        ]

        for url in bad_urls:

            assert not is_allowlisted(url), f"Aggregator URL should be rejected: {url}"

class TestStateLegPattern:

    def test_pattern_matches_pa(self):

        assert _is_state_leg_pattern("legis.state.pa.us")

    def test_pattern_matches_pa_with_www(self):

        assert _is_state_leg_pattern("www.legis.state.pa.us")

    def test_pattern_matches_nj(self):

        assert _is_state_leg_pattern("njleg.state.nj.us")

    def test_pattern_matches_mn_deep(self):

        assert _is_state_leg_pattern("www.house.leg.state.mn.us")

    def test_pattern_matches_ms(self):

        assert _is_state_leg_pattern("billstatus.ls.state.ms.us")

    def test_pattern_rejects_govtrack(self):

        assert not _is_state_leg_pattern("govtrack.us")

    def test_pattern_rejects_short_us(self):

        assert not _is_state_leg_pattern("example.us")

    def test_pattern_rejects_no_state_segment(self):

        assert not _is_state_leg_pattern("www.legislature.mi.gov")

    def test_pattern_rejects_wrong_tld(self):

        assert not _is_state_leg_pattern("legis.state.ca.com")

    def test_full_url_via_is_allowlisted(self):

        assert is_allowlisted("https://gencourt.state.nh.us/legislation/2025/SB0001.html")

class TestConfidence:

    def test_none_is_missing(self):

        assert _confidence(None) == "missing"

    def test_empty_string_is_missing(self):

        assert _confidence("") == "missing"

    def test_recent_timestamp_is_ok(self):

        recent = (datetime.now(timezone.utc) - timedelta(hours=1)).isoformat()

        assert _confidence(recent) == "ok"

    def test_exactly_stale_threshold_is_stale(self):

        old = (datetime.now(timezone.utc) - timedelta(hours=STALE_HOURS + 1)).isoformat()

        assert _confidence(old) == "stale"

    def test_very_old_is_stale(self):

        ancient = "2020-01-01T00:00:00+00:00"

        assert _confidence(ancient) == "stale"

    def test_invalid_timestamp_is_missing(self):

        assert _confidence("not-a-timestamp") == "missing"

    def test_utc_z_suffix_parses(self):

        recent = (datetime.now(timezone.utc) - timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%SZ")

        assert _confidence(recent) == "ok"

class TestIdParsing:

    def test_ocd_state(self):

        assert _infer_state_from_ocd(

            "ocd-bill/country:us/state:ca/legislature/2025-2026/HB1"

        ) == "CA"

    def test_ocd_district_dc(self):

        assert _infer_state_from_ocd(

            "ocd-jurisdiction/country:us/district:dc/government"

        ) == "DC"

    def test_ocd_territory_pr(self):

        assert _infer_state_from_ocd(

            "ocd-jurisdiction/country:us/territory:pr/government"

        ) == "PR"

    def test_ocd_empty_returns_empty(self):

        assert _infer_state_from_ocd("ocd-bill/country:us/") == ""

    def test_legiscan_id_ca(self):

        assert _infer_state_from_legiscan_id("legiscan-CA-12345") == "CA"

    def test_legiscan_id_dc(self):

        assert _infer_state_from_legiscan_id("legiscan-DC-999") == "DC"

    def test_legiscan_id_wrong_format_returns_empty(self):

        assert _infer_state_from_legiscan_id("openstates-CA-1") == ""

    def test_legiscan_id_no_state_returns_empty(self):

        assert _infer_state_from_legiscan_id("legiscan-12345") == ""

class TestStateCoverageCompute:

    """

    Core honesty layer tests.  These run without any API keys  -  they verify

    that compute() works off DB state alone.

    """

    def test_all_states_list_length(self):

        """ALL_STATES must contain exactly 52 entries (50 + DC + PR)."""

        assert len(ALL_STATES) == 52

    def test_all_states_has_dc_and_pr(self):

        assert "DC" in ALL_STATES

        assert "PR" in ALL_STATES

    def test_all_states_are_uppercase_two_char(self):

        for s in ALL_STATES:

            assert len(s) == 2, f"State code not 2 chars: {s!r}"

            assert s.isupper(), f"State code not uppercase: {s!r}"

    def test_empty_db_produces_all_missing(self):

        """With no data in DB, every (state, source, data_type) is 'missing'."""

        conn, tmp = _make_db()

        conn.close()

        try:

            rows = compute(tmp)

            expected = len(ALL_STATES) * len(SOURCES) * len(DATA_TYPES)

            assert len(rows) == expected, (

                f"Expected {expected} rows, got {len(rows)}"

            )

            for row in rows:

                assert row["confidence"] == "missing", (

                    f"Expected missing for {row['state']}/{row['source']}/{row['data_type']}, "

                    f"got {row['confidence']!r}"

                )

            assert row["last_scrape"] is None

        finally:

            os.unlink(tmp)

    def test_row_count_matches_52_times_sources_times_types(self):

        conn, tmp = _make_db()

        conn.close()

        try:

            rows = compute(tmp)

            assert len(rows) == 52 * 2 * 3

        finally:

            os.unlink(tmp)

    def test_after_log_scrape_confidence_is_ok(self):

        """After log_scrape(), the relevant row should be 'ok'."""

        conn, tmp = _make_db()

        try:

            log_scrape(conn, "openstates", "CA", "bills", 10)

            conn.commit()

            conn.close()

            rows = compute(tmp)

            target = [

                r for r in rows

                if r["state"] == "CA"

                and r["source"] == "openstates"

                and r["data_type"] == "bills"

            ]

            assert len(target) == 1

            assert target[0]["confidence"] == "ok"

            missing = [

                r for r in rows

                if r["state"] == "CA"

                and r["source"] == "openstates"

                and r["data_type"] != "bills"

            ]

            for r in missing:

                assert r["confidence"] == "missing"

        finally:

            os.unlink(tmp)

    def test_stale_timestamp_marks_stale(self):

        """A scrape older than STALE_HOURS should show as 'stale'."""

        conn, tmp = _make_db()

        try:

            old_ts = (

                datetime.now(timezone.utc) - timedelta(hours=STALE_HOURS + 2)

            ).isoformat()

            log_scrape(conn, "legiscan", "TX", "bills", 5, old_ts)

            conn.commit()

            conn.close()

            rows = compute(tmp)

            target = [

                r for r in rows

                if r["state"] == "TX"

                and r["source"] == "legiscan"

                and r["data_type"] == "bills"

            ]

            assert len(target) == 1

            assert target[0]["confidence"] == "stale"

        finally:

            os.unlink(tmp)

    def test_compute_is_idempotent(self):

        """Calling compute() twice should produce the same rows."""

        conn, tmp = _make_db()

        conn.close()

        try:

            rows1 = compute(tmp)

            rows2 = compute(tmp)

            assert len(rows1) == len(rows2)

            for r1, r2 in zip(rows1, rows2):

                assert r1["state"]      == r2["state"]

                assert r1["confidence"] == r2["confidence"]

        finally:

            os.unlink(tmp)

    def test_no_duplicate_rows_in_output(self):

        conn, tmp = _make_db()

        conn.close()

        try:

            rows = compute(tmp)

            seen_keys = set()

            for r in rows:

                key = (r["state"], r["source"], r["data_type"])

                assert key not in seen_keys, f"Duplicate key: {key}"

                seen_keys.add(key)

        finally:

            os.unlink(tmp)

    def test_all_50_states_present_in_output(self):

        conn, tmp = _make_db()

        conn.close()

        try:

            rows = compute(tmp)

            states_in_output = {r["state"] for r in rows}

            for state in ALL_STATES:

                assert state in states_in_output, f"State {state} missing from output"

        finally:

            os.unlink(tmp)