from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from OFS.Folder import Folder
from Globals import package_home
from Acquisition import aq_parent

import os
import logging
import datetime

from SrvTxtUtils import getDateString
import MPIWGHelper

class MPIWGFeature(Folder):
    """special object for feature texts on the MPIWG website.
    Has templates for English and German in Folders /en/ and /de/.
    Feature teaser is /(en|de)/teaser.pt. Full page is /(en|de)/main.pt.
    Full title is the title of /(en|de)/main.pt. 
    """

    meta_type = "MPIWGFeature"

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

    # templates
    changeWeightForm = PageTemplateFile('zpt/feature/manage_change_weight', globals())
    changeForm = PageTemplateFile('zpt/feature/manage_config', globals())
    feature_main = PageTemplateFile('zpt/feature/feature_template', globals())

    def __init__(self, id, title=None, weight=0, date=None, title_en=None, title_de=None, author=None, author_id=None):
        self.id = str(id)
        self.weight = weight
        self.author = author
        self.author_id = author_id
        if title is None:
            self.title = id
        else:
            self.title = title
            
        if date is None:
            self.date = datetime.date.today()
        else:
            self.date = date
        
        #    
        # add language folder and sample templates
        #
        mainid = 'main.pt'
        teaserid = 'teaser.pt'
        # english
        self.manage_addFolder('en')
        folder_en = getattr(self, 'en')
        folder_en[teaserid] = ZopePageTemplate(teaserid)
        teaser_en = getattr(folder_en, teaserid)
        teaser_en.pt_edit(open(os.path.join(package_home(globals()), 'zpt/feature/default_template_teaser.zpt')).read(), 'text/html')
        folder_en[mainid] = ZopePageTemplate(mainid)
        main_en = getattr(folder_en, mainid)
        main_en.pt_edit(open(os.path.join(package_home(globals()), 'zpt/feature/default_template_main.zpt')).read(), 'text/html')        
        if title_en is not None:
            main_en.title = title_en
        # german
        self.manage_addFolder('de')
        folder_de = getattr(self, 'de')
        folder_de[teaserid] = ZopePageTemplate(teaserid)
        teaser_de = getattr(folder_de, teaserid)
        teaser_de.pt_edit(open(os.path.join(package_home(globals()), 'zpt/feature/default_template_teaser.zpt')).read(), 'text/html')
        folder_de[mainid] = ZopePageTemplate(mainid)
        main_de = getattr(folder_de, mainid)
        main_de.pt_edit(open(os.path.join(package_home(globals()), 'zpt/feature/default_template_main.zpt')).read(), 'text/html')        
        if title_de is not None:
            main_de.title = title_de        


    def index_html(self):
        """default index page"""
        return self.getMain()

    def getAuthor(self):
        """returns the author name"""
        return getattr(self, 'author', None)

    def getAuthorId(self):
        """returns the author ID"""
        return getattr(self, 'author_id', None)
    
    def getFullTitle(self, lang=None):
        """returns the full title (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 getDate(self):
        """returns the date as a date object"""
        return getattr(self, 'date', None)
    
    def getDateString(self, lang=None):
        """returns the date as a string"""
        d = self.getDate()
        if d is None:
            return '???'
        
        if lang is None:
            # get Language from MPIWGRoot
            lang = self.getLang()
        
        return getDateString(date=d, lang=lang, withYear=True)
    

    getUrl = MPIWGHelper.getUrl

            
    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, None)
        if pt is not None:
            return pt.absolute_url_path()
        
        return None

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

    def getIntro(self, **args):
        """returns the intro as PageTemplate"""
        # get Language from MPIWGRoot
        lang = self.getLang()
        dir = getattr(self, lang, self.en)
        pt = getattr(dir, 'intro.pt')
        return pt(**args)

    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 getFrontpageImg(self):
        """returns the image object for the frontpage"""
        img = getattr(self, 'img-frontpage.jpg')
        return img

    def getFrontpageImgUrl(self):
        """returns the URL of the image object for the frontpage"""
        img = getattr(self, 'img-frontpage.jpg')
        return img.absolute_url()
        
    def getFrontpageThumb(self):
        """returns the image object for the frontpage thumbnail"""
        img = getattr(self, 'img-frontthumb.jpg')
        return img
        
    def getFrontpageThumbUrl(self):
        """returns the URL of the image object for the frontpage thumbnail"""
        img = getattr(self, 'img-frontthumb.jpg')
        return img.absolute_url()
        
    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 changeWeight(self, weight, RESPONSE=None):
        """change weight"""
        self.weight = weight
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def changeMPIWGFeature(self, title=None, weight=None, date=None, title_en=None, title_de=None,
                           author=None, author_id=None, RESPONSE=None):
        """change everything"""
        if title is not None:
            self.title = title
        if weight is not None:
            self.weight = weight            
        if author is not None:
            self.author = author            
        if author_id is not None:
            self.author_id = author_id            
        if date is not None:
            try:
                self.date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
            except:
                pass
            
        folder_en = self.get('en', None)
        if folder_en is not None:
            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:
            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"""
        # get acquisition parent (skipping folder "features")
        parent = aq_parent(aq_parent(self))
        baseUrl = parent.absolute_url() + '/features'
        crumbs = [{'text':self.getFullTitle(), 'url':self.getUrl(baseUrl=baseUrl), 'object':self}]
        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_addMPIWGFeatureForm(self):
    """Form for adding"""
    pt = PageTemplateFile(os.path.join(package_home(globals()), 'zpt/feature/manage_add_MPIWGFeature.zpt')).__of__(self)
    return pt()

def manage_addMPIWGFeature(self, id, title=None, weight=0, title_en=None, title_de=None, author=None, author_id=None, RESPONSE=None):
    "Add a MPIWG Feature object"
    newObj = MPIWGFeature(id, title=title, weight=weight, title_en=title_en, title_de=title_de, author=author, author_id=author_id)
    self.Destination()._setObject(id, newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')