# Objekte zur Erzeugung von Navigationselementen

from Globals import DTMLFile
from OFS.Image import Image,cookId
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
from ECHO_helpers import displayTypes,checkOnlyOneInGroup

class ECHO_contentType(Image):
    """ContentType Object"""

    meta_type="ECHO_contentType"

    
    manage_options=Image.manage_options+(
        {'label':'Change Description','action':'changeECHO_contentTypeForm'},
       )

    def changeECHO_contentTypeForm(self):
        """Change the description text"""
        pt=PageTemplateFile('Products/ECHO_content/zpt/changeECHO_contentType.zpt').__of__(self)
        return pt()

    def changeECHO_contentType(self,description,RESPONSE=None):
        """Change the Content"""
        self.description=description
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

manage_addECHO_contentTypeForm=DTMLFile('dtml/ECHO_contentTypeAdd',globals(),
                             Kind='ECHO_contentType',kind='ECHO_contentType')

def manage_addECHO_contentType(self, id, file=None, title='', precondition='', content_type='', description='',
                    REQUEST=None):
    """
    Add a new Image object.

    Creates a new Image object 'id' with the contents of 'file'.
    """

    id=str(id)
    title=str(title)
    content_type=str(content_type)
    precondition=str(precondition)

    id, title = cookId(id, title, file)

    self=self.this()

    # First, we create the image without data:
    self._setObject(id, ECHO_contentType(id,title,'',content_type, precondition))

    self._getOb(id).description=description
        
    # Now we "upload" the data.  By doing this in two steps, we
    # can use a database trick to make the upload more efficient.
    if file:
        self._getOb(id).manage_upload(file)
    if content_type:
        self._getOb(id).content_type=content_type

    if REQUEST is not None:
        try:    url=self.DestinationURL()
        except: url=REQUEST['URL1']
        REQUEST.RESPONSE.redirect('%s/manage_main' % url)
    return id


class ECHO_sqlElement(SimpleItem):
    """Erzeuge navigation aus sql-abfrage"""
    meta_type="ECHO_sqlElement"
    baseUrl=""
    
    def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType):
        """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=contentType

    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 getcontentType(self):
        """get weight"""
        
        if hasattr(self,'contentType'):
            return self.contentType
        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,contentType,RESPONSE=None):
        """change"""
        self.title=title
        self.query=query
        self.field=field
        self.searchField=searchField
        self.baseUrl=baseUrl
        self.weight=weight
        self.contentType=contentType
        
        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,contentType,RESPONSE=None):
    """Add an ECHO_sqlelement"""
    self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,contentType))
    
    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,contentType,label,RESPONSE=None):
        """change"""
        self.weight=weight
        self.contentType=contentType
        self.label=label
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def getLabel(self):
        if hasattr(self,'label'):
            return self.label.encode('utf-8')
        else:
            return 0
        
    def getWeight(self):
        """get weight"""
        if hasattr(self,'weight'):
            return self.weight
        else:
            return 0
        
    def getcontentType(self):
        """get weight"""
        if hasattr(self,'weight'):
            return self.weight
        else:
            return 0




    ## def __init__(self, id, text=None, contentType=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, contentType)

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, label, weight= 0,contentType=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,'label',label)
        setattr(ob,'contentType',contentType)
        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('contentType'))

        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=displayTypes
    
    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 x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
            x=x_objs[1]
            x = checkOnlyOneInGroup(x)
            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

        
        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,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)

        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],None))
                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.encode('utf-8')
                            
                        else:
                            label=temp[x][1].title.encode('utf-8')
                    else:
                        label=temp[x][1].title.encode('utf-8')                            
                    
                    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=[]

        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=""

        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 numberOfMainNavElements(self):
	"""number of main elements"""

	return len(self.barFromHash(self.createNavHash(0))) 

    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("/")
        

        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])