from functools import partial

from twisted.python import log
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:
    '''A Task is one message to one recipient and is a part of one :class:`iro.model.job.ExJob`.
    '''
    def __init__(self, recipient, job):
        """
        :param recipient: a recipient
        :param `iro.model.job.ExJob` job: connected job
        """
        self.recipient = recipient
        self.job = job
        self.status = None
        self.error = False

    def setStatus(self,status):
        """callback, to set status of task"""
        self.status = status
        return status

    def setError(self, error):
        """errback to set error of task"""
        self.status = error
        self.error = True
        return error

    def start(self):
        """Starting to send message to recipient.

        :return: a defer, that is fired, when message is sended successfully over any offer.
        """
        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):
        """sends the message to recipient, tries all possible offers."""
        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,offer)
                d.addErrback(self.d.errback)
                return d
            except StopIteration:
                self.d.errback(NoRouteForTask())

        def addErr(failure, offer):
            if not isinstance(failure.value, RejectRecipient):  
                log.err(_why="Job(%s): Send to '%s' failed via '%s'"%(self.job.dbjob, self.recipient, offer),_stuff=failure)
            n()
        
        n()


@inlineCallbacks
def createJob(user,recipients, msg, offers, info=None):
    """Creates a :class:`iro.model.job.ExJob` and start for all recipients one task.
    
    :param `iro.model.schema.User` user: the sender 
    :param `iro.model.message.Message` msg: the message
    :param list offers: a list of possible offer and provider names, to try to send the message over. The first entry will be tried first.
    :param string info: a bill group name
    :return: the new :class:`iro.model.job.ExJob` object.
    """
    job = yield exJobs.create(user, recipients, msg, offers, info)
    for r in recipients:
        task = Task(r,job)
        job.addTask(task)
        task.start()
    returnValue(job)