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