""" OSAS_contains the basic classes for configuring the OSAS and
basic objects for displaying data.
All site specific adaptation should be made in OSAS_Root
"""

from OSAS_helpers import *
import OSAS_helpers
from OFS.SimpleItem import SimpleItem
from time import localtime,strftime
from Acquisition import Implicit
from OFS.Folder import Folder
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
import urllib
from urlparse import *
import re
import xml.dom.minidom
from types import *
import logging

#ersetzt logging
def logger(txt,method,txt2):
    """logging"""
    logging.info(txt+ txt2)


import os.path
import Globals
from Globals import package_home
from AccessControl import ClassSecurityInfo
import xmlrpclib
from xml.sax import make_parser
from xml.sax.handler import ContentHandler
import sys

class OSAS_add_contextData(Folder):
    """Einfuegen eines Documentes in eine Collection"""
    
    security=ClassSecurityInfo()

            
    meta_type='OSAS_addObjectToCollection'    

    def XmlToTree(self,URL,pwstr=None):
        """Collection XML to Tree"""
        def spaces(depth):
            
            tmp=""
            k=0
            while k<2*depth:
                k+=1
                tmp=tmp+"&nbsp;"+"&nbsp;"
            return tmp

        class requestHandler(ContentHandler):
            def __init__(self):
                self.depth=0
                self.retStr=""
                
            def startElement(self,name,attrs):
                if name=="element":
                    self.depth+=1
                    begin=""
                    end=""
                    if self.depth==1:
                        begin="<b>"
                        end="</b>"
                        
                    self.retStr+=spaces(self.depth)+"<input type='radio' name='collection' value='%s'>%s</input>"%(attrs.get('url'),begin+urllib.unquote(attrs.get('name')))+end+"<br>\n"


                    
            def endElement(self,name):
                if name=="element":
                    self.depth-=1

        if pwstr=="":
            pwstr=None
            
       

        try:
            if pwstr:
                URL+="/getCollectionTreeXML?pwstr=%s"%pwstr    
            else:
                URL+="/getCollectionTreeXML"
            parser=make_parser()
            curHandler=requestHandler()
            parser.setContentHandler(curHandler)

            parser.parse(urllib.urlopen(URL))
            return curHandler.retStr.encode('utf-8')

        except:
            logger('OSAS_Root (addFileToDollection)',logging.ERROR,'%s %s'%sys.exc_info()[:2])
            return URL
            return urllib.urlopen(URL).read()
            
      
    def __init__(self,id,collection):
        self.id=id
        self.collection=collection

  
   

    def getPartners(self,URL):
        """Zeige Partnerliste"""
        class requestHandler(ContentHandler):
            def __init__(self):
                self.ret=[]
                
            def startElement(self,name,attrs):
                if name=="partner":
                    self.ret.append((attrs.get('id'),attrs.get('title').encode('utf-8')))


        URL+="/getPartnersXML"
        parser=make_parser()    
        curHandler=requestHandler()
        parser.setContentHandler(curHandler)
        parser.parse(urllib.urlopen(URL))               
        try:    
                  
                return curHandler.ret
        except:
                return [("",URL)]

    
    
    def addContextData(self,path):
        """Hinzufuegen zu einer Sammlung"""

        server=xmlrpclib.Server(self.serverUrl)
        

        self.REQUEST.SESSION['images']=server.getImages(path)


        self.REQUEST.SESSION['movies']=server.getMovies(path)


        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','contextDataMain.zpt')).__of__(self)
        return pt()
    
    index_html=addContextData
    
    def addContextData2(self,path,collection,label,description,content_type,responsible,weight,thumb="",streamingfile="",rawfile="",lowresfile="",credits=None):
        """Hinzufuegen der Resource"""
        splitted=path.split("/")
        #print "BLU"
        id=splitted[len(splitted)-1]
        title=splitted[len(splitted)-1]
        metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"
        
        #link=TOBEDONE"
        """Hinzufuegen der Ressource"""

        gifPath=path.replace("/mpiwg/online/","")
        rawPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
        lowresPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")

        thumbUrl="http://einst3.mpiwg-berlin.mpg.de/"+gifPath+"/"+thumb
        link="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+streamingfile
        rawFile="file:///Volumes/einstein_movies/"+rawPath+"/"+rawfile
        lowresFile="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+lowresfile

        
        params=urllib.urlencode({'id':id,'title':title,'link':link,'thumbUrl':thumbUrl,'rawFile':rawFile,'label':label,'description':description,'contentType':content_type,'responsible':responsible,'weight':weight,'credits':credits,'metalink':metalink})

                
        try:
            server=xmlrpclib.Server(collection,allow_none=True)
            retStr=server.addMovie(id,title,label,description,content_type,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits)
        except:
            logger('OSAS_Root (addFileToDollection2)',logging.ERROR,'%s %s'%sys.exc_info()[:2])
            return "An Error occured adding the resource\n", collection,params
        
        #print "added"
        if not retStr:
            return "An Error occured adding the resource\n", collection,params
        
        #print collection+"/"+id+"/copyIndex_meta2echo_resource"

        urllib.urlopen(collection+"/"+id+"/copyIndex_meta2echo_resource").read()
        #print "copy2res"
        urllib.urlopen(collection+"/"+id+"/generate_label").read()
        #print "label"
        urllib.urlopen(collection+"/"+id+"/generate_title").read()
        #print "title"
        return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'/browse?path='+path)
        
    manage_options = Folder.manage_options+(
            {'label':'Main Config','action':'add_contextData_config'},
            )
        
     
    def add_contextData_config(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeAddContextData.zpt')).__of__(self)
        return pt()
    
    
    def change_OSAS_add_contextData(self,collection,pwstr=None,RESPONSE=None):
        """Change"""
        self.pwstr=pwstr
        self.collection=collection
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')
            
def manage_AddOSAS_add_contextDataForm(self):
    """interface for adding the OSAS_add_Metadata"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addContextData.zpt')).__of__(self)
    return pt()

def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_add_contextData(id,collection)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

            


    

class OSAS_handlerObject(Folder):
    """
    Grundlegende Klasse fuer Handler zur Zeit noch in Entwicklung

    """
    meta_type="OSAS_HandlerObject__neu"

    
    def __init__(self,id,title,prefix,objectTypes,ignorePath=""):
        """inititialisiere die Klasse

        :Parameters:
         - `id` : Zope ID des Objektes
         - `title`: Titel des Objektes
         - `prefix` : URL bzw. URL Rumpf der Zusammen mit dem Pfad des Objectes die Anzeige URL ergibt
         - `objectType` : liste von Objekttypen die mittels dieses Handlers angezeigt werden koennen.
         - `ignorePath` : Pfad der bei dem uebergebenen Pfad element ignoriert werden soll. Optional.
        """
        self.id=id
        self.title=title
        self.prefix=prefix
        self.objectTypes=toList(objectTypes)
        self.ignorePath=ignorePath

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'changeHandlerObjectForm'},
        )

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

    def changeHandlerObject(self,title,prefix,objectTypes="",ignorePath=None,newTarget="yes",RESPONSE=None):
        """Change RootFolderName"""
        self.title=title
        self.prefix=prefix
        self.ignorePath=ignorePath
        self.objectTypes=toList(objectTypes)
        self.newTarget=newTarget
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')


def manage_addHandlerObjectForm(self):
    """form for adding a handler Object"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addHandlerObjectForm.zpt')).__of__(self)
    return pt()

def manage_addHandlerObject(self,id,title,prefix,objectTypes,ignorePath,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_handlerObject(id,title,prefix,objectTypes,ignorePath)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

    
class OSAS_root(Folder,Implicit):
    """Implicit Folder of the  Storage Systems"""

    security=ClassSecurityInfo()

    def __init__(self,id,rootFolderName,serverUrl,uploadServletUrl=None):
        """initialize a new instance


        @param id: Zope ID des Objektes
        @param rootFolderName : path zum root folder des Storagesystems
        @param uploadServerletUrl : url des UploadServlets (required fuer batch upload)

        """
        
        self.id = id
        self.rootFolderName = rootFolderName
        self.uploadServletUrl=uploadServletUrl
        self.serverUrl=serverUrl
    meta_type="OSAS_Root"

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'changeRootForm'},
        )


    OSASObjectTypes=OSAS_helpers.OSASObjectTypes

    def extendDict(self,dict1,dict2):
        """add two dicts"""
        ret=dict1
        for name in dict2.keys():
            ret[name]=dict2[name]
        return ret
    
        
    def generateMovieThumb(self,name):
        """generate movie"""
        server=xmlrpclib.Server(self.serverUrl)
        name="/mpiwg/online/permanent/einstein_exhibition/movies/"+name

        
        ret=server.generateMovieThumb(name,os.path.splitext(name)[0]+".gif")
        return ret
    
    security.declareProtected("View management screens","getOSASObjectTypes")
    def getOSASObjectTypes(self):
        """return list of objecttypes"""
        return OSASObjectTypes

    def setProxy(self,name,value):
        """set proxy"""
        self.REQUEST.SESSION[name]=value
        return True

    def listToSingle(self,path):
        """list to single"""
        if type(path)==ListType:
            return path[0]
        else:
            return path

    def splitPath(self,path):
        """split path"""
        if type(path)==ListType:
            path=path[0]
        return os.path.split(path)
    
    def changeRootForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeRootForm.zpt')).__of__(self)
        
        return pt()

    def changeRoot(self,rootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
        """Change RootFolderName"""
        self.rootFolderName=rootFolderName
        self.serverUrl=serverUrl
        self.uploadServletUrl=uploadServletUrl
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    localDate=localDate
    
    def getUploadServletUrl(self):
        """gibt  url des servlets zurueck"""
        return self.uploadServletUrl
        

    def validateIndexMeta(self,data):
        """TO BE DONE testet ob data ein gueltiges index.meta file ist, zur Zeit wird dom erzeugt ohne validierung.
        @param data: zu testendes XML file als string
        @return: zeiger auf dom  falls ok, None  andernfalls (z.Z: immmer dom falls parse possible)
        """
        try:
            return xml.dom.minidom.parseString(xmlneu)
        except:
            return None
        
    security.declareProtected('View management screens','uploadExternalXMLString','uploadExternalXMLUrl','uploadExternalXML')
    
    def uploadExternalXMLString(self,index_meta_url,xml_string):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_string: string mit index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        return self.uploadExternalXML(index_meta_url,xml_string)


    def uploadExternalXMLUrl(self,index_meta_url,xml_url):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_url: externe url auf ein index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        return self.uploadExternalXML(index_meta_url,xml_url)

    
    def uploadExternalXML(self,index_meta_url,xml_url=None,xml_string=None):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_url: (optional, default=None) externe url auf ein index_meta ersetzt obiges index.meta
        @param xml_string: (optional, default=None) string mit index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        if xml_url:
            xmlneu=urllib.urlopen(xml_url).read()
        else:
            xmlneu=xml_string
        
        dom=self.validateIndexMeta(xmlneu)
        if not dom:
            logger('OSAS_Root (downloadExternalXML)',logging.ERROR,'cannot parse: %s', xml_url)
            return "error"


        path=self.rootFolderName+urlparse(index_meta_url)[2]

        fh=open(path,'w')

        fh.write(xmlneu)
        fh.close()
        return "ok"

    security.declareProtected('View','getIndexMetaFile')

   
    def getIndexMetaFile(self,index_meta):
        """gibt index metafile aus
        @param index_meta: index_meta ist eine URI entweder url des index_meta oder file mit file://
        """
        filearray=[]
        urlparsed=urlparse(index_meta)[1:]

        for x in urlparsed:
            
            if not (x==''):
                filearray.append(x)

        path=os.sep.join(filearray)

        realPath=os.path.normpath(os.path.join(self.rootFolderName,path))
        
        if realPath.find(self.rootFolderName) <0: #versuch auf Pfad unterhalb des Rootfolder zuzugreifen
            return {}
            

        if not os.path.isfile(realPath):
            return None,"(ERROR) path %s does not exist."%path

    
        fh=file(realPath,'r')
        str=fh.read()
        fh.close()
        return str


Globals.InitializeClass(OSAS_root)

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

def manage_addOSAS_root(self,id,RootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_root(id,RootFolderName,serverUrl,uploadServletUrl)
    self._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')