import datetime, logging, smtplib, threading, time, Queue

class BufferingSMTPHandler(logging.Handler):
    """Set up a buffering SMTP logging handler."""
    
    # Configurable parameters
    _POLL_INTERVAL = 5       # Interval between checks for sets of new records.
    _POLL_DURATION_MAX = 10  # If a record is available, max time to continue 
    #                          polling for more records.
    _SEND_INTERVAL = 2 * 60  # Interval between sends.
    
    # Setup class environment
    _Q = Queue.Queue()
    _LOCK = threading.Lock()
    _LAST_SEND_TIME = float('-inf')
    
    def state(self):
        """Return a dict containing keys and values providing information about
        the state of the handler."""
        
        #time_now = time.time()
        time_now = datetime.datetime.utcnow()
        
        # Calculate time since last email
        if self._LAST_SEND_TIME != float('-inf'):
            time_of_last =  datetime.datetime.utcfromtimestamp(self._LAST_SEND_TIME)
            time_since_last = time_now - time_of_last
        else:
            time_since_last = '(none sent yet)'
            
        # Time to next earliest possible email
        if self._LAST_SEND_TIME != float('-inf'):
            time_of_next = datetime.datetime.utcfromtimestamp(self._LAST_SEND_TIME+self._SEND_INTERVAL)
            time_of_next = max(time_now, time_of_next)
            time_until_next = time_of_next - time_now
        else:
            time_until_next = time_now - time_now
        
        return {'Total number of unprocessed errors': self._Q.qsize() + self._q.qsize(),
                'Intervals': 'Poll: {}s, Send: {}s'.format(self._POLL_INTERVAL, self._SEND_INTERVAL),
                'Poll duration max': '{}s'.format(self._POLL_DURATION_MAX),
                'Time since last email': time_since_last,
                'Time to next earliest possible email': 'at least {}'.format(time_until_next),
                    # This simplification doesn't account for _POLL_INTERVAL and _POLL_DURATION_MAX, etc.
                'Recipients': self._header['toaddrs_str'],
                }
    
    def __init__(self, fromaddr, toaddrs, subject):
        
        # Setup instance environment
        self._active = True
        self._q = Queue.Queue()  # this is different from self._Q
        
        # Construct email header
        self._header = {'fromaddr': fromaddr,
                        'toaddrs': toaddrs,
                        'toaddrs_str': ','.join(toaddrs),
                        'subject': subject,
                        }
        self._header['header'] = 'From: {fromaddr}\r\nTo: {toaddrs_str}\r\nSubject: {subject}\r\n\r\n'.format(**self._header)
        
        # Start main buffer-processor thread
        thread_name = '{}Thread'.format(self.__class__.__name__)
        # Note: The class is intentionally not inherited from threading.Thread,
        #       as doing so was found to result in the target thread not being 
        #       named correctly, possibly due to a namespace collision.
        thread = threading.Thread(target=self.run, name=thread_name)
        thread.daemon = True
        thread.start()
        
        super(BufferingSMTPHandler, self).__init__()
    
    def close(self):
        """Process some remaining records."""
        
        super(BufferingSMTPHandler, self).close()
        
        self._active = False
        self._POLL_DURATION_MAX = min(0.25, self._POLL_DURATION_MAX)
            # no need to set self.__class__._POLL_DURATION_MAX
        self._process_recordset()
    
    def emit(self, record):
        """Queue a record into the class queue so it can be emitted 
        collectively."""
        
        # This method can be called by various threads.
        self._Q.put(self.format(record))

    def run(self):
        """Periodically flush the buffer."""
        
        while self._active:
            with self._LOCK: # protects _LAST_SEND_TIME and _q
                next_send_time = self._LAST_SEND_TIME + self._SEND_INTERVAL 
                if time.time() > next_send_time:
                    self._process_recordset()
                    sleep_time = self._POLL_INTERVAL
                else:
                    # assert (next_send_time != -inf)
                    sleep_time = max(next_send_time - time.time(), 0) 
            time.sleep(sleep_time)
                
    def _process_recordset(self):
        """Process a set of records buffered in class queue."""
        
        try:
            self._move_recordset_from_Q_to_q()
            if not self._q.empty():
                self._send_records_from_q()
                self.__class__._LAST_SEND_TIME = time.time()
        except (KeyboardInterrupt, SystemExit):
            pass
        
    def _move_recordset_from_Q_to_q(self):
        """Move a set of records from class queue to instance queue."""
        
        deadline = time.time() + self._POLL_DURATION_MAX
        while time.time() < deadline:
            try:
                self._q.put(self._Q.get_nowait())
                self._Q.task_done()
            except Queue.Empty:
                if self._q.empty():
                    break
                time.sleep(0.1)
    
    def _send_records_from_q(self):
        """Send records that are in instance queue."""
        
        records = []
        try:
            
            # Get formatted records from instance queue
            while True:
                records.append(self._q.get_nowait())
                self._q.task_done()
                
        except (Queue.Empty, KeyboardInterrupt, SystemExit):
            pass
        finally:
            
            # Send formatted records from instance queue
            if records:
                
                body =  'Included messages: {}\r\n'.format(len(records))
                
                num_pending_messages = self._Q.qsize() + self._q.qsize()
                if num_pending_messages > 0:
                    body += 'Pending messages:  {}\r\n'.format(num_pending_messages)
                
                # Add main content of message body
                body += '\r\n'
                body += '\r\n\r\n'.join(records)
                msg = self._header['header'] + body
                
                smtp = smtplib.SMTP()
                smtp.connect()
                smtp.sendmail(self._header['fromaddr'], self._header['toaddrs'], msg)
                smtp.quit()