import random

from collections import MutableMapping

from twisted.python import threadable

from .schema import Job as DBJob

from .dbdefer import dbdefer

from iro.error import JobNotFound

class Status:

    '''status for one recipient'''

    todo = 1

    good = 2

    error = 3

    def __init__(self, job):

        self.status = Status.todo

        self.job = job

        self.offer = None           #the offer over that this job was done

        self.errtext = None         #the error text

class Job:

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

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

        self.dbjob = None       #Connection to mysql job element

        self.message = message

        self.recipients = recipients

        self.offers = offers

        self.info = info

        self.tasks={}

        self.user = user

    def setStatus(task,status):

        pass

    def setError(task,err):

        pass

    @dbdefer

    def registerJob(self, session, id):

        self.id = id

        u = session.merge(self.user)

        self.dbjob=DBJob(hash=self.id, info=self.info, status="started")

        u.jobs.append(self.dbjob)

        session.commit()

    @classmethod

    @dbdefer

    def fromDB(cls, session, id):

        j = session.query(DBJob).filter_by(hash=id).first()

        if not j:

            raise JobNotFound

        job = cls(j.user, [], None, None, j.info)

        job.dbjob = j

        job.id = j.hash

        return job

class Jobs(dict, MutableMapping):

    synchronized = ['getNewId']

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

        job = Job(user, recipients, message, offers, info)

        job.registerJob(id = self.getNewId())

        self[job.id] = job

        return job

    @dbdefer

    def getNewId(self, session):

        while True:

            id = ''.join([random.choice('0123456789abcdef') for i in range(40)])

            if id not in self.keys():

                self[id]=None

                if not session.query(DBJob.hash).filter_by(hash=id).first():

                    return id

    def __getitem__(self, key):

        try:

            return dict.__getitem__(self, key)

        except KeyError as e:

            pass

        try:

            self[key]=Job.fromDB(key)

            return self[key]

        except JobNotFound:

            raise e

threadable.synchronize(Jobs)

jobs = Jobs()