"""Tests for the Ticketmaster provider."""

from datetime import date

import pytest

from src.providers.ticketmaster import TicketmasterProvider, MAJOR_VENUES
from tests.conftest import TICKETMASTER_RESPONSE


class TestTicketmasterProvider:
    def test_name(self):
        provider = TicketmasterProvider(api_key="test-key")
        assert provider.name == "ticketmaster"

    def test_fetch_skips_when_no_api_key(self):
        provider = TicketmasterProvider(api_key="")
        assert provider.fetch() == []

    def test_fetch_returns_only_major_venue_events(self, httpx_mock):
        httpx_mock.add_response(json=TICKETMASTER_RESPONSE)
        provider = TicketmasterProvider(api_key="test-key", lookahead_days=30)
        events = provider.fetch()

        venue_names = {e.venue.lower().strip() for e in events}
        assert venue_names <= MAJOR_VENUES
        assert len(events) == 2

    def test_fetch_normalizes_fields(self, httpx_mock):
        httpx_mock.add_response(json=TICKETMASTER_RESPONSE)
        provider = TicketmasterProvider(api_key="test-key")
        events = provider.fetch()

        raptors = next(e for e in events if "Raptors" in e.name)
        assert raptors.event_date == date(2026, 5, 10)
        assert raptors.venue == "Scotiabank Arena"
        assert raptors.source == "ticketmaster"
        assert "ticketmaster.ca" in raptors.url

    def test_fetch_handles_missing_venue(self, httpx_mock):
        response = {
            "_embedded": {
                "events": [
                    {
                        "name": "Mystery Event",
                        "dates": {"start": {"localDate": "2026-05-10"}},
                        "url": "https://example.com",
                        "_embedded": {"venues": []},
                    }
                ]
            }
        }
        httpx_mock.add_response(json=response)
        provider = TicketmasterProvider(api_key="test-key")
        events = provider.fetch()
        assert events == []

    def test_fetch_handles_missing_date(self, httpx_mock):
        response = {
            "_embedded": {
                "events": [
                    {
                        "name": "Raptors Game",
                        "dates": {"start": {}},
                        "_embedded": {
                            "venues": [{"name": "Scotiabank Arena"}]
                        },
                    }
                ]
            }
        }
        httpx_mock.add_response(json=response)
        provider = TicketmasterProvider(api_key="test-key")
        events = provider.fetch()
        assert events == []

    def test_fetch_handles_api_error(self, httpx_mock):
        httpx_mock.add_response(status_code=500)
        provider = TicketmasterProvider(api_key="test-key")
        events = provider.fetch()
        assert events == []

    def test_fetch_handles_empty_response(self, httpx_mock):
        httpx_mock.add_response(json={})
        provider = TicketmasterProvider(api_key="test-key")
        events = provider.fetch()
        assert events == []

    def test_is_major_venue_case_insensitive(self):
        assert TicketmasterProvider._is_major_venue("SCOTIABANK ARENA")
        assert TicketmasterProvider._is_major_venue("scotiabank arena")
        assert TicketmasterProvider._is_major_venue("  Rogers Centre  ")
        assert not TicketmasterProvider._is_major_venue("Horseshoe Tavern")

    def test_extract_date_valid(self):
        item = {"dates": {"start": {"localDate": "2026-05-10"}}}
        assert TicketmasterProvider._extract_date(item) == date(2026, 5, 10)

    def test_extract_date_invalid_format(self):
        item = {"dates": {"start": {"localDate": "not-a-date"}}}
        assert TicketmasterProvider._extract_date(item) is None

    def test_extract_date_missing(self):
        assert TicketmasterProvider._extract_date({}) is None
        assert TicketmasterProvider._extract_date({"dates": {}}) is None