#!/usr/bin/env python

"""
    Syslog -> Irk
"""

__version__ = '0.0'

import pvl.args
import pvl.syslog.args
import pvl.syslog.rule
import pvl.irk

import logging, optparse

log = logging.getLogger('main')

def parse_options (argv) :
    """
        Parse command-line arguments.
    """

    prog = argv[0]

    parser = optparse.OptionParser(
            prog        = prog,
            usage       = '%prog: [options]',
            version     = __version__,

            # module docstring
            description = __doc__,
    )
    
    # options
    parser.add_option_group(pvl.args.parser(parser))

    # input
    parser.add_option_group(pvl.syslog.args.parser(parser))
    parser.add_option_group(pvl.syslog.rule.parser(parser))
    parser.add_option_group(pvl.irk.parser(parser, connect=None))

    parser.add_option('--irker-target', metavar='IRC',
            help="Irker target URL")

    # parse
    options, args = parser.parse_args(argv[1:])
    
    # apply
    pvl.args.apply(options, prog, rootok=False)

    return options, args

def apply_irker (irker) :
    """
        Handle irker activity.
    """

    for msg in irker.irk :
        log.info("irk: %s", msg)
 
def apply_syslog (options, syslog, rules, irker) :
    """
        Handle syslog activity.
    """

    # syslogs
    for item in syslog :
        match, rulepath, apply = rules.apply(item)
        
        log.debug("%s: %s: %s", item, rulepath, apply)
        
        target = apply.get('irk', options.irker_target)
        
        tag = '/'.join(str(rule) for rule in reversed(rulepath[:-1]))
        text = apply.get('text')
        
        log.info("%s: %s: %s", target, tag, text)

        if not text :
            # XXX: plain irk = ... in rule is broken, as it always applies, and skips any further rules
            continue
        
        if irker and target :
            irker[target]('[' + tag + '] ' + text)
        else :
            print tag, text

def main (argv) :
    options, args = parse_options(argv)
    
    # no args
    if args :
        log.error("Usage: pvl.irker-syslog [options]")
        return 2
    
    # setup
    log.info("Open syslog...")
    syslog = pvl.syslog.args.apply(options)
    
    log.info("Load rules...")
    rules = pvl.syslog.rule.apply(options)

    log.info("Connect IRK..")
    irker = pvl.irk.apply(options)
    
    if options.irker_target :
        # pre-join target
        irker[options.irker_target]

    log.info("Process syslog messages...")

    # customized mainloop that supports irker.irk
    while True :
        try :
            apply_syslog(options, syslog, rules, irker)

        except EOFError as ex :
            log.error("syslog: EOF")
            return 1

        # quit unless we have something to poll
        if not syslog.poll :
            break

        # is irk pollable?
        if irker.irk.recv :
            reading = (irker.irk, )
        else :
            reading = ()
        
        poll = syslog.select(syslog.poll, reading=reading) or () # timeout -> ()
        
        if irker.irk in poll :
            # irks?
            try :
                apply_irker(irker)

            except EOFError :
                # exit
                log.error("irk: EOF")
                return 1
     
    # done
    log.info("Exiting...")
    return 0

if __name__ == '__main__':
    import sys

    sys.exit(main(sys.argv))