#! /usr/bin/env python3

import asynchat
import asyncore
import socket
import sys
import traceback
import time

class IRCHandler(asynchat.async_chat):
    """IRC Server connection.

    This is the one you want to derive your connection classes from.

    """

    debug = False
    heartbeat_interval = 1              # seconds per heartbeat

    def __init__(self, host=None, nick=None, gecos=None):
        asynchat.async_chat.__init__(self)
        self.line = b''
        self.timers = []
        self.last_heartbeat = 0
        self.set_terminator(b'\r\n')
        if host:
            self.open_connection(host, nick, gecos)

    def dbg(self, msg):
        if self.debug:
            print(msg)

    def open_connection(self, host, nick, gecos):
        self.nick = nick
        self.gecos = gecos
        self.host = host
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect(host)

    def handle_connect(self):
        self.write(['NICK', self.nick])
        self.write(['USER', self.nick, '+iw', self.nick], self.gecos)

    def connect(self, host):
        self.waiting = False
        asynchat.async_chat.connect(self, host)

    def heartbeat(self):
        """Invoke all timers."""

        if not self.timers:
            return
        timers, self.timers = self.timers, []
        now = time.time()
        for t, cb in timers:
            if t > now:
                self.timers.append((t, cb))
            else:
                cb()

    def add_timer(self, secs, callback):
        """After secs seconds, call callback"""
        self.timers.append((time.time() + secs, callback))

    def readable(self):
        """Called by asynchat to see if we're readable.

        We hook our heartbeat in here.
        """

        now = time.time()
        if now > self.last_heartbeat + self.heartbeat_interval:
            self.heartbeat()
            self.last_heartbeat = now

        if self.connected:
            return asynchat.async_chat.readable(self)
        else:
            return False

    def collect_incoming_data(self, data):
        """Called by asynchat when data arrives"""
        self.line += data

    def found_terminator(self):
        """Called by asynchat when it finds the terminating character.
        """
        line = self.line.decode('utf-8')
        self.line = b''
        self.parse_line(line)

    def write(self, args, text=None):
        """Send out an IRC command

        This function helps to prevent you from shooting yourself in the
        foot, by forcing you to send commands that are in a valid format
        (although it doesn't check the validity of the actual commands).

        As we all know, IRC commands take the form

          :COMMAND ARG1 ARG2 ARG3 ... :text string

        where 'text string' is optional.  Well, that's exactly how this
        function works.  Args is a list of length at least one, and text
        string is a string.

          write(['PRIVMSG', nick], 'Hello 12')

        will send

          PRIVMSG nick :Hello 12

        """

        cmdstr = ' '.join(args)
        if text:
            cmdstr = '%s :%s' % (cmdstr, text)
        self.dbg('-> %s' % cmdstr)
        try:
            line = '%s\n' % cmdstr
            self.send(line.encode('utf-8'))
        except socket.error:
            pass


    def parse_line(self, line):
        """Parse a server-provided line

        This does all the magic of parsing those ill-formatted IRC
        messages.  It will also decide if a PRIVMSG or NOTICE is using
        CTCP (the client-to-client protocol, which by convention is any
        of the above messages with ^A on both ends of the text.

        This function goes on to invoke self.eval_triggers on the parsed
        data like this:

          self.eval_triggers(operation, arguments, text)

        where operation and text are strings, and arguments is a list.

        It returns the same tuple (op, args, text).

        """

        if (line[0] == ':'):
            with_uname = 1
            line = line [1:]
        else:
            with_uname = 0
        try:
            [args, text] = line.split(' :', 1)
            args = args.split()
        except ValueError:
            args = line.split()
            text = ''
        if (with_uname != 1):
            op = args[0]
        elif ((args[1] in ["PRIVMSG", "NOTICE"]) and
              (text and (text[0] == '\001') and (text[-1] == '\001'))):
            op = "C" + args[1]
            text = text[1:-1]
        else:
            op = args[1]
        self.dbg("<- %s %s %s" % (op, args, text))
        self.handle(op, args, text)
        return (op, args, text)


    def handle(self, op, args, text):
        """Take action on a server message

        Right now, just invokes

          self.do_[op](args, text)

        where [op] is the operation passed in.

        This is a good method to overload if you want a really advanced
        client supporting bindings.

        """
        try:
            method = getattr(self, "do_" + lower(op))
        except AttributeError:
            self.dbg("Unhandled: %s" % (op, args, text))
            return
        method(args, text)


class Recipient:
    """Abstract recipient object"""

    def __init__(self, interface, name):
        self._interface = interface
        self._name = name

    def __repr__(self):
        return 'Recipient(%s)' % self.name()

    def name(self):
        return self._name

    def is_channel(self):
        return False

    def write(self, cmd, addl):
        """Write a raw IRC command to our interface"""

        self._interface.write(cmd, addl)

    def cmd(self, cmd, text):
        """Send a command to ourself"""

        self.write([cmd, self._name], text)

    def msg(self, text):
        """Tell the recipient something"""

        self.cmd("PRIVMSG", text)

    def notice(self, text):
        """Send a notice to the recipient"""

        self.cmd("NOTICE", text)

    def ctcp(self, command, text):
        """Send a CTCP command to the recipient"""

        return self.msg("\001%s %s\001" % (command.upper(), text))

    def act(self, text):
        """Send an action to the recipient"""

        return self.ctcp("ACTION", text)

    def cnotice(self, command, text):
        """Send a CTCP notice to the recipient"""

        return self.notice("\001%s %s\001" % (command.upper(), text))

class Channel(Recipient):
    def __repr__(self):
        return 'Channel(%s)' % self.name()

    def is_channel(self):
        return True

class User(Recipient):
    def __init__(self, interface, name, user, host, op=False):
        Recipient.__init__(self, interface, name)
        self.user = user
        self.host = host
        self.op = op

    def __repr__(self):
        return 'User(%s, %s, %s)' % (self.name(), self.user, self.host)

def recipient(interface, name):
    if name[0] in ['&', '#', '+']:
        return Channel(interface, name)
    else:
        return User(interface, name, None, None)

class SmartIRCHandler(IRCHandler):
    """This is like the IRCHandler, except it creates Recipient objects
    for IRC messages.  The intent is to make it easier to write stuff
    without knowledge of the IRC protocol.

    """

    def recipient(self, name):
        return recipient(self, name)

    def err(self, exception):
        if self.debug:
            traceback.print_exception(*exception)

    def handle(self, op, args, text):
        """Parse more, creating objects and stuff

        makes a call to self.handle_op(sender, forum, addl)

        sender is always a Recipient object; if you want to reply
        privately, you can send your reply to sender.

        forum is a Recipient object corresponding with the forum over
        which the message was carried.  For user-to-user PRIVMSG and
        NOTICE commands, this is the same as sender.  For those same
        commands sent to a channel, it is the channel.  Thus, you can
        always send a reply to forum, and it will be sent back in an
        appropriate manner (ie. the way you expect).

        addl is a tuple, containing additional information which might
        be relelvant.  Here's what it will contain, based on the server
        operation:

          op       | addl
          ---------+----------------
          PRIVMSG  | text of the message
          NOTICE   | text of the notice
          CPRIVMSG | CTCP command,  text of the command
          CNOTICE  | CTCP response, text of the response
          KICK *   | victim of kick, kick text
          MODE *   | all mode args
          JOIN *   | empty
          PART *   | empty
          QUIT     | quit message
          PING     | ping text
          NICK !   | old nickname
          others   | all arguments; text is last element

        * The forum in these items is the channel to which the action
          pertains.
        ! The sender for the NICK command is the *new* nickname.  This
          is so you can send messages to the sender object and they'll
          go to the right place.
        """

        try:
            sender = User(self, *unpack_nuhost(args))
        except ValueError:
            sender = None
        forum = None
        addl = ()

        if op in ("PRIVMSG", "NOTICE"):
            # PRIVMSG ['neale!~user@127.0.0.1', 'PRIVMSG', '#hydra'] firebot, foo
            # PRIVMSG ['neale!~user@127.0.0.1', 'PRIVMSG', 'firebot'] firebot, foo
            try:
                if args[2][0] in '#&':
                    forum = self.recipient(args[2])
                else:
                    forum = sender
                addl = (text,)
            except IndexError:
                addl = (text, args[1])
        elif op in ("CPRIVMSG", "CNOTICE"):
            forum = self.recipient(args[2])
            splits = text.split(" ")
            if splits[0] == "DCC":
                op = "DC" + op
                addl = (splits[1],) + tuple(splits[2:])
            else:
                addl = (splits[0],) + tuple(splits[1:])
        elif op in ("KICK",):
            forum = self.recipient(args[2])
            addl = (self.recipient(args[3]), text)
        elif op in ("MODE",):
            forum = self.recipient(args[2])
            addl = args[3:]
        elif op in ("JOIN", "PART"):
            try:
                forum = self.recipient(args[2])
            except IndexError:
                forum = self.recipient(text)
        elif op in ("QUIT",):
            addl = (text,)
        elif op in ("PING", "PONG"):
            # PING ['PING'] us.boogernet.org.
            # PONG ['irc.foonet.com', 'PONG', 'irc.foonet.com'] 1114199424
            addl = (text,)
        elif op in ("NICK",):
            # NICK ['brad!~brad@10.168.2.33', 'NICK'] bradaway
            #
            # The sender is the new nickname here, in case you want to
            # send something to the sender.

            # Apparently there are two different standards for this
            # command.
            if text:
                sender = self.recipient(text)
            else:
                sender = self.recipient(args[2])
            addl = (unpack_nuhost(args)[0],)
        elif op in ("INVITE",):
            # INVITE [u'pflarr!~pflarr@www.clanspum.net', u'INVITE', u'gallium', u'#mysterious']
            # INVITE [u'pflarr!~pflarr@www.clanspum.net', u'INVITE', u'gallium'] #mysterious
            if len(args) > 3:
                forum = self.recipient(args[3])
            else:
                forum = self.recipient(text)
        else:
            try:
                int(op)
            except ValueError:
                self.dbg("WARNING: unknown server code: %s" % op)
            addl = tuple(args[2:]) + (text,)

        try:
            self.handle_cooked(op, sender, forum, addl)
        except SystemExit:
            raise
        except:
            self.err(sys.exc_info())

    def handle_cooked(self, op, sender, forum, addl):
        try:
            func = getattr(self, 'cmd_' + op.upper())
        except AttributeError:
            self.unhandled(op, sender, forum, addl)
            return
        func(sender, forum, addl)

    def cmd_PING(self, sender, forum, addl):
        self.write(['PONG'], addl[0])

    def unhandled(self, op, sender, forum, addl):
        """Handle all the stuff that had no handler.

        This is a special handler in that it also gets the server code
        as the first argument.

        """

        self.dbg("unhandled: %s" % ((op, sender, forum, addl),))


class Bot(SmartIRCHandler):
    """A simple bot.

    This automatically joins the channels you pass to the constructor,
    tries to use one of the nicks provided, and reconnects if it gets
    booted.  You can use this as a base for more sophisticated bots.

    """

    def __init__(self, host, nicks, gecos, channels):
        self.nicks = nicks
        self.channels = channels
        self.waiting = True
        self._spool = []
        SmartIRCHandler.__init__(self, host, nicks[0], gecos)

    def despool(self, target, lines):
        """Slowly despool a bunch of lines to a target

        Since the IRC server will block all output if we send it too
        fast, use this to send large multi-line responses.

        """

        self._spool.append((target, list(lines)))

    def heartbeat(self):
        SmartIRCHandler.heartbeat(self)

        # Despool data
        if self._spool:
            # Take the first one on the queue, and put it on the end
            which = self._spool[0]
            del self._spool[0]
            self._spool.append(which)

            # Despool a line
            target, lines = which
            if lines:
                line = lines[0]
                target.msg(line)
                del lines[0]
            else:
                self._spool.remove(which)

    def announce(self, text):
        for c in self.channels:
            self.write(['PRIVMSG', c], text)

    def err(self, exception):
        SmartIRCHandler.err(self, exception)
        self.announce('*bzert*')

    def cmd_001(self, sender, forum, addl):
        # Welcome to IRC
        self.nick = addl[0]
        for c in self.channels:
            self.write(['JOIN'], c)

    def cmd_433(self, sender, forum, addl):
        # Nickname already in use
        self.nicks.append(self.nicks.pop(0))
        self.write(['NICK', self.nicks[0]])

    def cmd_NICK(self, sender, forum, addl):
        if addl[0] == self.nick:
            self.nick = sender.name()
            print(self.nick)

    def writable(self):
        if not self.waiting:
            return asynchat.async_chat.writable(self)
        else:
            return False

    def write(self, *args):
        SmartIRCHandler.write(self, *args)

    def close(self, final=False):
        SmartIRCHandler.close(self)
        if not final:
            self.dbg("Connection closed, reconnecting...")
            self.waiting = True
            self.connected = 0
            # Wait a bit and reconnect
            self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
            self.add_timer(23, lambda : self.connect(self.host))

    def handle_close(self):
        self.close()


##
## Miscellaneous IRC functions
##

def unpack_nuhost(nuhost):
    """Unpack nick!user@host

    Frequently, the first argument in a server message is in
    nick!user@host format.  You can just pass your whole argument list
    to this function and get back a tuple containing:

      (nick, user, host)

    """

    try:
        [nick, uhost] = nuhost[0].split('!', 1)
        [user, host] = uhost.split('@', 1)
    except ValueError:
        raise ValueError("not in nick!user@host format")
    return (nick, user, host)

def run_forever(timeout=2.0):
    """Run your clients forever.

    Just a handy front-end to asyncore.loop, so you don't have to import
    asyncore yourself.

    """

    asyncore.loop(timeout)