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


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

# 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

    @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

    @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_arg(self, diffusions_time_variation):
        (
            _,
            _,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        from_now_diffusions = Diffusion.objects.after()

        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_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 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

    @pytest.mark.django_db
    def test_before_without_arg(self, diffusions_time_variation):
        (
            _,
            _,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        before_now_diffusions = Diffusion.objects.before()

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

    @pytest.mark.django_db
    def test_before_with_datetime_arg(self, diffusions_time_variation):
        (
            _,
            now_datetime,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        before_now_diffusions = Diffusion.objects.before(date=now_datetime)

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

    @pytest.mark.django_db
    def test_before_with_date_arg(self, diffusions_time_variation):
        (
            now_date,
            _,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        before_today_diffusions = Diffusion.objects.before(date=now_date)

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

    @pytest.mark.django_db
    def test_range(self, episodes, diffusions_time_variation):
        (
            _,
            _,
            yesterday_diffusion,
            before_diffusion,
            now_diffusion,
            after_diffusion,
            tomorrow_diffusion,
        ) = diffusions_time_variation
        start = before_diffusion.start
        end = after_diffusion.end
        overlaping_start_diffusion = baker.make(
            Diffusion,
            episode=episodes[0],
            start=start - timedelta(minutes=30),
            end=end,
        )
        overlaping_end_diffusion = baker.make(
            Diffusion,
            episode=episodes[0],
            start=start,
            end=end + timedelta(minutes=30),
        )
        range_diffusion = Diffusion.objects.range(start=start, end=end)

        assert before_diffusion in range_diffusion
        assert after_diffusion in range_diffusion
        assert now_diffusion in range_diffusion
        assert overlaping_start_diffusion not in range_diffusion
        assert overlaping_end_diffusion not in range_diffusion
        assert tomorrow_diffusion not in range_diffusion
        assert yesterday_diffusion not in range_diffusion


class TestDiffusion:
    @pytest.mark.django_db
    def test__str__initial_diffusion(self, diffusions_with_rerun):
        (
            initial_diffusion,
            _,
        ) = diffusions_with_rerun
        initial_diffusion.episode.title = "Episode title"
        initial_diffusion.start = datetime.datetime(
            2023, 5, 12, 13, 0, tzinfo=pytz.UTC
        )
        assert (
            initial_diffusion.__str__()
            == "Episode title - 2023/05/12 13:00+0000"
        )

    @pytest.mark.django_db
    def test__str__rerun_diffusion(self, diffusions_with_rerun):
        (
            initial_diffusion,
            rerun_diffusion,
        ) = diffusions_with_rerun
        initial_diffusion.episode.title = "Episode title"
        rerun_diffusion.start = datetime.datetime(
            2023, 5, 12, 13, 0, tzinfo=pytz.UTC
        )
        assert (
            rerun_diffusion.__str__()
            == "Episode title - 2023/05/12 13:00+0000 (rerun)"
        )

    # dans la méthode self._initial[valeur] est un dictionnaire qui stocke les valeurs initiales des champs de l'objet au moment de sa création
    # save
    # si diffusion est initial et si son épisode a été modifié depuis la création initiale
    # la méthode save update l'épisode et le programme sur paramètre initial (rerun_set) de la rediffusion (qui représente l'objet diffusion initial).
    """ je ne comprends pas rerun_set.update, que la méthode l'update ou pas, on accède quand même à l'épisode mis à jour sur la diffusion initiale"""

    @pytest.mark.django_db
    def test_save_rerun_diffusion(self, episodes, diffusions_with_rerun):
        (
            initial_diffusion,
            rerun_diffusion,
        ) = diffusions_with_rerun
        initial_diffusion.episode = episodes[1]
        initial_diffusion.program = episodes[1].program
        initial_diffusion.save()
        assert rerun_diffusion.initial.episode == episodes[1]
        assert rerun_diffusion.initial.program == episodes[1].program

    @pytest.mark.django_db
    def test_save_rerun(self, diffusions_with_rerun):
        (
            initial_diffusion,
            rerun_diffusion,
        ) = diffusions_with_rerun
        rerun_diffusion.save_rerun()
        assert rerun_diffusion.episode == initial_diffusion.episode

    @pytest.mark.django_db
    def test_save_initial(self, diffusions_with_rerun):
        (
            initial_diffusion,
            rerun_diffusion,
        ) = diffusions_with_rerun
        initial_diffusion.save_initial()
        assert initial_diffusion.program == initial_diffusion.episode.program

    @pytest.mark.django_db
    def test_duration(self, diffusion):
        assert diffusion.duration == datetime.timedelta(seconds=1800)

    @pytest.mark.django_db
    def test_date(self, diffusion):
        assert diffusion.date == datetime.date(2023, 5, 12)

    @pytest.mark.django_db
    def test_local_start(self, diffusion):
        assert diffusion.local_start == datetime.datetime(
            2023, 5, 12, 13, 00, tzinfo=pytz.UTC
        )

    @pytest.mark.django_db
    def test_local_end(self, diffusion):
        assert diffusion.local_end == datetime.datetime(
            2023, 5, 12, 13, 30, tzinfo=pytz.UTC
        )

    @pytest.mark.django_db
    def test_is_now(self, diffusion):
        diffusion.type = Diffusion.TYPE_ON_AIR
        diffusion.start = tz.now()
        diffusion.end = tz.now() + timedelta(minutes=30)
        assert diffusion.is_now == True

    @pytest.mark.django_db
    def test_is_live(self, diffusion):
        diffusion.type = Diffusion.TYPE_ON_AIR
        diffusion.episode.sound_set == None
        assert diffusion.is_live == True

    # on ne peut pas changer l'heure de diffusion ? 
    # souci avec save
    # un autre souci ailleurs : est overlaping devrait être testé partout aussi ?