#!/usr/bin/env python
# -*- coding: utf-8 -*-
#    TOMUSS: The Online Multi User Simple Spreadsheetl)
#    Copyright (C) 2008-2011 Thierry EXCOFFIER, Universite Claude Bernard
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#    Contact: Thierry.EXCOFFIER@bat710.univ-lyon1.fr

import os
from . import inscrits
from . import utilities
from . import configuration

warn = utilities.warn

#REDEFINE
# Returns the UE list from LDAP or other sources.
# This function is called once per night,
# so it can be long to execute.
# The function result is stored as a Python and JavaScript file
def get_ue_dict():
    if configuration.ldap_server[0] != 'ldap1.domain.org':
        ldap_ues = inscrits.L_batch.get_ldap_ues()
    else:
        ldap_ues = ()
    ues = {}
    for apoge in ldap_ues:
        ues[apoge] = UE(apoge, [], 'UNKNOWN TITLE',
                        [], 0, [], 1, 1, [], 0)
    for i in range(1,10):
        name = "UE%d" % i
        ues[name] = UE(
            name, # UE Name
            ['ue%d.master' % i],# Teacher names
            u'UE%d Title' % i,  # UE title
            [],                 # Departments of UE
            1000+i,             # SPIRAL key for the UE
            ['ue%d.master' % i],# Login of teachers
            1,                  # #students registered
            0,                  # #students registered in EC
            ['ue%d_test@test.org' % i], # Teachers mails
            0,                  # ADE key for the UE
            ) 
    return ues


def create_all_ues_js(ues):
    ff_tt_list = utilities.AtomicWrite(os.path.join('TMP','tt_list.txt'))
    ff = utilities.AtomicWrite(os.path.join('TMP','all_ues.js'))
    ff.write('var all_ues = {\n')
    ue_list = []
    for ue, uev in ues.items():
        print ue
        tt_list = []
        ue_list.append('%s:%s' % (utilities.js(ue).encode('utf-8'),
                                      uev.js(tt_list).encode('utf-8')))
        ff_tt_list.write('%s : %s\n' % (ue, ', '.join(tt_list)))
    ff.write(',\n'.join(ue_list))
    ff.write('} ;\n')
    ff.close()
    ff_tt_list.close()

    os.system('gzip -9 <TMP/all_ues.js >all_ues.js.gz')
    os.rename('all_ues.js.gz',os.path.join('TMP','all_ues.js.gz'))

all_ues_is_running = False

def all_ues(compute=False):
    warn('start', what='debug')
    try:
        # Load precalculated ues
        # If the file is modified, reload it
        warn('import', what='debug')
        from .TMP import xxx_toute_les_ues
        warn('import done', what='debug')
        if compute is False:
            t = os.path.getmtime(os.path.join('TMP', 'xxx_toute_les_ues.py'))
            if not hasattr(all_ues,'t') or all_ues.t != t:
                warn('Reload all ues')
                utilities.unload_module('TOMUSS.TMP.xxx_toute_les_ues')
                from .TMP import xxx_toute_les_ues
                all_ues.t = t
                warn('ok')

            return xxx_toute_les_ues.all
    except (ImportError, OSError, ValueError):
        warn("The UE list does not exists, create first one")
        compute = True
    warn('compute', what='debug')

    ues = get_ue_dict()
        
    global all_ues_is_running
    if compute and not all_ues_is_running:
        all_ues_is_running = True
        create_all_ues_js(ues)
        all_ues_is_running = False

    # The JS creation updates the number of students per UE
    # So we create the .py file after.
    f = utilities.AtomicWrite(os.path.join('TMP','xxx_toute_les_ues.py'),
                              reduce_ok=False)
    f.write('# -*- coding: utf8 -*-\nfrom teacher import UE\nall = {\n')
    for ue in ues:
        f.write('%s:%s,\n' % (repr(ue), ues[ue]))
    f.write('}\n')
    f.close()
        
    return ues


def login_to_ue(login):
    ues = []    
    for ue in all_ues().values():
        if login in ue.responsables_login():
            ues.append(ue)
    return [(ue.intitule(), ue.name) for ue in ues]
    

class UE(object):
    """Contains all the information about the UE (Unity of Evaluation)."""
    def __init__(self, name, responsable=(), intitule=None, pparcours=(),
                 code=-1,responsable_login=[], nr_students_ue=0,
                 nr_students_ec=0, mails=(), planning={}, credit=-1,
                 old_names=[]):
        """This object may retrieve information from other data sources"""

        # The name is an human lisible code for the UE.
        self.name = name
        self._responsables = responsable
        self._responsables_login = responsable_login
        self._intitule = intitule
        self._parcours = pparcours
        self._code = code
        # Number of students subscribing to the UE
        self._nr_students_ue = nr_students_ue
        # Number of students subscribing to the EC
        self._nr_students_ec = nr_students_ec
        # These mails can't be extracted from responsable logins.
        self._mails = tuple(mails)
        self.len = len(pparcours)
        self.planning = planning
        self.credit = credit
        self.old_names = old_names

    def responsables(self):
        """Returns the NAME list of the manager of the UE."""
        return self._responsables

    def responsables_login(self):
        """Returns the LOGIN list of the manager of the UE."""
        if len(self._responsables_login) == 0:
            self._responsables_login = [responsable_pedagogique_ldap(name)
                                        for name in self._responsables]
            self._responsables_login = [ x.lower()
                                         for x in self._responsables_login
                                         if x != None ]
        return self._responsables_login

    def intitule(self):
        """Returns the title of the UE."""
        return self._intitule

    def parcours(self):
        """Return the list of diploma using this UE."""
        return self._parcours

    def code(self):
        """Returns a database code to access this UE."""
        return self._code

    def mails(self):
        """Returns all the mails of the managers of this UE."""
        return self._mails

    def __cmp__(self, other):
        return cmp(self.len, other.len)

    def __str__(self):
        """Returns the Python code creating this object."""
        return 'UE(%s,%s,%s,%s,%d,%s,%d,%d,%s,%s,%d,%s)' % (
            repr(self.name),
            repr(self._responsables),
            repr(self._intitule),
            repr(self._parcours),
            self._code,
            repr(self.responsables_login()),
            self._nr_students_ue, self._nr_students_ec,
            repr(self._mails),
            self.planning,
            self.credit,
            self.old_names,
            )

    def js(self, read_tt=True):
        """Returns the code to create the JavaScript object for this one.
        If read_tt is a list, then TT students are stored in the list.
        """
        if read_tt is not False:
            from . import document
            table = document.table(utilities.university_year(),
                                   'Dossiers', 'tt')
            tts = table.the_current_tt(table)
            tt = 0
            ue = document.table(configuration.year_semester[0],
                                configuration.year_semester[1],
                                'UE-' + self.name,
                                create=False)
            nr_students = 0
            if ue:
                for student in ue.the_keys():
                    if len(student) < 3: # Garbage student id (bad user input)
                        continue
                    nr_students += 1
                    student_id = inscrits.login_to_student_id(student)
                    if student_id in tts and tts[student_id].current():
                        tt += 1
                        if isinstance(read_tt, list):
                            read_tt.append(utilities.the_login(student))
                if self._intitule is None or len(self._intitule) <= 1:
                    # Too small UE name : take the comment as title
                    self._intitule = ue.comment
                ue.unload()
                self._nr_students_ue = nr_students

            if nr_students <= 10: # Problem ?
                self._nr_students_ue = 0
                for student in inscrits.L_batch.students('UE-' + self.name):
                    self._nr_students_ue += 1
                    if utilities.the_login(student[0]) in table.the_keys():
                        tt += 1
                        if isinstance(read_tt, list):
                            read_tt.append(utilities.the_login(student[0]))
        else:
            tt = 0
        

        return 'UE(%s,[%s],%s,[%s],%d,[%s],%d,%d,%s,%d,%d,%s)' % (
            utilities.js(self.name),
            ','.join([utilities.js(r) for r in self._responsables]),
            utilities.js(self._intitule),
            ','.join([utilities.js(p) for p in self._parcours]),
            self._code,
            ','.join([utilities.js(r) for r in self._responsables_login]),
            self._nr_students_ue, self._nr_students_ec, 
            self.planning,
            tt,
            self.credit,
            utilities.js(self.old_names),
            )

    def short_parcours(self):
        """Returns the UFR managing this UE."""
        return self.name[0:3]

def other_mails(code):
    try:
        from .TMP import xxx_mails
    except ImportError:
        return []
    try:
        return xxx_mails.mails[code]
    except KeyError:
        return []

def responsable_pedagogique_ldap(name):
    surname = []
    firstname = []
    for x in name.split(' '):
        if x.upper() == x:
            surname.append(x)
        else:
            firstname.append(x)
    return inscrits.L_batch.firstname_and_surname_to_login(' '.join(firstname),
                                                           ' '.join(surname))

def responsables_pedagogiques_ldap(ue):
    return all_ues()[ue].responsables_login()

def parcours_names(les_ues):
    names = {}
    for ue in les_ues.values():
        for q in ue.parcours():
            names[q] = True
    return names.keys()

def ues_for_parcour(les_ues, p):
    t = []
    for ue in les_ues.values():
        if p in ue.parcours():
            t.append(ue)
    return t