"""
    Format LogLines into some other representation
"""

# for escape
import cgi

from log_line import LogTypes

class LogFormatter (object) :
    """
        Provides a method to format series of LogLines into various output formats, with varying themes
    """

    # the formatter's code name
    name = None
    
    def __init__ (self, tz, timestamp_fmt="%H:%M:%S") :
        """
            Initialize to format timestamps with the given timezone and timestamp
        """

        self.tz = tz
        self.timestamp_fmt = timestamp_fmt
    
    def _format_line_text (self, line, template_dict) :
        """
            Format the given line as text, using the given { type: string template } dict
        """
        
        # look up the template
        template = template_dict[line.type]

        # build timestamp
        timestamp = line.timestamp.astimezone(self.tz).strftime(self.timestamp_fmt)
        
        # format with dict
        return template % dict(
            timestamp       = timestamp,
            source          = line.source,
            data            = line.data,
        )
    
    def format_txt (self, lines) :
        """
            Format as plaintext
        """

        abstract

    def format_html (self, lines) :
        """
            Format as HTML
        """

        abstract

class IrssiTextFormatter (LogFormatter) :
    """
        Implements format_txt for irssi-style output
    """

    # format definitions by type
    __FMT = {
        LogTypes.RAW        : "%(timestamp)s %(data)s",
    }

    def format_txt (self, lines) :
        # ...handle each line
        for line in lines :
            # using __TYPES
            yield self._format_line_text(line, self.__FMT)

class IrssiFormatter (IrssiTextFormatter) :
    """
        Implements plain black-and-white irssi-style formatting
    """

    name = 'irssi'
    title = "Irssi (plain)"

    def format_html (self, lines) :
        """
            Just uses format_txt, but wraps in <pre></pre>
        """
        
        # open pre
        yield "<pre>"
        
        # format using IrssiTextFormatter
        for line in self.format_txt(lines) :
            # escape HTML
            yield cgi.escape(line)

        # close pre
        yield "</pre>"

# define formatters by name
FORMATTERS = {
    'irssi':        IrssiFormatter,
}

def by_name (name) :
    """
        Lookup and return a class LogFormatter by name
    """

    return FORMATTERS[name]