#!/usr/bin/env python

import string, random, sys, os, re, imp
cp = imp.find_module('cPickle')
cPickle = imp.load_module('cPickle', cp[0], cp[1], cp[2])

MAXGEN=1000 # Max number of words to generate
NONWORD = '\n' # Use as start- and endmarkers
SAVECOUNT = 30

def register_handler(self, eventtype, handlerfunc, priority=0):
        """ handler modules call this to register to recieve events """
        if not self.event_dict.has_key(eventtype):
            self.event_dict[eventtype] = []
        self.event_dict[eventtype].append((priority, handlerfunc))


class MarkovChainer:
    def __init__(self, bot):
        self.bot = bot
        self.dict = cPickle.load(open("markov.state", 'r'))
        self.savecounter = 0

    def handle_pubmsg(self, origin, match, args):
        spoken = 0
        addressed = 0
        chainable = 1
        whonick = origin.nick
        message = event.arguments()[0]
        target = event.target()
        if re.search(string.lower(self.nick),
                     string.lower(message)):
            addressed = 1

        if message == "%s, status?" % self.nick:
            reply = (target, "I know %s phrases" %
                               str(len(self.dict.keys())))
            return

        message = self.strip_nick(message)
        message = self.strip_shit(message)

        if chainable:
            self.input(message)

        if not spoken:
            splitmsg = string.split(message, ' ')
            try:
                text = string.strip(self.output(splitmsg[0], splitmsg[1]))
            except:
                text = string.strip(self.output())

        if addressed:
            connection.privmsg(target, text)

    def strip_nick(self, message):
        return string.replace(string.strip(message),
                              self.nick, '')

    def strip_shit(self, message):
        index = 0 
        for char in string.lower(message):
            if char in [',']:
                index = index + 1
            else:
                break
        return string.strip(message[index:])

        
    def input(self, originalText):
        word1, word2 = NONWORD, NONWORD
        wordList = string.split(originalText)
        for word3 in wordList: # Loop over rest of words
            if not self.dict.has_key( (word1,word2) ):
                self.dict[(word1,word2)] = [] #initialize to empty list
            self.dict[(word1, word2)].append(word3) # Add suffix for word-pair
            word1,word2 = word2, word3 # Shift in new words as dictionary keys
        self.dict[(word1,word2)] = [NONWORD] # Mark end of text
        self.savecounter = self.savecounter + 1        
        if self.savecounter >= SAVECOUNT:
            self.dumpdb()
            self.savecounter = 0
            
    def dumpdb(self):
        try:
            os.rename("markov.state.2", "markov.state.3")
        except:
            pass
        try:
            os.rename("markov.state.1", "markov.state.2")
        except:
            pass
        try:
            os.rename("markov.state", "markov.state.1")
        except:
            pass
        cPickle.dump(self.dict, open("markov.state", "w"))

    def output(self, word1=NONWORD, word2=NONWORD):
        #word1,word2 = NONWORD, NONWORD # Start at beginning
        output = word1 + " " + word2
        for i in range(MAXGEN):
            successorList = self.dict[(word1,word2)]
            word3 = random.choice(successorList)
            if word3 == NONWORD:
                break
            output = output + " "  + word3
            word1, word2 = word2, word3

        return output