import logging

from rdflib import RDF, RDFS

from light9.rdfdb.currentstategraphapi import contextsForStatementNoWildcards

class AutoDepGraphApi(object):

    """

    knockoutjs-inspired API for automatically building a dependency

    tree while reading the graph. See addHandler().

        # no plan for sparql queries yet. Hook into a lower layer that

        # reveals all their statement fetches? Just make them always

        # new? Cache their results, so if i make the query again and

        # it gives the same result, I don't call the handler?

        self.currentFuncs.append(func)

        try:

            func()

        finally:

            self.currentFuncs.pop()

    def runDepsOnNewPatch(self, p):

        """

        patch p just happened to the graph; call everyone back who

        might care, and then notice what data they depend on now

        """

        for func in self._watchers.whoCares(p):

            # todo: forget the old handlers for this func

            self.addHandler(func)

    def _getCurrentFunc(self):

        if not self.currentFuncs:

            # this may become a warning later

            raise ValueError("asked for graph data outside of a handler")

        corrections.

        Edits you make during a resync will surely be lost, so I

        should just fail them. There should be a notification back to

        UIs who want to show that we're doing a resync.

        """

        self._sender.cancelAll()

        # this should be locked so only one resync goes on at once

        return cyclone.httpclient.fetch(

            url=self.rdfdbRoot + "graph",

            method="GET",

            headers={'Accept':['x-trig']},

            log.info("skipping no-op patch")

            return

        # these could fail if we're out of sync. One approach:

        # Rerequest the full state from the server, try the patch

        # again after that, then give up.

        try:

        except ValueError as e:

            log.error(e)

            self.sendFailed(None)

            return

        self.runDepsOnNewPatch(p)

        self._sender.sendPatch(p).addErrback(self.sendFailed)

    def sendFailed(self, result):

        """

        we asked for a patch to be queued and sent to the master, and

        that ultimately failed because of a conflict

        """

        #then requeue all the pending patches (minus the failing one?) after that's done.

    def _onPatch(self, p):

        """

        central server has sent us a patch

        """

        patchQuads(self._graph, p.delQuads, p.addQuads, perfect=True)

        log.debug("graph now has %s statements" % len(self._graph))

        try:

            self.runDepsOnNewPatch(p)

        except Exception:

            # don't reflect this error back to the server; we did