from AccessControl import ClassSecurityInfo
from OFS.Folder import Folder
from OFS.PropertyManager import PropertyManager
import OFS.Image
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from ZPublisher.Converters import type_converters

import Acquisition

import datetime
import random
import logging

from OFS.Cache import Cacheable

NS ="{http://www.filemaker.com/xml/fmresultset}"
 
class MPIWGFMItem(Folder, PropertyManager, Cacheable):
    """ 
    
    """

    meta_type = 'MPIWGItem'
    title = ""
    
    _properties = ({'id':'title', 'type':'string'},)
    
    manage_options = (
        {'label':'Edit', 'action':'manage_editItemForm'},
        ) + Folder.manage_options + (
        {'label':'Edit Item', 'action':'manage_editMPIWGItemForm'},
        )

    #def __init__(self,id, date=None, cat_en="", cat_de="", title_en="", title_de=""):
    
    def findText(self,record,xpath):
        
        tmp = record.find(xpath)
       
        if tmp is not None:
            return unicode(tmp[0].text)
        else:
            return ""
        
    def __init__(self,record,folder):
        self.id = id
        #self.Category = (cat_en,cat_de)
        
        xpathstr = ".//"+NS+"field[@name='%s']"
        
       
        title_de = self.findText(record,xpathstr%"Titel")
        
        title_en = self.findText(record,xpathstr%"EN_Titel")
        

        self.Title = (title_en,title_de)

        
        date =  self.findText(record,xpathstr%"TagderVeranstaltung")
        
       
        if date == "" or date is None:
            date = datetime.date.today().strftime("%d.%m.%Y")
            
            
        
        self.Date = self.parseDate(date) # sorting date
        
        self.Properties = []   # List of 6 Tuples (ID_EN,ID_DE,VALUE_EN,VALUE_DE, WEIGHT,ID)
                               # Note: ID_EN is the identifier for the getter-methods

        self.title = title_en
        
        self.getDataFromRecord(record, folder)
        
    def index_html(self):
        """index method"""
        # default template is called item_main
        pt = getattr(self, 'item_main', None)
        if pt is not None:
            return pt()

        # else try parent
        if hasattr(self.aq_parent, 'index_html'):
            return self.aq_parent.index_html()


    def parseDate(self, date):
        # parse the date from a DD.MM.YYYY string
        
        try:
            digits = [int(x) for x in date.split(".")]
            return datetime.date(digits[2],digits[1],digits[0])
        except: #try MM/TT/YYYY
            digits = [int(x) for x in date.split("/")]
            return datetime.date(digits[2],digits[0],digits[1])
        
    def getDate(self):
        """ return the date """
        return self.Date.strftime("%d.%m.%Y")

    def getProperty(self, id):
        for prop in self.Properties:
            if len(prop)==5: # add ID to the old format
                prop = (prop[0],prop[1],prop[2],prop[3],prop[4],prop[0])
            if prop[5].lower() == id.lower():
                return prop
        #if id_en == "category":
        #    return ("Category","Kategorie",self.Category[0],self.Category[1],0)
        if id == "title":
            return ("Title", "Titel", self.Title[0], self.Title[1],0,"title")
        if id == "date":
            return ("Date", "Datum",  self.Date.strftime("%d.%m.%Y"), self.Date.strftime("%d.%m.%Y"),0,"date")
        return None


    #def getUrl(self, baseUrl=None):
     #   """returns URL to this Department"""
      #  if baseUrl is None:
       #     return self.absolute_url()
#
 #       return '%s/%s'%(baseUrl, self.getId())
            
    def getImageIds(self, count=0):
        """ return the ids of images inside this MPIWGItem-object 
        not implemented for DB"""
        #ids = self.objectIds(spec="Image")
        #if len(ids) > 1:
        #    if count > 0:
        #        ids = ids[:count]
        #    else:
        #        ids = ids[:]
        #    ids.sort()
            
        return []

    def getImageUrls(self, count=0, baseUrl=None):
        """ return the urls of images inside this MPIWGItem-object - not implemented for DB"""
        #ids = self.getImageIds(count=count)
        #if baseUrl is None:
        #    baseUrl = self.absolute_url()
            
        #return ['%s/%s'%(baseUrl,id) for id in ids]
        return []
    def getImageUrl(self, idx=0, baseUrl=None):
        """ return the url of an image inside this MPIWGItem-object -not impelemted for DB"""
        #ids = self.getImageIds(count=idx+1)
        #if len(ids) < idx+1:
        #    return None
        #
        #if baseUrl is None:
        #    baseUrl = self.absolute_url()
#
        #return '%s/%s'%(baseUrl,ids[idx])
        return ""

    def getFileIds(self, count=0):
        """ return the ids of files inside this MPIWGItem-object --not impelemted for DB"""
        #ids = self.objectIds(spec="File")
        #if len(ids) > 1:
        #    if count > 0:
        #        ids = ids[:count]
        
            #else:
            #    ids = ids[:]
            #ids.sort()
            
        #return ids
        return[]

    def getFileUrls(self, baseUrl=None, count=0):
        """ return the urls of files inside this MPIWGItem-object -not impelemted for DB"""
       # ids = self.getFileIds(count=count)
       # if baseUrl is None:
       #     baseUrl = self.absolute_url()
            #    
        # return ['%s/%s'%(baseUrl,id) for id in ids]
        return []

    def getPropertyKeys(self):
        """ """
        return [x[5] for x in self.Properties if len(x)==6]+[x[0] for x in self.Properties if len(x)==5]

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

    def getByPrefix(self, prefix):
        """ returns all items with the same prefix in the ID """
        return [ prop for prop in self.Properties if prop[5].find(prefix)==0 ]


    def getValue(self, id, lang="EN"):
        """ """
        prop = self.getProperty(id)
        if prop==None:
            return None
        if lang=="DE":
            return prop[3]
        else:
            return prop[2]

    getInfo = getValue # compatibility 

    def getCaption(self, id, lang="EN"):
        """ """
        prop = self.getProperty(id)
        if prop==None:
            return None
        if lang=="DE":
            return prop[1]
        else:
            return prop[0]
        
    
    def getItems(self, lang="EN", excepts=[]):
        """ returns all the key/value pairs """

        if lang=="DE":
            return [(prop[1],prop[3]) for prop in self.Properties if not prop[0].lower() in excepts]
        else:
            return [(prop[0],prop[2]) for prop in self.Properties if not prop[0].lower() in excepts]

    getAllInfo = getItems # compatibility

    def addProperty(self, tup=("","","","",0,"")):
        """ """
        self.Properties.append(tup)
        # force update of the Properties list in the ZopeDB
        self._p_changed = 1



    def setProperty(self, tup):
        """  set the data of a property;  tup is a tuple, structured like the properties  """
        # find the property
        num = -1
        for i in range(len(self.Properties)):
            if self.Properties[i][5] == tup[5]:
                num = i

        # List of 6 Tuples (ID_EN,ID_DE,VALUE_EN,VALUE_DE, WEIGHT,ID)
        # update it
        if num != -1:
            self.Properties[num] = tup
        # force update of the Properties list in the ZopeDB
        self._p_changed = 1


    def delProperty(self, id):
        """ remove a property """
        num = -1
        for i in range(len(self.Properties)):
            if self.Properties[i][5] == id:
                del self.Properties[i]
                # force update of the Properties list in the ZopeDB
                self._p_changed = 1

                return

    def getNextGroupPropertyIndex(self, prefix):
        """ returns the logical next id for a property with a certain 'prefix'
        e.g. if there are properties 'dl_1' and 'dl_2' and the prefix is 'dl_', then the method will yield 'dl_3'.
        """
        oldproperties = [x[5] for x in self.Properties if x[5].find(prefix)==0 and x[5].split(prefix)[1].isdigit()]
        oldproperties.sort()
        if len(oldproperties)>0:
            lastparam = int(oldproperties[-1].split(prefix)[1])
            return prefix+str(lastparam+1)
        else:
            return prefix+"1"

    def getHighestGroupPropertyWeight(self, prefix):
        """ """
        propWeights = [x[4] for x in self.Properties if x[5].find(prefix)==0]
        if len(propWeights)>0:
            return max(propWeights)
        else:
            return 0

    def switchPropertyWeights(self, prop1, prop2):
        """ """
        p1 = list(self.getProperty(prop1))
        p2 = list(self.getProperty(prop2))

        w1 = p1[4]
        w2 = p2[4]

        p1[4] = w2
        p2[4] = w1

        self.setProperty(tuple(p1))
        self.setProperty(tuple(p2))

        self._p_changed = 1

    def setTitle(self, title_en, title_de=""):
        """ set the title """
        self.Title = (title_en, title_de)
        # force update of the Properties list in the ZopeDB
        self._p_changed = 1
        
    def setDate(self, dateString, dateObject=None):
        """ set the date """
        if dateObject is not None:
            self.Date = dateObject
        else:
            self.Date = self.parseDate(dateString)
            
        # force update of the Properties list in the ZopeDB
        self._p_changed = 1
        

    def deleteObject(self,id):
        """ delete an object inside the MPIWGItem """
        if self.hasObject(id):
            self._delObject(id)


    def manage_addImage(self, id, file, title='', redirect_url=None, precondition='', content_type='', REQUEST=None):
        """
        Add a new Image object.
        Creates a new Image object 'id' with the contents of 'file'.
        """
        # we use OFS/Image's method without the request
        OFS.Image.manage_addImage(self, id, file, title=title, precondition=precondition, content_type=content_type)

        # and do our own redirect
        if REQUEST is not None:
            if redirect_url is None:
                redirect_url = 'manage_editItemForm?rnd=%s'%''.join(random.sample("abcdefuvwxyz",8))
                
            REQUEST.RESPONSE.redirect(redirect_url)

    manage_addImageForm = OFS.Image.manage_addImageForm
    
    def manage_addFile(self, id, file, title='', redirect_url=None, precondition='', content_type='', REQUEST=None):
        """
        Add a new File object.
        Creates a new File object 'id' with the contents of 'file'.
        """
        # we use OFS/Image's method without the request
        OFS.Image.manage_addFile(self, id, file, title=title, precondition=precondition, content_type=content_type)

        # and do our own redirect
        if REQUEST is not None:
            if redirect_url is None:
                redirect_url = 'manage_editItemForm?rnd=%s'%''.join(random.sample("abcdefuvwxyz",8))
                
            REQUEST.RESPONSE.redirect(redirect_url)

    manage_addFileForm = OFS.Image.manage_addFileForm
    


    def manage_editItemForm(self, REQUEST=None):
        """edit item form"""
        # default template is called edit_item_form
        pt = getattr(self, 'edit_item_form', None)
        if pt is not None:
            try:
                return pt()
            except Exception, e:
                logging.error("Problem with edit_item_form: "+str(e))

        # else use builtin template
        return self.manage_editMPIWGItemForm()
        
        
    
               
               
              
    def getDataFromRecord(self,record,folder):
        
        # get predefined properties
        predef = folder.Properties[:]

      

        for prop in predef:
            self.addProperty(prop)
   
        index =0
        for property in self.getPropertyKeys():
            prop = self.Properties[index] # hole alten wert
              
            en_value=self.getValueFromRecord(record,property,'en')
            de_value=self.getValueFromRecord(record,property,'de')
            self.Properties[index]=(prop[0],prop[1],en_value,de_value,prop[4],prop[5]) #vordefinierte werte lassen ausser fuer die werte
            
          
            index+=1    
              
    transform={'Category':'Reihentitel',
               'Time':'Datum als Text','Presentation':'Titel','Address':'Ort','Notes':'Bemerkungen',
               'Organizers':'Veranstaltet von','Presenter':'Vortragende Person'}
    
    def getValueFromRecord(self,record,propertyID,lang):
        
        fieldName = ""
        if lang == "en":
            fieldName="EN_"
            
        
        #fieldName+=self.transform[propertyID]
        fieldName+=propertyID
            
        xpathstr = ".//"+NS+"field[@name='%s']"%fieldName
        
        val = self.findText(record,xpathstr)
        
        if val == "": # leer versuche die andere sprache
            if lang == "en":
                fieldName=""
            else:
                fieldName="EN_"
        
            #fieldName+=self.transform[propertyID]
            fieldName+=propertyID
            xpathstr = ".//"+NS+"field[@name='%s']"%fieldName
        
            val = self.findText(record,xpathstr)
       
        return val

    def manage_editMPIWGItem(self, formdata=None, REQUEST=None):
        """ """
        if REQUEST is not None:
            formdata = REQUEST.form

        # update property names and values and weights
            # date,title,category
        try:
            self.Date = self.parseDate(formdata['date'])
            self.Title = (formdata["title_en"],formdata["title_de"])
            self.title = formdata["title_en"]
        except:
            pass
        #self.Category = (formdata["category_en"],formdata["category_de"])
            # custom data
        property_ids = [int(x.split('_')[1]) for x in formdata.keys() if x.endswith('_id')]
        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])

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

        # delete images
        del_keys = [x.split('__')[1] for x in formdata.keys() if x.find("delimg__") == 0 and formdata[x] == "on"]
        for k in del_keys:
            self.deleteObject(k)

        # delete files
        del_keys = [x.split('__')[1] for x in formdata.keys() if x.find("delfil__") == 0 and formdata[x] == "on"]
        for k in del_keys:
            self.deleteObject(k)

        # sort
        try:
            self.Properties.sort(lambda a,b: cmp(int(a[4]),int(b[4])) )
        except:
            pass

        try:
            # add new properties (empty)
            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
        self.en.index_html.ZCacheable_invalidate()
        
        if REQUEST is not None:
            REQUEST.RESPONSE.redirect('manage_editItemForm?rnd=%s'%''.join(random.sample("abcdefuvwxyz",8)))


    manage_editMPIWGItemForm = PageTemplateFile('zpt/editMPIWGItem.pt', globals())


def manage_addMPIWGItem(self,REQUEST=None):
    """ create a new MPIWGItem """

    id = self.getNewID()

    # get predefined properties
    predef = self.Properties[:]

    newinst = MPIWGItem(id)

    for prop in predef:
        newinst.addProperty(prop)
        
    self._setObject(id, newinst)

    if REQUEST is not None:
        REQUEST.RESPONSE.redirect('%s/manage_editItemForm'%id)
        
    return id

def manage_addMPIWGItemForm(self, REQUEST):
    """ """
    manage_addMPIWGItem(self,REQUEST)