##############################################################################
#
# Copyright (c) 2004-1005 Michel Pelletier
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################


__rdf_description__ = '''\
<rdf:RDF xmlns="http://web.resource.org/cc/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<Work rdf:about="http://zemantic.org/zemantic/zemantic.py"
  dc:title="zemantic.zemantic"
  dc:date="2005"
  dc:description="Core zemantic utility object and triple store.">
    <dc:creator>
            <Agent dc:title="Michel Pelletier"/>
    </dc:creator>
    <dc:rights>
            <Agent dc:title="Michel Pelletier"/>
    </dc:rights>
    <license rdf:resource="http://zemantic.org/LICENSE.txt/"/>
</Work>
</rdf:RDF>
'''
from persistent import Persistent
from persistent.dict import PersistentDict

from rdflib.TripleStore import TripleStore     # not pickleable
from rdflib.URIRef import URIRef
from rdflib.BNode import BNode
from rdflib.Literal import Literal
from rdflib.Identifier import Identifier

from query import Query
from lib.ZODBBackend import ZODBBackend
from lib.IOZODBBackend import IOZODBBackend
from interfaces import IZemantic
from events import afterAdd, beforeRemove

from zope.interface import implements
from zope.interface.verify import verifyClass

class Zemantic(Persistent):
    """
    A semantic zemantic.  A wrapper around a persistent rdflib backend
    that is used to construct an rdflib triplestore.

      >>> c = Zemantic()
      >>> IZemantic.providedBy(c)
      True
      >>> verifyClass(IZemantic, Zemantic)
      True

    See Zontology class doctests for more tests.
    
    """

    implements(IZemantic)

    _v_store = backend = __parent__ = __name__ = None

    def __init__(self):
        self.backend = IOZODBBackend()
        self.schemata = PersistentDict()
        self.notify = False

    def clear(self):
        """
        Clear zemantic.
        """
        for t in self.triples((None, None, None)):
            self.remove(t)

    def notifyOn(self):
        """
        Turn on event notification.
        """
        self.notify = True

    def notifyOff(self):
        self.notify = False

    def getStore(self):
        """
        Returns a TripleStore wrapping the semantic storage.
        """
        if self._v_store is None:
            self._v_store = TripleStore(backend=self.backend)  # not pickleable
        return self._v_store

    store = property(getStore)

    def parse(self, rdf, format="xml"):
        """
        Parse RDF information.  The optional"format" argument can be "xml"
        (the default) or "nt".  Note, I have not tested nt yet.  Also a
        bug in rdflib requires you pass a file like object.
        """
        self.store.parse(rdf, format=format)

    def add(self, (subject, predicate, object)):
        """
        Add a triple to the storage.
        """
        t = (subject, predicate, object)
        self.store.add(t)
        if self.notify:
            afterAdd(t)

    def remove(self, (subject, predicate, object)):
        """
        Add a triple to the storage.
        """
        t = (subject, predicate, object)
        if self.notify:
            beforeRemove(t)
            
        self.store.remove(t)

    def triples(self, (subject, predicate, object)):
        """
        Query the triple storage.  The argument is a triple pattern
        which can contain a valid value or None to indicate any value
        is desired.
        """
        
        for triple in  self.store.triples((subject, predicate, object)):
            yield triple

    def query(self, q):
        """
        Query zemantic with a query object.
        """
        
        return q(self)

    # no need to test the rest, they're all based on triples()

    def subjects(self, predicate=None, object=None):
        return self.store.subjects(predicate, object)
        
    def predicates(self, subject=None, object=None):
        return self.store.predicates(subject, object)

    def objects(self, subject=None, predicate=None):
        return self.store.objects(subject, predicate)

    def subject_predicates(self, object=None):
        return self.store.subject_predicates(object)
            
    def subject_objects(self, predicate=None):
        return self.store.subject_objects(predicate)
        
    def predicate_objects(self, subject=None):
        return self.store.predicate_objects(subject)

    def transitive_objects(self, subject, property, remember=None):
        return self.store.transitive_objects(subject, property, remember)

    def transitive_subjects(self, predicate, object, remember=None):
        return self.store.transitive_subjects(predicate, object, remember)
        
    def uniqueSubjects(self):
        return self.backend.uniqueSubjects()

    def uniquePredicates(self):
        return self.backend.uniquePredicates()

    def uniqueObjects(self):
        return self.backend.uniqueObjects()

    def rdfxml(self):
        return self.store.serialize()

    def rdfnt(self):
        return self.store.serialize("nt")