from functools import partial

from twisted.internet.defer import inlineCallbacks, returnValue, maybeDeferred, Deferred

from ..error import NoRouteForTask, RejectRecipient

from ..model.offer import offers

from ..model.job import exJobs

from .pool  import taskPool

class Task:

    '''one single part of a job.

    a task is one message to one recipient

    '''

    def __init__(self, recipient, job):

        self.recipient = recipient

        self.job = job

        self.status = None

        self.error = False

    def setStatus(self,status):

        self.status = status

        return status

    def setError(self, error):

        self.status = error

        self.error = True

        return error

    def start(self):

        self.d = Deferred()

        self.d.addCallback(self.setStatus)

        self.d.addCallback(partial(self.job.setStatus,self))

        self.d.addErrback(self.setError)

        self.d.addErrback(partial(self.job.setError,self))

        taskPool.run(self._run)

        return self.d

    def _run(self):

        os= iter(self.job.offers)

        def n():

            try:

                offer = os.next()

                d = maybeDeferred(offers[offer],self.recipient,self.job.message)

                d.addCallback(self.d.callback)

                d.addErrback(addErr)

                d.addErrback(self.d.errback)

                return d

            except StopIteration:

                self.d.errback(NoRouteForTask())

        def addErr(failure):

            failure.trap(RejectRecipient)

            return n()

        n()

@inlineCallbacks

def createJob(user,recipients, msg, offers, info=None):

    job = yield exJobs.create(user, recipients, msg, offers, info)

    for r in recipients:

        task = Task(r,job)

        job.addTask(task)

        task.start()

    returnValue(job)