#include "crsm.hpp"
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <QThread>
#include <QTimer>
#include <QRegularExpression>

#define MGMT_BUFFER_FILENAME "CRSM-MGMT-Buffer"

CRSM::CRSM(QObject *parent) :
    QObject(parent), Session(this)
{
    qsrand(QDateTime::currentMSecsSinceEpoch());
    codec = QTextCodec::codecForName("Windows-1252");
    qout = new QTextStream(stdout, QIODevice::WriteOnly | QIODevice::Unbuffered);
    qin = new QTextStream(stdin, QIODevice::ReadOnly);
    qout->setCodec(QTextCodec::codecForName("UTF-8"));

    outputBuffer.setFileName(MGMT_BUFFER_FILENAME);
    outputBuffer.open(QFile::WriteOnly | QFile::Unbuffered);

    finish = false;

    ok = true;
    readConfig();
    if(!ok) return;

    ok = false;

    connect(&managementServer, SIGNAL(newConnection()), this, SLOT(newManagementConnection()));
    managementServer.listen(QHostAddress::LocalHostIPv6, Config.CRSM.ManagementPort);

    listC4Folders();
    readScenarios();

    if(!Config.Auto.ProcessManager.ReattachId.isEmpty())
    {
        processManager = new ProcessManager("CRSM-Clonkserver-", Config.Auto.ProcessManager.ReattachId);
    }
    else
    {
        processManager = new ProcessManager("CRSM-Clonkserver-");
    }


    if(!processManager->isOk())
    {
        out("Could not start Process Manager!\n");
        Config.Auto.ProcessManager.ReattachId.clear();
        writeConfig();
        return;
    }

    Config.Auto.ProcessManager.ReattachId = processManager->ID();
    writeConfig();

    if(processManager->isRunning())
    {
        Session.read(Config.CRSM.SessionFile, false);
        writeToServer("Der Server Manager läuft wieder.\nBis zur nächsten Runde könnte unerwartetes Verhalten auftreten.\n");
    }
    QFile sessionFile(Config.CRSM.SessionFile);
    if(sessionFile.exists()) sessionFile.remove();

    connect(&greetMapper, SIGNAL(mapped(QString)), this, SLOT(greet(QString)));

    autoHost = Config.Hosting.Auto;

    connect(processManager, SIGNAL(readyRead()), this, SLOT(readServerOutput()));

    connect(processManager, SIGNAL(finished(int)), this, SLOT(scenarioFinished()));

    afkAdminTimer.setSingleShot(true);
    connect(&afkAdminTimer, SIGNAL(timeout()), this, SLOT(afkAdminTimeout()));

    QFile *reallog = new QFile(Config.Auto.Volatile.Clonk.Directory + "CRSM.log");
    reallog->open(QIODevice::Append | QIODevice::Text);
    logstream.setDevice(reallog);

    ok = true;
}

CRSM::~CRSM()
{
}

void CRSM::start()
{
    if(autoHost && !processManager->isRunning())
        nextScen();
}

bool CRSM::isOk()
{
    return ok;
}

void CRSM::readServerOutput()
{
    static QRegExp timeRemover("^>?\\s*\\[(\\d\\d:\\d\\d:\\d\\d)\\]\\s+(.*)$");
    QString what(processManager->readLine());

    if(Config.Readline.ServerUses)
    {
        while(writtenToServer.length() > 0 && what.length() > 0 && writtenToServer.at(0) == what.at(0))
        {
            writtenToServer.remove(0, 1);
            what.remove(0, 1);
        }

        if(what.at(0) == '>')
            what.remove(0, 1);
    }

    if(what.isEmpty())
        return;

    logstream << what.trimmed() << endl;

    if(Config.IRC.Use)
    {
        foreach(const QString &mess, what.split("\n", QString::SkipEmptyParts))
            foreach(const QString &mod, ircModIOList)
            {
                connection->sendCommand(IrcCommand::createNotice(mod, mess));
            }
    }
    out(what.trimmed() + "\n");
    if(!timeRemover.exactMatch(what))
        return;
    what = timeRemover.cap(2).trimmed();

    static QRegExp userexp("^\\s*(\\*?)\\s*<(.*)\\|(\\d+)\\|([^>]*)>\\s+(.*)$");
    if(userexp.exactMatch(what))
    {
        bool isMeMessage = (userexp.cap(1) == "*");
        QString user = userexp.cap(4);
        QString pcName = userexp.cap(2);
        int cuid = userexp.cap(3).toInt();
        if(pcName != Config.Auto.Volatile.Clonk.ServerPCName)
        {
            ClientInfo& info = getClientInfo(pcName, cuid, user);
            if(info == Session.Clonk.Admin)
            {
                checkActivity(Session.Clonk.Admin);
            }
            QString msg = userexp.cap(5).trimmed();
            if(info.floodCheck(Config.Clonk.Chat.AntiFlood.Count, Config.Clonk.Chat.AntiFlood.Time, QDateTime(QDate::currentDate(), QTime::fromString(timeRemover.cap(1), "hh:mm:ss"))))
            {
                kick(pcName, "Flooding! Maximal " + QString::number(Config.Clonk.Chat.AntiFlood.Count) + " Nachrichten in " + QString::number(Config.Clonk.Chat.AntiFlood.Time) + "s");
            }
            else if(!isMeMessage)
            {
                if(msg.length() > Config.CRSM.CommandSign.length() && msg.left(Config.CRSM.CommandSign.length()) == Config.CRSM.CommandSign)
                {
                    QString command = msg.mid(Config.CRSM.CommandSign.length());
                    if(!cmd(command, info))
                    {
                        respond(info, "Unbekannter Befehl: \"" + command + "\"!\n");
                    }

                }
                else if(Session.IRC.UseIngameChat)
                {
                    connection->sendCommand(IrcCommand::createMessage(Config.IRC.IngameChannel, "[Clonk]<" + user + "> " + msg));
                }
            }
            else if(Session.IRC.UseIngameChat)
            {
                connection->sendCommand(IrcCommand::createCtcpAction(Config.IRC.IngameChannel, "[Clonk] " + user + " " + msg));
            }
        }
    }
    static QRegExp joinExp("^Client (.+) (?:verbunden|connected)\\.\\s*$");
    if(joinExp.exactMatch(what))
    {
        static QRegExp infoMatch("^<(.*)\\|(\\d+)\\|(.*)>$");
        if(infoMatch.exactMatch(joinExp.cap(1)))
        {
            const ClientInfo& info = ClientInfo::clonkClient(infoMatch.cap(3), infoMatch.cap(1), infoMatch.cap(2).toInt());
            Session.Clonk.Clients.insert(info.pcName, info);
            QTimer *timer = new QTimer;
            connect(timer, SIGNAL(timeout()), &greetMapper, SLOT(map()));
            connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
            greetMapper.setMapping(timer, info.pcName);
            timer->start(1000);
            if(Session.IRC.UseIngameChat)
            {
                connection->sendCommand(IrcCommand::createMessage(Config.IRC.IngameChannel, "[Clonk] " + info.toString() + " verbunden."));
            }
        }
    }

    static QRegExp activatedExp("^Client (.+) (?:aktiviert|activated)\\.\\s*$");
    if(activatedExp.exactMatch(what))
    {
        QRegExp infoMatch("^<(.*)\\|(\\d+)\\|(.*)>$");
        if(infoMatch.exactMatch(activatedExp.cap(1)))
        {
            ClientInfo &info = getClientInfo(infoMatch.cap(1), infoMatch.cap(2).toInt(), infoMatch.cap(3));
            info.activated = true;
        }
    }

    static QRegExp deactivatedExp("^Client (.+) (?:deaktiviert|deactivated)\\.\\s*$");
    if(deactivatedExp.exactMatch(what))
    {
        QRegExp infoMatch("^<(.*)\\|(\\d+)\\|(.*)>$");
        if(infoMatch.exactMatch(joinExp.cap(1)))
        {
            ClientInfo &info = getClientInfo(infoMatch.cap(1), infoMatch.cap(2).toInt(), infoMatch.cap(3));
            info.activated = false;
        }
    }

    static QRegExp lobbyStartExp(R"((?:Los geht's!|Action go!)\s*)");
    if(lobbyStartExp.exactMatch(what))
    {
        Session.State = CRSMSession::Loading;
        ircSetIngameChannelTopic();
    }

    static QRegExp startExp("^Start!\\s*$");
    if(startExp.exactMatch(what))
    {
        Session.State = CRSMSession::Running;
        Stats.AddScenarioStart(Session.Scenario.wishClient, scenarioFileName(Session.Scenario.name));
        if(!Session.League)
        {
            writeToServer(QString("/set maxplayer 0\n"));
        }
        ircSetIngameChannelTopic();
    }


    static QRegExp leaveExp("^Client (.+) (?:entfernt|removed)(.*)");
    if(leaveExp.exactMatch(what))
    {
        QRegExp infoMatch("^<(.*)\\|(\\d+)\\|(.*)>$");
        if(infoMatch.exactMatch(leaveExp.cap(1)))
        {
            ClientInfo &info = getClientInfo(infoMatch.cap(1), infoMatch.cap(2).toInt(), infoMatch.cap(3));
            writeToServer(QString(info.nick +" ist ein L34V0R!\n"));

            if(Session.IRC.UseIngameChat)
            {
                connection->sendCommand(IrcCommand::createMessage(Config.IRC.IngameChannel, "[Clonk] " + info.toString() + " entfernt" + leaveExp.cap(2)));
            }

            if(info == Session.Clonk.Admin)
            {
                Session.Clonk.LeaveAdmins.insert(info, QDateTime::currentDateTime());
                writeToServer("Rundenadmin wurde freigegeben.\n");
                Session.Clonk.Admin.clear();
            }

            Session.Clonk.Clients.remove(info.pcName);
        }
        if(Session.Clonk.Clients.size() == 0 && userlist.length() > 0 && !Session.UserWish)
        {
            processManager->closeProgFifos();
        }
        else if(Session.Clonk.Clients.size() == 0 && Config.Clonk.Server.EmptyTimer != -1 && (Session.CountDown == -1 || Session.CountDown > Config.Clonk.Server.EmptyTimer))
        {
            writeToServer("/start " + QString::number(Config.Clonk.Server.EmptyTimer) + "\n");
        }
    }

    static QRegExp countDownExp("^(?:Das Spiel beginnt in (\\d+) Sekunden\\!|The game will start in (\\d+) seconds\\.)");
    if(countDownExp.exactMatch(what))
    {
        Session.CountDown = countDownExp.cap(1).toInt();
    }
    static QRegExp countDownExp2(R"(^(\d+)\.\.\.)");
    if(countDownExp2.exactMatch(what))
    {
        Session.CountDown = countDownExp2.cap(1).toInt();
    }

    static QRegExp countDownStopExp("^(?:Spielstart abgebrochen\\.|Game start aborted\\.)");
    if(countDownStopExp.exactMatch(what))
    {
        Session.CountDown = -1;
    }

    static QRegExp gameRegisterFailExp(R"(^(?:Spiel konnte nicht registriert werden|Could not register game): (.*))");
    if(gameRegisterFailExp.exactMatch(what))
    {
        QString reason = gameRegisterFailExp.cap(1);
        userlist.clear();
        if(autoHost && !hostingIsErrorDeactivated)
        {
            hostingIsErrorDeactivated = true;
            gameRegisterFailTimer.singleShot(5*60*1000, this, SLOT(enableAutoHosting()));
        }
        autoHost = false;
        static const QString gameRegisterFailMessage = "Aufgrund eines Problems beim Registrieren des Spiels am Masterserver (%1) wird Hosting temporär (für 5 Minuten) deaktiviert.\n";
        out(gameRegisterFailMessage.arg(reason));
        if(Config.IRC.Use)
        {
            connection->sendCommand(IrcCommand::createMessage(Config.IRC.Channel, gameRegisterFailMessage.arg(reason)));
            if(Config.IRC.UseIngameChat)
            {
                connection->sendCommand(IrcCommand::createMessage(Config.IRC.IngameChannel, gameRegisterFailMessage.arg(reason)));
            }
        }
    }
}

void CRSM::nextScen()
{
    if(hostingIsErrorDeactivated)
    {
        return;
    }
    if(userlist.length()>0)
    {
        startScen(userlist.at(0), args);
        userlist.removeFirst();
        Session.UserWish = true;
    }
    else
    {
        startScen(nextAutoScens.first(), args);
        nextAutoScens.removeFirst();
        updateNextAutoScens();
    }
}

void CRSM::scenarioFinished()
{
    if(finish)
    {
        writeFiles();
        if(processManager != nullptr) processManager->exit();
        if(connection != 0)
        {
            connection->quit(Config.IRC.QuitMessage);
            connect(connection, SIGNAL(disconnected()), QCoreApplication::instance(), SLOT(quit()));
            QTimer::singleShot(500, QCoreApplication::instance(), SLOT(quit()));
        }
        else
            QCoreApplication::quit();
        return;
    }
    Session.clear();
    if((autoHost || userlist.length() > 0) && !finish)
    {
        nextScen();
    }
    else
    {
        ircSetIngameChannelTopic();
    }
    QFile lastScenFile(LAST_SCEN_FILE_NAME);
    QFile curScenFile(CUR_SCEN_FILE_NAME);
    curScenFile.open(QFile::ReadOnly);
    lastScenFile.open(QFile::WriteOnly);
    lastScenFile.write(curScenFile.readAll());
    lastScenFile.close();
    curScenFile.close();
    curScenFile.open(QFile::WriteOnly);
    curScenFile.close();
}

void CRSM::ircMessageReceived(IrcMessage *message)
{
    if(message->isOwn())
        return;
    if(message->type() == IrcMessage::Notice)
    {
        if(message->nick() == "NickServ")
        {
            QStringList split = message->parameters().at(1).split(' ', QString::SkipEmptyParts);
            if(((IrcNoticeMessage*)message)->content().contains("nickname is registered"))
            {
                connection->sendCommand(IrcCommand::createMessage("NickServ", "IDENTIFY " + Config.IRC.Nick + " " + Config.IRC.Password));
            }
            else if(split.first() == "STATUS")
            {
                QString statusNick = split.at(1);
                int status = split.at(2).toInt();
                if(ircStatusFifos.contains(statusNick))
                {
                    QList<QPair<ClientInfo, IrcCheckCallback>> &fifo = ircStatusFifos[statusNick];
                    while(fifo.size() > 0)
                    {
                        (this->*fifo.first().second)(fifo.first().first, status, ClientInfo::ircClient(statusNick));
                        fifo.removeFirst();
                    }
                }
            }
        }
    }
    else if(message->type() == IrcMessage::Private)
    {
        IrcPrivateMessage* privMessage = (IrcPrivateMessage*)message;
        QString target = privMessage->target();
        if(target == connection->nickName())
            target = message->nick();
        QString mess = privMessage->content();
        const ClientInfo& client = ClientInfo::ircClient(message->nick(), target);
        if(client == Session.IRC.Admin)
        {
            checkActivity(Session.IRC.Admin);
        }
        if(target == Config.IRC.IngameChannel && Session.IRC.UseIngameChat)
        {
            if(privMessage->isAction())
            {
                writeToServer("/me [IRC] " + message->nick() + " " + mess + "\n");
            }
            else
            {
                writeToServer("[IRC]<" + message->nick() + "> " + mess + "\n");
            }
        }
        else if(!privMessage->isAction() && (mess.length() > Config.CRSM.CommandSign.length() && mess.left(Config.CRSM.CommandSign.length()) == Config.CRSM.CommandSign))
        {
            QString command = mess.mid(Config.CRSM.CommandSign.length()).trimmed();
            if(!cmd(command, client))
            {
                respond(client, "Unbekannter Befehl: \"" + command + "\"!");
            }
        }
        else if(privMessage->isPrivate() && ircMods.contains(target))
        {
            if(aliasWishEditor == target)
            {
                editAliasWishes(mess);
            }
            else if(ircModIOList.contains(message->nick()))
            {
                QString writeMessage;
                if(mess.at(0) == '\\' || mess.at(0) == '/')
                {
                    mess[0] = '/';
                }
                else
                {
                    writeMessage = "[IRC]<" + message->nick() + "> ";
                }
                writeMessage += mess;
                writeToServer(writeMessage + "\n");
            }
        }

        if(ircModWatchList.length() > 0)
        {
            QString watchMsg = "<";
            if(!privMessage->isPrivate())
            {
                watchMsg += target + ":";
            }
            watchMsg += message->nick() + "> " + mess;

            foreach(const ClientInfo& client, ircModWatchList)
            {
                connection->sendCommand(IrcCommand::createMessage(client.nick, watchMsg));
            }
        }
    }
    else if(message->type() == IrcMessage::Join)
    {
        IrcJoinMessage* joinMessage = (IrcJoinMessage*) message;
        QString joinChannel = joinMessage->channel();
        connection->sendCommand(IrcCommand::createMessage(joinChannel, "Hallo " + message->nick() + "!"));
        if(joinChannel == Config.IRC.IngameChannel && Session.IRC.UseIngameChat)
        {
            writeToServer("[IRC] " + message->nick() + " hat den Channel betreten." + "\n");
        }
        else
            ircCheckUserStatus(ClientInfo::ircClient(message->nick()), ClientInfo::ircClient(message->nick()), &CRSM::ircModCmd);
    }
    else if(message->type() == IrcMessage::Quit)
    {
        ircMods.removeAll(message->nick());
        ircModChecks.removeAll(message->nick());
        ircModIOList.removeAll(message->nick());
        ircModWatchList.removeAll(ClientInfo::ircClient(message->nick()));
        if(aliasWishEditor == message->nick())
        {
            stopAliasWishEditing();
        }
        if(Session.IRC.Admin == ClientInfo::ircClient(message->nick()))
        {
            Session.IRC.Admin.clear();
        }
    }
    else if(message->type() == IrcMessage::Kick)
    {
        IrcKickMessage* kickMessage = (IrcKickMessage*)message;
        if(kickMessage->user() == connection->nickName())
        {
            connection->sendCommand(IrcCommand::createJoin(kickMessage->channel()));
        }
    }
    else if(message->type() == IrcMessage::Part)
    {
        IrcPartMessage* partMessage = (IrcPartMessage*)message;
        QString leaveChannel = partMessage->channel();
        if(leaveChannel == Config.IRC.IngameChannel && Session.IRC.UseIngameChat)
        {
            writeToServer("[IRC] " + message->nick() + " hat den Channel verlassen." + "\n");
        }
    }
    else if(message->type() == IrcMessage::Mode)
    {
        IrcModeMessage* modeMessage = (IrcModeMessage*)message;
        QRegExp modeExp("^\\+[a-zA-Z]*(a|o)");
        if(Config.IRC.UseIngameChat && message->parameters().size() >= 3 && modeMessage->target() == Config.IRC.IngameChannel && modeExp.exactMatch(modeMessage->mode()) && modeMessage->argument() == Config.IRC.Nick)
        {
            ircSetIngameChannelTopic();
        }
    }
}

void CRSM::ircConnected()
{
    IrcConnection* conn = (IrcConnection*)sender();
    Q_ASSERT(conn == connection);
    connection->sendCommand(IrcCommand::createMode(Config.IRC.Nick, "+B"));
    connection->sendCommand(IrcCommand::createJoin(Config.IRC.Channel));
    if(Config.IRC.UseIngameChat && !Config.IRC.IngameChannel.isEmpty())
    {
        connection->sendCommand(IrcCommand::createJoin(Config.IRC.IngameChannel));
        ircSetIngameChannelTopic();
    }
    else
    {
        Session.IRC.UseIngameChat = Config.IRC.UseIngameChat = false;
    }
}

void CRSM::greet(QString pcName)
{
    if(!Session.Clonk.Clients.contains(pcName))
        return;
    const ClientInfo &info = Session.Clonk.Clients.value(pcName);
    writeToServer(QString("Hallo " + info.nick + "!\n"));
    if(Session.Clonk.LeaveAdmins.contains(info))
    {
        int timeGone;
        if((timeGone = Session.Clonk.LeaveAdmins.value(info).secsTo(QDateTime::currentDateTime())) < Config.Clonk.Chat.RegainAdminTime && !Session.Clonk.Admin.empty())
        {
            writeToServer(info.nick + "! Der Rundenadmin wurde freigegeben, weil du das Spiel verlassen hast.\nDu hast noch " + QString::number(Config.Clonk.Chat.RegainAdminTime - timeGone) + "s Zeit um den Rundenadmin zurückzuholen.\n");
        }
        else
        {
            Session.Clonk.LeaveAdmins.remove(info);
        }
    }
}

void CRSM::newManagementConnection()
{
    QTcpSocket* sock = managementServer.nextPendingConnection();
    connect(sock, SIGNAL(readyRead()), this, SLOT(newManagementData()));
    connect(sock, SIGNAL(disconnected()), this, SLOT(managementConnectionDisconnected()));
    sock->write(QString("Willkommen beim CRSM-Management-Interface!\nIhr Name: ").toUtf8());
}

void CRSM::newManagementData()
{
    QTcpSocket* sock = (QTcpSocket*)sender();
    QString allData = sock->readAll().trimmed();
    foreach(const QString& data, allData.split('\n'))
    {
        if(!managementConnections.contains(sock))
        {
            if(data.isEmpty())
            {
                sock->write("Ihr Name: ");
            }
            else
            {
                ManagementConnection conn;
                conn.socket = sock;
                conn.name = data;
                out(conn.name + " logged in on Management-Interface.\n");
                managementConnections.insert(sock, conn);
                replayOutputBuffer(sock);
            }
        }
        else
        {
            if(data.isEmpty())
            {
                continue;
            }
            ManagementConnection& conn = managementConnections[sock];
            if(data.at(0) == '/')
            {
                QString command = data.mid(1).trimmed();
                if(cmd(command, ClientInfo::managementClient(conn)))
                {
                    continue;
                }
                else
                {
                    writeToServer(data + "\n");
                }
            }
            else
            {
                writeToServer(ClientInfo::managementClient(conn).toString(true) + " " + data + "\n");
            }
        }
    }
}

void CRSM::managementConnectionDisconnected()
{
    QTcpSocket* sock = dynamic_cast<QTcpSocket*>(sender());
    if(sock == nullptr) return;
    if(!managementConnections.value(sock).name.isEmpty()) out(managementConnections.value(sock).name + " disconnected from Management-Interface.\n");
    if(managementConnections.contains(sock))
    {
        managementConnections.remove(sock);
    }
}

void CRSM::updateNextAutoScens()
{
    if(autolist.length() <= 0) return;
    while(nextAutoScens.length() < Config.Hosting.UserListLength)
    {
        ScenarioSettings next("");
        if(Config.Hosting.RandomizeAuto)
        {
            next = autolist.at(qrand() % autolist.length());
        }
        else
        {
            next = autolist.at(current);
            if(++current >= autolist.length()) current = 0;
        }
        if(next.randomLeague)
        {
            next.league = qrand() % 2;
        }
        nextAutoScens.append(next);
    }
}

void CRSM::startScen(const ScenarioSettings &scen, QStringList argList)
{
    QString filename;
    QFile lastScenFile(LAST_SCEN_FILE_NAME);
    QFile curScenFile(CUR_SCEN_FILE_NAME);
    curScenFile.open(QFile::ReadOnly);
    lastScenFile.open(QFile::WriteOnly);
    lastScenFile.write(curScenFile.readAll());
    lastScenFile.close();
    curScenFile.close();
    curScenFile.open(QFile::WriteOnly);
    curScenFile.write(scen.name.toUtf8());
    curScenFile.close();
    QFile scoreboardFile(SCOREBOARD_FILE_NAME);
    scoreboardFile.open(QFile::WriteOnly);
    scoreboardFile.close();

    Session.Scenario = scen;
    Session.IRC.UseIngameChat = Config.IRC.UseIngameChat;
    Session.State = CRSMSession::Lobby;
    ircSetIngameChannelTopic();
    filename = scenarioFileName(scen.name);

    if(scen.league)
    {
        argList << "/league";
        Session.League = true;
    }
    else
    {
        argList << "/noleague";
    }
    argList << filename;
    processManager->setWorkingDirectory(Config.Auto.Volatile.Clonk.Directory);
    out(Packs.linkScenarioPacks(filename));
    processManager->start(Config.Clonk.Server.Executable, argList);
}

void CRSM::readConfig()
{
    Config.clear();
    out(Config.read(CONFIG_FILE_NAME));
    applyConfig();
    return;
}


void CRSM::readScenarios()
{
    QFile scenfile("scenarios.lst");
    if(!scenfile.exists())
    {
        out("No scenarios.lst found!");
        scenfile.open(QFile::WriteOnly);
        scenfile.write("Worlds.c4f/Goldmine.c4s");
        scenfile.close();
    }
    scenfile.open(QFile::ReadOnly);
    QStringList scenlist = QString(scenfile.readAll()).trimmed().split("\n",QString::SkipEmptyParts);
    out("Scenarios in list:\n");
    autolist.clear();
    nextAutoScens.clear();
    current = 0;
    foreach(const QString &args, scenlist)
    {
        ScenarioSettings scen(args, ClientInfo::autoClient());
        QStringList argList = args.split(' ', QString::KeepEmptyParts);
        if(argList.first().trimmed() == "--league")
        {
            argList.removeFirst();
            scen.league = true;
            scen.name = argList.join(' ');
        }
        else if(argList.first().trimmed() == "--random-league")
        {
            argList.removeFirst();
            scen.randomLeague = true;
            scen.name = argList.join(' ');
        }
        QString scenName = scen.name;
        if(!(scen.name = scenPath(scen.name)).isEmpty())
        {
            out(scen.name + "\n");
            autolist.append(scen);
        }
        else
        {
            out("WARNING: Scenario " + scenName + " not found!\n");
        }
    }

    out("\n");

    scenfile.close();
    updateNextAutoScens();
}

void CRSM::listC4Folders()
{
    out("Listing Contents of C4Folders...");
    QDirIterator it(Config.Auto.Volatile.Clonk.Directory, QDirIterator::FollowSymlinks);
    for(; it.hasNext(); it.next())
    {
        if(it.fileName() == ".." || it.fileName() == ".")
            continue;
        if((it.fileInfo().suffix() == "c4f" || (it.fileInfo().isDir() && !QDir(it.fileInfo().absoluteFilePath()).entryList(QStringList() << "*.c4f" << "*.c4s").isEmpty())) && it.fileName() != "." && it.fileName() != ".." && !Config.Clonk.Server.IgnoreFolders.contains(it.fileInfo().baseName()))
        {
            QFileInfo listInfo(Config.CRSM.ListFolder + it.fileName() + ".lst");
            if(listInfo.exists() && it.fileInfo().exists() && it.fileInfo().lastModified() < listInfo.lastModified()) continue;
            const QStringList& list = listC4Folder(it.filePath());
            if(!list.isEmpty())
            {
                QFile listFile(listInfo.filePath());
                listFile.open(QFile::WriteOnly);
                foreach(const QString& scen, list)
                {
                    listFile.write(scen.toUtf8() + "\n");
                }
                listFile.close();
            }
        }
    }
    out(QString(3, '\b') + ": Finished\n");
}

void CRSM::cleanUp()
{
    out("\nCleaning up Clonk Folder...\n");
    QDirIterator it(Config.Auto.Volatile.Clonk.Directory+"Network/", QDirIterator::FollowSymlinks | QDirIterator::Subdirectories);
    for(; it.hasNext(); it.next())
        if(it.fileInfo().exists()) QFile(it.fileInfo().absoluteFilePath()).remove();
    out("\n");
}

QString CRSM::scenPath(QString scenName)
{
    bool isAlias = false;
    QString aliasName;
    foreach(const QString& alias, Config.Hosting.Alias.keys())
    {
        if(alias.compare(scenName, Qt::CaseInsensitive) == 0)
        {
            aliasName = scenName = alias;
            break;
        }
    }
    while(Config.Hosting.Alias.contains(scenName))
    {
        scenName = Config.Hosting.Alias.value(scenName);
        isAlias = true;
    }
    QFileInfo fileInfo(Config.Auto.Volatile.Clonk.Directory + scenName);
    if(fileInfo.suffix() != "c4s")
    {
        return QString();
    }
    bool exists = fileInfo.exists();
    if(exists && isAlias)
    {
        return aliasName;
    }
    if(exists)
    {
        return scenName;
    }
    else
    {
        QStringList split = scenName.split('/');
        QString name = scenName.mid(split.first().length() + 1);
        if(split.length() >= 2)
        {
            if(split.first().right(4) == ".c4f")
            {
                const QStringList& entryList = QDir(Config.Auto.Volatile.Clonk.Directory).entryList(QStringList() << "*.c4f");
                QString folderName = split.first();
                foreach(const QString& entry, entryList)
                {
                    if(entry.compare(folderName, Qt::CaseInsensitive) == 0)
                    {
                        folderName = entry;
                        break;
                    }
                }
                QFile lstFile(Config.CRSM.ListFolder + folderName + ".lst");
                if(lstFile.exists())
                {
                    lstFile.open(QFile::ReadOnly);
                    while(!lstFile.atEnd())
                    {
                        const QString& line = lstFile.readLine().trimmed();
                        if(line.compare(name, Qt::CaseInsensitive) == 0)
                        {
                            lstFile.close();
                            if(isAlias)
                            {
                                return aliasName;
                            }
                            else
                            {
                                return folderName + '/' + line;
                            }
                        }
                    }
                }
                lstFile.close();
            }
        }
    }
    return QString();
}

QString CRSM::listScenarios(QString commandArgs)
{
    QString ret;
    if(commandArgs.isEmpty())
    {
        ret += "Folgende Szenarien stehen zur Auswahl:\n";
        QDirIterator it(Config.Auto.Volatile.Clonk.Directory, QDirIterator::FollowSymlinks);
        for(; it.hasNext(); it.next())
        {
            if(it.fileInfo().suffix() == "c4s" && !it.fileInfo().absoluteFilePath().contains(Config.Auto.Volatile.Clonk.Directory+"Network/"))
                ret += QString("   "+it.fileInfo().absoluteFilePath().replace(Config.Auto.Volatile.Clonk.Directory,"")+"\n");
        }
        ret += "-----------------------------------------------------------------\nFolgende Ordner stehen zur Auswahl:\n";
        QDirIterator folderIt(Config.CRSM.ListFolder, QDirIterator::FollowSymlinks);
        for(; folderIt.hasNext(); folderIt.next())
        {
            if(folderIt.fileInfo().suffix() == "lst" && !Config.Clonk.Server.IgnoreFolders.contains(folderIt.fileInfo().baseName()))
                ret += "   " + folderIt.fileInfo().completeBaseName() + "\n";
        }
    }
    else if(commandArgs.toLower() == "aliase")
    {
        ret += "Vorhandene Aliase:\n";
        foreach(const QString &alias, Config.Hosting.Alias.keys())
        {
            ret += QString("   " + alias + " = " + Config.Hosting.Alias.value(alias) + "\n");
        }
    }
    else
    {
        QFile file(Config.CRSM.ListFolder + commandArgs + ".lst");
        if(file.exists())
        {
            ret += "Der Ordner \"" + commandArgs + QString("\" enthält folgende Szenarien:\n");
            file.open(QFile::ReadOnly);
            while(!file.atEnd())
                ret += "   " + QString::fromUtf8(file.readLine()).trimmed() + "\n";
        }
        else
            ret += "Der Ordner \"" + commandArgs + "\" wurde nicht gefunden!\n";
    }
    return ret;
}

QString CRSM::printQueue()
{
    QString ret;
    if(userlist.length() == 0 && !autoHost)
    {
        return "Die Warteschlange ist leer.\n";
    }
    ret = "Folgende Szenarien befinden sich in der Warteschlange:\n";
    for(int i = 0; i < Config.Hosting.UserListLength; ++i)
    {
        const ScenarioSettings *scen;
        if(i < userlist.length())
        {
            scen = &userlist.at(i);
        }
        else if(!autoHost)
        {
            break;
        }
        else
        {
            scen = &nextAutoScens.at(i - userlist.length());
        }
        ret += "\t" + QString::number(i + 1) + ". " + scen->name + (scen->league ? " in der Liga" : "") + " (" + scen->wishClient.toString() + ")\n";
    }
    return ret;
}

void CRSM::ircCheckModCmd(const QString &nick, CmdFunctionRef func, QString arg)
{
    ircModFifos[nick].append(qMakePair<CmdFunctionRef, QString>(func, arg));
    ircCheckUserStatus(ClientInfo::ircClient(nick), ClientInfo::ircClient(nick), &CRSM::ircModCmd);
}

QString CRSM::skipScen()
{
    if(userlist.length() > 0)
    {
        QString skipped = userlist.first().name + " (" + userlist.first().wishClient.toString() + ")";
        userlist.removeFirst();
        return skipped;
    }
    else
        return "";
}

bool CRSM::skipCurrent()
{
    if(processManager->isRunning())
    {
        processManager->closeProgFifos();
        return true;
    }
    return false;
}

void CRSM::writeToServer(const QString &message)
{
    if(!processManager->isWritable())
        return;
    int i = 0;
    QStringList split = message.split('\n', QString::KeepEmptyParts);
    foreach(QString line, split)
    {
        if(!line.isEmpty())
        {
            if(i < split.length() - 1)
                line += "\n";
            while(line.length() > 240)
            {
                QString linePart = line.left(240);
                int pos = linePart.lastIndexOf(QRegExp("\\s"));
                bool wordSplit = false;
                if(pos <= 0)
                {
                    pos = 240;
                    wordSplit = true;
                }
                linePart = line.left(pos);
                line = line.mid(pos);
                if(wordSplit)
                {
                    linePart += "-";
                }
                linePart += "\n";
                processManager->write(codec->fromUnicode(linePart));
                if(Config.Readline.ServerUses)
                {
                    if(writtenToServer.length() > Config.Readline.RereadLimit)
                        writtenToServer.clear();
                    writtenToServer += codec->fromUnicode(linePart);
                }
            }
            processManager->write(codec->fromUnicode(line));
            if(Config.Readline.ServerUses)
            {
                if(writtenToServer.length() > Config.Readline.RereadLimit)
                    writtenToServer.clear();
                writtenToServer += codec->fromUnicode(line);
            }
        }
        ++i;
    }
}

void CRSM::writeConfig()
{
    Config.write(CONFIG_FILE_NAME);
}

QString CRSM::addAliasWish(const QString &param)
{
    QRegExp aliasExp("^([^=]+)=(.*)$");
    if(aliasExp.exactMatch(param))
    {
        const QString &alias = aliasExp.cap(1).trimmed();
        const QString &scen = aliasExp.cap(2).trimmed();
        QString scenP = scen;
        if(Config.Hosting.Alias.contains(alias))
        {
            return "Alias ist bereits vergeben!";
        }
        else if(Config.Auto.Hosting.AliasWishes.contains(alias))
        {
            return "Alias ist bereits als Wunsch vergeben!";
        }
        else if(!(scenP = scenPath(scen)).isEmpty())
        {
            Config.Auto.Hosting.AliasWishes.insert(alias, scenP);
            informModsAboutAliasWish();
            return "Aliaswunsch ist hinterlegt!";
        }
        else
        {
            return "Szenario \"" + scen + "\" wurde nicht gefunden!";
        }
    }
    else
    {
        return "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help für mehr Informationen.";
    }
}

void CRSM::informModsAboutAliasWish()
{
    foreach(const QString& mod, ircMods)
    {
        connection->sendCommand(IrcCommand::createNotice(mod, "Ein neuer Aliaswunsch ist verfügbar. Insgesamt verfügbar: " + QString::number(Config.Auto.Hosting.AliasWishes.size())));
    }
}

void CRSM::editAliasWishes()
{
    if(Config.Auto.Hosting.AliasWishes.isEmpty())
    {
        connection->sendCommand(IrcCommand::createMessage(aliasWishEditor, "Keine Aliaswünsche " + (currentAliasWish == "" ? QString("") : QString("mehr ")) + "vorhanden."));
        stopAliasWishEditing();
    }
    else
    {
        currentAliasWish = Config.Auto.Hosting.AliasWishes.firstKey();
        connection->sendCommand(IrcCommand::createMessage(aliasWishEditor, currentAliasWish + " = " + Config.Auto.Hosting.AliasWishes[currentAliasWish] + " [Ja|Nein|Stop]"));
    }
}

void CRSM::editAliasWishes(const QString &message)
{
    if(message.toLower() == "j" || message.toLower() == "ja")
    {
        Config.Hosting.Alias[currentAliasWish] = Config.Auto.Hosting.AliasWishes[currentAliasWish];
        Config.Auto.Hosting.AliasWishes.remove(currentAliasWish);
    }
    else if(message.toLower() == "n" || message.toLower() == "nein")
    {
        Config.Auto.Hosting.AliasWishes.remove(currentAliasWish);
    }
    else if(message.toLower() == "s" || message.toLower() == "stop")
    {
        connection->sendCommand(IrcCommand::createMessage(aliasWishEditor, "Aliaswunsch-Bearbeitung gestoppt."));
        stopAliasWishEditing();
        return;
    }
    else
    {
        connection->sendCommand(IrcCommand::createMessage(aliasWishEditor, "\"" + message + "\" ist keine Antwortmöglichkeit. Antwortmöglichkeiten: [Ja|Nein|Stop]"));
    }
    editAliasWishes();
}

void CRSM::stopAliasWishEditing()
{
    aliasWishEditor = "";
    currentAliasWish = "";
}

QString CRSM::ircActivateIngameChat(bool activated)
{
    if(Config.IRC.UseIngameChat && !Config.IRC.IngameChannel.isEmpty())
    {
        Session.IRC.UseIngameChat = activated;
        ircSetIngameChannelTopic();
        return "Ingamechat wurde " + (Session.IRC.UseIngameChat ? QString("") : QString("de")) + "aktviert.";
    }
    else
        return "Ingamechat ist administrativ deaktiviert!";
}

QStringList CRSM::listC4Folder(const QString &path)
{
    QStringList ret;
    QFileInfo fileInfo(path);
    if(fileInfo.isDir())
    {
        QDir dir(path);
        const QStringList folderList = dir.entryList(QStringList() << "*.c4f", QDir::NoFilter, QDir::Name | QDir::IgnoreCase);
        ret.append(dir.entryList(QStringList() << "*.c4s", QDir::NoFilter, QDir::Name | QDir::IgnoreCase));
        foreach(const QString &folder, folderList)
        {
            const QStringList &folderList = listC4Folder(path + '/' + folder);
            foreach (const QString &scen, folderList) {
                ret.append(folder + '/' + scen);
            }
        }
    }
    else
    {
        QProcess c4group;
        c4group.start(Config.Auto.Volatile.Clonk.Directory + C4GROUP_EXECUTABLE, QStringList() << path << "-l", QProcess::ReadOnly);
        c4group.waitForFinished();
        c4group.readLine();
        QRegExp finishExp("^\\d+ Entries, \\d+ Bytes$");
        QRegExp scenarioExp("^(.*\\.c4s)\\s+\\d+ Bytes\\s.*$");
        QRegExp folderExp("^(.*\\.c4f)\\s+\\d+ Bytes\\s.*$");
        QString line;
        while(!c4group.atEnd())
        {
            line = codec->toUnicode(c4group.readLine().trimmed());
            if(line.isEmpty())
                continue;
            if(finishExp.exactMatch(line))
                break;
            if(scenarioExp.exactMatch(line))
            {
                ret.append(scenarioExp.cap(1));
            }
            else if(folderExp.exactMatch(line))
            {
                const QStringList &folderList = listC4Folder(path + '/' + folderExp.cap(1));
                foreach (const QString &scen, folderList) {
                    ret.append(folderExp.cap(1) + '/' + scen);
                }
            }
        }
    }
    return ret;
}

void CRSM::ircSetIngameChannelTopic()
{
    if(Config.IRC.UseIngameChat && !Config.IRC.IngameChannel.isEmpty())
    {
        if(Session.State == CRSMSession::None)
        {
            connection->sendCommand(IrcCommand::createTopic(Config.IRC.IngameChannel, "Kein laufendes Spiel."));
        }
        else
        {
            QString statusText = "";
            switch(Session.State)
            {
                case CRSMSession::Lobby:
                    statusText = "Lobby";
                    break;
                case CRSMSession::Loading:
                    statusText = "Lädt ";
                    break;
                case CRSMSession::Running:
                    statusText = "Läuft";
                    break;
                default:
                    break;
            }
            connection->sendCommand(IrcCommand::createTopic(Config.IRC.IngameChannel, "Aktuelles Szenario: " + Session.Scenario.name + " | " + statusText + " | Ingamechat ist " + (Session.IRC.UseIngameChat ? "" : "de") + "aktviert."));
        }
    }
}

void CRSM::addCommand(const QString &name, CmdFunction func, int interfaces, UserType userType, const QString &shortDescription, const QString &argList, const QString &longDescription)
{
    cmds.insert(name.trimmed(), CmdFunctionRef(name.trimmed(), func, interfaces, userType, shortDescription, argList, longDescription));
}

void CRSM::addCommandGroup(const QString &name, int interfaces, UserType userType, const QString &shortDescription, const QString &longDescription, CmdFunction defaultFunc)
{
    if(!cmdGroups.contains(name)) cmdGroups.append(name);
    addCommand(name, defaultFunc, interfaces, userType, shortDescription, "", longDescription);
    addCommand(name + " help", &CRSM::grouphelp, interfaces, userType, "Gibt Hilfe zu den Unterbefehlen von " + name, "[Unterbefehlsname]");
}

bool CRSM::cmdExists(const QString &name, ClientInterface interface)
{
    return cmds.contains(name) && cmds.value(name).interfaces & interface;
}

CmdFunctionRef* CRSM::findCommand(const QString &cmd, ClientInterface interface)
{
    return findCommand(cmd.split(QRegularExpression(R"(\s)"), QString::KeepEmptyParts), interface);
}

CmdFunctionRef* CRSM::findCommand(QStringList&& cmd, ClientInterface interface)
{
    if(cmd.length() > 0)
    {
        const QString& cmdPart = cmd.join(' ');
        if(cmdExists(cmdPart, interface))
        {
            return &cmds[cmdPart];
        }
        else
        {
            cmd.removeLast();
            return findCommand(std::move(cmd), interface);
        }
    }
    else
    {
        return nullptr;
    }
}

bool CRSM::cmd(const QString &cmd, const ClientInfo &client)
{
    CmdFunctionRef* cmdPtr;
    if((cmdPtr = findCommand(cmd, client.interface)) != nullptr)
    {
        CmdFunctionRef cmdRef = *cmdPtr;
        QString args = cmd.mid(cmdRef.name.length()).trimmed();
        switch(client.interface)
        {
            case Clonk:
                if(clientUserType(client) >= cmdRef.userType)
                {
                    callCommand(cmdRef, args, client, clientUserType(client));
                }
                else
                {
                    rightsFailMessage(client, cmdRef.userType);
                    Stats.AddCommandResult(client, cmdRef.name, RightsFail);
                }
                break;
            case IRC:
                if(cmdRef.userType == User || ((cmdRef.userType == Admin && (clientUserType(client) >= Admin)) || (cmdRef.userType == Moderator && clientUserType(client) >= Moderator)))
                {
                    callCommand(cmdRef, args, client, clientUserType(client));
                }
                else if(cmdRef.userType >= Admin)
                {
                    ircCheckModCmd(client.nick, cmdRef, args);
                }
                break;
            case Management:
                callCommand(cmdRef, args, client, UserType::Max);
                break;
            case Auto: //just to avoid the compiler warning, there can't be a command from this interface
                break;
        }

        return true;
    }
    else
    {
        Stats.AddCommandResult(client, cmd, UnknownCommand);
        return false;
    }
}

void CRSM::rightsFailMessage(const ClientInfo &info, UserType minUserType)
{
    respond(info, "Nur ein " + userTypeStrings.value(minUserType) + " kann diesen Befehl verwenden.\n", RespondType::PrivateNotice);
}

UserType CRSM::clientUserType(const ClientInfo &client)
{
    switch(client.interface)
    {
        case Clonk:
            if(Config.Clonk.Chat.Moderators.contains(client.CUID))
                return Moderator;
            if(Session.Clonk.Admin == client)
                return Admin;
            break;
        case IRC:
            if(ircMods.contains(client.nick))
                return Moderator;
            else if(Session.IRC.Admin == client)
                return Admin;
            break;
        case Management:
            return Max;
        case Auto: //just to avoid the compiler warning
          break;
    }

    return User;
}

void CRSM::setupCmds()
{
    cmds.clear();
    cmdGroups.clear();

    addCommand("admin", &CRSM::admin, Clonk | IRC, User, "Ohne Name trägt es den Autor der Nachricht als Rundenadmin ein, bzw. mit Name den Spieler mit entsprechendem Namen, insofern nicht bereits ein Rundenadmin feststeht.", "[Chatnick¦PC-Name]");
    addCommand("admin?", &CRSM::getAdmin, Clonk | IRC | Management, User, "Fragt den aktuellen Rundenadmin ab.");
    addCommand("afkadmin", &CRSM::afkAdmin, Clonk | IRC | Management, User, "Gibt den Rundenadmin frei, wenn er nicht in den nächsten " + QString::number(Config.Hosting.AfkAdminTime) + "s reagiert.");
    addCommand("ingameadmin", &CRSM::ingameadmin, IRC | Management, Admin, "Legt den Ingame-Rundenadmin fest.", "<Ingame-Nick¦PC-Name>");

    addCommand("noadmin", &CRSM::noadmin, Clonk | IRC | Management, Admin, "Entzieht dem (IRC-)Rundenadmin seine Rechte, damit jemand anders Rundenadmin sein kann.");
    addCommand("aliaswish", &CRSM::aliaswish, Clonk | IRC, User, "Deponiert den Wunsch, <Alias> als Alias für <Szenario> einzutragen. Ein Moderator entscheidet darüber.", "<Alias> = <Szenario>");
    addCommand("queue", &CRSM::queue, Clonk | IRC | Management, User, "Zeigt die nächsten " + QString::number(Config.Hosting.UserListLength) + " Szenarien auf der Warteliste.");
    addCommand("host", &CRSM::host, Clonk | IRC | Management, User, "Nimmt das angegebene Szenario in die Warteschlange auf. Optional in der Liga, wenn \"--league\" angegeben wird.", "[--league] <Szenarioname¦Alias>");
    addCommand("list", &CRSM::list, Clonk | IRC | Management, User, "Listet alle definierten Aliase oder alle möglichen Szenarien und Ordner auf, bzw. alle Szenarien im Ordner oder Rundenordner.", "[Aliase¦Rundenordner[.c4f]]");
    addCommand("clientlist", &CRSM::clientlist, IRC | Management, User, "Listet alle verbundenen Clients mit PC-Name und Chatnick auf.");
    addCommand("help", &CRSM::help, Clonk | IRC | Management, User, "Zeigt die Hilfe an.",  "[long¦Befehlsname]", "Listet alle verfügbaren Befehle auf. Mit long werden alle verfügbaren Befehle mit Kurzbeschreibung aufgelistet.");
    addCommand("stop", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Stoppt einen laufenden Countdown.");
    addCommand("start", &CRSM::passToClonkNumericOrEmpty, Clonk | IRC | Management, Admin, "Startet den Countdown.", "[Countdownzeit in s]");
    addCommand("teamdist", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Ändert die Teamverteilung.", "<none¦free¦host¦random¦randominv>");
    addCommand("plrteam", &CRSM::passToClonk, Clonk | IRC, Admin, "Ändert das Team eines Spielers.", "<Spieler> <neues Team>", "Verschiebt <Spieler> in das <neue Team>.");
    addCommand("pause", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Pausiert das Spiel.");
    addCommand("unpause", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Setzt das pausierte Spiel fort.");
    addCommand("observer", &CRSM::passToClonkPcName, Clonk | IRC | Management, Admin, "Der angegebene Host muss zuschauen.", "<PC-Name¦Chatnick>");
    addCommand("deactivate", &CRSM::passToClonkPcName, Clonk | IRC | Management, Admin, "Deaktiviert den angegebenen Host.", "<PC-Name¦Chatnick>");
    addCommand("activate", &CRSM::passToClonkPcName, Clonk | IRC | Management, Admin, "Aktiviert den angegebenen Host.", "<PC-Name¦Chatnick>");
    addCommand("kick", &CRSM::passToClonkPcName, Clonk | IRC | Management, Admin, "Kickt den angegebenen Host.", "<PC-Name¦Chatnick>");
    addCommand("script", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Führt das angegebene Script aus.", "<Script>");
    addCommand("asyncctrl", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Aktiviert den asynchronen Netzwerkmodus.");
    addCommand("centralctrl", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Aktiviert den zentralen Netzwerkmodus.");
    addCommand("decentralctrl", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Aktiviert den dezentralen Netzwerkmodus.");
    addCommand("newscriptplayer", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Fügt in der Lobby einen Script spieler hinzu.", "[Spielername]");
    addCommand("removeplr", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Entfernt einen Spieler in der Lobby.", "[Spielername]");
    addCommand("nodebug", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Deaktiviert den Debug-Modus zwingend für alle.");
    addCommand("autohost", &CRSM::autohost, Clonk | IRC | Management, Moderator, "Aktiviert Auto-Hosting.");
    addCommand("noautohost", &CRSM::autohost, Clonk | IRC | Management, Moderator, "Deaktiviert Auto-Hosting.");

    addCommandGroup("set", Clonk | IRC | Management, Admin, "Setzt diverse Einstellungen entsprechend dem /set Befehl von Clonk.");
    addCommand("set maxplayer", &CRSM::passToClonkNumeric, Clonk | IRC | Management, Admin, "Setzt die maximale Anzahl an möglichen Spielern in dieser Runde.", "<Spieleranzahl>");
    addCommand("set password", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Setzt das Passwort für diese Runde, bzw. entfernt es, wenn kein Passwort angegeben wird.", "[Passwort]");
    addCommand("set faircrew", &CRSM::passToClonkOnOff, Clonk | IRC | Management, Admin, "De-/aktiviert Faire Crew für diese Runde.", "<on¦off>");
    addCommand("set teamcolors", &CRSM::passToClonkOnOff, Clonk | IRC | Management, Admin, "De-/aktiviert Teamfarben für diese Runde.", "<on¦off>");
    addCommand("set runtimejoin", &CRSM::passToClonkOnOff, Clonk | IRC | Management, Admin, "De-/aktiviert Laufzeitbeitritt für diese Runde.", "<on¦off>");
    addCommand("set comment", &CRSM::passToClonk, Clonk | IRC | Management, Moderator, "Setzt den Netzwerkkommentar, bzw. entfernt ihn, wenn kein Kommentar angegeben wird.", "[Kommentar]");
    addCommand("set raw", &CRSM::setRaw, Clonk | IRC | Management, Moderator, "Setzt beliebige /set-Werte.", "<Option> [Wert]");

    addCommand("skip", &CRSM::skip, Clonk | IRC | Management, Moderator, "Entfernt das nächste Szenario aus der Wunschliste.");
    addCommand("next", &CRSM::next, Clonk | IRC | Management, Moderator, "Versucht das aktuelle Szenario zu überspringen.");
    addCommand("kill", &CRSM::kill, IRC | Management, Moderator, "Tötet den Clonk-Server, vorausgesetzt es läuft einer.", "", "Tötet den Clonk-Server, vorausgesetzt es läuft einer. Bitte nur verwenden wenn " + Config.CRSM.CommandSign + "next nicht funktioniert.");
    addCommand("clear", &CRSM::clear, Clonk | IRC | Management, Moderator, "Löscht die Wunschliste.");
    addCommand("aliaswishes", &CRSM::aliaswishes, IRC | Management, Moderator, "Zum geführten Bearbeiten der Aliaswünsche.");
    addCommand("newalias", &CRSM::newalias, Clonk | IRC | Management, Moderator, "Trägt <Alias> als Alias für <Szenario> ein.", "<Alias> = <Szenario>");
    addCommand("modinfo", &CRSM::modinfo, IRC | Management, Moderator, "Listet alle Moderatoren auf.");


    if(Config.IRC.Use)
    {
        addCommandGroup("irc", Clonk | IRC | Management, Admin, "Die irc-Befehlsgruppe bietet diverse Befehle zur Steuerung der IRC-Funktionen.");

        addCommand("irc admin", &CRSM::ircadmin, Clonk | Management, Admin, "Legt den IRC-Rundenadmin fest.", "<IRC-Nick>", "Legt den IRC-Rundenadmin fest. Der IRC-Admin kann über den IRC dieselben Aktionen durchführen wie der Ingame-Rundenadmin.");
        addCommand("irc join", &CRSM::join, IRC | Management, Moderator, "Betritt den angegebenen IRC-Channel, optional mit angegebenem Schlüssel.", "<channel> [channel-key]");
        addCommand("irc leave", &CRSM::leave, IRC | Management, Moderator, "Verlässt den angegebenen oder aktuellen IRC-Channel, optional mit angegebenem Grund.", "[channel] [reason]");

        if(Config.IRC.UseIngameChat)
        {
            addCommand("irc ingamechat", &CRSM::ircchat, Clonk | IRC | Management, Admin, "Schaltet den Irc-Ingame-Chat ein bzw. aus.", "<on¦off>");
        }

        addCommand("irc io", &CRSM::io, IRC, Moderator, "Schaltet den IO-Modus ein bzw. aus.", "", "Schaltet den IO-Modus ein bzw. aus. Im IO-Modus wird die Ausgabe vom Clonk-Server an den Privat-Chat weitergeleitet und der Privat-Chat wird an den Clonk-Server weitergeleitet. Clonk-Befehle mit \\ statt /.");
        addCommand("irc reconnect", &CRSM::reconnectIrc, Management, UserType::Max, "Stellt die IRC-Verbindung wieder her.");
        addCommand("irc say", &CRSM::ircSay, IRC | Management, Moderator, "Schreibt die <Nachricht> an <Channel¦Nick>.", "<Channel¦Nick> <Nachricht>");
        addCommand("irc watch", &CRSM::ircWatch, IRC | Management, Moderator, "Sendet alle Nachrichten, die der Server im IRC-Netzwerk aufschnappt, an Moderatoren, die watch aktiviert haben.", "<on¦off>");
    }

    addCommandGroup("exit", Management, UserType::Max, "Beendet den Server Mananger.", "Beendet den Server Mananger und falls ein Clonk-Server läuft auch diesen. Die Unterbefehle ermöglichen außerdem diverse Zusatzvarienten des Beendens.", &CRSM::exit);
    addCommand("exit detach", &CRSM::exitDetach, Management, UserType::Max, "Beendet den Server Mananger, lässt den Clonk-Server weiterlaufen.", "",  "Beendet den Server Mananger und falls ein Clonk-Server läuft, läuft dieser weiter.");
    addCommand("exit update", &CRSM::exitUpdate, Management, UserType::Max, "Zusätzlich zu " + Config.CRSM.CommandSign + "exit detach wird im laufenden Spiel angekündigt, dass der Server-Manager wegen eines Updates beendet wird.");
    addCommand("exit after", &CRSM::exitAfter, Management, UserType::Max, "Beendet den Server-Manager, sobald das laufende Spiel vorbei ist.");

    addCommandGroup("config", Management, UserType::Max, "Die config-Befehlsgruppe bietet diverse Befehle zum Verwalten der Konfiguration.");
    addCommand("config reload", &CRSM::reload, Management, UserType::Max, "Liest die Konfigurationsdatei neu ein.");
    addCommand("config save", &CRSM::saveConfig, Management, UserType::Max, "Speichert die aktuelle Konfiguration in die Konfigurationsdatei.");
    addCommand("config get", &CRSM::getConfigValue, Management, UserType::Max, "Gibt den aktuellen Wert <Wertname> von der Konfiguration an.", "<Wertname>");
    addCommand("config set", &CRSM::setConfigValue, Management, UserType::Max, "Setzt einen Konfigurationswert.", "<Konfigurationszeile>", "Setzt einen Konfigurationswert. Der Wert wird wie eine Zeile in der Konfigurationsdatei angegeben.");

    addCommandGroup("packs", Management, UserType::Max, "Über die packs-Befehlsgruppe lassen sich mehrere Versionen eines Objektpakets für unterschiedliche Szenarien verwalten.");
    addCommand("packs list", &CRSM::packsList, Management, UserType::Max, "Listet alle bekannten Packs und ihre Versionen auf.");
    addCommand("packs directory", &CRSM::packsDirectory, Management, UserType::Max, "Fragt den aktuellen Unterordner für Packversionen ab, bzw. setzt ihn auf <Directory>.", "[Directory]");
    addCommandGroup("packs versions", Management, UserType::Max, "Über die packs versions-Befehlsgruppe werden die einzelnen bekannten Packs und vorhandenen Versionen verwaltet.");
    addCommand("packs versions add", &CRSM::packsVersionsAdd, Management, UserType::Max, "Fügt eine neue <Packversion> für das <Pack> hinzu.", "<Packversion> = <Pack>");
    addCommand("packs versions delete", &CRSM::packsVersionsDelete, Management, UserType::Max, "Löscht eine <Packversion>.", "<Packversion>");
    addCommand("packs versions default", &CRSM::packsVersionsDefault, Management, UserType::Max, "Fragt die Packversion ab, die standardmäßig für das <Pack> verwendet wird, oder setzt sie, wenn <Packversion> angegeben wird.", "<Pack> [= <Packversion>]");
    addCommandGroup("packs scenarios", Management, UserType::Max, "Über die packs scenarios-Befehlsgruppe werden die einzelnen Packversionen den Szenarien zugeteilt.");
    addCommand("packs scenarios add", &CRSM::packsScenariosAdd, Management, UserType::Max, "Aktiviert für das <Szenario> die <Packversion>.", "<Szenario> <Packversion>");
    addCommand("packs scenarios delete", &CRSM::packsScenariosDelete, Management, UserType::Max, "Löscht für das <Szenario> die <Packversion>.", "<Szenario> <Packversion>");
    addCommand("packs scenarios list", &CRSM::packsScenariosList, Management, UserType::Max, "Listet alle Szenarien mit ihren Packversionen auf.");

    addCommand("relist", &CRSM::relist, Management, UserType::Max, "Durchsucht veränderte Rundenordner erneut.");
}

void CRSM::respond(const ClientInfo &client, const QString &message, const RespondType type)
{
    switch(client.interface)
    {
    case Clonk:
        writeToServer(message);
        break;
    case IRC:
        foreach(const QString line, message.split('\n', QString::SkipEmptyParts))
        {
            switch(type)
            {
                case RespondType::Normal:
                case RespondType::Private:
                    connection->sendCommand(IrcCommand::createMessage(type == Normal ? client.target : client.nick, line));
                    break;
                case RespondType::Notice:
                case RespondType::PrivateNotice:
                    connection->sendCommand(IrcCommand::createNotice(type == Notice ? client.target : client.nick, line));
                    break;
            }
        }
        break;
    case Management:
        client.management.socket->write(message.toUtf8());
        break;
    case Auto: //just to avoid the compiler warning
        break;
    }
}

void CRSM::ircCheckUserStatus(const ClientInfo &requester, const ClientInfo &subject, IrcCheckCallback callback)
{
    ircStatusFifos[subject.nick].append(qMakePair<ClientInfo, IrcCheckCallback>(requester, callback));
    connection->sendCommand(IrcCommand::createMessage("NickServ", "STATUS " + subject.nick));
}

void CRSM::setIngameAdmin(const ClientInfo &client, const QString& newAdmin)
{
    if(Session.Clonk.Clients.contains(newAdmin))
    {
        const ClientInfo& info = Session.Clonk.Clients.value(newAdmin);
        if(Session.Clonk.Admin == info)
        {
            respond(client, info.toString() + " ist bereits Rundenadmin.\n");
        }
        Session.Clonk.Admin = info;
    }
    else
    {
        bool notFound = true, ambigous = false;
        ClientInfo foundClient;
        foreach(const ClientInfo& client, Session.Clonk.Clients)
        {
            if(client.nick == newAdmin)
            {
                if(!notFound)
                {
                    ambigous = true;
                    break;
                }
                foundClient = client;
                notFound = false;
            }
        }
        if(ambigous)
        {
            respond(client, "Chat-Nickname " + newAdmin + " ist nicht eindeutig. Bitte PC-Namen verwenden.\n");
            return;
        }
        else if(notFound)
        {
            respond(client, newAdmin + " wurde nicht gefunden!\n");
            return;
        }
        else if(Session.Clonk.Admin == foundClient)
        {
            respond(client, Session.Clonk.Admin.toString() + " ist bereits Rundenadmin!\n");
            return;
        }
        else
        {
            Session.Clonk.Admin = foundClient;
        }
        respond(client, Session.Clonk.Admin.toString() + " wurde als Rundenadmin eingetragen.\n");
    }
}

void CRSM::out(const QString &text)
{
    *qout << text;
    qout->flush();
    if(managementConnections.size() == 0)
    {
        outputBuffer.write(text.toUtf8());
    }
    else
    {
        foreach(const ManagementConnection& conn, managementConnections)
        {
            conn.socket->write(text.toUtf8());
        }
    }
}

void CRSM::replayOutputBuffer(QTcpSocket *socket, bool clear)
{
    QFile outputBufferRead(MGMT_BUFFER_FILENAME);
    outputBufferRead.open(QFile::ReadOnly);
    const QByteArray& data = outputBufferRead.readAll();
    outputBufferRead.close();
    socket->write(data);
    if(clear)
    {
        outputBuffer.close();
        outputBuffer.open(QFile::WriteOnly | QFile::Unbuffered);
    }
}

bool CRSM::scenAllowed(const ScenarioSettings &scen, const ClientInfo &client, UserType userType)
{
    if(userType >= UserType::Moderator)
    {
        return true;
    }
    QString scenName = scen.name;
    while(Config.Hosting.Alias.contains(scenName))
        scenName = Config.Hosting.Alias.value(scenName);

    int scenCount = 0;
    int userCount = 0;
    foreach(const ScenarioSettings& setting, userlist)
    {
        userCount += (setting.wishClient == client);

        QString otherScenName = setting.name;
        while(Config.Hosting.Alias.contains(otherScenName))
            otherScenName = Config.Hosting.Alias.value(otherScenName);

        scenCount += (otherScenName == scenName);
    }
    if(scenCount >= Config.Hosting.MaxWishesPerScen)
    {
        respond(client, "Dieses Szenario ist jetzt oft genug in der Wunschliste!\n");
        return false;
    }
    if(userCount >= Config.Hosting.MaxWishesPerUser)
    {
        respond(client, "Von dir sind jetzt genug Wünsche in der Liste!\n");
        return false;
    }
    return true;
}

void CRSM::kick(const QString& pcName, const QString& reason)
{
    writeToServer("/kick " + pcName + (reason.isEmpty() ? QString("") : QString(" ") + reason) + "\n");
}

void CRSM::prepareAndConnectIrc()
{
    connection = new IrcConnection(Config.IRC.Server);
    connection->setUserName(Config.IRC.Nick);
    connection->setNickName(Config.IRC.Nick);
    connection->setRealName(Config.IRC.RealName);
    connection->setReconnectDelay(Config.IRC.ReconnectDelay);
    connection->setPassword(Config.IRC.Password);

    connect(connection, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(ircMessageReceived(IrcMessage*)));
    connect(connection, SIGNAL(connected()), this, SLOT(ircConnected()));
    connection->open();
}

void CRSM::reconnectIrc()
{
    if(connection != nullptr)
    {
        connection->close();
        delete connection;
    }
    prepareAndConnectIrc();
}

void CRSM::enableAutoHosting()
{
    gameRegisterFailTimer.stop();
    hostingIsErrorDeactivated = false;

    autoHost = true;
    if(Session.State == CRSMSession::None)
    {
        nextScen();
    }
}

void CRSM::afkAdminTimeout()
{
    Session.IRC.Admin.clear();
    Session.Clonk.Admin.clear();
    writeToServer("Der Rundenadmin war zu lange AFK und wurde freigegeben.\n");
    if(Session.IRC.UseIngameChat)
    {
        connection->sendCommand(IrcCommand::createMessage(Config.IRC.IngameChannel, "Der Rundenadmin war zu lange AFK und wurde freigegeben.\n"));
    }
    Session.AfkAdmin = false;
}

ClientInfo &CRSM::getClientInfo(const QString &pcName, int cuid, const QString &user)
{
    if(!Session.Clonk.Clients.contains(pcName))
    {
        Session.Clonk.Clients.insert(pcName, ClientInfo::clonkClient(user, pcName, cuid));
    }
    return Session.Clonk.Clients[pcName];
}

void CRSM::exit()
{
    if(processManager != nullptr) processManager->closeProgFifos();
    Config.Auto.ProcessManager.ReattachId.clear();
    finish = true;
    if(Session.State == CRSMSession::None)
        scenarioFinished();
}

void CRSM::applyConfig()
{
    writeFiles(false, true);
    args.clear();
    args << "/config:" + Config.Clonk.Server.Config;
    args << Config.Clonk.Server.Arguments.split(" ");
    Config.Auto.Volatile.Clonk.Directory = QFileInfo(Config.Clonk.Server.Executable).absoluteDir().absolutePath() + QDir::separator();
    afkAdminTimer.setInterval(Config.Hosting.AfkAdminTime * 1000);

    Config.CRSM.ListFolder = QDir(Config.CRSM.ListFolder).absolutePath() + QDir::separator();

    if(!QDir(Config.CRSM.ListFolder).exists())
    {
        if(!QDir().mkpath(Config.CRSM.ListFolder))
        {
            out("ERROR: Could not create the CRSM.ListFolder: " + Config.CRSM.ListFolder + "\n");
            ok = false;
            exit();
        }
    }

    QFile clonkConfig(Config.Clonk.Server.Config);
    if(!clonkConfig.exists())
    {
        out("WARNING: Clonk's config file is not existing!");
    }
    else
    {
        clonkConfig.open(QFile::ReadOnly);
        static QRegExp nickExp(R"_(^\s*Nick="(.*)"\s*$)_");
        static QRegExp pcNameExp(R"_(^\s*LocalName="(.*)"\s*$)_");
        foreach(const QString &line, QString(clonkConfig.readAll().trimmed()).split("\n"))
        {
            if(!Config.Auto.Volatile.Clonk.ServerNick.isEmpty() && !Config.Auto.Volatile.Clonk.ServerPCName.isEmpty()) break;
            if(nickExp.exactMatch(line.trimmed()))
            {
                Config.Auto.Volatile.Clonk.ServerNick = Util::unescapeClonkString(nickExp.cap(1));
                continue;
            }
            else if(pcNameExp.exactMatch(line.trimmed()))
            {
                Config.Auto.Volatile.Clonk.ServerPCName = Util::unescapeClonkString(pcNameExp.cap(1));
                continue;
            }
        }
    }
    if((ushort)Config.CRSM.ManagementPort == 0)
    {
        Config.CRSM.ManagementPort = 9372;
    }
    if(!QFile(Config.Clonk.Server.Executable).exists())
    {
        out("ERROR: The Clonk.Server.Executable doesn't exist: \"" + Config.Clonk.Server.Executable + "\"\n");
        ok = false;
        exit();
    }

    if(Config.IRC.Use)
    {
        if(connection == nullptr)
        {
            prepareAndConnectIrc();
        }
        else
        {
            if(connection->isConnected())
            {
                if(connection->nickName() != Config.IRC.Nick)
                {
                    connection->sendCommand(IrcCommand::createNick(Config.IRC.Nick));
                }
            }
        }
    }
    else
    {
        Config.IRC.UseIngameChat = false;
        if(connection != nullptr)
        {
            connection->quit(Config.IRC.QuitMessage);
        }
    }

    if(!Config.IRC.UseIngameChat)
    {
        Session.IRC.UseIngameChat = false;
    }

    setupCmds();
    out(Stats.read(Config.CRSM.StatsFile));
    out(Packs.read(Config.CRSM.PacksFile, Config.Auto.Volatile.Clonk.Directory));
}

QString CRSM::scenarioFileName(QString name)
{
    while(Config.Hosting.Alias.contains(name))
        name = Config.Hosting.Alias.value(name);
    return name;
}

CmdResult CRSM::callCommand(const CmdFunctionRef &func, const QString &args, const ClientInfo &client, UserType userType)
{
    CmdResult ret = (this->*func.func)(func.name, args, client, userType);
    Stats.AddCommandResult(client, func.name, ret);
    return ret;
}

void CRSM::writeFiles(bool writeSession, bool writeNoConfig)
{
    if(writeSession)
    {
        Session.write(Config.CRSM.SessionFile);
    }
    Stats.write();
    Packs.write();
    if(!writeNoConfig)
    {
        writeConfig();
    }
}

void CRSM::checkActivity(ClientInfo &client)
{
    if(client.antiFloodList.isEmpty())
    {
        client.antiFloodList.append(QDateTime::currentDateTime());
    }
    else
    {
        client.antiFloodList.last() = QDateTime::currentDateTime();
    }

    if(Session.AfkAdmin)
    {
        respond(client, "Da du reagiert hast, kannst du den Rundenadmin beibehalten.\n");
        afkAdminTimer.stop();
        Session.AfkAdmin = false;
    }
}

CMD_FUNCTION_IMPL(help)
    bool longHelp = (args == "long");
    if(args.isEmpty() || longHelp)
    {
        QString response = "Verfügbare Befehle: ";
        foreach(const CmdFunctionRef& cmd, cmds)
        {
            if(cmd.name.contains(' ')) continue;
            if((cmd.interfaces & client.interface) == client.interface && userType >= cmd.userType)
            {
                if(longHelp)
                {
                    response += "\n" + Config.CRSM.CommandSign + cmd.name + QString(" ") + (!cmd.argList.isEmpty() ? cmd.argList + QString(" ") : QString("")) + (!cmd.shortDescription.isEmpty() ? QString("- ") + cmd.shortDescription : QString(""));
                }
                else
                    response += cmd.name + ", ";
            }
        }
        if(!longHelp)
            response = response.left(response.length() - 2);
        respond(client, response + "\n");
        respond(client, "Genauere Informationen zu einem Befehl mit " + Config.CRSM.CommandSign + "help <Befehlsname>\n"
                        "[Sachen in eckigen Klammern sind optional]\n"
                        "<Sachen in spitzen Klammern sind benoetigte Argumente>\n"
                        "Beim Einsetzen der Argumente werden <> bzw. [] weggelassen.\n");
    }
    else
    {
        if(cmdExists(args, client.interface))
        {
            const CmdFunctionRef& cmd = cmds.value(args);
            respond(client, Config.CRSM.CommandSign + cmd.name + " " + (!cmd.argList.isEmpty() ? cmd.argList + " " : "") + (!cmd.longDescription.isEmpty() ? "- " + cmd.longDescription : !cmd.shortDescription.isEmpty() ? "- " + cmd.shortDescription : "") + "\n");
            if(cmdGroups.contains(args))
            {
                bool first = true;
                QString response;
                QString cmdPart = args + " ";
                foreach(const QString& cmdName, cmds.keys())
                {
                    if(cmdName.count(' ') > args.count(' ') + 1) continue;
                    if(cmdName.length() > args.length() && cmdName.left(args.length() + 1) == cmdPart)
                    {
                        CmdFunctionRef& cmdRef = cmds[cmdName];
                        if(cmdRef.userType > userType || !(cmdRef.interfaces & client.interface)) continue;
                        if(first)
                        {
                            response = "Verfügbare Unterbefehle für " + args + " (nähere Infos zu einem Befehl mit " + Config.CRSM.CommandSign + "help " + args + " <Unterbefehlsname>):\n ";
                            first = false;
                        }
                        else
                        {
                            response += ", ";
                        }
                        response += cmdName.midRef(args.length() + 1);
                    }
                }
                if(first)
                {
                    respond(client, "Dieser Befehl hat keine Unterbefehle.\n");
                }
                else
                {
                    response += "\n";
                    respond(client, response);
                }
            }
        }
        else
        {
            respond(client, "Der Befehl " + args + " existiert nicht.\n");
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(passToClonk)
    writeToServer('/' + cmd + ' ' + args + '\n');
    return Success;
}

CMD_FUNCTION_IMPL(admin)
    ClientInfo *interfaceAdminPtr;
    switch(client.interface)
    {
        case Clonk:
            interfaceAdminPtr = &Session.Clonk.Admin;
            if(args == Config.Auto.Volatile.Clonk.ServerNick || args == Config.Auto.Volatile.Clonk.ServerPCName)
            {
                respond(client, "Der Server kann nicht als Rundenadmin eingetragen werden!\n");
                return Success;
            }
            break;
        case IRC:
            interfaceAdminPtr = &Session.IRC.Admin;
            break;
        default:
            return Success;
    }
    ClientInfo& interfaceAdmin = *interfaceAdminPtr;
    if(args.isEmpty() && interfaceAdmin == client)
    {
        respond(client, "Du bist bereits Rundenadmin!\n");
        return Success;
    }
    else if((!Session.IRC.Admin.empty() || !Session.Clonk.Admin.empty()) && userType < Admin && !(Session.Clonk.LeaveAdmins.contains(client) && Session.Clonk.LeaveAdmins.value(client).secsTo(QDateTime::currentDateTime()) < Config.Clonk.Chat.RegainAdminTime))
    {
        respond(client, Session.IRC.Admin.toString() + (!Session.IRC.Admin.nick.isEmpty() && !Session.Clonk.Admin.nick.isEmpty() ? " und " : "") + Session.Clonk.Admin.toString() + " ist bereits Rundenadmin!\n");
        return Success;
    }
    else if(args.isEmpty())
    {
        interfaceAdmin = client;
        respond(client, client.toString() + " wurde als Rundenadmin eingetragen!\n");
        return Success;
    }
    else if(client.interface == Clonk)
    {
        setIngameAdmin(client, args);
    }
    else if(client.interface == IRC)
    {
        ircCheckUserStatus(client, ClientInfo::ircClient(args), &CRSM::ircSetAdmin);
    }
    return Success;
}

CMD_FUNCTION_IMPL(afkAdmin)
    if(Session.IRC.Admin.empty() && Session.Clonk.Admin.empty())
    {
        respond(client, "Es gibt noch keinen Rundenadmin.\n");
    }
    else if((!Session.IRC.Admin.empty() && !Session.IRC.Admin.antiFloodList.isEmpty() && Session.IRC.Admin.antiFloodList[0].secsTo(QDateTime::currentDateTime()) < Config.Hosting.AfkAdminPreAfkTime) || (!Session.Clonk.Admin.empty() && !Session.Clonk.Admin.antiFloodList.isEmpty() && Session.Clonk.Admin.antiFloodList[0].secsTo(QDateTime::currentDateTime()) < Config.Hosting.AfkAdminPreAfkTime))
    {
        respond(client, "Der Rundenadmin war gerade aktiv.\n");
    }
    else
    {
        Session.AfkAdmin = true;
        afkAdminTimer.start();
        if(client.interface != Clonk || Session.Clonk.Admin.empty())
        {
            respond(client, "Der Rundenadmin wird nach weiteren " + QString::number(Config.Hosting.AfkAdminTime) + "s Inaktivität freigegeben.\n");
        }
        writeToServer("/alert\n");
        if(!Session.Clonk.Admin.empty())
        {
            writeToServer(Session.Clonk.Admin.nick + "! Wenn du dich nicht in den nächsten " + QString::number(Config.Hosting.AfkAdminTime) + "s meldest, wird der Rundenadmin freigegeben.\n");
        }
        if(!Session.IRC.Admin.empty())
        {
            respond(Session.IRC.Admin, Session.IRC.Admin.nick + "! Wenn du dich nicht in den nächsten " + QString::number(Config.Hosting.AfkAdminTime) + "s meldest, wird der Rundenadmin freigegeben.\n");
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(host)
    if(hostingIsErrorDeactivated)
    {
        respond(client, "Hosting ist aufgrund eines Problems temporär deaktiviert.\n");
        return Success;
    }
    else if(userlist.length() >= Config.Hosting.UserListLength)
        respond(client, "Maximale Warteschlangenlänge von " + QString::number(Config.Hosting.UserListLength) + " erreicht!\n");
    else
    {
        if(args.trimmed().isEmpty())
            respond(client, "Bitte gib einen Szenarionamen an!\n");
        else
        {
            ScenarioSettings scen(args, client);
            QStringList argList = args.split(' ', QString::KeepEmptyParts);
            if(argList.first().trimmed() == "--league")
            {
                argList.removeFirst();
                scen.league = true;
                scen.name = argList.join(' ');
            }
            if(!(scen.name = scenPath(scen.name)).isEmpty())
            {
                if(scenAllowed(scen, client, userType))
                {
                    userlist << scen;
                    Stats.AddScenarioWish(client, scenarioFileName(scen.name));

                    respond(client, "Szenario " + scen.name + (scen.league ? " mit Liga" : "") + " " + (Session.State == CRSMSession::None || (Session.Clonk.Clients.size() == 0 && !Session.UserWish) ? "wird jetzt gehostet" : "wurde der Warteschlange hinzugefügt") + ".\n");
                    if(userlist.length() == 1 && !Session.UserWish && !Session.Running && Session.State != CRSMSession::None && Session.Clonk.Clients.size() > 0)
                        respond(client, "Überrede alle Spieler zu leaven und dein Wunsch wird sofort gehostet ;-)\n");
                    else if(Session.State == CRSMSession::None)
                    {
                        nextScen();
                    }
                    else if(Session.Clonk.Clients.size() == 0 && !Session.UserWish)
                    {
                        processManager->closeProgFifos();
                    }
                }
            }
            else
            {
                respond(client, "Szenario \"" + argList.join(' ') + "\" wurde nicht gefunden!\n");
            }
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(list)
    if(client.interface == Clonk || client.interface == Management)
    {
        respond(client, listScenarios(args));
    }
    else if(client.interface == IRC)
    {
        respond(client, Config.IRC.ScenListMessage);
    }
    return Success;
}

CMD_FUNCTION_IMPL(queue)
    respond(client, printQueue(), RespondType::PrivateNotice);
    return Success;
}

CMD_FUNCTION_IMPL(aliaswish)
    respond(client, addAliasWish(args) + "\n");
    return Success;
}

CMD_FUNCTION_IMPL(ircchat)
    respond(client, ircActivateIngameChat(args.toLower() == "on") + "\n");
    return Success;
}

CMD_FUNCTION_IMPL(autohost)
    if(cmd == "autohost")
    {
        respond(client, "Automatisches Hosting aktiviert.\n");
        enableAutoHosting();
    }
    else if(cmd == "noautohost")
    {
        autoHost = false;
        gameRegisterFailTimer.stop();
        respond(client, "Automatisches Hosting deaktiviert.\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(skip)
    QString skipped;
    if((skipped = skipScen()) != "")
    {
        respond(client, "\"" + skipped + "\" übersprungen.\n");
    }
    else
    {
        respond(client, "Userliste ist leer!\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(next)
    if(skipCurrent())
    {
        respond(client, "Versuche zu überspringen...\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(kill)
    processManager->kill();
    respond(client, "Clonk-Server wurde gekillt.\n");
    return Success;
}

CMD_FUNCTION_IMPL(clear)
    if(userlist.length() > 0)
    {
        userlist.clear();
        respond(client, "Userliste geleert.\n");
    }
    else
    {
        respond(client, "Userliste ist leer!\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(aliaswishes)
    if(aliasWishEditor == "")
    {
        aliasWishEditor = client.nick;
        if(ircModIOList.contains(client.nick))
            respond(client, "IO-Eingabe ist während dem Aliaswünsche-Bearbeiten deaktiviert.\n", RespondType::Private);
        editAliasWishes();
    }
    else
        respond(client, aliasWishEditor + " bearbeitet bereits die Aliase. Danke für die Bemühung.\n", RespondType::Private);
    return Success;
}

CMD_FUNCTION_IMPL(newalias)
    QRegExp aliasExp("^([^=]+)=(.*)$");
    if(aliasExp.exactMatch(args))
    {
        const QString &scen = aliasExp.cap(2).trimmed();
        const QString &alias = aliasExp.cap(1).trimmed();
        QString scenP = scen;
        if(!(scenP = scenPath(scen)).isEmpty())
        {
            if(Config.Auto.Hosting.AliasWishes.contains(alias))
            {
                respond(client, "Aliaswunsch für \"" + Config.Auto.Hosting.AliasWishes.value(alias) + "\" entfernt und Alias hinzugefügt!\n");
                Config.Auto.Hosting.AliasWishes.remove(alias);
            }
            else if(Config.Hosting.Alias.contains(alias))
            {
                respond(client, "Alias für \"" + Config.Hosting.Alias[alias] + "\" überschrieben!\n");
            }
            else
            {
                respond(client, "Alias hinzugefügt!\n");
            }
            Config.Hosting.Alias[alias] = scenP;
        }
        else
        {
            respond(client, "Szenario \"" + scen + "\" wurde nicht gefunden!\n");
        }
    }
    else
    {
        respond(client, "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help newalias für mehr Informationen.\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(modinfo)
    respond(client, "Moderatoren sind (* ist aktiv, + verwendet IO, - verwendet irc watch):\n", RespondType::Private);
    foreach(const QString &mod, Config.IRC.Moderators.keys())
    {
        respond(client, (ircMods.contains(mod) ? QString("*") : QString(" ")) + (ircModIOList.contains(mod) ? QString("+") : QString(" ")) + (ircModWatchList.contains(ClientInfo::ircClient(mod)) ? QString("-") : QString(" ")) + " " + Config.IRC.Moderators.value(mod) + "\n", RespondType::Private);
    }
    return Success;
}

CMD_FUNCTION_IMPL(io)
    if(ircModIOList.contains(client.nick))
        ircModIOList.removeAll(client.nick);
    else
        ircModIOList.append(client.nick);
    return Success;
}

CMD_FUNCTION_IMPL(passToClonkPcName)
    if(args == Config.Auto.Volatile.Clonk.ServerNick || args == Config.Auto.Volatile.Clonk.ServerPCName)
    {
        respond(client, Config.CRSM.CommandSign + cmd + " kann nicht auf den Server angewendet werden!\n");
        return Success;
    }
    ClientInfo info;
    if(Session.Clonk.Clients.contains(args))
    {
        info = Session.Clonk.Clients.value(args);
    }
    else
    {
        foreach(const QString& pcName, Session.Clonk.Clients.keys())
        {
            if(pcName.compare(args, Qt::CaseInsensitive) == 0)
            {
                info = Session.Clonk.Clients.value(pcName);
                break;
            }
        }
    }
    if(info.empty())
    {
        bool notFound = true, ambigous = false;
        ClientInfo foundClient;
        foreach(const ClientInfo& client, Session.Clonk.Clients)
        {
            if(client.nick.compare(args, Qt::CaseInsensitive) == 0)
            {
                if(!notFound)
                {
                    ambigous = true;
                    break;
                }
                foundClient = client;
                notFound = false;
            }
        }
        if(ambigous)
        {
            respond(client, "Chat-Nickname " + args + " ist nicht eindeutig. Bitte PC-Namen verwenden.\n");
            return Success;
        }
        else if(notFound)
        {
            respond(client, args + " wurde nicht gefunden!\n");
            return Success;
        }
        else
        {
            info = foundClient;
        }
    }
    if(cmd == "kick" && clientUserType(info) > userType)
    {
        respond(client, "Moderatoren können nur von anderen Moderatoren gekickt werden.\n");
        return RightsFail;
    }
    writeToServer("/" + cmd + " " + info.pcName + "\n");
    return Success;
}

CMD_FUNCTION_IMPL(ircadmin)
    ircCheckUserStatus(client, ClientInfo::ircClient(args), &CRSM::ircSetAdmin);
    return Success;
}

CMD_FUNCTION_IMPL(ingameadmin)
    setIngameAdmin(client, args);
    return Success;
}

CMD_FUNCTION_IMPL(noadmin)
    Session.IRC.Admin.clear();
    Session.Clonk.Admin.clear();
    respond(client, "Rundenadmin wurde freigegeben.\n");
    return Success;
}

CMD_FUNCTION_IMPL(clientlist)
    QString response = "Verbundene Clients (Chatnick (PC-Name)): ";
    foreach(const ClientInfo& connectedClient, Session.Clonk.Clients)
    {
        if(connectedClient.nick.isEmpty())
            continue;
        response += connectedClient.toString() + ", ";
    }
    response = response.left(response.length() - 2);
    respond(client, response + "\n");
    return Success;
}

CMD_FUNCTION_IMPL(passToClonkNumeric)
    bool ok;
    int number = args.toInt(&ok);
    if(!ok)
    {
        respond(client, Config.CRSM.CommandSign + cmd + " kann nur mit einer Zahl verwendet werden!\n");
        return SyntaxFail;
    }
    else
    {
        writeToServer("/" + cmd + " " + QString::number(number) + "\n");
        return Success;
    }
}

CMD_FUNCTION_IMPL(passToClonkNumericOrEmpty)
    if(args.isEmpty())
    {
        writeToServer("/" + cmd + "\n");
        return Success;
    }
    else
    {
        return passToClonkNumeric(cmd, args, client, userType);
    }
}

CMD_FUNCTION_IMPL(passToClonkOnOff)
    if(args != "on" && args != "off")
    {
        respond(client, Config.CRSM.CommandSign + cmd + " kann nur mit \"on\" oder \"off\" verwendet werden.\n");
        return SyntaxFail;
    }
    else
    {
        writeToServer("/" + cmd + " " + args + "\n");
        return Success;
    }
}

CMD_FUNCTION_IMPL(join)
    QStringList argList = args.split(' ');
    static QRegExp chanExp("^#[^\\s]+$");
    if(argList.size() < 1 || argList.first().isEmpty())
    {
        respond(client, "Kein Channel angegeben!\n");
        return SyntaxFail;
    }
    else if(chanExp.exactMatch(argList.first()))
    {
        QString chan = argList.first();
        argList.removeFirst();
        connection->sendCommand(IrcCommand::createJoin(chan, argList.join(' ')));
        return Success;
    }
    else
    {
        respond(client, "\"" + argList.first() + "\" ist kein gültiger Channel-Name.\n");
        return SyntaxFail;
    }
}

CMD_FUNCTION_IMPL(leave)
    QStringList argList = args.split(' ');
    QString chan, reason;
    if(!argList.isEmpty())
    {
        chan = argList.first();
        argList.removeFirst();
    }
    if(chan.isEmpty())
    {
        chan = client.target;
    }
    reason = argList.join(' ');
    if(reason.isEmpty())
    {
        reason = client.toString();
    }
    static QRegExp chanExp("^#[^\\s]+$");
    if(chanExp.exactMatch(chan))
    {
        connection->sendCommand(IrcCommand::createPart(chan, reason));
        return Success;
    }
    else
    {
        respond(client, "\"" + chan + "\" ist kein gültiger Channel-Name.\n");
        return SyntaxFail;
    }
}

CMD_FUNCTION_IMPL(exit)
    exit();
    return Success;
}

CMD_FUNCTION_IMPL(exitDetach)
    Config.Auto.ProcessManager.ReattachId = processManager->ID();
    writeFiles(true);
    connection->quit(Config.IRC.QuitMessage);
    QCoreApplication::quit();
    return Success;
}

CMD_FUNCTION_IMPL(exitUpdate)
    writeToServer("Der Server Manager wird upgedatet. Befehle funktionieren temporär nicht.\n");
    return exitDetach(cmd, args, client, userType);
}

CMD_FUNCTION_IMPL(exitAfter)
    if(processManager->isRunning())
    {
        finish = true;
        respond(client, "Beende nach dieser runde.\n");
        return Success;
    }
    else
    {
        respond(client, "Es läuft gerade kein Spiel, beende sofort.\n");
        return exit(cmd, args, client, userType);
    }
}

CMD_FUNCTION_IMPL(reload)
    out("Reloading configuration...\n");
    ircModChecks.clear();
    ircMods.clear();
    ircModIOList.clear();
    ircStatusFifos.clear();
    readConfig();
    readScenarios();
    out("Configuration reloaded.\n");
    return Success;
}

CMD_FUNCTION_IMPL(saveConfig)
    out("Saving Configuration...\n");
    writeConfig();
    out("Configuration saved.\n");
    return Success;
}

CMD_FUNCTION_IMPL(reconnectIrc)
    respond(client, "Reconnecting...\n");
    reconnectIrc();
    return Success;
}

CMD_FUNCTION_IMPL(groupinfo)
    if(!args.isEmpty())
    {
        respond(client, "Unbekannter Unterbefehl: \"" + args + "\"!\n");
    }
    help("help", cmd, client, userType);
    return Success;
}

CMD_FUNCTION_IMPL(grouphelp)
    if(args.isEmpty())
    {
        groupinfo(QString(cmd).replace(" help", ""), "", client, userType);
    }
    else
    {
        help("help", QString(cmd).replace(cmd.indexOf("help"), 4, "") + args, client, userType);
    }
    return Success;
}

CMD_FUNCTION_IMPL(setRaw)
    writeToServer("/set " + args + '\n');
    return Success;
}

CMD_FUNCTION_IMPL(relist)
    listC4Folders();
    readScenarios();
    return Success;
}

CMD_FUNCTION_IMPL(getConfigValue)
    try
    {
        respond(client, Config.getConfigValueLine(args));
    }
    catch(ConfigException)
    {
        respond(client, "Es existiert kein Wert mit dem Namen \"" + args + "\"\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(setConfigValue)
    try
    {
        Config.setConfigLine(args);
        applyConfig();
        respond(client, "Wert wurde erfolgreich übernommen.\n");
    }
    catch(ConfigException e)
    {
        respond(client, QString("Fehler beim Setzen: ") + e.what() + "\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(ircSay)
    QStringList parts = args.split(' ', QString::KeepEmptyParts);
    if(parts.length() < 2)
    {
        respond(client, "Es wird ein Empfänger und eine Nachricht benötigt.\n");
        return SyntaxFail;
    }
    else
    {
        QString target = parts.first();
        parts.removeFirst();
        QString message = parts.join(' ');
        if(target.at(0) != '#')
        {
            ircSayQueryFifos[target].append(message);
            ircCheckUserStatus(client, ClientInfo::ircClient(target), &CRSM::ircSayQuery);
        }
        else
        {
            connection->sendCommand(IrcCommand::createMessage(target, message));
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(ircWatch)
    if(args == "on")
    {
        if(ircModWatchList.contains(client))
        {
            respond(client, "irc watch ist bereits aktiviert.\n", RespondType::Private);
        }
        else
        {
            ircModWatchList.append(client);
            respond(client, "irc watch wurde aktiviert.\n", RespondType::Private);
        }
    }
    else if(args == "off")
    {
        if(!ircModWatchList.contains(client))
        {
            respond(client, "irc watch ist bereits deaktiviert.\n", RespondType::Private);
        }
        else
        {
            ircModWatchList.removeAll(client);
            respond(client, "irc watch wurde deaktiviert.\n", RespondType::Private);
        }

    }
    else
    {
        respond(client, Config.CRSM.CommandSign + cmd + " kann nur mit \"on\" oder \"off\" verwendet werden.\n");
        return SyntaxFail;
    }
    return Success;
}

CMD_FUNCTION_IMPL(getAdmin)
    if(Session.IRC.Admin.empty() && Session.Clonk.Admin.empty())
    {
        respond(client, "Zurzeit gibt es keinen Rundenadmin.\n");
    }
    else
    {
        QString response;
        int count = 0;
        if(!Session.IRC.Admin.empty())
        {
            response = Session.IRC.Admin.toString();
            ++count;
        }
        if(!Session.Clonk.Admin.empty())
        {
            if(count > 0)
            {
                response.append(" und ");
            }
            response.append(Session.Clonk.Admin.toString());
            ++count;
        }
        response.append(count > 1 ? " sind " : " ist ");
        response.append("Rundenadmin.\n");
        respond(client, response);
    }
    return Success;
}

CMD_FUNCTION_IMPL(packsList)
    if(Packs.PackDefaultVersion.size() == 0)
    {
        respond(client, "Es sind noch keine speziellen Packversionen bekannt.\n");
        return Success;
    }
    QString response("Folgende Packs und ihre Versionen sind bekannt:\n");

    QMap<QString, QStringList> packVersions;
    foreach(const QString& packVersion, Packs.PackVersions.keys())
    {
        packVersions[Packs.PackVersions.value(packVersion)].append(packVersion);
    }

    foreach(const QString& pack, Packs.PackDefaultVersion.keys())
    {
        response.append("\t" + pack + "\t-\t" + packVersions[pack].join(", ") + "\n");
    }

    respond(client, response);
    return Success;
}

CMD_FUNCTION_IMPL(packsDirectory)
    if(args.isEmpty())
    {
        respond(client, "Das aktuelle PacksDirectory ist \"" + Packs.PacksDirectory + "\".\n");
        return Success;
    }
    else
    {
        Packs.PacksDirectory = args;
        QString response = Packs.applyConfig();
        if(response.isEmpty())
        {
            response = "Das PackDirectory wurde erfolgreich geändert.\n";
        }
        respond(client, response);
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsVersionsAdd)
    const QStringList& argList = Util::splitEscaped(args, '=');
    if(argList.length() != 2)
    {
        respond(client, "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help für mehr Informationen.\n");
        return SyntaxFail;
    }
    else
    {
        QString response = Packs.addPackVersion(argList.first().trimmed(), argList.at(1).trimmed());
        if(response.isEmpty())
        {
            response = "PackVersion wurde erfolgreich eingetragen.\n";
        }
        respond(client, response);
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsVersionsDelete)
    QString pack = Packs.PackVersions[args];
    QString response = Packs.deletePackVersion(args);
    if(response.isEmpty())
    {
        response = "PackVersion \"" + args + "\" vom Pack \"" + pack + "\" wurde erfolgreich entfernt.\n";
    }
    respond(client, response);
    return Success;
}

CMD_FUNCTION_IMPL(packsVersionsDefault)
    const QStringList& argList = Util::splitEscaped(args, '=');
    if(argList.length() != 2 && argList.length() != 1)
    {
        respond(client, "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help für mehr Informationen.\n");
        return SyntaxFail;
    }
    else if(argList.length() == 2)
    {
        QString oldDefault = Packs.PackDefaultVersion[argList.first().trimmed()];
        QString response = Packs.setDefaultPackVersion(argList.at(1).trimmed(), argList.first().trimmed());
        if(response.isEmpty())
        {
            if(oldDefault.isEmpty())
            {
                response = "Neues PackDefault wurde erfolgreich eingetragen.\n";
            }
            else
            {
                response = "Altes PackDefault \"" + oldDefault + "\" wurde erfolgreich überschrieben.\n";
            }
        }
        respond(client, response);
        return Success;
    }
    else
    {
        if(Packs.PackDefaultVersion.contains(args))
        {
            respond(client, "Standardversion für \"" + args + "\" ist \"" + Packs.PackDefaultVersion.value(args) + "\".\n");
        }
        else
        {
            respond(client, "Unbekanntes Pack: \"" + args + "\"!\n");
        }
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsScenariosAdd)
    const QStringList& argList = Util::splitEscaped(args, ' ');
    if(argList.length() != 2)
    {
        respond(client, "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help für mehr Informationen.\n");
        return SyntaxFail;
    }
    else
    {
        QString response = Packs.addScenarioPackVersion(argList.at(1).trimmed(), argList.first().trimmed());
        if(response.isEmpty())
        {
            response = "Packversion für das Szenario wurde erfolgreich hinzugefügt.\n";
        }
        respond(client, response);
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsScenariosDelete)
    const QStringList& argList = Util::splitEscaped(args, ' ');
    if(argList.length() != 2)
    {
        respond(client, "Eingabefehler! Siehe " + Config.CRSM.CommandSign + "help für mehr Informationen.\n");
        return SyntaxFail;
    }
    else
    {
        QString response = Packs.deleteScenarioPackVersion(argList.at(1).trimmed(), argList.first().trimmed());
        if(response.isEmpty())
        {
            response = "Packversion für das Szenario wurde erfolgreich entfernt.\n";
        }
        respond(client, response);
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsScenariosList)
    if(Packs.ScenarioPacks.size() == 0)
    {
        respond(client, "Es sind noch keine Szenarios mit speziellen Packversionen bekannt.\n");
        return Success;
    }
    QString response("Folgende Szenarien mit speziellen Packversionen sind bekannt:\n");

    foreach(const QString& scenario, Packs.ScenarioPacks.keys())
    {
        response.append("\t" + scenario + "\t-\t" + Packs.ScenarioPacks.value(scenario).join(", ") + "\n");
    }

    respond(client, response);

    return Success;
}

IRC_CHECK_CALLBACK_IMPL(ircSayQuery)
    if(status <= 0)
    {
        respond(requester, "IRC-Nutzer " + subject.nick + " wurde nicht gefunden!\n");
    }
    else
    {
        foreach(const QString& message, ircSayQueryFifos[subject.nick])
        {
            connection->sendCommand(IrcCommand::createMessage(subject.nick, message));
        }
    }
    ircSayQueryFifos[subject.nick].clear();
}

IRC_CHECK_CALLBACK_IMPL(ircSetAdmin)
    if(status <= 0)
    {
        respond(requester, "IRC-Nutzer " + subject.toString() + " wurde nicht gefunden!\n");
    }
    else
    {
        Session.IRC.Admin = subject;
        respond(requester, subject.nick + " wurde als Rundenadmin eingetragen.\n");
    }
}

IRC_CHECK_CALLBACK_IMPL(ircModCmd)
    if(status == 3 && Config.IRC.Moderators.contains(subject.nick))
    {
        ircMods.append(subject.nick);
        QList<QPair<CmdFunctionRef, QString>> &fifo = ircModFifos[subject.nick];
        while(fifo.size() > 0)
        {
            callCommand(fifo.first().first, fifo.first().second, subject, clientUserType(subject));
            fifo.removeFirst();
        }
        if(!Config.Auto.Hosting.AliasWishes.isEmpty())
        {
            respond(subject, QString::number(Config.Auto.Hosting.AliasWishes.size()) + " neue" + (Config.Auto.Hosting.AliasWishes.size() > 1 ? QString("") : QString("r")) + " Aliasw" + (Config.Auto.Hosting.AliasWishes.size() > 1 ? QString("ü") : QString("u")) + "nsch" + (Config.Auto.Hosting.AliasWishes.size() > 1 ? QString("e") : QString("")) + " " + (Config.Auto.Hosting.AliasWishes.size() > 1 ? QString("sind") : QString("ist")) + " verfügbar.", RespondType::PrivateNotice);
            respond(subject, "Bitte bei nächster Gelegenheit mit " + Config.CRSM.CommandSign + "aliaswishes bearbeiten.", RespondType::PrivateNotice);
        }
    }
    else
    {
        if(ircModFifos.contains(subject.nick))
        {
            rightsFailMessage(subject, ircModFifos[subject.nick].first().first.userType);
            using CmdArgType = QPair<CmdFunctionRef, QString>;
            foreach(const CmdArgType& cmd, ircModFifos[subject.nick])
            {
                Stats.AddCommandResult(subject, cmd.first.name, RightsFail);
            }
            ircModFifos.remove(subject.nick);
        }
    }
}