path: root/geldschieberbot.py

#!/usr/bin/env python3
"""Bot to manage a groups finances"""

from datetime import date, datetime, timedelta
import json
import os
import subprocess
import sys

import tanken

# Path where our data is stored persistent on disk
STATE_FILE = os.environ["GSB_STATE_FILE"]

GROUP_ID = os.environ["GSB_GROUP_ID"]

SEND_CMD = os.environ["GSB_SEND_CMD"]
GROUP_SEND_CMD = SEND_CMD + GROUP_ID


def to_cent(euro):
    """Parse string containing euros into a cent value"""
    if '.' in euro:
        euro = euro.split('.')
    else:
        euro = euro.split(',')
    if len(euro) > 2:
        raise TypeError
    euro[0] = int(euro[0])
    if len(euro) < 2:
        euro.append(0)
    else:
        if len(euro[1]) == 1:
            euro[1] = int(euro[1]) * 10
        else:
            euro[1] = int(euro[1])
    amount = euro[0] * 100 + euro[1]
    if amount < 0:
        raise ValueError
    return amount


def to_euro(cents):
    """Format cents as euro"""
    return f"{cents/100:.2f}"


class Geldschieberbot:
    """
    State of the geldschieberbot
    """

    def load_state(self, state_path=STATE_FILE):
        """Load state from disk"""
        if os.path.isfile(state_path):
            with open(state_path, 'r', encoding='utf-8') as state_f:
                self.state = json.load(state_f)
        else:
            # Dict containing the whole state of geldschieberbot
            # balance - dict of dicts associating two persons to an amount
            # name2num, num2name - dicts associating numbers to names and vice versa
            # cars - dict associating car names to their service charge
            # scheduled_cmds - dict associating names to cmds, their schedule, and the last execution
            # changes - dict associating users with their changes
            self.state = {
                "balance": {},
                "name2num": {},
                "num2name": {},
                "cars": {},
                "scheduled_cmds": {},
                "changes": {},
                "aliases": {},
            }

        self.balance = self.state["balance"]
        self.name2num = self.state["name2num"]
        self.num2name = self.state["num2name"]
        self.available_cars = self.state["cars"]
        self.scheduled_cmds = self.state["scheduled_cmds"]
        self.changes = self.state["changes"]
        self.aliases = self.state.setdefault("aliases", {})

    def save_state(self, state_path=STATE_FILE):
        """Load state from disk"""
        with open(state_path, 'w', encoding='utf-8') as f:
            json.dump(self.state, f)

    def record(self, recipient, donor, amount):
        """Apply changes to the balance"""

        # Only change anything if this is not a dry run
        if self.dry_run:
            return

        self.balance[donor][recipient] += amount
        self.balance[recipient][donor] -= amount

    def send(self, msg, attachment=None, cmd=SEND_CMD):
        """Send a message with optional attachment"""
        if not self.quiet:
            if attachment:
                cmd += f' -a {attachment}'
            subprocess.run(cmd.split(' '), input=msg.encode(), check=False)

    def create_summary(self, user) -> str:
        """Create a summary for a user"""
        msg = ''
        cars_summary = ""
        total = 0
        cars_total = 0
        p_balances = self.balance[user]  # failes if user is not in balance
        for person in p_balances:
            amount = p_balances[person]
            if amount == 0:
                continue
            if person in self.available_cars:
                cars_total -= amount
                cars_summary += f'\t{"<-" if amount < 0 else "->"} {person} {to_euro(abs(amount))}\n'
            else:
                total -= amount
                msg += f'\t{"<-" if amount < 0 else "->"} {person} {to_euro(abs(amount))}\n'

        if not msg:
            msg = '\tAll fine :)'
        else:
            msg += f'\tBalance: {to_euro(total)}'

        ret_summary = f'{user}:\n{msg}'

        if cars_summary:
            cars_summary += f'\tLiability: {to_euro(cars_total)}'
            ret_summary += f'\n\tCars:\n{cars_summary}'

        return ret_summary

    def create_total_summary(self) -> str:
        """Create a summary of all balances"""
        msg = 'Summary:'

        cars_summary = ''
        for person in self.balance:
            p_summary = self.create_summary(person)
            if person in self.available_cars:
                cars_summary += f'\n{p_summary}'
            else:
                msg += f'\n{p_summary}'

        if cars_summary:
            msg += f'\nCars:{cars_summary}'
        return msg

    def create_members(self) -> str:
        """Create a list of all group members"""
        r = ""
        for m in self.name2num:
            r += m + ": " + self.name2num[m] + "\n"
        return r

    def add_to_balance(self, name):
        """Add a new user balance"""
        nb = {}
        for m in self.balance:
            self.balance[m][name] = 0
            nb[m] = 0
        self.balance[name] = nb

    def remove_from_balance(self, name):
        """Remove a user balance"""
        del self.balance[name]
        for m in self.balance:
            del self.balance[m][name]

    def expand_aliases(self,
                       users: list[str],
                       exclude_users=None) -> list[str]:
        """Expand any alias

        Any user name in exclude_users will not be expanded. This is usefull
        when using aliases with commands implicitly adding a user like !split.
        """
        ret = []
        for user in users:
            if not user in self.aliases and user != 'all':
                ret.append(user)
                continue

            expanded_users = []
            if user in self.aliases:
                expanded_users += self.aliases[user]
            else:
                expanded_users += list(self.name2num.keys())

            ret.extend([
                u for u in expanded_users
                if not exclude_users or u not in exclude_users
            ])

        return ret

    @classmethod
    def create_help(cls) -> str:
        return """
    Usage: send a message starting with '!' followed by a command
    Commands:
    ls | list - print all registered members
    help - print this help message
    reg name - register the sender with the name: name
    sum [name] - print summary of specific users
    full-sum - print summary of all users

    alias - list registered aliases
    alias name person [persons] - create an alias for one or multiple persons
    alias remove name - remove an alias

    split amount person [persons] - split amount between the sender and persons
    teil amount person [persons] - split amount between the sender and persons

    schieb amount recipient - give money to recipient
    gib amount recipient - give money to recipient
    zieh amount donor - get money from donor
    nimm amount donor - get money from donor

    transfer amount source destination - transfer amount of your balance from source to destination

    cars [cmd] - interact with the available cars
    cars [list | ls] - list available cars and their service charge
    cars add car-name service-charge - add new car
    cars new car-name service-charge - add new car
    cars remove car-name - remove a car
    cars pay car-name amount - pay a bill for the specified car

    tanken amount [person] [car] [info] - calculate fuel costs, service charge and add them to the person's and car's balance respectively

    fuck [change] - rewind last or specific change
    list-changes [n] [first] - list the last n changes starting at first

    export-state - send the state file

    weekly name cmd -  repeat cmd each week
    monthly name cmd - repeat cmd each month
    yearly name cmd - repeat cmd each year
    cancel name - stop repeating cmd

    Happy Geldschieben!
    """

    def register(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Register a new user"""
        if len(args) != 2:
            return {'err': f'not in form "{args[0]} name"'}
        name = args[1]

        try:
            to_cent(name)
            return {'err': 'pure numerical names are not allowed'}
        except (ValueError, TypeError):
            pass

        if name in self.name2num:
            return {'err': f'{name} already registered'}

        if sender in self.num2name:
            return {'err': 'you are already registered'}

        self.num2name[sender] = name
        self.name2num[name] = sender

        self.add_to_balance(name)

        # add changes list
        self.changes[name] = []
        return {'msg': f'Happy geldschiebing {name}!'}

    def summary(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Print summary for one or multiple balances"""
        if len(args) == 1:
            if not sender in self.num2name:
                return {'err': 'You must register first to print your summary'}
            name = self.num2name[sender]
            return {'msg': f'Summary:\n{self.create_summary(name)}'}

        msg = "Summary:\n"
        for name in self.expand_aliases(args[1:]):
            if name in self.name2num or name in self.available_cars:
                msg += self.create_summary(name) + "\n"
            else:
                return {'err': f'name "{name}" not registered'}
        return {'msg': msg}

    def full_summary(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Print a summary of all balances"""
        if len(args) == 1:
            return {'msg': self.create_total_summary()}

        return {'err': f'{args[0][1:]} takes no arguments'}

    def list_users(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """List all registered users"""
        return {'msg': self.create_members()}

    @classmethod
    def usage(cls, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Return the usage"""
        return {'msg': cls.create_help()}

    def split(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Split a fixed amount across multiple persons"""
        if not sender in self.num2name:
            return {'err': 'you must register first'}

        if len(args) < 3:
            return {'err': f'not in form "{args[0]} amount [name]+"'}

        try:
            amount = to_cent(args[1])
            persons = args[2:]
        except (ValueError, TypeError):
            # support !split name amount
            if len(args) == 3:
                try:
                    amount = to_cent(args[2])
                    persons = [args[1]]
                except (ValueError, TypeError):
                    return {'err': 'amount must be a positive number'}
            else:
                return {'err': 'amount must be a positive number'}

        recipient = self.num2name[sender]
        # exclude the implicit recipient from alias expension
        persons = self.expand_aliases(persons, exclude_users=[recipient])
        # persons + sender
        npersons = len(persons) + 1
        amount_per_person = int(amount / npersons)

        output = f"Split {to_euro(amount)} between {npersons} -> {to_euro(amount_per_person)} each\n"
        change = [args]
        for p in persons:
            if p in self.name2num:
                if p == recipient:
                    output += (f'{p}, you will be charged multiple times. '
                               'This may not be what you want\n')
                else:
                    self.record(recipient, p, amount_per_person)
                    change.append([recipient, p, amount_per_person])
            else:
                output += f"{p} not known. Please take care manually\n"

        self.may_record_change(recipient, change)

        output += "New Balance:\n"
        output += self.create_summary(recipient)
        return {'msg': output}

    def transaction(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Record a transaction"""
        if len(args) != 3:
            return {'err': f'not in form "{args[0]} amount recipient"'}

        if not sender in self.balance:
            if sender not in self.num2name:
                return {'err': 'you must register first'}
            sender = self.num2name[sender]

        if args[1] in self.balance:
            recipient, amount = args[1:3]
        elif args[2] in self.balance:
            amount, recipient = args[1:3]
        else:
            return {'err': 'recipient not known'}

        if sender == recipient:
            return {'err': 'you can not transfer money to or from yourself'}

        try:
            amount = to_cent(amount)
        except (ValueError, TypeError):
            return {'err': 'amount must be a positive number'}

        if args[0] in ["!zieh", "!nimm"]:
            amount *= -1

        self.may_record_change(sender, [args, [sender, recipient, amount]])

        self.record(sender, recipient, amount)

        p_balance = self.balance[sender][recipient]

        output = ("New Balance: {} {} {} {}\n".format(
            sender, ("->" if p_balance > 0 else "<-"), to_euro(abs(p_balance)),
            recipient))
        return {'msg': output}

    def transfer(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Transfer amount from one balance to another"""
        if len(args) < 4:
            return {
                'err': f'not in form "{args[0]} amount source destination"'
            }

        if not sender in self.num2name:
            return {'err': 'you must register first'}

        sender = self.num2name[sender]

        try:
            amount_raw = args[1]
            amount_cent = to_cent(amount_raw)
        except (ValueError, TypeError):
            return {'err': 'amount must be a positive number'}

        source, destination = args[2:4]
        if source not in self.balance:
            return {'err': f'source "{source}" not known'}

        if destination not in self.balance:
            return {'err': f'destination "{destination}" not known'}

        output = ""
        saved_record_changes = self.disable_record_changes()
        change = [args]

        ret = self.transaction(sender, ["!zieh", source, amount_raw], "")
        if 'err' in ret:
            # No changes yet we can fail
            return {'err': ret['err']}

        output += ret['msg']
        # Sender <- X Source
        change.append((sender, source, -amount_cent))

        ret = self.transaction(sender, ["!schieb", destination, amount_raw],
                               "")
        err = ret.get('err', None)
        if err:
            output += err + "\nThe balance may be in a inconsistent state please take care manually"
            return {'msg': output}

        output += ret['msg']
        # Sender -> X Destination
        change.append((sender, destination, amount_cent))

        ret = self.transaction(source, ["!zieh", destination, amount_raw], "")
        err = ret.get('err', None)
        if err:
            output += err + "\nThe balance may be in a inconsistent state please take care manually"
            return {'msg': output}

        output += ret['msg']
        # Destination -> X Source
        change.append((destination, source, amount_cent))

        self.restore_record_changes(saved_record_changes)
        self.may_record_change(sender, change)

        return {'msg': output}

    def cars(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Manage available cars

        List, add, remove or pay a bill for a car.
        """
        # list cars
        if len(args) < 2 or args[1] in ["ls", "list"]:
            if len(self.available_cars) == 0:
                return {'msg': 'No cars registered yet.'}

            ret_msg = ""

            if len(args) > 2:
                cars_to_list = args[2:]
            else:
                cars_to_list = self.available_cars

            for car in cars_to_list:
                if car in self.available_cars:
                    ret_msg += f"{car} - service charge {self.available_cars[car]}ct/km\n"
                    ret_msg += self.create_summary(car) + "\n"
                else:
                    return {'err': f'"{car}" is no available car\n'}

            return {'msg': ret_msg[:-1]}

        # add car
        if args[1] in ["add", "new"]:
            if len(args) < 4:
                return {
                    'err':
                    f'not in form "{args[0]} {args[1]} car-name service-charge"'
                }

            car = args[2]
            if car in self.available_cars:
                return {'err': f'"{car}" already registered'}

            if car in self.balance:
                return {
                    'err':
                    f'A user named "{car}" already exists. Please use a different name for this car'
                }

            try:
                service_charge = to_cent(args[3])
            except (ValueError, TypeError):
                return {'err': 'service-charge must be a positive number'}

            self.available_cars[car] = service_charge
            self.add_to_balance(car)
            return {'msg': f'added "{car}" as an available car'}

        # remove car
        if args[1] in ["rm", "remove"]:
            if len(args) < 3:
                return {'err': f'not in form "{args[0]} {args[1]} car-name"'}

            car = args[2]
            if car not in self.available_cars:
                return {'err': f'A car with the name "{car}" does not exists'}

            del self.available_cars[car]
            self.remove_from_balance(car)
            return {'msg': f'removed "{car}" from the available cars'}

        # pay bill
        if args[1] in ["pay"]:
            if len(args) < 4:
                return {
                    'err': f'not in form "{args[0]} {args[1]} car-name amount"'
                }

            if not sender in self.num2name:
                return {'err': 'you must register first'}

            sender_name = self.num2name[sender]

            car = args[2]
            if car not in self.available_cars:
                return {'err': f'car "{car}" not known'}

            try:
                amount = to_cent(args[3])
                amount_euro = to_euro(amount)
            except (ValueError, TypeError):
                return {'err': 'amount must be a positive number'}

            output = ""

            saved_record_changes = self.disable_record_changes()
            change = [args]

            total_available_charge = 0
            available_charges = []
            for person in self.balance[car]:
                _amount = self.balance[car][person]
                if _amount < 0:
                    total_available_charge -= _amount
                    available_charges.append((person, _amount))

            proportion = -1
            if amount < total_available_charge:
                proportion = -1 * (amount / total_available_charge)

            ret = self.transaction(sender, f'!gib {car} {amount_euro}'.split(),
                                   '')
            assert 'err' not in ret
            output += f"{sender_name} payed {amount_euro}\n"

            # transfer money
            output += f"Transferring {proportion * -100:.2f}% of everybody's charges\n"
            for person, _amount in available_charges:
                if person == sender_name or _amount >= 0:
                    continue

                to_move = int(_amount * proportion)
                to_move_euro = to_euro(to_move)
                ret = self.transfer(sender,
                                    ['transfer', to_move_euro, car, person],
                                    '')
                assert 'err' not in ret

                output += "Transfer {} from {} to {}\n".format(
                    to_move_euro, person, sender_name)

            output += "New Balances:\n"
            output += self.create_summary(sender_name) + "\n"
            output += self.create_summary(car)

            self.restore_record_changes(saved_record_changes)
            self.may_record_change(sender_name, change)

            return {'msg': output}

        return {'err': f'unknown car subcommand "{args[1]}".'}

    def _tanken(self, sender, args, msg) -> dict[str, str]:
        """Split a tank across all passengers"""
        if len(args) < 2:
            return {
                'err': f'not in form "{args[0]} amount [person] [car] [info]"'
            }
        try:
            amount = to_cent(args[1])
        except (ValueError, TypeError):
            return {'err': 'amount must be a number'}

        # find recipient
        if len(args) > 2 and args[2] in self.name2num:
            recipient = args[2]
        elif sender in self.num2name:
            recipient = self.num2name[sender]
        else:
            return {'err': 'recipient unknown'}

        # find car
        car = None
        if len(args) > 2 and args[2] in self.available_cars:
            car = args[2]
        elif len(args) > 3 and args[3] in self.available_cars:
            car = args[3]

        service_charge = 0
        if car:
            service_charge = self.available_cars[car]

        parts, err = tanken.tanken(msg[1:], amount, service_charge)

        if err:
            return {'err': err}

        assert parts

        output = ""
        change = [args]
        for pname, values in parts.items():
            output += pname + ": {}km = fuel: {}, service charge: {}\n".format(
                values["distance"], to_euro(values["cost"]),
                to_euro(values["service_charge"]))
            # record service charges
            if pname not in self.name2num:
                output += pname + " not known."
            if car:
                person_to_charge = pname
                if pname not in self.name2num:
                    person_to_charge = recipient
                    output += f" {recipient} held accountable for service charge."

                self.record(car, person_to_charge, values["service_charge"])
                change.append(
                    [car, person_to_charge, values["service_charge"]])

            # recipient paid the fuel -> don't charge them
            if pname == recipient:
                continue

            if pname in self.name2num:
                self.record(recipient, pname, values["cost"])
                change.append([recipient, pname, values["cost"]])
            else:
                output += " Please collect fuel cost manually\n"

        self.may_record_change(self.num2name[sender], change)

        output += "New Balance:\n"
        output += self.create_summary(recipient)
        if car:
            output += "\nCar "
            output += self.create_summary(car)
        return {'msg': output}

    def fuck(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Rewind past changes"""
        if not sender in self.num2name:
            return {'err': 'you must register first'}

        name = self.num2name[sender]

        nchanges = len(self.changes[name])
        if nchanges == 0:
            return {'msg': 'Nothing to rewind'}

        change_to_rewind = -1
        if len(args) >= 2:
            try:
                change_to_rewind = int(args[1]) - 1
            except ValueError:
                return {'err': 'change to rewind must be a number'}

            if change_to_rewind > nchanges:
                return {
                    'err': 'change to rewind is bigger than there are changes'
                }

        # pop last item
        last_changes = self.changes[name].pop(change_to_rewind)
        args, last_changes = last_changes[0], last_changes[1:]

        output = name + ": sorry I fucked up!\nRewinding:\n"
        output += ' '.join(args) + "\n"
        for change in last_changes:
            if not change[0] in self.cmds:
                output += "{} {} {} {}\n".format(
                    change[0], ("->" if change[2] < 0 else "<-"),
                    to_euro(abs(change[2])), change[1])
                self.record(change[1], change[0], change[2])

        for change in last_changes:
            if change[0] in self.cmds:
                ret = self.cmds[change[0]](sender, change, "")

                if 'err' in ret:
                    output += "ERROR: " + ret['err']
                else:
                    output += ret['msg']

        return {'msg': output}

    def list_changes(self, sender, args, msg) -> dict[str, str]:
        """List changes made by the sender"""
        if not sender in self.num2name:
            return {'err': 'you must register first'}

        sender_name = self.num2name[sender]

        changes_to_list = 5
        if len(args) >= 2:
            try:
                changes_to_list = int(args[1])
            except ValueError:
                return {
                    'err': 'the amount of changes to list must be a number'
                }

        nchanges = len(self.changes[sender_name])
        if nchanges == 0:
            return {'msg': 'Nothing to list'}

        first_to_list = max(nchanges - changes_to_list, 0)

        if len(args) == 3:
            try:
                first_to_list = int(args[2]) - 1
            except ValueError:
                return {'err': 'the first change to list must be a number'}

            if first_to_list > nchanges:
                return {
                    'err':
                    'the first change to list is bigger than there are changes'
                }

        msg = ""
        i = 0
        for i, change in enumerate(self.changes[sender_name]):
            if i < first_to_list:
                continue

            if i >= first_to_list + changes_to_list:
                # i is used to track how many changes we listed
                # This change will not be listed so decrement i before extiting the loop.
                i -= 1
                break

            msg += f'Change {i + 1}:\n'
            msg += f'\t{" ".join(change[0])}\n'
            for sender, recipient, amount in change[1:]:
                msg += "\t{} {} {} {}\n".format(sender,
                                                ("->" if amount < 0 else "<-"),
                                                to_euro(abs(amount)),
                                                recipient)

        # prepend message header because we want to know how much changes we actually listed
        msg = f'Changes from {sender_name} {first_to_list + 1}-{i + 1}\n' + msg

        return {'msg': msg}

    def export_state(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Send the state file as attachment"""
        if not sender in self.num2name:
            return {'err': 'you must register first'}

        msg = f'State from {datetime.now().date().isoformat()}'
        return {'msg': msg, 'attachment': STATE_FILE}

    def schedule(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Schedule a command for periodic execution"""
        if not sender in self.num2name:
            return {'err': 'you must register first'}

        sender_name = self.num2name[sender]

        if len(args) < 3:
            return {'err': f'not in form "{args[0]} name cmd"'}

        name = args[1]
        cmd = args[2:]

        if name in self.scheduled_cmds:
            return {
                'err': f'there is already a scheduled command named "{name}"'
            }

        # Test the command
        saved_dry_run = self.enable_dry_run()
        ret = self.cmds[cmd[0]](sender, cmd, '')
        self.restore_dry_run(saved_dry_run)

        if 'err' in ret:
            return {'err': 'the command "{}" failed and will not be recorded'}

        scheduled_cmd = {
            "schedule": args[0][1:],
            "last_time": None,
            "sender": sender,
            "cmd": cmd
        }

        self.scheduled_cmds[name] = scheduled_cmd
        output = 'Recorded the {} command "{}" as "{}"\n'.format(
            args[0][1:], ' '.join(cmd), name)

        output += "Running {} command {} for {} initially\n".format(
            scheduled_cmd["schedule"], name, sender_name)

        ret = self.cmds[cmd[0]](sender, cmd, "")
        if 'err' in ret:
            output += 'ERROR: ' + ret['err']
        else:
            output += ret['msg']

        self.changes[sender_name][0].append(["cancel", name])

        now = datetime.now().date()
        scheduled_cmd["last_time"] = now.isoformat()

        return {'msg': output}

    def cancel(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Cancel a previously scheduled command"""
        cmd_name = args[1]
        if not cmd_name in self.scheduled_cmds:
            return {'err': f'"{cmd_name}" is not a scheduled command'}
        cmd = self.scheduled_cmds[cmd_name]

        if not cmd["sender"] == sender:
            return {'err': 'only the original creator can cancel this command'}

        del self.scheduled_cmds[cmd_name]
        return {'msg': f'Cancelled the {cmd["schedule"]} cmd "{cmd_name}"'}

    def thanks(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """Thank geldschieberbot for its loyal service"""
        sender_name = self.num2name.get(sender, sender)
        msg = f'You are welcome. It is a pleasure to work with you, {sender_name}.'
        nick = None if len(args) == 1 else args[1]
        if nick:
            msg = f"{msg}\nBut don't call me {nick}."

        return {'msg': msg}

    def alias(self, sender, args, msg) -> dict[str, str]:  # pylint: disable=unused-argument
        """List or create aliases"""

        if len(args) == 1:
            msg = ''
            for alias, users in self.aliases.items():
                msg += f'\n\t{alias}: {" ".join(users)}'
            return {'msg': f'Aliases:\n\tall: {" ".join(self.name2num)}{msg}'}

        if len(args) == 2:
            return {'err': 'Not a valid alias command'}

        if args[1] == 'remove':
            alias = args[2]
            if alias not in self.aliases:
                return {'err': f'Alias "{alias}" not registered'}

            del self.aliases[alias]
            return {'msg': f'Alias "{alias}" removed'}

        # create a new alias
        alias = args[1]
        if alias in self.aliases or alias == 'all':
            return {'err': f'Alias "{alias}" is already registered'}

        if alias in self.name2num:
            return {'err': f'A user "{alias}" is already registered'}

        try:
            to_cent(alias)
            return {'err': 'Pure numerical aliases are not allowed'}
        except (ValueError, TypeError):
            pass

        users = args[2:]
        for user in users:
            if user not in self.name2num:
                return {'err': f'User {user} is not registered'}

        self.aliases[alias] = users
        return {'msg': f'New alias "{alias}" registered'}

    def __init__(self, dry_run=False):
        self.dry_run = dry_run  # Run without changing the stored state
        self.load_state()
        self.quiet = False  # Run without sending messages
        self.record_changes = True  # Should changes be recorded

        # Command dispatch table
        self.cmds = {
            'reg': self.register,
            'register': self.register,
            'alias': self.alias,
            'sum': self.summary,
            'summary': self.summary,
            'full-sum': self.full_summary,
            'full-summary': self.full_summary,
            'ls': self.list_users,
            'list': self.list_users,
            'split': self.split,
            'teil': self.split,
            'schieb': self.transaction,
            'gib': self.transaction,
            'zieh': self.transaction,
            'nimm': self.transaction,
            'help': self.usage,
            'usage': self.usage,
            'transfer': self.transfer,
            'cars': self.cars,
            'tanken': self._tanken,
            'fuck': self.fuck,
            'rewind': self.fuck,
            'undo': self.fuck,
            'list-changes': self.list_changes,
            'export-state': self.export_state,
            'weekly': self.schedule,
            'monthly': self.schedule,
            'yearly': self.schedule,
            'cancel': self.cancel,
            'thanks': self.thanks,
        }

    def __del__(self):
        self.save_state()

    def enable_dry_run(self) -> bool:
        """Enable dry run"""
        old_value = self.dry_run
        self.dry_run = True
        return old_value

    def restore_dry_run(self, old_value: bool):
        """Restore dry run setting to old value"""
        self.dry_run = old_value

    def disable_record_changes(self) -> bool:
        """Disable change recording and return previous value"""
        old_value = self.record_changes
        self.record_changes = False
        return old_value

    def restore_record_changes(self, old_value: bool):
        """Restore record change setting to old value"""
        self.record_changes = old_value

    def may_record_change(self, user: str, change):
        """Record a change for a user if change recording is enabled"""
        if self.record_changes and not self.dry_run:
            self.changes[user].append(change)

    def handle(self, message: dict):
        """Parse and respond to a message"""
        sender_number = message["source"]
        if not "dataMessage" in message or not message[
                "dataMessage"] or not message["dataMessage"]["message"]:
            return

        message = message["dataMessage"]
        if message["groupInfo"] and message["groupInfo"]["groupId"] != GROUP_ID:
            return

        body = [l.strip() for l in message["message"].lower().splitlines()]

        if len(body) == 0 or not body[0].startswith('!'):
            return

        args = body[0].split(' ')
        cmd = args[0][1:]
        if cmd in self.cmds:
            ret = self.cmds[cmd](sender_number, args, body)
            if 'err' in ret:
                self.send(f'ERROR: {ret["err"]}')
            else:
                if not 'msg' in ret:
                    print(ret)
                self.send(ret['msg'], attachment=ret.get('attachment', None))
        else:
            self.send(
                'ERROR: unknown cmd. Enter !help for a list of commands.')

        self.save_state()

    def run_scheduled_cmds(self):
        """Progress the scheduled commands"""
        self.record_changes = False

        now = datetime.now().date()
        week_delta = timedelta(days=7)
        for name, cmd in self.scheduled_cmds.items():

            last_time = cmd["last_time"]
            if hasattr(date, "fromisoformat"):
                last_time = date.fromisoformat(last_time)
            else:
                last_time = date(*map(int, last_time.split("-")))

            d = last_time
            while True:
                if cmd["schedule"] == "yearly":
                    d = date(d.year + 1, d.month, d.day)
                elif cmd["schedule"] == "monthly":
                    if d.day > 28:
                        d = date(d.year, d.month, 28)
                    if d.month == 12:
                        d = date(d.year + 1, 1, d.day)
                    else:
                        d = date(d.year, d.month + 1, d.day)
                else:
                    d = d + week_delta

                if d <= now:
                    self.send("Running {} command {} for {} triggered on {}\n".
                              format(cmd["schedule"],
                                     name, self.num2name[cmd["sender"]],
                                     d.isoformat()))

                    ret = self.cmds[cmd["cmd"][0]](cmd["sender"], cmd["cmd"],
                                                   "")

                    if 'err' in ret:
                        self.send("ERROR: " + ret['err'])
                    else:
                        self.send(ret['msg'],
                                  attachment=ret.get('attachment', None))

                    cmd["last_time"] = d.isoformat()
                else:
                    break


def main():
    dry_run = len(sys.argv) > 1 and sys.argv[1] in ["-d", "--dry-run"]
    if dry_run:
        print("Dry Run no changes will apply!")

    bot = Geldschieberbot(dry_run=dry_run)

    # Read cmds from stdin
    for l in sys.stdin.read().splitlines():
        try:
            message = json.loads(l)["envelope"]
        except json.JSONDecodeError:
            print(datetime.now(), l, "not valid json")
            continue

        bot.handle(message)

    bot.run_scheduled_cmds()


if __name__ == "__main__":
    main()