from twisted.python import log

from twisted.python import threadable

from datetime import datetime

from collections import MutableMapping

import schema

import offer

from .dbdefer import dbdefer

class ExJob:

    '''One Job is a class that handles one job. One Job has multiple tasks.'''

    synchronized = ["incStatus", "_status"]

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

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

        self.message = message

        self.recipients = recipients

        self.offers = offers

        self.tasks={}

        self.c = 0

        self.status = "started"

    def addTask(self,task):

        self.tasks[task.recipient] = task

    def incStatus(self):

        self.c += 1

        return self.c

    def _status(self, session, 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

        session.commit()

    @dbdefer

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

        c = self.incStatus()

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

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

            self._status(session,"sending")

        if c == len(self.recipients):

            self._status(session,"sended") 

        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):

        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):

    @dbdefer

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

        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()