import threading # Only used in SetupEvent

class _Callback(object):

    def __init__(self, callback, errorback, threaded = False):

        self.callback = callback

        self.errorback = errorback

        self.next = None

        self.threaded = threaded

    def Chain(self, next):

        # Can only be called once

        assert(self.next is None)

        self.next = next

        return next

    def Next(self):

        return self.next

##

# A task, representing a series of linked pairs of callback and error

# handler Concept is similar to twisted, but you need to put all your

# callback on the task before giving it to the Scheduler.  For this

# reason, you shouldnt call the callback/errorback method yourself (or

# at least, don't put it back in the scheduler after that).

class Task(object):

    @staticmethod

    def DefaultCallback(result):

        return result

    @staticmethod

    def DefaultErrorback(error):

        return error

    def __init__(self, func = None, *args, **kwargs):

        super(Task, self).__init__()

        self.head = None

        self.tail = None

        if func:

            def callback(result):

                return func(*args, **kwargs)

            self.AddCallback(callback)

    def _AddCallback(self, callback):

        if self.head is None:

            self.head = self.tail = callback

        else:

            self.tail = self.tail.Chain(callback)

    def _GetNext(self):

        head = self.head

        if head:

            self.head = head.Next()

        return head

    def AddCallback(self, callback, errorback = None, threaded = False):

        if errorback == None:

            errorback = self.DefaultErrorback

        cb = _Callback(callback, errorback, threaded)

        self._AddCallback(cb)

        # permit chained calls

        return self

    def AddThreadedCallback(self, callback, errorback = None):

        return self.AddCallback(callback, errorback, True)

    def ChainTask(self, task):

        self.tail.Chain(task.head)

        self.tail = task.tail

    def GrabResult(self, data = None):

        if data is None:

            data = {}

        def SetResult(result):

            data["result"] = result

            return result

        def SetError(error):

            data["error"] = error

        self.AddCallback(SetResult, SetError)

        return data

    def SetupEvent(self, event = None, data = None):

        if not event:

            event = threading.Event()

        def SetEvent(dummy):

            event.set()

        self.AddCallback(SetEvent, SetEvent)

        return event

##

# Helper class

class ThreadedTask(Task):

    def __init__(self, func, *args, **kwargs):

        super(ThreadedTask, self).__init__(func, *args, **kwargs)

        self.head.threaded = True