import pytest
import random
import datetime
from model_bakery import baker
from django.utils import timezone as tz
from datetime import timedelta
import pytz
from aircox.models import Diffusion


# TODO déplacer fixutre dans conftest.py / rechercher si il y a une méthode plus lisible que celle utilisée dans ce test pour utiliser ces deux fixtures.
@pytest.fixture
def diffusions_time_variation(episodes):
    random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
    now = tz.now()
    now_date = datetime.date.today()
    now_datetime = tz.now()
    tomorrow_datetime = now + timedelta(hours=25)
    yesterday_datetime = now - timedelta(hours=25)
    now_diffusion = baker.make(
        Diffusion,
        episode=random_episode,
        start=now - timedelta(minutes=30),
        end=now + timedelta(minutes=30),
    )
    after_diffusion = baker.make(
        Diffusion,
        episode=random_episode,
        start=now + timedelta(minutes=30),
        end=now + timedelta(minutes=60),
    )
    tomorrow_diffusion = baker.make(
        Diffusion,
        episode=random_episode,
        start=tomorrow_datetime,
        end=tomorrow_datetime + timedelta(minutes=30),
    )
    before_diffusion = baker.make(
        Diffusion,
        episode=random_episode,
        start=now - timedelta(minutes=60),
        end=now - timedelta(minutes=30),
    )
    yesterday_diffusion = baker.make(
        Diffusion,
        episode=random_episode,
        start=yesterday_datetime,
        end=yesterday_datetime + timedelta(minutes=30),
    )
    return (
        now_date,
        now_datetime,
        yesterday_diffusion,
        before_diffusion,
        now_diffusion,
        after_diffusion,
        tomorrow_diffusion,
    )


@pytest.fixture
def diffusions_episode_variation(episodes):
    key_episode = episodes[1]
    another_episode = episodes[2]
    diffusions_with_the_key_episode = baker.make(
        Diffusion, _quantity=3, episode=key_episode
    )
    diffusions_without_the_key_episode = baker.make(
        Diffusion, _quantity=3, episode=another_episode
    )
    return (
        key_episode,
        another_episode,
        diffusions_with_the_key_episode,
        diffusions_without_the_key_episode,
    )


class TestDiffusionQuerySet:
    @pytest.mark.django_db
    def test_episode_by_obj(self, diffusions_episode_variation):
        (
            key_episode,
            _,
            diffusions_with_the_key_episode,
            diffusions_without_the_key_episode,
        ) = diffusions_episode_variation
        result = Diffusion.objects.episode(episode=key_episode)

        for diffusion in diffusions_with_the_key_episode:
            assert diffusion in result
        for diffusion in diffusions_without_the_key_episode:
            assert diffusion not in result

    @pytest.mark.django_db
    def test_episode_by_id(self, diffusions_episode_variation):
        (
            key_episode,
            _,
            diffusions_with_the_key_episode,
            diffusions_without_the_key_episode,
        ) = diffusions_episode_variation
        result = Diffusion.objects.episode(id=key_episode.id)

        for diffusion in diffusions_with_the_key_episode:
            assert diffusion in result
        for diffusion in diffusions_without_the_key_episode:
            assert diffusion not in result

    @pytest.mark.django_db
    def test_on_air(self, episodes):
        for episode in episodes:
            random_type = random.choice(
                [Diffusion.TYPE_ON_AIR, Diffusion.TYPE_UNCONFIRMED]
            )
            baker.make(Diffusion, episode=episode, type=random_type)
        result = Diffusion.objects.on_air()

        for diffusion in result:
            assert diffusion.type == Diffusion.TYPE_ON_AIR
            assert diffusion.type != Diffusion.TYPE_UNCONFIRMED

    # la méthode "now" filtre les diffusions en cours d'un moment précis.
    # elle prend en compte un objet datetime (date + heure)
    # les diffusions en cours sont définie en fonction de l'argument "now" ou de l'heure actuelle si now=None.
    # la méthode distinct élimine les doublons de diffusions (si ils ont des valeurs identiques pour tous les champs de la db)
    # TODO test si il y a doublon qu'un seul objet soit récupéré.
    @pytest.mark.django_db
    def test_now_test(self, diffusions_time_variation):
        now = tz.now()
        (
            _,
            _,
            _,
            _,
            now_diffusion,
            _,
            _,
        ) = diffusions_time_variation
        result = Diffusion.objects.now(now=now, order=True)

        assert len(result) == 1
        assert result[0] == now_diffusion
        assert result[0].start <= now <= result[0].end

    # méthode date filtre les diffusions en cours d'une date précise.
    # elle ne prend pas en compte un objet datetime mais un "objet date" uniquement
    # elle crée deux objets datetime (start and end) à partir de l'argument "date" (if none = today)
    # elle utilise la méthode "combine" de la classe "datetime" pour créer ces deux objets à partir de la date
    # elle filtre ensuite les diffusions qui ont lieu entre "start" et "end".
    @pytest.mark.django_db
    def test_date_without_date_arg(self, diffusions_time_variation):
        (
            _,
            _,
            _,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            _,
        ) = diffusions_time_variation
        result = Diffusion.objects.date()

        assert len(result) == 3
        assert result[0] == before_diffusion
        assert result[1] == now_diffusion
        assert result[2] == after_diffusion

    @pytest.mark.django_db
    def test_date_with_date_arg(self, diffusions_time_variation):
        today_date = datetime.date.today()
        tomorrow_date = today_date + timedelta(days=1)
        (
            _,
            _,
            _,
            _,
            _,
            _,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        result = Diffusion.objects.date(date=tomorrow_date)

        assert len(result) == 1
        assert result[0] == tomorrow_diffusion

    # la méthode at récupère les diffusions à une date donnée.
    # elle utilise la méthode now si la date est un objet datetime
    # elle utilise la méthode date si la date est un objet date
    @pytest.mark.django_db
    def test_at_datetimeobj(self, diffusions_time_variation):
        (
            _,
            now_datetime,
            _,
            _,
            now_diffusion,
            _,
            _,
        ) = diffusions_time_variation
        result = Diffusion.objects.at(date=now_datetime)

        assert len(result) == 1
        assert now_diffusion in result

    @pytest.mark.django_db
    def test_at_dateobj(self, diffusions_time_variation):
        (
            now_date,
            _,
            _,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            _,
        ) = diffusions_time_variation
        result = Diffusion.objects.at(date=now_date)

        assert len(result) == 3
        assert result[0] == before_diffusion
        assert result[1] == now_diffusion
        assert result[2] == after_diffusion

    @pytest.mark.django_db
    def test_after_without_date_arg(self, diffusions_time_variation):
        (
            _,
            _,
            yesterday_diffusion,
            _,
            now_diffusion,
            _,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        from_now_diffusions = Diffusion.objects.after()

        assert tomorrow_diffusion in from_now_diffusions
        assert now_diffusion in from_now_diffusions
        assert yesterday_diffusion not in from_now_diffusions

    @pytest.mark.django_db
    def test_after_with_datetime_arg(self, diffusions_time_variation):
        (
            _,
            now_datetime,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        from_now_diffusions = Diffusion.objects.after(date=now_datetime)

        assert tomorrow_diffusion in from_now_diffusions
        assert after_diffusion in from_now_diffusions
        assert now_diffusion in from_now_diffusions
        assert before_diffusion not in from_now_diffusions
        assert yesterday_diffusion not in from_now_diffusions

    @pytest.mark.django_db
    def test_after_with_date_arg(self, diffusions_time_variation):
        (
            now_date,
            _,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        from_today_diffusions = Diffusion.objects.after(date=now_date)

        #assert now_date == 'today'
        assert tomorrow_diffusion in from_today_diffusions
        assert after_diffusion in from_today_diffusions
        assert now_diffusion in from_today_diffusions
        assert before_diffusion in from_today_diffusions
        assert yesterday_diffusion not in from_today_diffusions