""" Classes for managing metadata"""

from OFS.SimpleItem import SimpleItem
from Globals import InitializeClass,package_home
from OFS.Folder import Folder
from AccessControl import ClassSecurityInfo
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
import os.path
import xml.dom.minidom
import OSAS_helpers
import zLOG

class OSAS_MetadataMapping(SimpleItem):
    """Einfaches Mapping Object"""

    meta_type="OSAS_MetadataMapping__neu"

    def readFieldsFromParent(self):
        """read all elements from root"""
        
        return self.aq_parent.fieldList
    
    def __init__(self,id,title,arglist):
        """init
        @param id: id
        @param title: title fuer zope navigation
        @param arglist: dictionary mit Namen der zugelassenen generische Metadaten als key und Tripel  als Werte (human readable, tag version,explanation
        """
        self.id=id
        self.title=title
        for fieldName in arglist.keys():
            setattr(self,"md_"+fieldName,arglist[fieldName])
        
            
    manage_options = SimpleItem.manage_options+(
        {'label':'Main Config','action':'changeMetadataMappingForm'},
        )


    def showSetXML(self,RESPONSE=None):
        """prints out the mapping as XML"""
        ret="""<set name="%s">"""%self.title
        for fieldName in self.readFieldsFromParent():
            entry=getattr(self,"md_"+fieldName)
            if entry[2]=="": # no explanation of this field
                ret+="""<entry genericName="%s" tag="%s" label="%s"/>"""%(fieldName,entry[0],entry[1])
            else:
                ret+="""<entry genericName="%s" tag="%s" label="%s">%s</entry>"""%(fieldName,entry[0],entry[1],entry[2])
        ret+="</set>"

        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret

    def getValue(self,fieldName):
        """get md value
        @param fieldName: Bezeichnung des gesuchten Metadatums
        @retunr: Value des Metadatums"""

        return getattr(self,"md_"+fieldName,(None,None,None))


    def isEmptyValue(self,fieldName):
        """teste ob fielname in diesem Metadatenschema definiert ist"""
        field=getattr(self,"md_"+fieldName,'')
        if field[1]=='':
            return 0
        else:
            return 1
        
    def generateMappingHash(self):
        """erzeugen des dictionaries: generisches Feld -> Definition in diesem Schema"""
        hash={}
        for field in self.fieldList:
            hash[field]=getattr(self,"md_"+field)
        return hash

       
    
    def changeMetadataMappingForm(self):
        """change"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadataMapping.zpt')).__of__(self)
        return pt()
    
    def changeMetadataMapping(self,titleOfObject,RESPONSE=None):
        """change"""

        self.title=titleOfObject
        arglist=self.REQUEST.form
        
        for fieldName in self.readFieldsFromParent():
            setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName]))
            
            
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    

def manage_addMetadataMappingForm(self):
    """interface for adding the OSAS_root"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataMappingForm.zpt')).__of__(self)

    return pt()

def manage_addMetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
    """add the OSAS_root"""
    
    argList={}
    for arg in self.fieldList:
        if not (arg in ['idOfObject','titleOfObject']):
            argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg])
            
    newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList)
    self._setObject(idOfObject,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

   

class OSAS_Metadata(Folder):
    """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
    security=ClassSecurityInfo()
    
    def __init__(self,id,linklabel,description,fields):
        """initialize a new instance"""
        self.id = id
        self.linklabel =linklabel #label fuer link auf add page
        self.description=description #description of the method for link page
        self.fieldList=fields.split(",")[0:]
        
    meta_type='OSAS_Metadata__neu'

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'changeMetadataForm'},
        {'label':'Import XML Schema','action':'importXMLSchemaForm'},
        {'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'},
        )

    def showGenericXML(self,RESPONSE=None):
        """show generic fields as XML"""
        ret="""<set name="%s">"""%"generic"
        for field in self.fieldList:
            ret+="""<entry genericName="%s"/>"""%field

        ret+="</set>"
        
        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret
        
    def showOverviewXML(self,RESPONSE):
        """gives an overview over the Metadata stored in this folder"""
        ret="""<metadata name="%s">"""%self.getId()
        ret+=self.showGenericXML()
        for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']):
            ret+=entry[1].showSetXML()

        ret+="</metadata>"

        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret
        
    def generateMappingList(self):
        """Erzeuge Mapping"""
        mapping={}
        for dict in self.__dict__:
            #print dict
            obj=getattr(self,dict)
            if hasattr(obj,'meta_type'):
                if obj.meta_type=="OSAS_MetadataMapping":
                    mapping[obj.getId()]=obj.generateMappingHash()
        return mapping
    
    def generateMappingForType(self,type,clean="yes"):
        """erzeuge spezifisches Mapping"""
        hash=self.generateMappingList()
        if hash.has_key(type):
            if clean=="yes":
                temp={}
                for x in hash[type].keys():
                    if not hash[type][x]=="":
                        temp[x]=hash[type][x]
                return temp
            else:
                return hash[type]
        
        else:
            return {}

    def getFieldList(self):
        """erzeuge string aus fields"""
        try:
            return string.join(self.fieldList,",")
        except:
            return ""
        
    def getFields(self):
        """ausgabe der Felder"""
        return self.fieldList

    def getTypeTitle(self,id):
        """Title von ID"""
        try:
            obj=getattr(self,id)
            return obj.title
        except:
            return id
        
    def getStoredTypes(self):
        """Gebe gespeicherte typen zurück"""
        
        types=[]

        for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping_neu']):
             if obj.title=="":
                 title=obj.id
             else:
                 title=obj.title
             types.append((obj.id,title))

        return types

    def indicateDisplayFieldsForm(self):
        """form zur Makierung der Felder die in der Browserumgebung angezeigt werden"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','indicateDisplayFieldsForm.zpt')).__of__(self)
        return pt()

    def indicateDisplayFields(self,displayFields,RESPONSE=None):
        """set Displayfields
        @param displayFields: Liste von Felder die im Browserenvironment angezeigt werden
        """
        self.displayFields=OSAS_helpers.toList(displayFields)
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def getDisplayFieldsAsStr(self,path):
        """Gebe display fields als string zurück
        @param path: Pfad zum Object
        """
        ret=[]
        if not os.path.exists(os.path.join(path,'index.meta')):
            return ""
        try:
            dom=xml.dom.minidom.parse(os.path.join(path,'index.meta'))
        except:
            zLOG.LOG("OSAS_metadata (getDisplayFieldsAsStr)",zLOG.INFO,"Cannot parse: %s"%path)
        try:
            bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0]
        except:
            return ""
        try:
            type=bib.getAttribute('type')
            mapping=getattr(self,type).generateMappingHash()
        except:
            type='generic'
            mapping=getattr(self,type).generateMappingHash()

        for field in self.displayFields:
            try:
                ret.append(OSAS_helpers.getText(bib.getElementsByTagName(mapping[field][0])[0].childNodes))
            except:
                """nothing"""
                
        return "; ".join(ret)

    security.declarePublic('changeMetadataForm')
    def changeMetadataForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadata.zpt')).__of__(self)
        return pt()
    
    security.declarePublic('changeMetadata')
    def changeMetadata(self,linklabel,description,fields,RESPONSE=None):
        """Change Metadata"""
        self.linklabel=linklabel
        self.description=description
        self.fieldList=fields.split(",")[0:]
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    security.declarePublic('index_html')

    def importXMLSchemaForm(self):
        """form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importXMLSchemaForm.zpt')).__of__(self)
        return pt()

    def importXMLSchema(self,file,RESPONSE=None):
       """import xmlschema, Metadatenschema wird eingelesen und entsprechende Metadatenmappings angelegt."""

       dom=xml.dom.minidom.parse(file)
       sets=dom.getElementsByTagName('set')
       #erster schritt: anlegen der fieldlist
       for set in sets:
           if set.getAttribute('name')=='generic':
               list=[]
               for entry in set.getElementsByTagName('entry'):
                   list.append(entry.getAttribute('genericName'))
               self.fieldList=list[0:]

       #zweiter schritt: anlegen der mapping
       for set in sets:
           id=set.getAttribute('name').encode('utf-8')
           list=[]
           argList={}
           for entry in set.getElementsByTagName('entry'):
               genericName=entry.getAttribute('genericName')
               tag=entry.getAttribute('tag')
               label=entry.getAttribute('label')
               description=OSAS_helpers.getText(entry.childNodes)
               argList[genericName]=(tag,label,description)
           self._setObject(id,OSAS_MetadataMapping(id,id,argList))
           if RESPONSE:
               RESPONSE.write("Wrote: %s"%id)
       
    
def manage_addMetadataForm(self):
    """interface for adding the OSAS_add_Metadata"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm.zpt')).__of__(self)
    return pt()

def manage_addMetadata(self,id,linklabel,description,fields,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_Metadata(id,linklabel,description,fields)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

            
InitializeClass(OSAS_Metadata)