import gevent
import logging as log
import time

import uuid
from random import randint

from gevent import queue, pool, monkey, sleep
from functools import wraps

def with_timeout(timeout, exception=False):
    '''Timeout decorator
    Maybe usefull for functions that are unable to watch it's timeout
    by themselves.
    ``timeout`` - seconds
    ``exception``- if set to None, gevent.Timeout will be raisen.
    False value will suppress any exception and other values will be
    raised as exception.
    Usage:

    @with_timeout(5) # 5 seconds timeout set
    def foo_handler(task, queue, bar):
        pass
    '''
    def factory(fn):
        @wraps(fn)
        def decorator(*args):
            with gevent.Timeout(timeout, exception):
                return fn(*args)
        return decorator
    return factory

class ProcessingError(Exception):
    pass
class HandlerError(ProcessingError):
    pass
class HandlerTimeout(HandlerError):
    pass

class BaseProcessing(object):
    '''Abstract processing class designed for conrete tasks support
    You can subclass this class, build your own logic and then simply
    call to instance.dispatch(tasks) in order to process your tasks asynchronously
    '''

    def __init__(self, max_workers=1, handlers=None, log_file='runtime.txt', \
                 apply_patch=True):
        '''Setup processor:
        ``handlers`` - dictionary of custom task handlers, this handlers
        has higher priority than thoose defined in class object itself.
        Key of dictionary element maps to task name
        ``max_workers`` - how much asynchronicity you need?
        ``log_file`` - enable process log, usefull for debug, None value
        disables logging functionality
        '''

        self.handlers = handlers
        if handlers is None:
            self.handlers = {}

        self.max_workers = max_workers
        self.pool = pool.Pool(self.max_workers)
        self.queue = queue.PriorityQueue()
        self.log = None
        if log_file is not None:
            self.log = log
            self.log.basicConfig(filename=log_file, level=log.DEBUG)
        if apply_patch:
            monkey.patch_all()
        self.start_time = 0
        self.end_time = 0
        self.finished = False

    def debug(self, message):
        '''Saves message to logfile if enabled'''
        if self.log:
            self.log.debug(message)

    def get_stats(self):
        '''Current status of jobs'''
        if self.finished:
            return "Jobs done in {:.3}s".format(self.end_time - self.start_time)
        return "Jobs are not finished yet"

    def dispatch(self, tasks):
        '''Run defined asynchronous tasks in an endless loop
        ``tasks`` iterator object of tasks.
        Single task typically looks like (priority, task, ...)
        '''
        self.start_time = time.time()
        for _task in tasks:
            self.queue.put(_task)
        while True:
            while self.pool.free_count():
                try:
                    task = self.queue.get_nowait()
                except queue.Empty:
                    break
#                self.debug("Got taks from queue: {}".format(task[:3]))
                handler = getattr(self, task[1], None)
                if task[1] in self.handlers:
                    handler = self.handlers[task[1]]
                if handler is None:
                    raise HandlerError, \
                    "Required handler for task {} not defined".format(task[1])
                # pass pool to task, could be used for adding tasks dynamically
                self.pool.spawn(handler, self.pool, *(task[2:]))
#                self.debug("Started task: {}".format(task[1]))
            if self.pool.free_count() == self.max_workers:
                self.end_time = time.time()
                self.finished = True
                break
            sleep(1)

class RssProcessing(BaseProcessing):
    def __init__(self, **kwargs):
        super(RssProcessing, self).__init__(**kwargs)

    @with_timeout(1.5)
    def image_handler(self, pool, *task):
        self.debug('image_handler on {} started'.format(task[0]))
        sleep(randint(0, 5))
        self.debug('image_handler on {} completed'.format(task[0]))

    @with_timeout(3)
    def document_handler(self, pool, *task):
        self.debug('document_handler on {} started'.format(task[0]))
        for i in range(randint(0, 50)):
            self.queue.put((0, 'image_handler', uuid.uuid4()))
        sleep(randint(0, 4))
        self.debug('document_handler {} completed'.format(task[0]))

    @with_timeout(3.5)
    def feed_handler(self, pool, *task):
        self.debug('feed_handler on {} started'.format(task[0]))
        for i in range(randint(1, 10)):
            self.queue.put((1, 'document_handler', uuid.uuid4()))
        sleep(randint(0, 3))
        self.debug('feed_handler {} completed'.format(task[0]))

if __name__ == '__main__':

#    def foo(pool, *task):
#        sleep(randint(1,3))
#        processing.debug("Task {} finished".format(task[0]))
#        print task, pool
    tasks = [(2, 'feed_handler', uuid.uuid4()) for i in xrange(100)]
#    handlers = {
#        'foo': foo,
#    }
    processing = RssProcessing(max_workers=500)
    processing.dispatch(tasks)
    print processing.get_stats()