import logging
import threading
import os

try:
    from logging.handlers import QueueHandler, QueueListener
except:  # pragma: no cover
    from stackify.handler_backport import QueueHandler, QueueListener

try:
    import Queue as queue
except ImportError:  # pragma: no cover
    import queue

from stackify import QUEUE_SIZE, API_URL, MAX_BATCH
from stackify.log import LogMsg, LogMsgGroup
from stackify.error import ErrorItem
from stackify.http import HTTPClient
from stackify.application import get_configuration


class StackifyHandler(QueueHandler):
    '''
    A handler class to format and queue log messages for later
    transmission to Stackify servers.
    '''

    def __init__(self, queue_=None, listener=None, **kwargs):
        if queue_ is None:
            queue_ = queue.Queue(QUEUE_SIZE)
        logger = logging.getLogger(__name__)

        super(StackifyHandler, self).__init__(queue_)

        if listener is None:
            listener = StackifyListener(queue_, **kwargs)

        self.listener = listener

    def enqueue(self, record):
        '''
        Put a new record on the queue. If it's full, evict an item.
        '''
        try:
            self.queue.put_nowait(record)
        except queue.Full:
            logger = logging.getLogger(__name__)
            logger.warn('StackifyHandler queue is full, '
                        'evicting oldest record')
            self.queue.get_nowait()
            self.queue.put_nowait(record)


class StackifyListener(QueueListener):
    '''
    A listener to read queued log messages and send them to Stackify.
    '''

    def __init__(self, queue_, max_batch=MAX_BATCH, config=None, **kwargs):
        super(StackifyListener, self).__init__(queue_)

        if config is None:
            config = get_configuration(**kwargs)

        self.max_batch = max_batch
        self.messages = []
        self.http = HTTPClient(config)

    def handle(self, record):
        if not self.http.identified:
            logger = logging.getLogger(__name__)
            logger.debug('Identifying application')
            self.http.identify_application()

        msg = LogMsg()
        msg.from_record(record)
        self.messages.append(msg)

        if len(self.messages) >= self.max_batch:
            self.send_group()

    def send_group(self):
        group = LogMsgGroup(self.messages)
        try:
            self.http.send_log_group(group)
        except:
            logger = logging.getLogger(__name__)
            logger.exception('Could not send %s log messages, discarding',
                             len(self.messages))
        del self.messages[:]

    def stop(self):
        logger = logging.getLogger(__name__)
        logger.debug('Shutting down listener')
        super(StackifyListener, self).stop()

        # send any remaining messages
        if self.messages:
            logger.debug('%s messages left on shutdown, uploading',
                         len(self.messages))
            self.send_group()