# Copyright (c) 2004 Guido Wesdorp. All rights reserved.
# Contributions by Roman Joost (2005, 2006)
# See also LICENSE.txt
# $Id$

# Zope3 imports
from zope.interface import implements

# Zope imports
from Globals import InitializeClass
from AccessControl import ClassSecurityInfo
from Products.PageTemplates.PageTemplateFile import PageTemplateFile

# Silva imports
from Products.SilvaMetadata.Compatibility import registerTypeForMetadata
from Products.Silva.helpers import add_and_edit
from Products.Silva import mangle
from Products.SilvaDocument.Document import Document, DocumentVersion
from Products.Silva.interfaces import IVersionedContent, IVersion

# SilvaBlog imports
from Products.SilvaBlog.interfaces import ISilvaBlogEntry

icon = "www/silvablogarticle.png"

class SilvaBlogEntry(Document):
    """Silva Blog Article"""

    security = ClassSecurityInfo()
    meta_type = 'Silva Blog Entry'
    implements(IVersionedContent, ISilvaBlogEntry)

    def __init__(self, id):
        SilvaBlogEntry.inheritedAttribute('__init__')(self, id)

    def manage_beforeDelete(self, *args, **kwargs):
        # somehow uncataloging in manage_beforeDelete fails, while this seems
        # to work just fine...
        path = '/'.join(self.getPhysicalPath())
        for version in self._get_indexable_versions():
            self.blog_catalog.uncatalog_object('%s/%s' % (path, version.id))
        for versionid in self.get_previous_versions():
            self.blog_catalog.uncatalog_object('%s/%s' % (path, versionid))
        SilvaBlogEntry.inheritedAttribute('manage_beforeDelete')(
                                                self, *args, **kwargs)
    
    def close_version(self, *args, **kwargs):
        """Close published version
        
            only delegates to super and reindexes version
        """
        SilvaBlogEntry.inheritedAttribute('close_version')(
                                            self, *args, **kwargs)
        version = getattr(self, self._previous_versions[-1][0])
        path = '/'.join(version.getPhysicalPath())
        self.blog_catalog.uncatalog_object(path)
        self.blog_catalog.catalog_object(version, path)

    def is_cacheable(self):
        return 0

    def is_default(self):
        return 1
     
    def _index_version(self, version):
        obj = getattr(self, str(version))
        path = '/'.join(obj.getPhysicalPath())
        #self.blog_catalog.uncatalog_object(path)
        self.blog_catalog.catalog_object(obj, path)
        SilvaBlogEntry.inheritedAttribute('_index_version')(self, version)

    def _update_publication_status(self):
        public = self.get_public_version(0)
        SilvaBlogEntry.inheritedAttribute('_update_publication_status')(self)
        if public != self.get_public_version(0):
            last_closed = self.get_last_closed_version(0)
            if last_closed is not None:
                self._index_version(self.get_last_closed_version(0))
	
InitializeClass(SilvaBlogEntry)
	
class SilvaBlogEntryVersion(DocumentVersion):
    """Silva Blog Article Version"""

    default_catalog = 'service_catalog'
    security = ClassSecurityInfo()
    meta_type = 'Silva Blog Entry Version'
    implements(IVersion)

    def __init__(self, id):
        SilvaBlogEntryVersion.inheritedAttribute('__init__')(
                                                  self, id, 'dummy title')
    
    def index_object(self, *args, **kwargs):
        SilvaBlogEntryVersion.inheritedAttribute('index_object')(
                                                    self, *args, **kwargs)
        self.blog_catalog.catalog_object(self,
                                        '/'.join(self.getPhysicalPath()))

    def reindex_object(self):
        SilvaBlogEntryVersion.inheritedAttribute('reindex_object')(self)
        self.blog_catalog.uncatalog_object('/'.join(self.getPhysicalPath()))
        self.blog_catalog.catalog_object(self,
                                            '/'.join(self.getPhysicalPath()))

InitializeClass(SilvaBlogEntryVersion)

def manage_addSilvaBlogEntry(self, id, title, REQUEST=None):
    if not mangle.Id(self, id).isValid():
        return
    o = SilvaBlogEntry(id)
    self._setObject(id, o)
    object = getattr(self, id)
    object.manage_addProduct['SilvaBlog'].manage_addSilvaBlogEntryVersion(
                                                                '0', title)
    object.create_version('0', None, None)
    add_and_edit(self, id, REQUEST)
    return ''

def manage_addSilvaBlogEntryVersion(self, id, title, REQUEST=None):
    version = SilvaBlogEntryVersion(id)
    self._setObject(id, version)
    version = getattr(self, id)

    if type(title) != type(u''):
        title = unicode(title, 'UTF-8')
    version.set_title(title)
    add_and_edit(self, id, REQUEST)
    return ''

manage_addSilvaBlogEntryForm = PageTemplateFile("www/silvaBlogEntryAdd",
                globals(), __name__ = 'manage_addSilvaBlogEntryForm')

manage_addSilvaBlogEntryVersionForm = PageTemplateFile(
                "www/silvaBlogEntryVersionAdd", globals(),
                __name__ = 'manage_addSilvaBlogEntryVersionForm')

registerTypeForMetadata(SilvaBlogEntryVersion.meta_type)