"""This files contains the class MPIWG Projects"""
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate

import MPIWGStaff
import string
import re
from types import *

import xmlhelper # Methoden zur Verwaltung der projekt xmls
from OFS.SimpleItem import SimpleItem
from OFS.Folder import Folder

definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']

checkFields = ['xdata_01']

def sortF(x,y):
    
    return cmp(x[1],y[1])

def sortI(x,y):
    xsplit=x[1].split(".")
    ysplit=y[1].split(".")
    xret=""
    yret=""
    try:
        for i in range(5):
            try:
                yret=yret+"%04i"%int(xsplit[i])
            except:
                yret=yret+"%04i"%0

            try:
                xret=xret+"%04i"%int(ysplit[i])
            except:
                xret=xret+"%04i"%0
                
        
        return cmp(int(yret),int(xret))
    except:
        return cmp(x[1],y[1])

    
class MPIWGRoot(Folder):
    """Stammordner für den Web-Server"""

    folders=['MPIWGProject','Folder']
    meta_type='MPIWGRoot'
    
    def __init__(self, id, title):
        """init"""
        self.id=id
        self.title=title

    def getProjectFields(self,fieldName,folder=None,sort=None):
        """getListofFieldNames"""
        ret=[]
        #print "FN",fieldName
        if not folder:
            folder=self
        for object in folder.__dict__:

            obj=getattr(folder,object)
            if hasattr(obj,'meta_type'):
                #print obj.meta_type
                if obj.meta_type=='MPIWGProject':
                    if fieldName=="WEB_title_or_short":
                        #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
                        #print len(obj.getContent('xdata_07'))
                        if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
                            fieldNameTmp="WEB_title"
                        else:
                            fieldNameTmp="xdata_07"
                    else:
                        fieldNameTmp=fieldName
                    
                    ret.append((obj,obj.getContent(fieldNameTmp)))

                if obj.meta_type in self.folders:
                    
                    ret += self.getProjectFields(fieldName,obj)

        if sort=="int":
            ret.sort(sortI)
        else:
            ret.sort(sortF)
        
        return ret

    def showNewProjects(self):
        projects=[]
        for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
            if objs[0].xdata_05[0] == "":
                
                projects.append(objs)
                
        return projects
    
        
    manage_options = Folder.manage_options+(
        {'label':'Import Persons','action':'importNamesForm'},
        )
    
    def importNamesForm(self):
        """Form"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)
        return pt()

    def importNames(self,fileupload,folderName,RESPONSE=None):
        """import komma-sep list email,lastName,firstName"""
        project=getattr(self,folderName)
        
        for line in fileupload.readlines():
            #print line
            splitted=line.split(",")
            if not (splitted[0]==""):
                newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
                try:
                    project._setObject(splitted[0],newObj)
                except:
                    print "not done:",splitted[0]
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def getAllMembers(self):
        """give list of all members"""
        ret=[]

        for x in self.members.objectValues('MPIWGStaff'):
            #print x.title
            ret.append(x.title)
            
        ret.sort()
        return ret

    def makeList(self,entry):
        """makes a list out of one entry or repeat a list"""
        if type(entry) is StringType:
            return [entry]
        else:
            return entry


    def getTree(self):
        """generate Tree from project list"""
        returnList=[]
        for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05
            for idNr in project[1].split(";"): # more than one number
                if not idNr=="":
                    splittedId=idNr.split(".")
                    depth=len(splittedId)
                    nr=idNr
                    title=project[0].WEB_title
                    returnList.append((depth,nr,title,project[0]))
        
        return returnList

    def changePosition(self,treeId,select,RESPONSE=None):
        """Change Postion Entry"""
        numbers=[]

        # Suche hoechste bisherige nummer
        projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
        for project in projects: #suche alle subtrees der treeId
            #print treeId
            
            founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
            if founds:
                #print "x",founds.group(0),len(founds.group(0).split("."))
                if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
                    try:
                        numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
                    except:
                        numbers.append(0)
        numbers.sort()
        highest=int(numbers[len(numbers)-1])
        projects=self.showNewProjects()
        for i in self.makeList(select):
            highest+=10
            projects[int(i)][0].xdata_05=treeId+"."+str(highest)


        if RESPONSE is not None:
            RESPONSE.redirect('showTree')
        
    def changeTree(self,RESPONSE=None):
        """change the complete tree"""
        form=self.REQUEST.form
        hashList={}
        fields=self.getTree()

        
        for idNr in form.keys():
            fields[int(idNr)][3].xdata_05=form[idNr]

        

        if RESPONSE is not None:
            RESPONSE.redirect('showTree')

    def getProjectWithId(self,id):
        fields=self.getProjectFields('xdata_05')
        for field in fields:
            if field[1]==id:
                return field[0]

        return None
            
        
            
        
        
            
    def getUrlFromPerson(self,list):
        """get urls to person list"""
        ret=[]
        persons=list.split(";")
        for person in persons:
            
            splitted=person.split(",")
            if len(splitted)==1:
                splitted=person.split(" ")
            splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
            if splittedNew[0]=='':
                del splittedNew[0]
            search=string.join(splittedNew,' AND ')
            if not search=='':
                
                try:
                    proj=self.MembersCatalog({'title':search})
                except:
                    proj=None
        
            if proj:
                ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))
            else:
                ret.append("%s"%person)
        return string.join(ret,";")
                         
    def getProjectsOfMembers(self):
        """give tuple member /projects"""
        ret=[]
        members=self.getAllMembers()
        for x in members:
            splitted=x.split(",")
            
            proj=self.ProjectCatalog({'xdata_01':string.join(splitted,' AND')})
            if proj:
              ret.append((x,proj))
        return ret
    def givePersonList(self,name):
        """check if person is in personfolder and return list of person objects"""
        
        splitted=name.split(",")
        if len(splitted)==1:
            splitted=name.split(" ")
        splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
        if splittedNew[0]=='':
            del splittedNew[0]
        search=string.join(splittedNew,' AND ')
        if not search=='':
            proj=self.MembersCatalog({'title':search})

        if proj:
            return [[x.lastName,x.firstName] for x in proj]
        else:
            return []
            
##         splitted=name.split(",") # version nachname, vorname...
##         if len(splitted)>1:
##             lastName=splitted[0] 
##             firstName=splitted[1]
##         else: 
##             splitted=name.split(" ") #version vorname irgenwas nachnamae
        
##             lastName=splitted[len(splitted)-1]
##             firstName=string.join(splitted[0:len(splitted)-1])

##         objs=[]

        #print  self.members 
      ##   for x in self.members.__dict__:
##             obj=getattr(self.members,x)
##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
                
##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
                    
##                     objs.append((obj,lastName+", "+firstName))

        
        return objs


    def personCheck(self,names):
        """all persons for list"""
        #print "names",names
        splitted=names.split(";")
        ret={}
        for name in splitted:

            if not (name==""):
                try:
                    ret[name]=self.givePersonList(name)
                except:
                    """NOTHIHN"""
        #print "RET",ret
        return ret

    def giveCheckList(self,person,fieldname):
        """return checklist"""
        #print "GCL",fieldname
        if fieldname=='xdata_01':
            x=self.personCheck(person.getContent(fieldname))
            #print "GCLBACKX",x
            return x
        

    def isCheckField(self,fieldname):
        """return chechfield"""
        
        return (fieldname in checkFields)

    
    
        
def manage_addMPIWGRootForm(self):
    """form for adding the root"""
    pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
    return pt()

def manage_addMPIWGRoot(self,id,title,RESPONSE=None):
    """add a root folder"""
    newObj=MPIWGRoot(id,title)
    self._setObject(id,newObj)

    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
        

class MPIWGProject(Folder):
    """Class for Projects"""

    meta_type='MPIWGProject'

    def crossLinker(self):
        """experimental crosslinker"""
        splitted=self.WEB_project_description[0].split()
        new=[]
        for split in splitted:
            try:
                found=self.DescriptionCatalog({'fulltext':split})
          
                if len(found)>1:
             
                    new.append("<a href=%s>%s</a>"%(split,split))
                else:
                    new.append(split)
            except:
                new.append(split)
        return string.join(new)
            
            


    def generateTemplate(self,RESPONSE=None):
        """Erzeuge Template für defined fields not_used"""

        id="index_html"
        title=id
        if self._getOb('index_html'):
            self._delObject('index_html')

        
        newObj=ZopePageTemplate(id,'TEXT')
        self._setObject(id,newObj)
        #self.manage_addPageTemplate(id,title)
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')
            
    def __init__(self, id, argv=None):
        """initieriere classe"""
        
        self.id=id
        self.title=id
        if argv:
            for arg in definedFields:
                setattr(self,arg,argv[arg])
        else:
            for arg in definedFields:
                setattr(self,arg,'')
            
    manage_options = Folder.manage_options+(
        {'label':'Load New File','action':'loadNewFileForm'},
        {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
        {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
        {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
        )

    def getDataFields(self):
        """giveListofDatafields"""
        ret=[]
        for x in range(1,14):
            ret.append('xdata_%02i'%x)
        return ret
            
    def getDefinedFields(self):
        """show all defined fields"""
        
        return definedFields

    def getAttribute(self,field):
        """get attrbiute"""
        return getattr(self,field)

    def getContent(self,field):
        """Inhalt des Feldes"""
        
        text=u''
        #print "FIELD",field
        for x in getattr(self,field):
            #print "HIHIIII"
            
            try:
                text +=x
            except:
                try:
                    text =x
                except:
                    text="ERROR"
        #print "TEXT",text.encode('ascii','ignore')  
        return text
    
    def show_html(self):
        """simple index"""
        #return "HI"
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)
        return pt()

    def editMPIWGProjectForm(self):
        """editform"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
        return pt()

    def editMPIWGBasisForm(self):
        """editform"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)
        return pt()
    def editMPIWGRelatedPublicationsForm(self):
        """Edit related Publications"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)
        return pt()
        
    def editMPIWGProject(self,RESPONSE=None):
        """edit the project"""
        
        #return self.REQUEST
        for x in definedFields:
            if self.REQUEST.has_key(x):
                
                setattr(self,x,[self.REQUEST[x]])
            
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

        
    def loadNewFileForm(self):
        """Neues XML-File einlesen"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)
        return pt()

    def loadNewFile(self,RESPONSE=None):
        """einlesen des neuen files"""
        fileupload=self.REQUEST['fileupload']
        if fileupload:
            file_name=fileupload.filename
            filedata=fileupload.read()

            argv=xmlhelper.proj2hash(filedata)
            #print argv.keys()
            for arg in definedFields:
                
                #print arg,argv[arg],getattr(self,arg)
                try:
                    temp=argv[arg][0:]
                    #old=getattr(self,arg)
                    setattr(self,arg,temp)
                    #print old,getattr(self,arg)
                except:
                    """nothing"""
                    
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

def manage_addMPIWGProjectForm(self):
    """form for adding the project"""
    pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)
    return pt()

def manage_addMPIWGProject(self,id,RESPONSE=None):
    """method to add a project"""
    #print argv
    if self.REQUEST.has_key('fileupload'):
        fileupload=self.REQUEST['fileupload']
        if fileupload:
            file_name=fileupload.filename
            filedata=fileupload.read()

            argv=xmlhelper.proj2hash(filedata)

            #print argv
        newObj=MPIWGProject(id,argv)
    else:
        newObj=MPIWGProject(id)

    self._setObject(id,newObj)


    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')