from datetime import timedelta
from uuid import UUID

import arrow
import pytest

from mobilizon_reshare.event.event import MobilizonEvent, EventPublicationStatus
from mobilizon_reshare.models.event import Event
from mobilizon_reshare.models.publication import PublicationStatus
from mobilizon_reshare.storage.query import events_with_status
from mobilizon_reshare.storage.query import (
    get_published_events,
    get_unpublished_events,
    create_unpublished_events,
    get_mobilizon_event_publications,
    prefetch_event_relations,
    get_publishers,
    publications_with_status,
)
from tests.storage import complete_specification
from tests.storage import result_publication
from tests.storage import today

event_0 = MobilizonEvent(
    name="event_0",
    description="desc_0",
    mobilizon_id="mobid_0",
    mobilizon_link="moblink_0",
    thumbnail_link="thumblink_0",
    location="loc_0",
    publication_time={
        "telegram": arrow.get(today + timedelta(hours=0)),
        "twitter": arrow.get(today + timedelta(hours=1)),
        "mastodon": arrow.get(today + timedelta(hours=2)),
    },
    status=EventPublicationStatus.COMPLETED,
    begin_datetime=arrow.get(today + timedelta(days=0)),
    end_datetime=arrow.get(today + timedelta(days=0) + timedelta(hours=2)),
)


@pytest.mark.asyncio
async def test_get_published_events(generate_models):
    await generate_models(complete_specification)
    published_events = list(await get_published_events())

    assert len(published_events) == 3


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "specification,expected_result",
    [
        [
            complete_specification,
            [
                MobilizonEvent(
                    name="event_3",
                    description="desc_3",
                    mobilizon_id=UUID(int=3),
                    mobilizon_link="moblink_3",
                    thumbnail_link="thumblink_3",
                    location="loc_3",
                    status=EventPublicationStatus.WAITING,
                    begin_datetime=arrow.get(today + timedelta(days=3)),
                    end_datetime=arrow.get(
                        today + timedelta(days=3) + timedelta(hours=2)
                    ),
                ),
            ],
        ]
    ],
)
async def test_get_unpublished_events(specification, expected_result, generate_models):
    await generate_models(specification)
    unpublished_events = list(await get_unpublished_events())

    assert len(unpublished_events) == len(expected_result)
    assert unpublished_events == expected_result


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "expected_result",
    [
        [
            [
                Event(
                    name="event_1",
                    description="desc_1",
                    mobilizon_id=UUID(int=101112),
                    mobilizon_link="moblink_1",
                    thumbnail_link="thumblink_1",
                    location="loc_1",
                    begin_datetime=today + timedelta(days=1),
                    end_datetime=today + timedelta(days=1) + timedelta(hours=2),
                ),
                Event(
                    name="test event",
                    description="description of the event",
                    mobilizon_id=UUID(int=12345),
                    mobilizon_link="http://some_link.com/123",
                    thumbnail_link="http://some_link.com/123.jpg",
                    location="location",
                    begin_datetime=today + timedelta(days=6),
                    end_datetime=today + timedelta(days=6) + timedelta(hours=2),
                ),
                Event(
                    name="test event",
                    description="description of the event",
                    mobilizon_id=UUID(int=67890),
                    mobilizon_link="http://some_link.com/123",
                    thumbnail_link="http://some_link.com/123.jpg",
                    location="location",
                    begin_datetime=today + timedelta(days=12),
                    end_datetime=today + timedelta(days=12) + timedelta(hours=2),
                ),
            ],
        ]
    ],
)
async def test_create_unpublished_events(
    expected_result,
    generate_models,
    event_generator,
):
    await generate_models(complete_specification)
    event_3 = event_generator(begin_date=arrow.get(today + timedelta(days=6)))
    event_4 = event_generator(
        begin_date=arrow.get(today + timedelta(days=12)), mobilizon_id=UUID(int=67890)
    )
    models = await prefetch_event_relations(Event.filter(name="event_1"))

    events_from_internet = [MobilizonEvent.from_model(models[0]), event_3, event_4]

    await create_unpublished_events(
        unpublished_mobilizon_events=events_from_internet,
    )
    unpublished_events = list(await get_unpublished_events())

    assert len(unpublished_events) == 4


@pytest.mark.asyncio
async def test_get_mobilizon_event_publications(generate_models):
    await generate_models(complete_specification)

    models = await prefetch_event_relations(Event.filter(name="event_0"))
    mobilizon_event = MobilizonEvent.from_model(models[0])

    publications = list(await get_mobilizon_event_publications(mobilizon_event))
    for pub in publications:
        await pub.fetch_related("event")
        await pub.fetch_related("publisher")

    assert len(publications) == 3

    assert publications[0].event.name == "event_0"
    assert publications[0].publisher.name == "telegram"
    assert publications[0].status == PublicationStatus.COMPLETED

    assert publications[1].event.name == "event_0"
    assert publications[1].publisher.name == "twitter"
    assert publications[1].status == PublicationStatus.COMPLETED

    assert publications[2].event.name == "event_0"
    assert publications[2].publisher.name == "mastodon"
    assert publications[2].status == PublicationStatus.COMPLETED


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "name,expected_result",
    [[None, {"telegram", "twitter", "mastodon", "zulip"}], ["telegram", {"telegram"}]],
)
async def test_get_publishers(
    name,
    expected_result,
    generate_models,
):
    await generate_models(complete_specification)
    result = await get_publishers(name)

    if type(result) == list:
        publishers = set(p.name for p in result)
    else:
        publishers = {result.name}

    assert len(publishers) == len(expected_result)
    assert publishers == expected_result


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "status,mobilizon_id,from_date,to_date,expected_result",
    [
        [
            PublicationStatus.WAITING,
            None,
            None,
            None,
            [
                result_publication[3],
                result_publication[4],
                result_publication[8],
                result_publication[9],
                result_publication[10],
                result_publication[11],
            ],
        ],
        [
            PublicationStatus.WAITING,
            UUID(int=1),
            None,
            None,
            [result_publication[3], result_publication[4]],
        ],
        [
            PublicationStatus.WAITING,
            None,
            arrow.get(today),
            arrow.get(today + timedelta(hours=6)),
            [result_publication[3], result_publication[4]],
        ],
        [
            PublicationStatus.COMPLETED,
            None,
            arrow.get(today + timedelta(hours=1)),
            None,
            [result_publication[2], result_publication[5], result_publication[7]],
        ],
        [
            PublicationStatus.COMPLETED,
            None,
            None,
            arrow.get(today + timedelta(hours=2)),
            [result_publication[0], result_publication[1]],
        ],
    ],
)
async def test_publications_with_status(
    status,
    mobilizon_id,
    from_date,
    to_date,
    expected_result,
    generate_models,
):
    await generate_models(complete_specification)
    publications = await publications_with_status(
        status=status,
        event_mobilizon_id=mobilizon_id,
        from_date=from_date,
        to_date=to_date,
    )

    assert publications == {pub.id: pub for pub in expected_result}


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "status, expected_events_count",
    [
        (EventPublicationStatus.COMPLETED, 1),
        (EventPublicationStatus.FAILED, 1),
        (EventPublicationStatus.PARTIAL, 1),
        (EventPublicationStatus.WAITING, 1),
    ],
)
async def test_event_with_status(generate_models, status, expected_events_count):
    await generate_models(complete_specification)
    result = list(await events_with_status([status]))

    assert len(result) == expected_events_count


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "status, expected_events_count, begin_window, end_window",
    [
        (
            EventPublicationStatus.COMPLETED,
            1,
            arrow.get(today + timedelta(hours=-1)),
            None,
        ),
        (
            EventPublicationStatus.COMPLETED,
            0,
            arrow.get(today + timedelta(hours=1)),
            None,
        ),
        (
            EventPublicationStatus.COMPLETED,
            1,
            arrow.get(today + timedelta(hours=-2)),
            arrow.get(today + timedelta(hours=1)),
        ),
        (
            EventPublicationStatus.COMPLETED,
            0,
            arrow.get(today + timedelta(hours=-2)),
            arrow.get(today + timedelta(hours=0)),
        ),
    ],
)
async def test_event_with_status_window(
    generate_models, status, expected_events_count, begin_window, end_window
):
    await generate_models(complete_specification)
    result = list(
        await events_with_status([status], from_date=begin_window, to_date=end_window)
    )

    assert len(result) == expected_events_count