from twisted.python import log, threadable

from datetime import datetime

from collections import MutableMapping

import schema

import offer

from .dbdefer import dbdefer

class ExJob:

    ''' A ExJob object represents a message to multiple recipients over multiple offers to send.  

    One single message to one recipient is handeld in :class:`iro.controller.task.Task`.

    This class holds connections to all tasks.

    This class is responsiple to update the status in database of one job and updating the bill.

    '''

    synchronized = ["incStatus", "_status"]

    def __init__(self, dbjob, recipients, message, offers):

        """Constructor of ExJob.

        :param dbjob: primary key of the job element in database

        :param list recipients: list of all recipients

        :param `iro.model.message.Message` message: message to send

        :param list offers: list of all possible offers to send message over

        """

        self.dbjob = dbjob       #Connection to database job element (id)

        self.message = message

        self.recipients = recipients

        self.offers = offers

        self.tasks={}

        self.c = 0

        self.status = "started"

        log.msg("Job(%s) created."%(self.dbjob))

    def addTask(self,task):

        """adding a task to tasks dict - key is the recipient.

        :param `iro.controller.task.Task` task: a task

        """

        self.tasks[task.recipient] = task

    def incStatus(self):

        """increments the processed messages (function is threadsafe)."""

        self.c += 1

        return self.c

    def _status(self, session, status):

        """updates the status of the database object (function is threadsafe).

        :param session: a valid database session

        :param string status: new status

        """

        job = schema.Job.get(session, self.dbjob)

        if self.status == "error":

            return

        elif self.status == "sended" and status != "error":

            return

        job.status = status

        self.status = status

        log.msg("Job(%s) status changed to: %s."%(self.dbjob, status))

        session.commit()

    @dbdefer

    def setStatus(self, session, task, status):

        """callback of one task.

        This function  updates the database object and the bill.

        """

        c = self.incStatus()

        job = schema.Job.get(session, self.dbjob)

        if c == len(self.recipients):

            self._status(session,"sended") 

        elif job.status in ["started","init"]:

            self._status(session,"sending")

        if status.costs > 0:

            o = schema.Offer.get(session, status.provider.name, status.route, self.message.typ)

            job.messages.append(schema.Message(price=status.costs, isBilled=False, recipient=str(task.recipient), count=status.count, exID=status.exID, date=datetime.today(), offer=o))

        session.commit()

        log.msg("Job(%s) to '%s' ended sucecessfully via %s:%s."%(self.dbjob, task.recipient, status.provider.name,status.route))

    @dbdefer

    def setError(self, session, task, err):

        """errback for one task.

        This function updates the database object.

        """

        self.incStatus()

        if self.status != "error":

            self._status(session,"error")

        log.err(_why="Error: Job(%s) to '%s' failed."%(self.dbjob, task.recipient),_stuff=err)

threadable.synchronize(ExJob)

class ExJobs(dict, MutableMapping):

    """ a dict to handle all jobs.

    """

    @dbdefer

    def create(self, session, user, recipients, message, offers, info=None):

        """creates on new Job.

        :param session: a valid session ( created by decorator :func:`iro.model.dbdefer.dbdefer`)

        :param `iro.model.schema.User` user: a user object

        :param list recipients: list of all recipients

        :param `iro.model.message.Message` message: message to send

        :param list offers: a list of offers ( list will be reduced to the allowed offers for the **user** -- using :func:`iro.model.offer.extendProvider`)

        :returns: the new job

        """

        user = session.merge(user)

        job = schema.Job(info=info, status="started")

        user.jobs.append(job)

        session.commit()

        o = offer.extendProvider(user, message.typ, offers, session=session)

        self[job.id] = ExJob(job.id, recipients, message, o)

        return self[job.id]

exJobs = ExJobs()

"""the dict of all available jobs."""