import logging
from threading import Lock, Thread

from .cached_queue import CachedQueue


class Worker(Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.daemon = True
        self.quit = False

    def terminate(self):
        self.quit = True


class ThreadPool:
    """Simple implementation of a thread pool

    This is the base class of :class:`Feeder`, :class:`Parser` and
    :class:`Downloader`, it incorporates two FIFO queues and a number of
    "workers", namely threads. All threads share the two queues, after each
    thread starts, it will watch the ``in_queue``, once the queue is not empty,
    it will get a task from the queue and process as wanted, then it will put
    the output to ``out_queue``.

    Note:
        This class is not designed as a generic thread pool, but works
        specifically for crawler components.

    Attributes:
        name (str): thread pool name.
        thread_num (int): number of available threads.
        in_queue (Queue): input queue of tasks.
        out_queue (Queue): output queue of finished tasks.
        workers (list): a list of working threads.
        lock (Lock): thread lock.
        logger (Logger): standard python logger.
    """

    def __init__(self, thread_num, in_queue=None, out_queue=None, name=None):
        self.thread_num = thread_num
        self.in_queue = in_queue if in_queue else CachedQueue(5 * self.thread_num)
        self.out_queue = out_queue if out_queue else CachedQueue(5 * self.thread_num)
        self.name = name if name else __name__
        self.workers = []
        self.lock = Lock()
        self.logger = logging.getLogger(self.name)

    def init_workers(self, *args, **kwargs):
        self.workers = []
        for i in range(self.thread_num):
            worker = Worker(target=self.worker_exec, name=f"{self.name}-{i + 1:03d}", args=args, kwargs=kwargs)
            self.workers.append(worker)

    def start(self, *args, **kwargs):
        self.init_workers(*args, **kwargs)
        for worker in self.workers:
            self.logger.debug("thread %s started", worker.name)
            worker.start()

    def input(self, task, block=True, timeout=None):
        if self.in_queue is not None:
            self.in_queue.put(task, block, timeout)

    def output(self, task, block=True, timeout=None):
        if self.out_queue is not None:
            self.out_queue.put(task, block, timeout)

    def clear_buffer(self, clear_out=False):
        self.in_queue.queue.clear()
        if clear_out:
            self.out_queue.queue.clear()

    def worker_exec(self, *args, **kwargs):
        raise NotImplementedError

    def connect(self, component):
        """Connect two ThreadPools.

        The ``in_queue`` of the second pool will be set as the ``out_queue`` of
        the current pool, thus all the output will be input to the second pool.

        Args:
            component (ThreadPool): the ThreadPool to be connected.
        Returns:
            ThreadPool: the modified second ThreadPool.
        """
        if not isinstance(component, ThreadPool):
            raise TypeError('"component" must be a ThreadPool object')
        component.in_queue = self.out_queue
        return component

    def is_alive(self):
        for worker in self.workers:
            if worker.is_alive():
                return True
        return False

    def terminate(self):
        for worker in self.workers:
            worker.terminate()