from AccessControl import ClassSecurityInfo
from OFS.Folder import Folder
from OFS.PropertyManager import PropertyManager
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
import Acquisition

import random
import datetime
import logging
import httplib2
import MPIWGFMItem
import xml.etree.ElementTree as ET


# TODO: compatibility
months = [(u"January", u"Januar"),
          (u"February", u"Februar"),
          (u"March", u"M\u00e4rz"),
          (u"April", u"April"),
          (u"May", u"Mai"),
          (u"June", u"Juni"),
          (u"July", u"Juli"),
          (u"August", u"August"),
          (u"September", u"September"),
          (u"October", u"Oktober"),
          (u"November", u"November"),
          (u"December", u"Dezember"),
          ]

map_months = {'EN': [u"",
               u"January",
               u"February",
               u"March",
               u"April",
               u"May",
               u"June",
               u"July",
               u"August",
               u"September",
               u"October",
               u"November",
               u"December"],
              'DE': [u"",
               u"Januar",
               u"Februar",
               u"M\u00e4rz",
               u"April",
               u"Mai",
               u"Juni",
               u"Juli",
               u"August",
               u"September",
               u"Oktober",
               u"November",
               u"Dezember"]}


class MPIWGFMManager(Folder, PropertyManager):
    """ A Zope-Object for management of the Events  
    
    manages MPIWGItem-Objects inside this Folder-like object. 
    """
    _v_items=None   
    meta_type = 'MPIWGFMManager'
    title = ""
    project_link = ""  # WTF?

    _properties = ({'id':'title', 'type':'string'},)
                   
    manage_options = Folder.manage_options + (
        {'label':'Edit Defaults', 'action':'manage_editMPIWGFMManagerForm'},
         {'label':'Edit FM Connection', 'action':'manage_editMPIWGFMConnectionForm'},

        )


    def __init__(self, id, title,url,username=None,password=None):
        self.id = id
        self.title = title
        self.url=url
        self.username=username
        self.password=password
        self.count = 0
        self.Properties = []  # List of 6-tuples (ID_EN,ID_DE,VALUE_EN,VALUE_DE, WEIGHT,ID)
                             # Note: this defines properties that MPIWGItems will get on creation by default


    def getDefaultProperties(self):
        """ """
        return self.Properties

    def deleteObject(self, id):
        """ delete an object not implemented management via DB"""
        pass

    def addProperty(self, tup=("", "", "", "", 0, "")):
        self.Properties.append(tup)

    def getWeight(self, n):
        """ """
        return self.Properties[n][4]

    def getItems(self):
        """returns all items directly"""
        
        if self._v_items is not None:
            return self._v_items
        
        ret=[]
        #fh = file("/usr/local/testzope13/Products/MPIWGFMManager/kalender.xml")
        #root = ET.parse(fh);
        url="http://fm8-server.mpiwg-berlin.mpg.de/fmi/xml/fmresultset.xml?-db=Kalender&-lay=Eingabe&-findall"
        
        h =httplib2.Http("/var/tmp/.cacheWWW")
        if self.username is not None:
            h.add_credentials(self.username,self.password)
        
        logging.debug(self.url)
        resp, content = h.request(self.url)
        
        
        
        root=ET.fromstring(content)
       
        ET.register_namespace('', 'http://www.filemaker.com/xml/fmresultset')
        records = root.findall(".//{http://www.filemaker.com/xml/fmresultset}record")
        #records = root.findall(".//record")
        
        for record in records:
            
            ret.append(MPIWGFMItem.MPIWGFMItem(record,self));
        
        self._v_items=ret
        return ret;

    def getSortedItems(self, field='Date'):
        """return all items sorted by field"""
        if field == 'Date':
            items = self.getSortedByDate()
        else:
            items = self.getItems()
            items.sort(key=lambda x:x.getValue(field))
            
        return items

    def getAllItemsFromTodayOn(self):
        """ """
        return self.getSortedByDate(startdate=datetime.date.today())
    
    def getAllItemsUntilToday(self, newestFirst=False):
        """ """
        return self.getSortedByDate(enddate=datetime.date.today(), newestFirst=newestFirst)

    def getSortedByDate(self, startdate=None, enddate=None, newestFirst=False):
        """ return the Items, sorted by date. The start- and enddate parameters can be set (as strings YYYY.MM.DD) to limit 
        the list to items that have a date greater or equal to startdate and lower or equal to enddate."""
        logging.debug("getsortedbydate startdate=%s enddate=%s" % (startdate, enddate))
        #items = [self._getOb(x) for x in self.objectIds(spec="MPIWGItem")]
        items = self.getItems()
        
        # filter for startdate
        if startdate != None:
            try:
                if isinstance(startdate, str):
                    startdatesplitted = [int(x) for x in startdate.split(".")]
                    logging.debug("getsortedbydate startdate=%s" % repr(startdatesplitted))
                    startdate = datetime.date(*startdatesplitted)
                    
                items = [x for x in items if x.Date >= startdate]
            except:
                pass
            
        # filter for enddate
        if enddate != None:
            try:
                if isinstance(enddate, str):
                    enddatesplitted = [int(x) for x in enddate.split(".")]
                    enddate = datetime.date(*enddatesplitted)
                    
                items = [x for x in items if x.Date <= enddate]
            except:
                pass

        if not newestFirst:
            items.sort(key=lambda x:x.Date)
        else:
            items.sort(key=lambda x:x.Date, reverse=True)
        return items

    def getGroupedByDate(self, lang="EN"):
        """ return the entries in a dictionary structure, 
        grouped by Year, then by Month (and then a sorted list) """

        result = {}
        for item in self.getItems():
            m = item.Date.month
            y = item.Date.year

            d = 0
            if lang.upper() == "DE":
                d = 1

            if not y in result:
                result[y] = {}
            
            if not m in result[y]:
                result[y][m] = [months[m - 1][d]]

            result[y][m] += [item]

        return result

    def getGrouped(self, field, type, lang="EN"):
        """ return the entries in a dictionary structure, 
        grouped by the values of field with grouping type.
        type='year_month','a_z'"""

        if type == 'year_month':
            # sort by year, then month
            map = map_months[lang.upper()]
            key1 = lambda x:x.Date.year
            key2 = lambda x:map[x.Date.month]
        else:
            # sort by first letter of field
            key1 = lambda x:x.getValue(field, lang)[0].upper()
            key2 = None
            
        result = []
        k1 = None
        k2 = None
        list1 = None
        list2 = None
        if key2 is None:
            # single level
            for item in self.getSortedItems(field=field):
                if k1 != key1(item):
                    # new key
                    k1 = key1(item)
                    list1 = []
                    result.append({'key':k1, 'list':list1})
                             
                # add item to list      
                list1.append(item)
        
        else:
            # two level
            for item in self.getSortedItems(field=field):
                if k1 != key1(item):
                    # new key1
                    k1 = key1(item)
                    list1 = []
                    result.append({'key':k1, 'list':list1})
                    # invalidate key2
                    k2 = None
                             
                if k2 != key2(item):
                    # new key2
                    k2 = key2(item)
                    list2 = []
                    list1.append({'key':k2, 'list':list2})
                             
                # add item to list      
                list2.append(item)
                
        return result


    def getMostRecent(self, count=2):
        """ returns the 'count' most recent event entries as EventObjects """
        events = self.getItems()
        events.sort(key=lambda x:x.Date)
        events.reverse()
        return events[:count]

    def getFirst(self, count=2, start=0):
        """ returns the count first elements """
        events = self.getSortedItems()
        return events[start:count]
        

    def getNext(self, count=2):
        """ returns the next 'count' upcoming events; if there are not enough upcoming events, fill with the latest past events """
        today = datetime.date.today()
        events = self.getItems()
        events.sort(key=lambda x:x.Date)
        upcoming = [x for x in events if x.Date >= today]
        short = count - len(upcoming)
        if short > 0:
            pastevents = [x for x in events if x.Date < today]
            upcoming += pastevents[-short:]
        # upcoming.reverse()
        return upcoming[:count]

    def getNewID(self):
        """ """
        items = self.getItems()
        if len(items) == 0:
            count = 1
        else:
            itemsnum = [x for x in items if x.id.isdigit()]
            itemsnum.sort(lambda a, b :cmp(a.id, b.id))
        
            count = int(itemsnum[-1].id) + 1
        return "%04d" % (count)


    
    def manage_editMPIWGFMManager(self, REQUEST):
        """ """

        formdata = REQUEST.form

        # update property names and values and weights
        # date,title,category
        property_ids = [int(x.split('_')[1]) for x in formdata.keys() if x.endswith('_en_key')]
        for pid in property_ids:
            if pid < len(self.Properties):
                self.Properties[pid] = (
                    formdata["property_%s_en_key" % pid],
                    formdata["property_%s_de_key" % pid],
                    formdata["property_%s_en_value" % pid],
                    formdata["property_%s_de_value" % pid],
                    formdata["property_%s_weight" % pid],
                    formdata["property_%s_id" % pid])

        # check if properties need to be removed
        deltoken = "del__"
        # e.g. "del__property_1"
        relevant_keys = [int(x.split('_')[-1]) for x in formdata.keys() if x.find(deltoken) == 0 and formdata[x] == "on"]
        relevant_keys.sort()
        relevant_keys.reverse()
        for n in relevant_keys:
            del self.Properties[n]

        # sort
        self.Properties.sort(lambda a, b: cmp(int(a[4]), int(b[4])))
        
        # add new properties (empty)
        try:
            add_new = int(formdata['add_new'])
            
            for x in range(add_new):
                self.addProperty()
        except:
            pass

        # force update of the Properties list in the ZopeDB
        self._p_changed = 1

        REQUEST.RESPONSE.redirect('manage_editMPIWGFMManagerForm?rnd=%s' % ''.join(random.sample("abcdefuvwxyz", 8)))

    manage_editMPIWGFMManagerForm = PageTemplateFile('zpt/editMPIWGManager.pt', globals())
    
    def manage_editMPIWGFMConnection(self,url,username,password,REQUEST=None):
        """change the parameters for connections"""
        self.url=url
        self.username=username
        self.password=password
        
        REQUEST.RESPONSE.redirect(' manage_editMPIWGFMConnectionForm?rnd=%s' % ''.join(random.sample("abcdefuvwxyz", 8)))
            
    manage_editMPIWGFMConnectionForm = PageTemplateFile('zpt/editConnection.pt', globals())
   

def manage_addMPIWGFMManager(self, id, title, url, username=None,password=None, REQUEST=None):
    """ create the new MPIWGManager """
    newinst = MPIWGFMManager(id, title,url, username,password)
    self._setObject(id, newinst)

    REQUEST.RESPONSE.redirect('manage_main')

manage_addMPIWGFMManagerForm = PageTemplateFile('zpt/addMPIWGManager.pt', globals())