views.py

from datetime import datetime, timedelta
import math

from django.views.generic.base import TemplateView

from emissions.models import Emission, Episode, Diffusion, SoundFile, Schedule

class ProgramView(TemplateView):
    template_name = 'program.html'

    def get_context_data(self, **kwargs):
        context = super(ProgramView, self).get_context_data(**kwargs)
        schedules = Schedule.objects.all().order_by('datetime')
        days = []
        for day in range(7):
            days.append({'schedules': [x for x in schedules if x.is_on_weekday(day+1)],
                         'datetime': datetime(2007, 1, day+1)})
        context['days'] = days
        return context

program = ProgramView.as_view()

class TimeCell:
    emissions = None
    nonstop = None
    w = 1
    h = 1
    time_label = None

    def __init__(self, i, j):
        self.x = i
        self.y = j
        self.schedules = []

    def add_schedule(self, schedule):
        end_time = schedule.datetime + timedelta(
                minutes=schedule.emission.duration)
        self.time_label = '%02d:%02d-%02d:%02d' % (
                schedule.datetime.hour,
                schedule.datetime.minute,
                end_time.hour,
                end_time.minute)
        self.schedules.append(schedule)

    def __unicode__(self):
        if self.schedules:
            return ', '.join([x.emission.title for x in self.schedules])
        else:
            return self.nonstop

    def __eq__(self, other):
        return (unicode(self) == unicode(other))


class Grid(TemplateView):
    template_name = 'grid.html'

    def get_context_data(self, **kwargs):
        context = super(Grid, self).get_context_data(**kwargs)
        schedules = Schedule.objects.all().order_by('datetime')

        nb_lines = 2 * 24 # the cells are half hours
        grid = []

        times = ['%02d:%02d' % (x/2, x%2*30) for x in range(nb_lines)]
        # start grid after the night programs
        times = times[2*Schedule.DAY_HOUR_START:] + times[:2*Schedule.DAY_HOUR_START]

        nonstops = [[0, 2, 'Biodiversite'],
                    [2, 5, 'Reveries'],
                    [5, 7.5, 'La Panique'],
                    [7.5, 10, 'Matin tranquille'],
                    [10, 12, 'Up Beat Tempo'],
                    [12, 13, 'L\'heure de pointe'],
                    [13, 16, 'Le Mange Disque'],
                    [16, 19, 'Hop Bop and co'],
                    [19, 22, 'Acouphene'],
                    [22, 24, 'Biodiversite']
                   ]

        for i in range(nb_lines):
            grid.append([])
            for j in range(7):
                grid[-1].append(TimeCell(i, j))

            nonstop = [x for x in nonstops if i>=x[0]*2 and i<x[1]*2][0]
            for time_cell in grid[-1]:
                time_cell.nonstop = nonstop[2]
                if nonstop[2] == 'Reveries':
                    time_cell.time_label = '02:00-05:00'

        for schedule in Schedule.objects.all():
            row_start = schedule.datetime.hour * 2 + \
                    int(math.ceil(schedule.datetime.minute / 30))
            day_no = schedule.get_weekday()

            for step in range(int(math.ceil(schedule.emission.duration / 30))):
                if grid[(row_start+step)%nb_lines][day_no] is None:
                    grid[(row_start+step)%nb_lines][day_no] = TimeCell()
                grid[(row_start+step)%nb_lines][day_no].add_schedule(schedule)

        # start grid after the night programs
        grid = grid[2*Schedule.DAY_HOUR_START:] + grid[:2*Schedule.DAY_HOUR_START]

        # merge adjacent cells
        for i in range(nb_lines):
            for j, cell in enumerate(grid[i]):
                if grid[i][j] is None:
                    continue
                t = 1
                try:
                    while grid[i][j+t] == cell:
                        cell.w += 1
                        grid[i][j+t] = None
                        t += 1
                except IndexError:
                    pass
            grid[i] = [x for x in grid[i] if x is not None]

        for i in range(nb_lines):
            grid[i] = [x for x in grid[i] if x is not None]
            for j, cell in enumerate(grid[i]):
                if grid[i][j] is None:
                    continue
                t = 1
                try:
                    while True:
                        same_cell_below = [(bj, x) for bj, x in enumerate(grid[i+cell.h])
                                           if x == cell and x.y == cell.y and x.w == cell.w]
                        if not same_cell_below:
                            break
                        bj, same_cell_below = same_cell_below[0]
                        del grid[i+cell.h][bj]
                        cell.h += 1
                except IndexError:
                    pass

        # cut night at 3am
        grid = grid[:42]
        times = times[:42]

        context['grid'] = grid
        context['times'] = times
        context['weekdays'] = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi',
                'Vendredi', 'Samedi', 'Dimanche']

        return context

grid = Grid.as_view()


class Home(TemplateView):
    template_name = 'home.html'

    def get_context_data(self, **kwargs):
        context = super(Home, self).get_context_data(**kwargs)
        context['emissions'] = Emission.objects.filter(archived=False).order_by('?')
        return context

home = Home.as_view()

class Get(TemplateView):
    template_name = 'get.html'

    def get_context_data(self, **kwargs):
        context = super(Get, self).get_context_data(**kwargs)
        context['emissions'] = Emission.objects.all().order_by('title')
        return context

get = Get.as_view()

class WhatsOnAir(TemplateView):
    template_name = 'whatsonair.html'
    def get_context_data(self, **kwargs):
        context = super(WhatsOnAir, self).get_context_data(**kwargs)
        now = datetime.now()
        date_start = now - timedelta(days=1)
        date_end = now + timedelta(days=1)
        diffusions = Diffusion.objects.filter(
                datetime__range=(date_start, date_end)).order_by('datetime')
        diffusions = [x for x in diffusions if x.datetime <= now and
                        now <= x.datetime + timedelta(minutes=x.episode.emission.duration)]

        episode = None
        emission = None
        if diffusions: # there should be only one
            diffusion = diffusions[0]
            episode = diffusion.episode
            emission = episode.emission
        else:
            for schedule in Schedule.objects.all():
                if not schedule.matches(now):
                    continue
                emission = schedule.emission
                break

	context['episode'] = episode
	context['emission'] = emission
        return context

what = WhatsOnAir.as_view()

class Player(TemplateView):
    template_name = 'player.html'

    def get_context_data(self, **kwargs):
        context = super(Player, self).get_context_data(**kwargs)
	#context['whatsonair'] = WhatsOnAir.as_view() #HOW TO PRELOAD WHATSONAIR ON PLAYER?
        return context

player = Player.as_view()