"""

Tests for member_photos poller.

Coverage:

  • build_photo_url()   -  URL format and bioguide substitution

  • head_check()        -  200/404/exception handling (mocked network)

  • poll()              -  DB writes, idempotency, stats (mocked network)

  • Schema              -  photo_url column exists after ensure_votes_schema()

"""

import os

import tempfile

from unittest.mock import MagicMock, patch

import pytest

import requests

from ingest.db import get_connection, init_schema

from ingest.pollers.members import ensure_votes_schema

from ingest.pollers.member_photos import (

    PHOTO_BASE,

    build_photo_url,

    head_check,

    poll,

)

class TestBuildPhotoUrl:

    def test_known_bioguide(self):

        """A000055 is Robert Aderholt  -  canonical test bioguide."""

        url = build_photo_url("A000055")

        assert url == f"{PHOTO_BASE}/A000055.jpg"

    def test_url_contains_bioguide(self):

        url = build_photo_url("Z999999")

        assert "Z999999" in url

    def test_url_ends_with_jpg(self):

        url = build_photo_url("B000574")

        assert url.endswith(".jpg")

    def test_url_uses_450x550_size(self):

        url = build_photo_url("A000055")

        assert "congress/450x550" in url

    def test_url_host_is_github_pages(self):

        url = build_photo_url("A000055")

        assert "unitedstates.github.io" in url

    def test_url_format_is_stable(self):

        """Verify the full URL matches the documented pattern exactly."""

        bioguide = "S000033"

        url = build_photo_url(bioguide)

        expected = (

            "https://unitedstates.github.io/images/congress/450x550/S000033.jpg"

        )

        assert url == expected

class TestHeadCheck:

    def _make_session(self, status_code=200):

        session = MagicMock()

        resp = MagicMock()

        resp.status_code = status_code

        session.head.return_value = resp

        return session

    def test_200_returns_true(self):

        session = self._make_session(200)

        assert head_check("https://example.com/photo.jpg", session) is True

    def test_404_returns_false(self):

        session = self._make_session(404)

        assert head_check("https://example.com/photo.jpg", session) is False

    def test_301_after_redirect_returns_true(self):

        session = self._make_session(200)

        assert head_check("https://example.com/photo.jpg", session) is True

    def test_500_returns_false(self):

        session = self._make_session(500)

        assert head_check("https://example.com/photo.jpg", session) is False

    def test_request_exception_returns_false(self):

        session = MagicMock()

        session.head.side_effect = requests.RequestException("connection timeout")

        assert head_check("https://example.com/photo.jpg", session) is False

    def test_connection_error_returns_false(self):

        session = MagicMock()

        session.head.side_effect = requests.ConnectionError("refused")

        assert head_check("https://example.com/photo.jpg", session) is False

    def test_head_called_with_allow_redirects(self):

        session = self._make_session(200)

        head_check("https://example.com/photo.jpg", session)

        call_kwargs = session.head.call_args

        assert call_kwargs.kwargs.get("allow_redirects") is True or \

               (call_kwargs.args and True in call_kwargs.args)

class TestSchema:

    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_photo_url_column_exists(self):

        conn, tmp = self._make_db()

        info = {row[1] for row in conn.execute("PRAGMA table_info(members)")}

        assert "photo_url" in info, "photo_url column should be in members table"

        conn.close()

        os.unlink(tmp)

    def test_photo_url_is_nullable(self):

        """photo_url must be nullable  -  many historical members have no image."""

        conn, tmp = self._make_db()

        conn.execute(

            "INSERT INTO members (bioguide_id, full_name, source_url) "

            "VALUES (?, ?, ?)",

            ("T000001", "Test Member",

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

        )

        conn.commit()

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='T000001'"

        ).fetchone()

        assert row is not None

        assert row["photo_url"] is None

        conn.close()

        os.unlink(tmp)

    def test_ensure_votes_schema_idempotent_with_photo_url(self):

        """Calling ensure_votes_schema twice should not raise."""

        conn, tmp = self._make_db()

        ensure_votes_schema(conn)

        info = {row[1] for row in conn.execute("PRAGMA table_info(members)")}

        assert "photo_url" in info

        conn.close()

        os.unlink(tmp)

def _make_db_with_members():

    """Helper: create a temp DB seeded with two members."""

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

    conn = get_connection(tmp)

    init_schema(conn)

    ensure_votes_schema(conn)

    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",

        ),

    )

    conn.execute(

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

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

        (

            "Z999999",

            "Historical Member (no photo)",

            "Democratic",

            "NY",

            "senate",

            "https://bioguide.congress.gov/search/bio/Z999999",

        ),

    )

    conn.commit()

    conn.close()

    return tmp

def _mock_session_factory(hits: set):

    """

    Return a context-manager patch for requests.Session that returns 200 for

    bioguide_ids in `hits` and 404 for all others.

    """

    def fake_head(url, timeout=10, allow_redirects=True):

        resp = MagicMock()

        resp.status_code = 200 if any(h in url for h in hits) else 404

        return resp

    mock_session = MagicMock()

    mock_session.head.side_effect = fake_head

    return mock_session

class TestPoll:

    def test_photo_url_set_for_200(self):

        tmp = _make_db_with_members()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            poll(db_path=tmp, delay=0)

        conn = get_connection(tmp)

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='A000055'"

        ).fetchone()

        assert row["photo_url"] is not None

        assert "A000055" in row["photo_url"]

        assert row["photo_url"].endswith(".jpg")

        conn.close()

        os.unlink(tmp)

    def test_photo_url_null_for_404(self):

        tmp = _make_db_with_members()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            poll(db_path=tmp, delay=0)

        conn = get_connection(tmp)

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='Z999999'"

        ).fetchone()

        assert row["photo_url"] is None

        conn.close()

        os.unlink(tmp)

    def test_stats_returned(self):

        tmp = _make_db_with_members()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            result = poll(db_path=tmp, delay=0)

        assert result["checked"] == 2

        assert result["updated"] == 1

        assert result["skipped"] == 1

        os.unlink(tmp)

    def test_idempotent_rerun_preserves_url(self):

        """Second poll() with same hits must not clear a previously set URL."""

        tmp = _make_db_with_members()

        for _ in range(2):

            with patch("ingest.pollers.member_photos.requests.Session") as cls:

                cls.return_value = _mock_session_factory({"A000055"})

                poll(db_path=tmp, delay=0)

        conn = get_connection(tmp)

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='A000055'"

        ).fetchone()

        assert row["photo_url"] is not None

        conn.close()

        os.unlink(tmp)

    def test_reset_clears_then_repopulates(self):

        """reset=True should clear photo_url before re-checking."""

        tmp = _make_db_with_members()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            poll(db_path=tmp, delay=0)

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            result = poll(db_path=tmp, delay=0, reset=True)

        conn = get_connection(tmp)

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='A000055'"

        ).fetchone()

        assert row["photo_url"] is not None

        assert result["updated"] == 1

        conn.close()

        os.unlink(tmp)

    def test_empty_members_table(self):

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

        conn = get_connection(tmp)

        init_schema(conn)

        ensure_votes_schema(conn)

        conn.close()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory(set())

            result = poll(db_path=tmp, delay=0)

        assert result["checked"] == 0

        assert result["updated"] == 0

        assert result["skipped"] == 0

        os.unlink(tmp)

    def test_photo_url_points_to_correct_base(self):

        """Stored URL must use the 450x550 base path."""

        tmp = _make_db_with_members()

        with patch("ingest.pollers.member_photos.requests.Session") as cls:

            cls.return_value = _mock_session_factory({"A000055"})

            poll(db_path=tmp, delay=0)

        conn = get_connection(tmp)

        row = conn.execute(

            "SELECT photo_url FROM members WHERE bioguide_id='A000055'"

        ).fetchone()

        assert "congress/450x550" in row["photo_url"]

        assert "unitedstates.github.io" in row["photo_url"]

        conn.close()

        os.unlink(tmp)