#!/usr/bin/python

from twisted.internet import reactor, endpoints, defer
from twisted.python import usage, log

import urlparse

import pvl.irker.irk
import pvl.irker.irc

class Options (usage.Options) :
    optParameters = [
            [ 'irc-nickname', 'n',  pvl.irker.irc.IRCFactory.NICKNAME, "Default IRC nickname" ],
    ]

    def __init__ (self) :
        usage.Options.__init__(self)

        self.listen = []
        self.connect = []
        self.target = []
        self.privmsg = []

    def opt_listen_tcp (self, listen) :
        """
            Twisted endpoint.
        """

        self.listen.append((endpoints.TCP4ServerEndpoint, (int(listen), )))

    def opt_connect (self, connect) :
        """
            Connect to given target.
        """

        self.connect.append(urlparse.urlparse(connect))

    def opt_target (self, target) :
        """
            Join given target.
        """

        self.target.append(urlparse.urlparse(target))

    def opt_privmsg (self, privmsg) :
        """
            Send message to targets
        """

        self.privmsg.append(privmsg)

@defer.inlineCallbacks
def connect (irc, connect) :
    """
        Connect to given urls.
    """
            
    try :
        clients = yield defer.gatherResults([irc.client(url) for url in connect])

    except Exception as ex :
        log.err(ex)
        return

    for client in clients :
        log.msg('--connect', client)

@defer.inlineCallbacks
def target (irc, target, privmsg) :
    """
        Connect to given urls.
    """
            
    try :
        targets = yield defer.gatherResults([irc.target(url) for url in target])

    except Exception as ex :
        log.err(ex)
        return

    for target in targets :
        log.msg('--target', target)

        target.privmsg(*privmsg)

def main (args) :
    options = Options()
    options.parseOptions(args)

    # logging
    log.startLogging(sys.stderr, setStdout=False)

    # connect
    irc = pvl.irker.irc.IRCFactory()
    
    connect(irc, options.connect)
    target(irc, options.target, options.privmsg)

    # listen
    irk = pvl.irker.irk.IrkFactory(irc)

    for endpoint, args in options.listen :
        endpoint = endpoint(reactor, *args)

        log.msg("listen:", endpoint)

        endpoint.listen(irk)


    # go
    reactor.run()

    return 0

if __name__ == '__main__' :
    import sys
    sys.exit(main(sys.argv[1:]))