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