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

        # 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 getDirectorId(self):
        """returns the id of the director"""
        return self.director_id

    def getProjectId(self):
        """return the project id"""
        return self.project_id
    
    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 getThumbImgUrl(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"""
        proj = self.getProjects(count=1, onlyActive=1, onlyArchived=1)
        return getAt(proj, 0, None) 

    def getProjects(self, count=0, onlyActive=0, onlyArchived=0):
        """returns a list of projects of this department.
        
        onlyActive = 0 : all projects
        onlyActive = 1 : active projects
        onlyActive = 2 : inactive projects
        
        onlyArchived = 0 : all projects
        onlyArchived = 1 : current projects
        onlyArchived = 2 : archived projects
        """
        pf = self.en.getProjectsFolder()
        projects = pf.getProjectList(self.getProjectId(), active=onlyActive, archived=onlyArchived)
        #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, 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
        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"""
    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, RESPONSE=None):
    "Add a MPIWG Department object"
    newObj=MPIWGDepartment(id,title,weight,project_id,director,director_id,type_en,type_de,title_en,title_de)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')