modular.py

import re
import threading
import time

from mcp.mcp_negotiate import Negotiate
from requests.structures import CaseInsensitiveDict


def stack(line: str) -> list[str]:
    assert '\n' not in line
    if line.startswith('#$#'):  # mcp
        return [line]

    out = []
    startmatch = 0
    for i in range(1, len(line) - 1):
        if line[i] == ';' and line[i - 1] != ';' and line[i + 1] != ';':
            out.append(line[startmatch:i].replace(';;', ';'))
            startmatch = i + 1
    out.append(line[startmatch:].replace(';;', ';'))
    return out


class TimerMixin(object):
    def __init__(self):
        self.previous_checkpoint = time.time()
        self.stopflag = threading.Event()
        self.timer_thread = threading.Thread(target=TimerMixin.timer_thread_fn, args=(self,))
        self.timer_thread.start()

    def timer_thread_fn(self):
        while not self.stopflag.is_set():
            now = time.time()
            delta = now - self.previous_checkpoint
            self.timeslice(delta)
            self.previous_checkpoint = now
            time.sleep(0.1)

    def timeslice(self, delta):
        def update(name, rem_time):
            timer = self.timers[name]
            self.timers[name] = (timer[0], timer[1], rem_time, timer[3])
            return rem_time

        # deep copy timers to permit editing timers inside timers (changes dict size)
        tmp_timers = {}
        for name, timer in self.timers.items():
            tmp_timers[name] = timer

        remove = []
        try:
            for name, timer in tmp_timers.items():
                oneshot, period, remaining, fn = timer
                remaining = update(name, remaining - delta)
                if remaining < 0:
                    if oneshot:
                        remove.append(name)
                    else:
                        update(name, period)
                    try:
                        fn(self)
                    except Exception as e:
                        self.log(e)
                        self.mud.logException(e)
        except RuntimeError as e:
            # RuntimeError: dictionary changed size during iteration
            self.log(e)
            self.mud.logException(e)

        for name in remove:
            del self.timers[name]

    @staticmethod
    def mktimer(period, fn, oneshot=False):
        return (oneshot, period, period, fn)

    @staticmethod
    def mktimernow(period, fn, oneshot=False):
        return (oneshot, period, 0, fn)

    @staticmethod
    def mkdelay(delay, fn):
        return (True, delay, delay, fn)

    def quit(self):
        self.stopflag.set()
        self.timer_thread.join()

    def setTimerRemaining(self, timer, remainingTime):
        self.timers[timer] = (self.timers[timer][0], self.timers[timer][1], remainingTime, self.timers[timer][3])


class ModularClient(TimerMixin):
    def __init__(self, mud, *args):
        # self.modules must be set up by child class
        self.mud = mud
        self.state = {}
        self.gmcp = CaseInsensitiveDict()
        self.mcp = [Negotiate(self)]
        self.aliases = {}
        self.triggers = {}
        self.oneTimeTriggers = {}
        self.timers = self.getTimers()
        TimerMixin.__init__(self)
        if not hasattr(self, 'modules'):
            self.modules = {}
        self.autowalk = True

        for m in self.modules.values():
            m.world = self
            self.aliases.update(m.getAliases())
            self.triggers.update(m.getTriggers())
            self.oneTimeTriggers.update(m.getOneTimeTriggers())
            self.timers.update(m.getTimers())

    def getHostPort(self) -> tuple[str, str | int]:
        for m in self.modules.values():
            if hasattr(m, 'getHostPort'):
                return m.getHostPort()
        return input("Hostname: "), input("Port: ")

    def alias(self, line: str) -> bool:
        # It's possible to move command stacking and spamrepeat into modules, at the cost of horribly complicating
        # everything in this function. Implementing them here results in less overall ugliness.

        if self.autowalk:
            sublines = stack(line)
            if len(sublines) > 1:
                for subline in sublines:
                    if not self.alias(subline):
                        self.mud.send(subline)
                return True
            else:
                line = sublines[0]

        if re.match(r'#\d+ .+', line):
            match = re.match(r'#(\d+) (.+)', line)
            times, cmd = match.groups()
            for i in range(int(times)):
                if not self.alias(cmd):
                    self.send(cmd)
            return True

        for alias, action in self.aliases.items():
            if re.match(alias, line):
                if isinstance(action, str):
                    self.send(action)
                else:
                    output = action(self, re.match(alias, line).groups())
                    if output:  # might be for side effects
                        self.send(output)
                return True
        else:
            for module in self.modules.values():
                # If alias wants to signal that it consumed the command, return True -- it won't be sent to MUD then
                # Otherwise, the line is sent to MUD
                if hasattr(module, 'alias'):
                    if module.alias(line):
                        return True
        return False

    def trigger(self, raw):
        stripped = self.mud.strip_ansi(raw).strip()

        for trigger, response in self.triggers.items():
            if re.match(trigger, stripped):
                if isinstance(response, str):
                    self.send(response)
                else:
                    output = response(self, re.match(trigger, stripped).groups())
                    if output:  # might be for side effects
                        self.send(output)
                break

        toDelete = []
        for trigger, response in self.oneTimeTriggers.items():
            if re.match(trigger, stripped):
                if isinstance(response, str):
                    self.send(response)
                else:
                    output = response(self, re.match(trigger, stripped).groups())
                    if output:  # might be for side effects
                        self.send(output)
                toDelete.append(trigger)
                break
        for item in toDelete:
            del self.oneTimeTriggers[item]

        replacement = None
        for module in self.modules.values():
            if hasattr(module, 'trigger'):
                repl = module.trigger(raw, stripped)
                if replacement is None and repl is not None:  # modules come in order of priority, so first one wins
                    replacement = repl
        return replacement

    def handleGmcp(self, cmd, value):
        for module in self.modules.values():
            if hasattr(module, 'handleGmcp'):
                try:
                    module.handleGmcp(cmd, value)
                except Exception as e:
                    self.log("Exception in handleGmcp of {}: {}".format(module, e))
                    self.mud.logException(e)

    def handleMcp(self, name: str, keys: dict[str, str], line: str) -> bool:
        for package in self.mcp:
            if package.handle(name, keys):
                return True
        print('Got unknown MCP message: ' + line)
        return False

    def handleMcpMultiline(self, tag: str, key: str, val: str) -> None:
        for package in self.mcp:
            if package.handleMultiline(tag, key.strip(':'), val):
                return

    def quit(self) -> None:
        for module in self.modules.values():
            if hasattr(module, 'quit'):
                module.quit()
        self.log("Stopping timers")
        TimerMixin.quit(self)
        self.log("Stopped timers")

    def send(self, *args):
        self.mud.send(*args)

    def log(self, *args, **kwargs) -> None:
        self.mud.log(*args, **kwargs)

    def show(self, *args):
        self.mud.show(*args)

    def getTimers(self):
        return {}

def getClass():
    return ModularClient