# Objekte zur Erzeugung von Navigationselementen


from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
import re
import string
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
import os.path
from Globals import package_home
import urllib

class ECHO_sqlElement(SimpleItem):
    """Erzeuge navigation aus sql-abfrage"""
    meta_type="ECHO_sqlElement"
    baseUrl=""
    
    def __init__(self,id,title,query,field,searchField,baseUrl,weight,content_type):
        """init"""
        self.id=id
        self.title=title
        self.query=query
        self.field=field
        if searchField=="":
            self.searchField=field
        else:
            self.searchField=searchField
        self.baseUrl=baseUrl
        self.weight=weight
        self.content=content_type

    manage_options= SimpleItem.manage_options+(
        {'label':'Main Config','action':'changeECHO_sqlElementForm'},
        )

    def getSearchField(self):
        try:
            return self.searchField
        except:
            return self.field
        
    def getWeight(self):
        """get weight"""
        if hasattr(self,'weight'):
            return self.weight
        else:
            return 0
        
    def getContent_type(self):
        """get weight"""
        
        if hasattr(self,'content_type'):
            return self.content_type
        else:
            return 0
        

    def changeECHO_sqlElementForm(self):
        """change"""
        
        pt=PageTemplateFile('Products/ECHO_content/zpt/changeECHO_sqlElement.zpt').__of__(self)
        return pt()

    def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,content_type,RESPONSE=None):
        """change"""
        self.title=title
        self.query=query
        self.field=field
        self.searchField=searchField
        self.baseUrl=baseUrl
        self.weight=weight
        self.content_type=content_type
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def searchQuery(self):
        return self.search(var=self.query)
    
    def getNavList(self):
        """ausgabe der treffer list für navigation"""
        records=self.searchQuery()
        if not records:
            return []
        else:
            ret=[]
            for record in records:
                try:
                    ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField())))))
                except:
                    """notrhing"""
                    
            return ret
    

def manage_addECHO_sqlElementForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_sqlElement.zpt').__of__(self)
    return pt()

def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,content_type,RESPONSE=None):
    """Add an ECHO_sqlelement"""
    self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,content_type))
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


class ECHO_pageTemplate(ZopePageTemplate):
    """pageTemplate Objekt"""
    meta_type="ECHO_pageTemplate"

    _default_content_fn = os.path.join(package_home(globals()),
                                       'html/ECHO_pageTemplateDefault.html')

    manage_options=ZopePageTemplate.manage_options+(
        {'label':'Weight and Type','action':'changeECHO_pageTemplateWeightForm'},
        )

    def changeECHO_pageTemplateWeightForm(self):
        """change"""
        pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)
        return pt()

    def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):
        """change"""
        self.weight=weight
        self.content_type=content_type

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')
        
    def getWeight(self):
        """get weight"""
        if hasattr(self,'weight'):
            return self.weight
        else:
            return 0
        
    def getContent_Type(self):
        """get weight"""
        if hasattr(self,'weight'):
            return self.weight
        else:
            return 0




    ## def __init__(self, id, text=None, content_type=None):
##         self.id = str(id)
##         self.ZBindings_edit(self._default_bindings)
##         if text is None:
##             text = open(self._default_cont).read()
##         self.pt_edit(text, content_type)

def manage_addECHO_pageTemplateForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_pageTemplate.zpt').__of__(self)
    return pt()

from urllib import quote


def manage_addECHO_pageTemplate(self, id, weight= 0,content_type=0,title=None, text=None,
                           REQUEST=None, submit=None):
    "Add a Page Template with optional file content."

    
    id = str(id)
    if REQUEST is None:
        self._setObject(id, ECHO_pageTemplate(id, text))
        ob = getattr(self, id)
        setattr(ob,'weight',weight)
        setattr(ob,'content_type',content_type)
        if title:
            ob.pt_setTitle(title)
        return ob
    else:
        file = REQUEST.form.get('file')
        headers = getattr(file, 'headers', None)
        if headers is None or not file.filename:
            zpt = ECHO_pageTemplate(id)
        else:
            zpt = ECHO_pageTemplate(id, file, headers.get('content_type'))

        self._setObject(id, zpt)
        ob = getattr(self, id)
        setattr(ob,'weight',weight)
        if title:
            ob.pt_setTitle(title)
        
        try:
            u = self.DestinationURL()
        except AttributeError:
            u = REQUEST['URL1']

        if submit == " Add and Edit ":
            u = "%s/%s" % (u, quote(id))
        REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''


class ECHO_navigation(Folder):
    """Navigations Element"""
    meta_type="ECHO_Navigation"

    displayedMetaTypes=['ImageCollectionIFrame','ECHO_collection','ECHO_pageTemplate','ZSQLExtendFolder','ECHO_sqlElement','ECHO_resource','ECHO_externalLink']
    
    def __init__(self,id,title,pathToHierarchy):
        """init"""
        self.id=id
        self.title=title
        self.pathToHierarchy=pathToHierarchy

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

    def ECHO_navigationConfigForm(self):
        """configForm"""
        pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_navigation.zpt').__of__(self)
        return pt()
    
    def ECHO_navigationConfig(self,title,pathToHierarchy,RESPONSE=None):
        """config"""
        self.title=title
        self.pathToHierarchy=pathToHierarchy

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


    def getColls(self,obj,depth):
        nav={}
        #print "HERE",obj.
        for keys in obj.__dict__.keys():
            x=getattr(obj,keys)
            if hasattr(x,"meta_type"):
                if x.meta_type in self.displayedMetaTypes:
                    if depth>1:
                        nav[x.getId()]=(self.getColls(x,depth-1),x)
                    else:
                        nav[x.getId()]=(None,x)
        return nav
    
    def createNavHash(self,depth):
        """Auslesen des Hierarchiebuames"""
        temp=self.pathToHierarchy[0:]
        temp=re.sub("/",".",temp)
        temp="self.aq_parent"+temp
        
        objtemp=eval(temp)
        nav={}
        obj=objtemp
        
        #exec(obj)

        #objtemp = compile(temp,'<string>','single')
        #obj=eval(objtemp)
        #print obj 
        
        #print obj.__dict__.keys()
        
        for keys in obj.__dict__.keys():
            x=getattr(obj,keys)
            if hasattr(x,"meta_type"):
                #print x.meta_type
                if x.meta_type in self.displayedMetaTypes:
                   
                    if depth>1:
                        nav[x.getId()]=(self.getColls(x,int(depth)-1),x)
                    else:
                        nav[x.getId()]=(None,x)
                    

        #print nav
        return nav

    def barFromHash(self,hash,start=None,sortField=None):
        """Erzeuge Navigations Element"""
        #print "hash",hash
        listNav=[]
        if not start:
            temp=hash
            sortField="weight"
        else: # list mit pfad zum hash
            temp=hash
            #print "HI",sortField
            if not sortField:
                tempObj=self.pathToHierarchy[0:]
                tempObj=re.sub("/",".",tempObj)
                tempObj="self.aq_parent"+tempObj

                objtemp=eval(tempObj)

                obj=objtemp

                for x in start:
                    #print "OBJ",start,obj,obj.getId(),x

                    obj=getattr(obj,x)

                if hasattr(obj,'sortfield'):
                    sortField=obj.sortfield
                else:
                    sortField='weight'
            #print "START",start
            for x in start:
                #print "N2",x,temp[x]
                try:
                    temp=temp[x][0]
                except:
                    """nothing"""
                    return []
            #print "TEMP",temp,self.tempSorted(temp, field=sortField)
        print "HELL",sortField
        for x in self.tempSorted(temp, field=sortField):
            if not temp[x][1].title == "":
                if temp[x][1].meta_type=="ECHO_sqlElement":
                    for z in temp[x][1].getNavList():
                        listNav.append((z[0],z[1]))
                else:
                    # add label fals existiert und nicht leer
                    if hasattr(temp[x][1],'label'):
                        if not temp[x][1].label=='':
                            label=temp[x][1].label
                            print "HAS LABEL",label
                        else:
                            label=temp[x][1].title
                    else:
                        label=temp[x][1].title                            
                    
                    listNav.append((label,createPath(self.absolute_url(),temp[x][1].absolute_url()),temp[x][1]))
                    
        #print self.getId(),start
        #print listNav

        #html=""
        #for k in listNav:
        #    print k
        #    html=html+"<a href='%s'>%s</a>   "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0])

        return listNav

    def tempSorted(self,hash,field="weight"):
        ls=[]
        print "SORT",field
        for x in hash.keys():
            #print hash[x][1]
            if hasattr(hash[x][1],field):
                weight=getattr(hash[x][1],field)
                #print weight
            else:
                weight=0

            ls.append((x,weight))

        ls.sort(sortWeight)
        
        return [x[0] for x in ls]

    
        
            
    def isSelectedPath(self,item):
        """test is path is already selected"""
        found=re.search("\?(.*)",item[1])
        if found:
            temp=re.sub(" ","%20",found.group(0))
            #print temp+"::"+self.REQUEST['QUERY_STRING']
            if ("?"+self.REQUEST['QUERY_STRING'])==temp:
                return 1

        if re.search(item[1],self.REQUEST['URL']):
            return 1
        else:
            return 0
        
    
    def buttonsFromHash(self,hash,start=None,orientation="horizontal"):
        
        """Generate Buttons"""
        if orientation=="horizontal":
            html="<table><tr>"
            startTag="<td>"
            endTag="</td>"
            endHtml="</tr></table>"

        else:
            html="<table>"
            startTag="<tr><td>"
            endTag="</td></tr>"
            endHtml="</table>"
            
        if not start:
            temp=hash
        else:
            temp=hash
            for x in start:
                temp=temp[x][0]
                #print temp
        
        for key in self.tempSorted(temp):
            
            description=temp[x][1].title
         
            url=createPath(self.absolute_url(),temp[key][1].absolute_url())

            if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):
                html=html+startTag+"[%s]" % description+endTag
            else:                
                html=html+startTag+"[<a href='%s'>%s</a>]" % (url,description)+endTag
            

        html=html+endHtml
        
        return html

    def mainNavBar(self):
        """print main navigation bar"""
        keys=""
        print "NAVBAR",self.getId()
        try:
            keys=self.buttonsFromHash(self.createNavHash(0))
        except:
            keys=""
            
        return keys

    def mainNavElements(self):
        """print main navigation bar"""
        keys=""
        print "NAVELEMENT",self.getId()
        #try:
      
        keys=self.barFromHash(self.createNavHash(0))

        #except:
        #    keys=""
            
        return keys
    
    def secondNavElements(self):
        """Zweite Ordnung"""
        
        hash=self.createNavHash(2)
        actual_url=self.REQUEST['URL']
        
        ult_temp=re.sub(self.absolute_url(),"",actual_url)
        #print ult_temp

        splitted=ult_temp.split("/")
        

        ## if splitted[len(splitted)-1]=="index_html":
##             start=[splitted[len(splitted)-2]]
##         else:
##             start=[splitted[len(splitted)-1]]

        start=[splitted[2]]
        #print start
       
        keys=self.barFromHash(hash,start=start)
        
        
        return keys

    def navElements(self,order):
        """n-te Ordnung"""
        
        hash=self.createNavHash(order)
        actual_url=self.REQUEST['URL']
        
        ult_temp=re.sub(self.absolute_url(),"",actual_url)
        #print ult_temp

        splitted=ult_temp.split("/")
        

        ## if splitted[len(splitted)-1]=="index_html":
##             start=[splitted[len(splitted)-2]]
##         else:
##             start=[splitted[len(splitted)-1]]

        start=splitted[2:order+1]
        #print start
       
        keys=self.barFromHash(hash,start=start)
        
        
        return keys


    def secondNavBar(self):
        """Zweite Ordnung"""

        hash=self.createNavHash(2)
        actual_url=self.REQUEST['URL']
        
        ult_temp=re.sub(self.absolute_url(),"",actual_url)
        #print ult_temp

        splitted=ult_temp.split("/")
        

        ## if splitted[len(splitted)-1]=="index_html":
##             start=[splitted[len(splitted)-2]]
##         else:
##             start=[splitted[len(splitted)-1]]

        start=[splitted[2]]
        #print start
        
        keys=self.buttonsFromHash(hash,start=start,orientation="vertical")
        
        
        return keys

def manage_addECHO_navigationForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_navigation.zpt').__of__(self)
    return pt()

def manage_addECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):
    """Add an ECHO_root"""
    self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


#helpers



def createPath(url1,url2):
    temp1=url1.split("/")
    temp2=url2.split("/")
    for test in temp1:
        if temp2[0]==test:
            del temp2[0]

    return url1+"/"+string.join(temp2,"/")

def sortWeight(x,y):
    #print x[1],y[1]
    return cmp(x[1],y[1])