from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Globals import package_home
import string
import re
import os
import logging
from OFS.Folder import Folder
from AccessControl import ClassSecurityInfo

from SrvTxtUtils import getAt

import MPIWGHelper

class MPIWGDepartment(Folder):
    """special object for departments on the MPIWG website """

    meta_type="MPIWGDepartment"

    manage_options=Folder.manage_options+(
        {'label':'Configure','action':'changeForm'},
        )

    #changeWeightForm = PageTemplateFile('zpt/department/manage_change_weight', globals())
    changeForm = PageTemplateFile('zpt/department/manage_config', globals())

    def __init__(self, id, title=None, weight=0, project_id=0, director='', director_id='', 
                 type_en=None, type_de=None, title_en=None, title_de=None, staffdb_key=None):
        self.id = str(id)
        self.weight = weight
        self.project_id = project_id
        if title is None:
            self.title = id
        else:
            self.title = title

        self.director = director
        self.director_id = director_id
        
        self.staffdb_key = staffdb_key

        # add language folders and sample templates
        mainid = 'main.pt'
        self.manage_addFolder('en')
        folder_en = getattr(self, 'en')
        main_en = ZopePageTemplate(mainid)
        folder_en[mainid] = main_en
        main_en.pt_edit(open(os.path.join(package_home(globals()),'zpt/department/default_template_main.zpt')).read(),'text/html')
        if type_en is not None:
            folder_en.title = type_en        
        if title_en is not None:
            main_en.title = title_en        
        self.manage_addFolder('de')
        folder_de = getattr(self, 'de')
        main_de = ZopePageTemplate(mainid)
        folder_de[mainid] = main_de
        main_de.pt_edit(open(os.path.join(package_home(globals()),'zpt/department/default_template_main.zpt')).read(),'text/html')        
        if type_de is not None:
            folder_de.title = type_de        
        if title_de is not None:
            main_de.title = title_de


    def index_html(self):
        """default index page"""
        return self.getMain()
    
    def getType(self, lang=None):
        """returns the type of department (from /en/ folder)"""
        if lang is None:
            # get Language from MPIWGRoot
            lang = self.getLang()
            
        dir = getattr(self, lang, self.en)
        t = dir.title
        return t
    
    def getTitle(self, lang=None):
        """returns the title of the department (from main.pt)"""
        if lang is None:
            # get Language from MPIWGRoot
            lang = self.getLang()
            
        dir = getattr(self, lang, self.en)
        pt = getattr(dir, 'main.pt')
        t = pt.title
        if not t:
            t = self.title
            
        return t
    
    def getDirector(self):
        """returns the name of the director"""
        return self.director
    
    def getDirectorUsername(self):
        """returns the username of the director"""
        return self.director_id

    def getProjectNumber(self):
        """return the project number"""
        return self.project_id
    
    def getStaffDbKey(self):
        """Return the key for this department in the staff db (personalwww)."""
        return getattr(self, 'staffdb_key', None)
    
    def getUrl(self, baseUrl=None):
        """returns URL to this Department"""
        if baseUrl is None:
            return self.absolute_url()

        return '%s/%s'%(baseUrl, self.getId())
            
    def getPath(self, page, relative=True):
        """returns path to template page"""
        # get Language from MPIWGRoot
        lang = self.getLang()
        dir = getattr(self, lang, self.en)
        if relative:
            return '%s/%s/%s'%(self.getId(), dir.getId(), page)
        
        pt = getattr(dir, page)
        return pt.absolute_url_path()

    def getMainPath(self):
        """returns the path to the main template"""
        return self.getPath('main.pt')

    def getMain(self, **args):
        """returns the main part as PageTemplate"""
        # get Language from MPIWGRoot
        lang = self.getLang()
        dir = getattr(self, lang, self.en)
        pt = getattr(dir, 'main.pt')
        return pt(**args)
    
    def getThumbImg(self):
        """returns the image object for the sidebar thumbnail"""
        img = getattr(self, 'img-thumb.jpg')
        return img
        
    def getThumbUrl(self):
        """returns the URL of the image object for the sidebar thumbnail"""
        img = getattr(self, 'img-thumb.jpg')
        return img.absolute_url()

    def getProject(self):
        """returns the default project"""
        pf = self.getMPIWGRoot().getProjectFolder()
        proj = pf.getProject(projectNumber=self.getProjectNumber())
        return proj

    def getProjects(self, count=0, active=0, archived=0, depthFirst=True):
        """returns a list of projects of this department.
        
        active = 0 : all projects
        active = 1 : active projects
        active = 2 : inactive projects
        
        archived = 0 : all projects
        archived = 1 : current projects
        archived = 2 : archived projects
        """
        pf = self.getMPIWGRoot().getProjectFolder()
        projects = pf.getProjectsAsList(self.getProjectNumber(), active=active, archived=archived, depthFirst=depthFirst)
        #logging.debug("getProjects projects=%s"%repr(projects))
        if count > 0:
            return projects[:count]
            
        return projects
    
    def changeWeight(self,weight,RESPONSE=None):
        """change weight"""
        self.weight=weight
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')
            

    def changeMPIWGDepartment(self, title=None, weight=None, project_id=None, director=None, director_id=None, 
                              type_en=None, type_de=None, title_en=None, title_de=None, staffdb_key=None, RESPONSE=None):
        """change everything"""
        if title is not None:
            self.title = title
        if weight is not None:
            self.weight = weight
        if project_id is not None:
            self.project_id = project_id
        if director is not None:
            self.director = director
        if director_id is not None:
            self.director_id = director_id
        if staffdb_key is not None:
            self.staffdb_key = staffdb_key
        folder_en = self.get('en', None)
        if folder_en is not None:
            if type_en is not None:
                folder_en.title = type_en        
            main_en = folder_en.get('main.pt', None)
            if main_en is not None and title_en is not None:
                main_en.title = title_en        
        folder_de = self.get('de', None)
        if folder_de is not None:
            if type_de is not None:
                folder_de.title = type_de        
            main_de = folder_de.get('main.pt', None)
            if main_de is not None and title_de is not None:
                main_de.title = title_de        

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

    def getBreadcrumbs(self):
        """return list of breadcrumbs from here to the root"""
        crumbs = [(self.getFullTitle(), self.absolute_url(), self)]
        parent = self.aq_parent
        if hasattr(parent, 'getBreadcrumbs'):
            if self.title:
                return parent.getBreadcrumbs() + crumbs
            else:
                # if there's no title, skip this level
                return parent.getBreadcrumbs()
            
        return crumbs
    
    getSection = MPIWGHelper.getSection

    getSubSection = MPIWGHelper.getSubSection
    

def manage_addMPIWGDepartmentForm(self):
    """Form for adding a MPIWGDepartment"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/department/manage_add_MPIWGDepartment.zpt')).__of__(self)
    return pt()


def manage_addMPIWGDepartment(self, id, title=None, weight=0, project_id=0, director=None, director_id=None, 
                              type_en=None, type_de=None, title_en=None, title_de=None, staffdb_key=None, RESPONSE=None):
    """Add a MPIWGDepartment object"""
    newObj = MPIWGDepartment(id, title, weight, project_id, director, director_id, type_en, type_de, title_en, title_de, staffdb_key)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')