import datetime
import random

from calendar import monthrange
from django.test import TestCase

from .models import (
    Maraude, Maraudeur, Planning,
    WEEKDAYS, HORAIRES_SOIREE,
    )
# Create your tests here.

from maraudes_project.base_data import MARAUDEURS

MARAUDE_DAYS = [
    True, True, False, True, True, False, False
]

def get_maraude_days(start, end):
    """ Iterator that returns date of maraude within start-end range """
    maraude_days = []
    first_loop = True
    for m in range(start.month, end.month + 1):
        start_day = 1
        if first_loop:
            start_day = start.day
            first_loop = False

        month_range = monthrange(start.year, m)[1]
        for d in range(start_day, month_range + 1):
            date = datetime.date(start.year, m, d)
            if MARAUDE_DAYS[date.weekday()]:
                maraude_days.append(date)

    return maraude_days

class PlanningTestCase(TestCase):

    def setUp(self):
        for i, is_maraude in enumerate(MARAUDE_DAYS):
            if is_maraude:
                Planning.objects.create(week_day=i, horaire=HORAIRES_SOIREE)

    def test_get_planning(self):
        maraudes = {i for i in range(7) if MARAUDE_DAYS[i]}
        test_maraudes = set()
        for p in Planning.get_planning():
            test_maraudes.add(p.week_day)
            self.assertEqual(p.horaire, HORAIRES_SOIREE)
        self.assertEqual(maraudes, test_maraudes)

    def test_get_maraudes_days_for_month(self):
        test_values = [
                {'year': 2017, 'month': 2,
'test': [(day, HORAIRES_SOIREE) for day in (2,3,6,7,9,10,13,14,16,17,20,21,23,24,27,28)] },
                {'year': 2016, 'month': 3,
'test': [(day, HORAIRES_SOIREE) for day in (1,3,4,7,8,10,11,14,15,17,18,21,22,24,25,28,29,31)] },
            ]

        for test in test_values:
            self.assertEqual(test['test'], list(Planning.get_maraudes_days_for_month(test['year'], test['month'])))


class MaraudeManagerTestCase(TestCase):

    maraudeurs = [{"first_name": "Astérix", "last_name": "Le Gaulois"}, {"first_name": "Obélix", "last_name": "et Idéfix"}]

    def setUp(self):
        first = True
        for maraudeur in self.maraudeurs:
            if first:
                first = False
                self.referent = Maraudeur.objects.set_referent(*list(maraudeur.values()))
            else:
                self.binome = Maraudeur.objects.create(
                    **maraudeur
                )

        self.today = datetime.date.today()
        self.past_dates = [self.today - datetime.timedelta(d) for d in (1, 3, 5)]
        self.future_dates = [self.today + datetime.timedelta(d) for d in (2, 4, 6)]

        for date in [self.today,] + self.past_dates + self.future_dates:
            Maraude.objects.create(
                date = date,
                referent = self.referent,
                binome = self.binome
            )

    def retrieve_date(self, maraude):
        return maraude.date

    def test_all_of(self):
        _all = set([self.today, ] + self.past_dates + self.future_dates)
        for maraudeur in self.maraudeurs:
            maraudeur = Maraudeur.objects.get(**maraudeur)
            self.assertEqual(
                set(map(self.retrieve_date, Maraude.objects.all_of(maraudeur))),
                _all
                )

    def test_future_maraudes_no_args(self):
        """ La liste des futures maraudes """
        test_set = set(self.future_dates + [self.today,])
        check_set = set(map(self.retrieve_date, Maraude.objects.get_future()))
        self.assertEqual(test_set, check_set)

    def test_future_maraudes_are_sorted_by_date(self):
        check_generator = iter(sorted(self.future_dates + [self.today,]))
        for maraude in Maraude.objects.get_future():
            self.assertEqual(maraude.date, next(check_generator))

    def test_past_maraudes_are_sorted_by_date(self):
        check_generator = iter(sorted(self.past_dates))
        for maraude in Maraude.objects.get_past():
            self.assertEqual(maraude.date, next(check_generator))

    def test_past_maraudes_no_args(self):
        check_set = set(self.past_dates)
        test_set = set(map(self.retrieve_date, Maraude.objects.get_past()))
        self.assertEqual(test_set, check_set)

    def test_next_property(self):
        self.assertEqual(self.retrieve_date(Maraude.objects.next), self.today)

    def test_last_property(self):
        self.assertEqual(self.retrieve_date(Maraude.objects.last), max(self.past_dates))

    def test_get_next_of(self):
        self.assertEqual(self.retrieve_date(Maraude.objects.get_next_of(self.binome)), self.today)



class MaraudeTestCase(TestCase):

    def test_est_terminee(self):
        pass


class RencontreTestCase(TestCase):
    pass