#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 24 08:51:58 2022
@author: antoine
"""

################
### UniSquat ###
################

"""
    Une application pour afficher les salles libres dans les différents
    départements de l'Université de Strasbourg.
"""


### Fichier du backend (récupération des salles libres et des départements ###


# Modules :
import requests
import icalendar
import pytz
import os
import shutil
import time

# Fichiers locaux :
from objects import Room
from objects import Dept

# Constantes :
CACHE_DIR = "cache"
CACHE_TTL = 5 # Intervalle de temps entre les réinitialisations du cache, en minutes
CACHE_SIZE = 10 # Nombres maximum de fichier dans le cache

# Globales
last_cache_init = -999

# Fonctions :
def reinit_cache() :
    global last_cache_init
    """
    Vide le dossier CACHE_DIR et l'initialise.
    Modifie la variable globale 'last_cache_init'.

    Parameters
    ----------
        None
    
    Returns
    -------
        None
    """
    if os.path.isdir(CACHE_DIR):
        shutil.rmtree(CACHE_DIR)
    os.mkdir(CACHE_DIR)
    last_cache_init = time.time()


def trim(link) :
    """
    Retourne la chaîne de caractères 'link' en minuscule, sans les caractères
    spéciaux (utilisé pour le cache des requêtes).

    Parameters
    ----------
    link: str
        Le lien à simplifier
    
    Returns
    -------
    str
        La chaine de caractères correspondante
    """
    result = ""
    for i in link.lower() :
        if i not in "/:;\\'\" *?":
            result+=i

    return result

def sched_get(date, link, enddate = None, nocache = False) :
    """
    Récupère l'emploi du temps de toutes les salles (pour le moment, juste
    de l'UFR) sur ADE depuis le site de l'Unistra.

    Parameters
    ----------
    date : datetime.datetime()
        Date du calendrier à télécharger (date de début si une date de fin
        'enddate' est indiquée).

    link:
        Un lien vers lequel effectuer la recherche, des informations seront remplacées :
        $YEAR$ : l'année
        $MONTH$ : le mois
        $DAY$ : le jour
        Par défaut, sera un lien des salles de l'UFR.
    
    Optional :
        enddate : datetime.datetime()
            Date de fin du calendrier à télécharger (par défaut, il s'agit de
            la date de début).
            
        nocache : booléen
            Si mit à 'True', ne modifie pas, ni ne lit, le dossier CACHE_DIR

    Returns
    -------
    bytes
        Le texte du résultat de la requête.
    """
    link += "&firstDate=$YEAR1$-$MONTH1$-$DAY1$&lastDate=$YEAR2$-$MONTH2$-$DAY2$"
    
    day1 = str(date.day)
    month1 = str(date.month)
    year1 = str(date.year)

    finallink = link.replace("$DAY1$", day1)
    finallink = finallink.replace("$MONTH1$", month1)
    finallink = finallink.replace("$YEAR1$", year1)

    if enddate != None :
        day2 = str(enddate.day)
        month2 = str(enddate.month)
        year2 = str(enddate.year)

        finallink = finallink.replace("$DAY2$", day2)
        finallink = finallink.replace("$MONTH2$", month2)
        finallink = finallink.replace("$YEAR2$", year2)

    else :
        finallink = finallink.replace("$DAY2$", day1)
        finallink = finallink.replace("$MONTH2$", month1)
        finallink = finallink.replace("$YEAR2$", year1)

    if nocache:
        return requests.get(finallink).content
    else :
        # Vérifie la TTL
        elapsed = time.time() - last_cache_init
        if elapsed>CACHE_TTL*60:
            reinit_cache()
        # Vérifie que le nombre total de fichiers dans le cache n'est pas dépassé
        if len(os.listdir(CACHE_DIR))>CACHE_SIZE:
            reinit_cache()

        # Vérifie que le lien est dans le cache
        cachepath = os.path.join(CACHE_DIR,trim(finallink))
        if os.path.isfile(cachepath) :
            result = ""
            with open(cachepath,'rb') as f :
                result = f.read()
            return result
        else:
            result = requests.get(finallink).content
            with open(cachepath,'wb') as f :
                f.write(result)
            return result


def get_depts(filename) :
    """
    Crée une liste de tous les départements disponibles.

    Parameters
    ----------
    filename : str
        Nom du fichier contenant les départements, et les liens
        permettant d'accéder au fichier iCal des salles du département.

    Returns
    -------
    dept_list : list
        Liste des départements.
    """
    dept_list = list()
    
    dept_file = open(filename, "r")
    
    i = 0
    
    # dept = Dept("", "", [])
    
    dfile_content = dept_file.readlines()

    ident = 0 # Compteur pour les identifiants des départements
    
    for i in range(0, len(dfile_content) - 1, 2) :
        dept_list.append(Dept(ident, dfile_content[i], dfile_content[i + 1], []))
        ident += 1
        
    dept_file.close()
    
    return dept_list


def get_tot_rooms(datet, depts, ignore_list) :
    """
    Crée une liste de toutes les salles des départements choisis.

    Parameters
    ----------
    datet : datetime.datetime()
        Date pour la recherche de salles.

    depts : list
        Liste des départements dans lesquels chercher des salles.

    ignore_list : list
        Liste des noms de salles à ignorer.

    Returns
    -------
    total_rooms : list
        Liste des salles.
    """
    total_rooms = list()
    
    margintime = 1 # Marge de temps (en mois) pour le début du calendrier (il se peut que des salles existent et soient dispos, mais qu'elles ne sont pas affichées dans l'EDT du jour choisi, donc on prend l'EDT du mois)
    
    cal_start = datet
    
    if cal_start.month == 1 :
        cal_start.replace(year = cal_start.year - 1)
        cal_start.replace(month = 12)
    else :
        cal_start.replace(month = cal_start.month - margintime)
        
    # Récupération des calendriers correspondants aux liens des départements, sur une période de 'margintime' mois :
    cals = list() # Liste des emplois du temps des départements choisis
    for d in depts :
        if datet.month < 12 :
            result = sched_get(datet, d.link, datet.replace(month = datet.month + margintime))
        else :
            result = sched_get(datet, d.link, datet.replace(month = 1, year = datet.year + 1))
        cals.append(icalendar.Calendar.from_ical(result))
    
    roomnames = [] # Contient le nom de toutes les salles indiquées dans la section "LOCATION"

    # Parcours de ces calendriers, pour faire la liste de toutes les salles :
    dept_index = 0
    for cal in cals :
        for comp in cal.walk() : # Événements
            if comp.name == "VEVENT" :
                # Ajout de la salle dans le dictionnaire, si elle n'y est pas :
                roomname = str(comp.get("location"))

                rnamelist = list() # Contient le nom de toutes les salles indiquées dans la section "LOCATION" (il peut y en avoir plusieurs, séparées par des virgules)

                if "," in roomname :
                    rnamelist = roomname.split(",")
                else :
                    rnamelist.append(roomname)

                for rname in rnamelist :
                    rname = rname.strip()
                    if (rname not in roomnames) and (rname not in ignore_list) :
                        roomnames.append(rname)

                        start = datet.replace(hour = 0, minute = 0, second=0) # Par défaut, l'heure de début de disponibilité est aujourd'hui à 00:00
                        end = datet.replace(hour = 23, minute = 59, second = 59) # Par défaut, l'heure de fin de la prochaine période disponibilité est aujourd'hui à 23:59

                        is_free = True # Par défaut, la salle est libre

                        # Réglage du fuseau horaire :
                        start = start.astimezone(pytz.timezone('Europe/Paris'))
                        end = end.astimezone(pytz.timezone('Europe/Paris'))

                        total_rooms.append(Room(rname, start, end, is_free, depts[dept_index].name))
        dept_index += 1

    return total_rooms


def getrooms(datet, depts, ignore_list) :
    """
    Ajout des informations supplémentaires à la liste des salles
    (heures de début et fin de dispo, indicateur de dispo).

    Parameters
    ----------
    datet : datetime.datetime()
        Date pour la recherche de salles.

    depts : list
        Liste des départements dans lesquel chercher des salles.

    ignore_list : list
        Liste des noms de salles à ignorer.

    Returns
    -------
    total_rooms : list
        Liste des salles.
    """
    # Création de la liste de toutes les salles :
    total_rooms = get_tot_rooms(datet, depts, ignore_list)
    
    # Récupération des calendriers correspondants au lien du département :
    cals = list() # Liste des emplois du temps des départements choisis
    for d in depts :
        result = sched_get(datet, d.link, datet)
        cals.append(icalendar.Calendar.from_ical(result))
    
    # Ajout des infos supplémentaires sur les salles (heures de début-fin de dispo, indicateur de dispo), s'il y en a :
    for cal in cals :
        # Première boucle, pour déterminer les salles occupées :
        for comp in cal.walk() : # Événements
            if comp.name == "VEVENT" :
                # Récupération des infos :
                datestart = comp.decoded("dtstart")
                dateend = comp.decoded("dtend")
                roomname = str(comp.get("location"))

                rnamelist = list() # Contient le nom de toutes les salles indiquées dans la section "LOCATION" (il peut y en avoir plusieurs, séparées par des virgules)

                if "," in roomname :
                    rnamelist = roomname.split(",")
                else :
                    rnamelist.append(roomname)

                for rname in rnamelist :
                    # L'événement se passe maintenant (salle occupée maintenant) :
                    if datestart.timestamp() <= datet.timestamp() and dateend.timestamp() > datet.timestamp() :
                        start = dateend # L'heure de début de la prochaine période de disponibilité est la fin de l'événement
                        end = datet.replace(hour = 23, minute = 59, second = 59) # Par défaut, l'heure de fin de la prochaine période disponibilité est aujourd'hui à 23:59

                        is_free = False

                        # Réglage du fuseau horaire :
                        start = start.astimezone(pytz.timezone('Europe/Paris'))
                        end = end.astimezone(pytz.timezone('Europe/Paris'))

                        for r in total_rooms :
                            if r.name == rname :
                                r.start = start
                                r.end = end
                                r.is_free = is_free

        # Deuxième boucle, pour ajouter les heures de dispos des salles :
        for comp in cal.walk() : # Événements
            if comp.name == "VEVENT" :
                # Récupération des infos :
                datestart = comp.decoded("dtstart")
                dateend = comp.decoded("dtend")
                roomname = str(comp.get("location"))

                rnamelist = list() # Contient le nom de toutes les salles indiquées dans la section "LOCATION" (il peut y en avoir plusieurs, séparées par des virgules)

                if "," in roomname :
                    rnamelist = roomname.split(",")
                else :
                    rnamelist.append(roomname)

                for rname in rnamelist :
                    # L'événement se passe prochainement (salle occupée à l'occasion de cet événement) :
                    if datestart.timestamp() > datet.timestamp() :
                        for r in total_rooms :
                            if r.name == roomname :
                                if datestart.timestamp() < r.end.timestamp() :
                                    if not(r.is_free) and (datestart.timestamp() == r.start.timestamp()) :
                                        start = dateend
                                        end = r.end
                                    else :
                                        start = r.start
                                        end = datestart

                                    # Réglage du fuseau horaire :
                                    start = start.astimezone(pytz.timezone('Europe/Paris'))
                                    end = end.astimezone(pytz.timezone('Europe/Paris'))

                                    r.start = start
                                    r.end = end
    
    return total_rooms