__docformat__ = 'restructuredtext'

from interfaces import IDBXMLDocument
from dbxmlfolder import BDBXMLDA

from zope.component.interfaces import IFactory
from zope.app import zapi
from zope.app.container.interfaces import IContainer
from zope.app.folder.interfaces import IFolder
from zope.app.folder import Folder
from zope.interface import implements
from zope.app.container.contained import Contained, setitem, uncontained
from zope.interface import implementedBy, directlyProvides, directlyProvidedBy 
from zope.component.interfaces import IFactory


class IDBXMLFolder(IFolder):
    """Marker for folders whose contained items keys are case insensitive.

    When traversing in this folder, all names will be converted to lower
    case. For example, if the traverser requests an item called 'Foo', in
    reality the first item matching 'foo' or any upper-and-lowercase variants
    are looked up in the container."""


# things inside a container should be locatable (that means, provide
# ILocation and have __name__ and __parent__ attributes). For the stub
# content object we have here, we just derive from Contained, which is
# an ILocation
class DBXMLDocument(Contained):
    __doc__ = IDBXMLDocument.__doc__

    implements(IDBXMLDocument)

    #ctitle="Class DBMLDocument title"

    def __init__(self, xmldoc):
        self.ctitle = "Instance title"

    def title(self):
        return self.ctitle # Doesn't work for self.xmldoc
    
    def asXML(self):
        return self.xmldoc.getContent()

class DBXMLFolder(Contained):
    """Sample container implementation suitable for testing.

    It is not suitable, directly as a base class unless the subclass
    overrides `_newContainerData` to return a persistent mapping object.
    """
    implements(IContainer)

    def __init__(self):
        self.__data = self._newContainerData()
        self.bdbxmlda = BDBXMLDA("/tmp/foo")

    def _newContainerData(self):
        """Construct an item-data container

        Subclasses should override this if they want different data.

        The value returned is a mapping object that also has `get`,
        `has_key`, `keys`, `items`, and `values` methods.
        """
	from zope.app.location import locate

	# contained objects should be located

        doc = self.bdbxmlda.getID("1")
        first = DBXMLDocument(doc)
        first.xmldoc = doc
	locate(first, self, 'first')

        second = DBXMLDocument()
	locate(second, self, 'second')

        return {'first': first, 'second': second}

    def keys(self):
        '''See interface `IReadContainer`'''
        return self.__data.keys()

    def __iter__(self):
        return iter(self.__data)

    def __getitem__(self, key):
        '''See interface `IReadContainer`'''
        return self.__data[key]

    def get(self, key, default=None):
        '''See interface `IReadContainer`'''
        return self.__data.get(key, default)

    def values(self):
        '''See interface `IReadContainer`'''
        return self.__data.values()

    def __len__(self):
        '''See interface `IReadContainer`'''
        return len(self.__data)

    def items(self):
        '''See interface `IReadContainer`'''
        return self.__data.items()

    def __contains__(self, key):
        '''See interface `IReadContainer`'''
        return self.__data.has_key(key)

    has_key = __contains__

    def __setitem__(self, key, object):
        '''See interface `IWriteContainer`'''
        setitem(self, self.__data.__setitem__, key, object)

    def __delitem__(self, key):
        '''See interface `IWriteContainer`'''
        uncontained(self.__data[key], self, key)
        del self.__data[key]