import pytest

from apollo_playlists_messages.constants import EventCode
from tests.data.events import pack_events, create_raw_event, create_full_event, create_parsed_full_event


@pytest.mark.parametrize(
    "input_event,expected_result_len,expected_result",
    (
        (
            pack_events([
                create_raw_event(1, EventCode.ENTRY),  # outdated
                create_raw_event(2, EventCode.ENTRY, ttl=10)
            ]),
            1, None
        ),
        (
            pack_events([
                create_raw_event(1, EventCode.UPDATE),  # unsupported code
                create_raw_event(2, EventCode.ENTRY),
                create_raw_event(3, EventCode.ENTRY, exclude=("code",))
            ]),
            1, None
        ),
        (
            pack_events([
                create_raw_event(1, EventCode.ENTRY),  # unsupported holder
                create_raw_event(2, EventCode.ENTRY, app="unsupported"),
                create_raw_event(3, EventCode.ENTRY, exclude=("app",)),
            ]),
            1, None
        ),
        (
            pack_events([
                create_raw_event(1, EventCode.ENTRY, exclude=("id",)),  # invalid data
                create_raw_event(2, EventCode.ENTRY, exclude=("ttl",)),
            ]),
            0, None
        ),
        (
            pack_events(
                [
                    create_raw_event(i, EventCode.ENTRY) for i in range(1, 3)
                ] + [
                    create_raw_event(i, EventCode.ENTRY, extra={"meta.country_code": [], "meta.top_country_code": []})
                    for i in range(3, 5)
                ]),
            4,
            [
                create_raw_event(
                    i, EventCode.ENTRY, exclude=("meta", "publisher", "external_id", "created_at")
                ) for i in range(1, 5)
            ]
        ),
    ),
)
def test_parse_raw_input(test_logger, input_event, expected_result_len, expected_result):
    from apollo_playlists_messages.utils.input import parse_raw_input

    result = parse_raw_input(test_logger, input_event)
    assert len(result) == expected_result_len

    if expected_result is not None:
        for i, item in enumerate(expected_result):
            result_item = result[i]
            assert result_item.pop("created_at") is not None
            assert result[i] == item


@pytest.mark.parametrize(
    "input_events,expected_result_len,expected_result",
    (
        (
            [
                create_full_event(1, EventCode.ENTRY, extra={"meta.dsp": "unknown"}),
                create_full_event(2, EventCode.ENTRY, exclude=("id",)),
                create_full_event(3, EventCode.ENTRY, extra={"meta.country_code": []}),
                create_full_event(4, EventCode.ENTRY, exclude=("data.content.playlist.id",)),
                create_full_event(5, EventCode.ENTRY, exclude=("data.content.track.image_url",)),
                create_full_event(6, EventCode.ENTRY, extra={"meta.country_code": ["us", "gb"]}),  # multiple codes are not allowed for spotify
                create_full_event(7, EventCode.ENTRY, extra={"data.content.track.artists": []}),
            ],
            0, None
        ),
        (
            [
                create_full_event(1, EventCode.ENTRY),
                create_full_event(2, EventCode.ENTRY),
                create_full_event(3, EventCode.ENTRY, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(4, EventCode.ENTRY, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(5, EventCode.ENTRY, exclude=("id",)),

            ],
            3,
            [
                create_parsed_full_event(i, EventCode.ENTRY) for i in range(1, 3)
            ] + [
                create_parsed_full_event(4, EventCode.ENTRY,  country_code=[""], top_country_code=[])
            ]
        ),
    ),
)
def test_parse_full_entry_events(test_logger, input_events, expected_result_len, expected_result):
    from apollo_playlists_messages.utils.input import parse_full_events
    from apollo_playlists_messages.schemas.events_full import PlaylistEntryFullEvent

    result = parse_full_events(test_logger, input_events, PlaylistEntryFullEvent())
    assert len(result) == expected_result_len

    if expected_result is not None:
        for i, item in enumerate(expected_result):
            result_item = result[i]
            assert result_item == item


@pytest.mark.parametrize(
    "input_events,expected_result_len,expected_result",
    (
        (
            [
                create_full_event(1, EventCode.UPDATE, extra={"meta.dsp": "unknown"}),
                create_full_event(2, EventCode.UPDATE, exclude=("id",)),
                create_full_event(3, EventCode.UPDATE, extra={"meta.country_code": []}),
                create_full_event(4, EventCode.UPDATE, exclude=("data.content.playlist.id",)),
                create_full_event(4, EventCode.UPDATE, exclude=("data.content.playlist.last_updated_at",)),
            ],
            0, None
        ),
        (
            [
                create_full_event(1, EventCode.UPDATE),
                create_full_event(2, EventCode.UPDATE),
                create_full_event(3, EventCode.UPDATE, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(4, EventCode.UPDATE, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(3, EventCode.UPDATE, exclude=("id",)),

            ],
            3,
            [
                create_parsed_full_event(i, EventCode.UPDATE) for i in range(1, 3)
            ] + [
                create_parsed_full_event(4, EventCode.UPDATE, country_code=[""], top_country_code=[])
            ]
        ),
    ),
)
def test_parse_full_update_events(test_logger, input_events, expected_result_len, expected_result):
    from apollo_playlists_messages.utils.input import parse_full_events
    from apollo_playlists_messages.schemas.events_full import PlaylistUpdateFullEvent

    result = parse_full_events(test_logger, input_events, PlaylistUpdateFullEvent())
    assert len(result) == expected_result_len

    if expected_result is not None:
        for i, item in enumerate(expected_result):
            result_item = result[i]
            assert result_item == item


@pytest.mark.parametrize(
    "input_events,expected_result_len,expected_result",
    (
        (
            [
                create_full_event(1, EventCode.EXIT, extra={"meta.dsp": "unknown"}),
                create_full_event(2, EventCode.EXIT, exclude=("id",)),
                create_full_event(3, EventCode.EXIT, extra={"meta.country_code": []}),
                create_full_event(4, EventCode.EXIT, exclude=("data.content.playlist.id",)),
                create_full_event(4, EventCode.EXIT, exclude=("data.content.playlist.last_updated_at",)),
            ],
            0, None
        ),
        (
            [
                create_full_event(1, EventCode.EXIT),
                create_full_event(2, EventCode.EXIT),
                create_full_event(3, EventCode.EXIT, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(4, EventCode.EXIT, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(3, EventCode.EXIT, exclude=("id",)),

            ],
            3,
            [
                create_parsed_full_event(i, EventCode.EXIT) for i in range(1, 3)
            ] + [
                create_parsed_full_event(4, EventCode.EXIT, country_code=[""], top_country_code=[])
            ]
        ),
    ),
)
def test_parse_full_exit_events(test_logger, input_events, expected_result_len, expected_result):
    from apollo_playlists_messages.utils.input import parse_full_events
    from apollo_playlists_messages.schemas.events_full import PlaylistExitFullEvent

    result = parse_full_events(test_logger, input_events, PlaylistExitFullEvent())
    assert len(result) == expected_result_len

    if expected_result is not None:
        for i, item in enumerate(expected_result):
            result_item = result[i]
            assert result_item == item


@pytest.mark.parametrize(
    "input_events,expected_result_len,expected_result",
    (
        (
            [
                create_full_event(1, EventCode.MAJOR_MOVE, extra={"meta.dsp": "unknown"}),
                create_full_event(2, EventCode.MAJOR_MOVE, exclude=("id",)),
                create_full_event(3, EventCode.MAJOR_MOVE, extra={"meta.country_code": []}),
                create_full_event(4, EventCode.MAJOR_MOVE, exclude=("data.content.playlist.id",)),
                create_full_event(4, EventCode.MAJOR_MOVE, exclude=("data.content.playlist.last_updated_at",)),
            ],
            0, None
        ),
        (
            [
                create_full_event(1, EventCode.MAJOR_MOVE),
                create_full_event(2, EventCode.MAJOR_MOVE),
                create_full_event(3, EventCode.MAJOR_MOVE, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(4, EventCode.MAJOR_MOVE, playlist_country_code="", extra={"meta.country_code": [], "meta.top_country_code": []}),
                create_full_event(3, EventCode.MAJOR_MOVE, exclude=("id",)),

            ],
            3,
            [
                create_parsed_full_event(i, EventCode.MAJOR_MOVE) for i in range(1, 3)
            ] + [
                create_parsed_full_event(4, EventCode.MAJOR_MOVE, country_code=[""], top_country_code=[])
            ]
        ),
    ),
)
def test_parse_full_exit_events(test_logger, input_events, expected_result_len, expected_result):
    from apollo_playlists_messages.utils.input import parse_full_events
    from apollo_playlists_messages.schemas.events_full import PlaylistMajorMoveFullEvent

    result = parse_full_events(test_logger, input_events, PlaylistMajorMoveFullEvent())
    assert len(result) == expected_result_len

    if expected_result is not None:
        for i, item in enumerate(expected_result):
            result_item = result[i]
            assert result_item == item