joeni

""" This is a module dedicated to collecting all functionality regarding the

building of the roster. """

from django.shortcuts import render

from collections import OrderedDict

import datetime

from django.urls import reverse

from django.utils.translation import gettext as _

from .models import *

import administration

def same_day(datetime_a, datetime_b):

    """True if both a and b are on the same day, false otherwise."""

    return (

        datetime_a.day == datetime_b.day and

        datetime_a.month == datetime_b.month and

        datetime_a.year == datetime_b.year)

def same_daytime(moment, hour, minute):

    return (moment.minute == minute and moment.hour == hour)

def conflicting_events(events):

    """Finds conflicting events in the given set, and returns a list of all

    conflicting events, grouped according to their conflicts in lists."""

    conflicts = list()

    test_conflict = list()

    #for event in events.order_by("begin_time"):

    for event in events:

        if len(test_conflict) == 0:

            test_conflict.append(event)

        else:

            possible_conflict = test_conflict.pop()

            #print("comparing" + str(possible_conflict) + " - " + str(event))

            if possible_conflict.end_time > event.begin_time:  # New conflict!

                test_conflict.append(possible_conflict)

                test_conflict.append(event)

                #print(test_conflict)

            elif len(test_conflict) == 0:  # No conflict

                test_conflict.append(event)

            else:  # No conflict, but previous conflicting events exist

                test_conflict.append(possible_conflict)

                conflicts.append(test_conflict.copy())

                test_conflict.clear()

    if len(test_conflict) >= 2:

        conflicts.append(test_conflict.copy())

    return conflicts

def replace_conflict(events, conflicts):

    """Removes the conflicts from events, and replaces them with a new

    event. Returns the key number for this conflict set. Expects the conflicts

    to be in chronological order based on begin_time."""

    for conflict in conflicts:

        events.remove(conflict)

    conflict_number = 0

    for event in events:

        if event.note == "Conflict " + str(conflict_number):

            conflict_number += 1

    replacement = Event(

        begin_time = conflicts[0].begin_time,

        end_time = conflicts[-1].end_time,

        note = "Conflict " + str(conflict_number),

        )

    events.append(replacement)

    return conflict_number

def replace_conflicts(events):

    """Searches for all events that are in conflict regarding timespans, and

    replaces them with a general event. Returns a dictionary with keys referencing

    a specific conflict block, and the values being a list of the events that are

    in conflict with each other."""

    all_conflicts = conflicting_events(events)

    conflict_dict = dict()

    for conflict_list in all_conflicts:

        conflict_number = replace_conflict(events, conflict_list)

        conflict_dict[conflict_number] = conflict_list

    return conflict_dict

def create_roster_event(event_type, quarters, content, style="", note=""):

    return '<td class="{event_type}" style="{style}" {title} rowspan="{quarters}">{content}</td>'.format(

        event_type=event_type,

        style=style,

        quarters=quarters,

        content=content,

        title=note)

def create_roster_conflict_event(event):

    quarters = (event.end_time - event.begin_time).seconds // 60 // 15

    content = _('<strong>Conflicting events!<br />See <a href="#'+event.note+'">'+event.note+'</a> for more information.</strong>')

    return create_roster_event("event-conflict", quarters, content)

def create_roster_study_event(event):

    pass  # TODO

def create_roster_university_event(event):

    pass  # TODO

def create_roster_course_event(event):

    # FIXME: Currently not all users are equipped with a user_data object.

    # Because of this, reversing the link to the docent's page may throw a

    # RelatedObjectDoesNotExist error. Until that's resolved, I've wrapped

    # creating that link in a try catch.

    docent_link = ""

    try:

        docent_link = reverse('administration-user', args=(event.docent.user_data.slug_name(),))

    except :

        pass

    quarters = (event.end_time - event.begin_time).seconds // 60 // 15

    course_link = reverse('courses-course-index', args=(event.course.course.slug_name,))

    room_link = reverse('administration-room-detail', args=(str(event.room),))

    event_type = "event"

    content = "{course}<br /> {docent}<br />{begin} - {end}<br /> {room} ({subject})".format(

        course = '<a href="'+course_link+'">'+str(event.course.course.name)+'</a>',

        docent = '<a href="'+docent_link+'">'+str(event.docent)+'</a>',

        begin  = event.begin_time.strftime("%H:%M"),

        end    = event.end_time.strftime("%H:%M"),

        room   = '<a href="'+room_link+'">'+str(event.room)+'</a>',

        subject = event.subject,

        )

    style = "background-color: #"+event.course.course.color+"; color: white;"

    if event.recently_created():

        event_type = "event-new"

        style = ""

    elif event.recently_updated():

        event_type = "event-update"

        style = ""

    elif event.note != "":

        event_type = "event-note"

    return create_roster_event(event_type, quarters, content, style, event.note)

def first_last_day(events):

    """Returns the first and last day of the starting times of the given events."""

    earliest = events[0].begin_time

    latest = events[0].begin_time

    for event in events:

        if event.begin_time < earliest:

            earliest = event.begin_time

        if event.begin_time > latest:

            latest = event.begin_time

    first = datetime.date(earliest.year, earliest.month, earliest.day)

    last = datetime.date(latest.year, latest.month, latest.day)

    return first, last

def create_roster_for_event(event, conflict=False):

    """Determines which function to call to build the roster entry for the given event."""

    if conflict and isinstance(event, Event):

        return create_roster_conflict_event(event)

    elif isinstance(event, CourseEvent):

        return create_roster_course_event(event)

    elif isinstance(event, UniversityEvent):

        return create_roster_university_event(event)

    elif isinstance(event, StudyEvent):

        return create_roster_study_event(event)

    elif isinstance(event, Event):

        return create_roster_event(event)

    else:

        raise TypeError("Given object is not of any Event type")

def make_first_quarter_column(hour, quarter):

    """Creates and returns the first part of the quarter row, which is the

    column with the current time in it."""

    quarter_line = "<tr><td style='font-size:"

    if quarter != 0:

        quarter_line += "xx-small; color: grey;"

    else:

        quarter_line += "x-small;"

    quarter_line += "'>"

    if hour < 10:

        quarter_line += "0"

    quarter_line +=  str(hour) +":"

    if quarter == 0:

        quarter_line += "0"

    quarter_line +=  str(quarter)

    quarter_line += "</td>"

    return quarter_line

def make_quarter_row(events, hour, quarter):

    """Creates an HTML row for a quarter. Expects *NO conflicts!*"""

    if len(conflicting_events(events)) != 0:

        print(conflicting_events(events))

        raise ValueError("events contains conflicts!")

    quarter_line = make_first_quarter_column(hour, quarter)

    first_day, last_day = first_last_day(events)

    for i in range((first_day - last_day).days, 1):

        column_added = False

        current_day = (last_day + datetime.timedelta(days=i))

        current_daytime = datetime.datetime(

            current_day.year,

            current_day.month,

            current_day.day,

            hour=hour,

            minute=quarter,

            tzinfo = datetime.timezone.utc)

        for event in events:

            if (same_day(event.begin_time, current_day) and

                same_daytime(event.begin_time, hour, quarter)):  # Event starts on this quarter

                quarter_line += create_roster_for_event(

                    event,

                    conflict = (event.note.startswith("Conflict ")))

                column_added = True

            elif (same_day(event.begin_time, current_day) and

                  event.begin_time < current_daytime and

                  event.end_time >= current_daytime):

                column_added = True

                break

        if not column_added:

            quarter_line += "<td></td>"

    quarter_line += "</tr>"

    return quarter_line

def create_roster_rows(events):

    if len(events) == 0:

        return {}, []

    events = list(events.order_by("begin_time"))

    conflict_dict = replace_conflicts(events)

    print(conflict_dict)

    for event in events:

        print(event.begin_time)

    table_code = []

    current_quarter = datetime.datetime.now().replace(hour=8, minute=0)

    while current_quarter.hour != 20 or current_quarter.minute != 00:

        table_code.append(make_quarter_row(events, current_quarter.hour, current_quarter.minute))

        current_quarter += datetime.timedelta(minutes=15)

    return conflict_dict, table_code