#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>
#include <QHostInfo>

#include "CRSMUtil.hpp"

#define MGMT_BUFFER_FILENAME "CRSM-MGMT-Buffer"

CRSM::CRSM(QObject *parent) :
    QObject(parent), Session(this), parser(Session), ingameChat(Config.IRC.IngameChannel, *this)
{
    control.setController(this);
    parser.addTarget(this);

    qsrand((uint)QDateTime::currentMSecsSinceEpoch());
    codec = QTextCodec::codecForName("Windows-1252");

    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);

    connect(&dccServer, SIGNAL(newConnection()), this, SLOT(newDCCConnection()));

    listC4Folders();
    readScenarios();

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


    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);
        control.serverMessage("Der Server Manager läuft wieder.");
        if(Session.State == CRSMSession::Running)
        {
            watchdog();
        }
        unRegisterIngameChat();
    }
    QFile sessionFile(Config.CRSM.SessionFile);
    if(sessionFile.exists()) sessionFile.remove();

    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()));
    connect(&gameRegisterFailTimer, SIGNAL(timeout()), this, SLOT(enableAutoHosting()));
    gameRegisterFailTimer.setInterval(5*60*1000);

    connect(&watchDogTimer, SIGNAL(timeout()), this, SLOT(watchdog()));

    ok = true;
}

CRSM::~CRSM()
{
}

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

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

QString CRSM::findClientByName(ClientInfo &info, const QString &name)
{
    if(Session.Clonk.Clients.contains(name))
    {
        info = Session.Clonk.Clients.value(name);
        return "";
    }
    else
    {
        for(const QString& pcName : Session.Clonk.Clients.keys())
        {
            if(pcName.compare(name, Qt::CaseInsensitive) == 0)
            {
                info = Session.Clonk.Clients.value(pcName);
                return "";
            }
        }
    }

    bool notFound = true;
    for(const ClientInfo& client : Session.Clonk.Clients)
    {
        bool foundHere = false;
        if(client.nick.compare(name, Qt::CaseInsensitive) == 0)
        {
            foundHere = true;
        }
        else
        {
            for(const QString& player : client.players)
            {
                if(name.compare(player, Qt::CaseInsensitive) == 0)
                {
                    foundHere = true;
                }
            }
        }

        if(foundHere)
        {
            if(!notFound && info != client)
            {
                return "Name \"" + name + "\" ist nicht eindeutig. Bitte PC-Namen verwenden.\n";
            }

            info = client;
            notFound = false;
        }
    }
    if(notFound)
    {
        if(name.isEmpty())
        {
         return "Es wird ein PC-Name, Chat-Nick oder Spielername benötigt.";
        }
        else
        {
            return "\"" + name + "\" wurde nicht gefunden!\n";
        }
    }
    else
    {
        return "";
    }
}

bool CRSM::lobbyCountdown(unsigned int seconds)
{
    Session.CountDown = (int)seconds;
    return false;
}

bool CRSM::lobbyCountdownAborted()
{
    Session.CountDown = -1;
    return false;
}

bool CRSM::watchdog(const QString& id)
{
    if(id == watchDogString)
    {
        watchDogString.clear();
        watchDogTimer.start(Config.Clonk.Server.Watchdog.Interval * 1000);
    }
    return false;
}

QString CRSM::cmdErrorText(const QString& command, const ClientInfo& client, bool& ret)
{
    QString retText;
    QStringList corrections;
    if(!(ret = cmd(command, client, corrections)))
    {
        retText = "Unbekannter Befehl: \"" + command + "\"!\n";
        if(!corrections.isEmpty())
        {
            retText += "Meintest du: " + corrections.join(", ") + "?\n";
        }
    }
    return retText;
}

bool CRSM::clientMessage(ClientInfo& client, const QString& message, ClonkOutputInterface::MessageType type, const QTime& time)
{
    bool isMeMessage = (type == Action);
    if(type == Sound)
    {
        Log.clonkChatLog("Sound: " + client.toString(true, true) + " " + message);
    }
    else if(isMeMessage)
    {
        Log.clonkChatLog("* " + client.toString(true, true) + " " + message);
    }
    else
    {
        Log.clonkChatLog(client.toString(true, true) + " " + message);
    }

    if(client.pcName != Config.Auto.Volatile.Clonk.ServerPCName)
    {
        Log.clonkUserLog(message, client, isMeMessage);
        if(client == Session.Clonk.Admin)
        {
            checkActivity(Session.Clonk.Admin);
        }
        if(client.floodCheck(Config.Clonk.Chat.AntiFlood.Count, Config.Clonk.Chat.AntiFlood.Time, QDateTime(QDate::currentDate(), time)))
        {
            kick(client, "Flooding! Maximal " + QString::number(Config.Clonk.Chat.AntiFlood.Count) + " Nachrichten in " + QString::number(Config.Clonk.Chat.AntiFlood.Time) + "s");
        }
        else if(type == Sound)
        {
            return false;
        }
        else if(!isMeMessage)
        {
            QString command = getCommand(message);
            if(!command.isEmpty())
            {
                bool ret;
                const QString& txt = cmdErrorText(command, client, ret);
                if(ret)
                {
                    return true;
                }
                else
                {
                    respond(client, txt);
                }
            }
        }
    }
    return false;
}

bool CRSM::clientConnected(const ClientInfo& client)
{
    QTimer *timer = new QTimer;
    connect(timer, &QTimer::timeout, [this, pcName = client.pcName]{ greet(pcName); });
    connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
    timer->start(1000);
    if(Session.CountDown != -1 && Session.CountDown <= Config.Clonk.Server.JoinStopCountDown)
    {
        control.abortCountdown();
    }
    return false;
}

bool CRSM::clientRemoved(const ClientInfo& client, const QString& reason)
{
    Q_UNUSED(reason);
    control.serverMessage(client.nick + " ist ein L34V0R!");

    if(client == Session.Clonk.Admin)
    {
        Session.Clonk.LeaveAdmins.insert(client, QDateTime::currentDateTime());
        afkAdminTimer.stop();
        Session.AfkAdmin = false;
        control.serverMessage("Rundenadmin wurde freigegeben.");
        Session.Clonk.Admin.clear();
    }

    Session.Clonk.Clients.remove(client.pcName);

    if(Session.Clonk.Clients.size() == 0 && ((userlist.length() > 0 && !Session.UserWish) || (Session.State == CRSMSession::Running || Session.State == CRSMSession::Loading)))
    {
        processManager->closeProgFifos();
    }
    else if(Session.Clonk.Clients.size() == 0 && Config.Clonk.Server.EmptyTimer != -1 && (Session.CountDown == -1 || Session.CountDown > Config.Clonk.Server.EmptyTimer))
    {
        control.setCountdown(Config.Clonk.Server.EmptyTimer);
    }
    return false;
}

bool CRSM::gameLoading()
{
    setSessionState(CRSMSession::Loading);
    return false;
}

bool CRSM::gameStarted()
{
    Stats.AddScenarioStart(Session.Scenario.wishClient, scenarioFileName(Session.Scenario.name));
    if(!Session.League)
    {
        control.setCommand("maxplayer 0");
    }
    setSessionState(CRSMSession::Running);
    watchdog();
    return false;
}

bool CRSM::masterserverError(const QString& msg)
{
    userlist.clear();
    if(autoHost && !hostingIsErrorDeactivated)
    {
        hostingIsErrorDeactivated = true;
        gameRegisterFailTimer.start();
    }
    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";
    announceInfo(gameRegisterFailMessage.arg(msg));
    return false;
}

bool CRSM::raw(const QString &line)
{
    if(Config.IRC.Use)
    {
        foreach(const QString &mess, line.split("\n", Qt::SkipEmptyParts))
            foreach(const QString &mod, ircModIOList)
            {
                sendIrcMessage(mess, mod, false, true, true);
            }
    }
    out(line + "\n");
    return false;
}

bool CRSM::rawTimed(const QString &line, const QTime &time)
{
    Q_UNUSED(time);
    Log.clonkLog(line);
    return false;
}

bool CRSM::playerRemoved(const QString& name)
{
    Q_UNUSED(name);
    return false;
}

void CRSM::readServerOutput()
{
    QString what(processManager->readLine().trimmed());

    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);
        }
        what = what.trimmed();
    }

    if(what.isEmpty())
    {
        return;
    }

    parser.parseMessage(what);
}

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 != nullptr)
        {
            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();
    watchDogString.clear();
    watchDogTimer.stop();
    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->type() == IrcMessage::Notice)
    {
        IrcNoticeMessage* noticeMessage = (IrcNoticeMessage*)message;
        if(message->nick() == "NickServ")
        {
            QStringList split = message->parameters().at(1).split(' ', Qt::SkipEmptyParts);
            if(noticeMessage->content().contains("nickname is registered"))
            {
                sendIrcMessage("IDENTIFY " + Config.IRC.Nick + " " + Config.IRC.Password, "NickServ", false, false);
            }
            else if(split.size() >= 2 && 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();
                    }
                }
            }
        }
        Log.ircLog(noticeMessage->content(), noticeMessage->nick(), noticeMessage->isPrivate(), noticeMessage->target(), false, true);
        if(!message->isOwn())
        {
            Log.ircUserLog(noticeMessage->content(), ClientInfo::ircClient(noticeMessage->nick(), noticeMessage->target()), noticeMessage->isPrivate(), noticeMessage->target(), false, true);
        }
    }
    else if(message->type() == IrcMessage::Private)
    {
        IrcPrivateMessage* privMessage = (IrcPrivateMessage*)message;
        if(!privMessage->isRequest())
        {
            QString target = privMessage->target();
            if(target == connection->nickName())
                target = message->nick();
            const ClientInfo& client = ClientInfo::ircClient(message->nick(), target);
            handleIrcMessage(client, privMessage->content(), privMessage->target(), privMessage->isPrivate(), privMessage->isAction(), message->isOwn());
        }
        else
        {
            if(privMessage->isPrivate() && Config.DCC.Use)
            {
                if(privMessage->content().startsWith("DCC CHAT CHAT ", Qt::CaseInsensitive))
                {
                    const QStringList& parts = privMessage->content().split(' ', Qt::SkipEmptyParts);
                    if(parts.size() == 5)
                    {
                        dccChatRequest(ClientInfo::ircClient(message->nick()));
                    }
                    else if(parts.size() == 6 && parts.at(3) == "199" && parts.at(4) == "0")
                    {
                        dccChatRequest(ClientInfo::ircClient(message->nick()), parts.at(5));
                    }
                }
            }
        }
    }
    else if(message->isOwn())
    {
        return;
    }
    else if(message->type() == IrcMessage::Join)
    {
        IrcJoinMessage* joinMessage = (IrcJoinMessage*)message;
        QString joinChannel = joinMessage->channel();

        auto setting = greetingSetting(ClientInfo::ircClient(joinMessage->nick(), joinMessage->channel()));
        if(setting != GreetingSetting::Disabled)
        {
            sendIrcMessage("Hallo, " + message->nick() + "!", joinChannel, false, setting == GreetingSetting::Notice);
        }

        if(joinChannel == Config.IRC.IngameChannel && Session.IRC.UseIngameChat)
        {
            control.serverMessage("[IRC] " + message->nick() + " hat den Channel betreten.");
        }
        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)
        {
            control.serverMessage("[IRC] " + message->nick() + " hat den Channel verlassen.");
        }
    }
    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() == connection->nickName())
        {
            ircSetIngameChannelTopic();
        }
    }
}

void CRSM::ircConnected()
{
    IrcConnection* conn = (IrcConnection*)sender();
    Q_ASSERT(conn == connection);
    connection->sendCommand(IrcCommand::createMode(connection->nickName(), "+B"));
    connection->sendCommand(IrcCommand::createJoin(Config.IRC.Channel));
    if(Config.IRC.UseIngameChat)
    {
        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);

    if(greetingSetting(info) == GreetingSetting::Disabled)
    {
        return;
    }

    control.serverMessage("Hallo, " + info.nick + "!");
    if(Session.Clonk.LeaveAdmins.contains(info) && Session.Clonk.Admin != info)
    {
        qint64 timeGone;
        if((timeGone = Session.Clonk.LeaveAdmins.value(info).secsTo(QDateTime::currentDateTime())) < Config.Clonk.Chat.RegainAdminTime && (!Session.Clonk.Admin.empty() || !Session.IRC.Admin.empty()))
        {
            control.serverMessage(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.");
        }
        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;

                if(conn.name.length() > 1 && conn.name.at(0) == '!')
                {
                    conn.noLogging = true;
                }

                out(conn.name + " logged in on Management-Interface.\n");
                managementConnections.insert(sock, conn);
                if(!conn.noLogging)
                {
                    replayOutputBuffer(sock);
                }
            }
        }
        else
        {
            if(data.isEmpty())
            {
                continue;
            }
            ManagementConnection& conn = managementConnections[sock];
            if(data.at(0) == '/')
            {
                QString command = data.mid(1).trimmed();
                QStringList corrections;
                if(cmd(command, ClientInfo::managementClient(conn), corrections))
                {
                    continue;
                }
                else
                {
                    control.rawCommand(command);
                }
            }
            else
            {
                const QString& msg = ClientInfo::managementClient(conn).toString(true) + " " + data + "\n";
                control.serverMessage(msg);
                if(Session.IRC.UseIngameChat)
                {
                    sendIrcMessage(msg, Config.IRC.IngameChannel, false, false);
                }
            }
        }
    }
}

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::dccChatRequest(const ClientInfo &client, QString extraArgs)
{
    if(dccNickConnections.contains(client.nick))
    {
        QTimer::singleShot(0, dccNickConnections[client.nick].socket, &QTcpSocket::close);
    }

    QHostInfo info = QHostInfo::fromName(Config.DCC.Address);
    connection->sendCommand(IrcCommand::createCtcpRequest(client.nick, "DCC CHAT chat " + QString::number(info.addresses().first().toIPv4Address()) + " " + QString::number(Config.DCC.ListenPort) + (!extraArgs.isEmpty() ? " " + extraArgs : extraArgs)));
}

// modified version of http://stackoverflow.com/a/18866593
QString GetRandomString(int length = 5)
{
    static const QString possibleCharacters("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

    QString randomString;
    for(int i=0; i<length; ++i)
    {
        int index = qrand() % possibleCharacters.length();
        QChar nextChar = possibleCharacters.at(index);
        randomString.append(nextChar);
    }
    return randomString;
}

void CRSM::newDCCData()
{
    QTcpSocket* socket = (QTcpSocket*)sender();
    const DCCConnection& dccConnection = dccSocketConnections[socket];
    while(socket->bytesAvailable() > 0)
    {
      QString message = QString::fromUtf8(socket->readLine()).trimmed();
      if(message.length() > 0)
      {
          handleIrcMessage(dccConnection.client, message, connection->nickName(), true, false);
      }
    }
}

void CRSM::newDCCConnection()
{
    QTcpSocket* socket = dccServer.nextPendingConnection();
    QString identifier;
    do
    {
        identifier = GetRandomString();
    }
    while(dccConnectionIdentifiers.contains(identifier));

    dccConnectionIdentifiers.insert(identifier, socket);
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnectedDCCConnection()));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(disconnectedDCCConnection()));

    socket->write(QString("Weise diese Verbindung deinem IRC-Nick zu, indem du diesen Befehl eingibst: /msg " + connection->nickName() + " dcc identify " + identifier + "\n").toUtf8());
}

void CRSM::disconnectedDCCConnection()
{
    QTcpSocket* socket = (QTcpSocket*)sender();
    if(dccSocketConnections.contains(socket))
    {
        dccNickConnections.remove(dccSocketConnections[socket].client.nick);
        dccSocketConnections.remove(socket);
    }

    dccConnectionIdentifiers.remove(dccConnectionIdentifiers.key(socket));
    socket->deleteLater();
}

void CRSM::updateNextAutoScens()
{
    if(autolist.length() <= 0) return;
    while(nextAutoScens.length() < Config.Hosting.UserListLength || (nextAutoScens.length() <= 0))
    {
        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;
    unRegisterIngameChat();

    Session.Clonk.Server.pcName = Config.Auto.Volatile.Clonk.ServerPCName;
    Session.Clonk.Server.nick = Config.Auto.Volatile.Clonk.ServerNick;

    setSessionState(CRSMSession::Lobby);
    filename = scenarioFileName(scen.name);

    if(scen.league && !Config.Hosting.DisableLeague)
    {
        argList << "/league";
        Session.League = true;
    }
    else
    {
        argList << "/noleague";
    }

    argList << Packs.getScenarioCmdOptions(filename).split(' ');

    argList << filename;
    processManager->setWorkingDirectory(Config.Auto.Volatile.Clonk.Directory);
    out(Packs.linkScenarioPacks(filename));
    processManager->start(Config.Clonk.Server.Executable, argList);
    Log.scenLog(scen);
}

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!\n");
        scenfile.open(QFile::WriteOnly);
        scenfile.write("Worlds.c4f/Goldmine.c4s");
        scenfile.close();
    }
    scenfile.open(QFile::ReadOnly);
    QStringList scenlist = QString(scenfile.readAll()).trimmed().split("\n",Qt::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(' ', Qt::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().fileName()))
        {
            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("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::caseInsensitive(QString name, QString dir, QString trySuffix)
{
    QString suffixedName;
    if(!trySuffix.isEmpty())
    {
        suffixedName = name + trySuffix;
    }
    const QStringList& entryList = QDir(Config.Auto.Volatile.Clonk.Directory + dir + QDir::separator()).entryList();
    foreach(const QString& entry, entryList)
    {
        if(entry.compare(name, Qt::CaseInsensitive) == 0 || entry.compare(suffixedName, Qt::CaseInsensitive) == 0)
        {
            return entry;
        }
    }
    return QString();
}

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;
    }
    if(!isAlias && !scenName.endsWith(".c4s", Qt::CaseInsensitive))
    {
        scenName.append(".c4s");
    }
    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)
        {
            QString folderName = caseInsensitive(split.first(), "", ".c4f");
            if(!folderName.isEmpty())
            {
                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().completeBaseName()))
                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
    {
        QString folder = caseInsensitive(commandArgs, "", ".c4f");
        QFile file(Config.CRSM.ListFolder + folder + ".lst");
        if(!folder.isEmpty() && file.exists() && !Config.Clonk.Server.IgnoreFolders.contains(QFileInfo(file).completeBaseName()))
        {
            ret += "Der Ordner \"" + folder + 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
        {
            if(i - userlist.length() < nextAutoScens.length())
            {
                scen = &nextAutoScens.at(i - userlist.length());
            }
            else
            {
                break;
            }
        }
        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(int pos)
{
    if(userlist.length() > pos)
    {
        QString skipped = userlist.at(pos).name + " (" + userlist.at(pos).wishClient.toString() + ")";
        userlist.removeAt(pos);
        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', Qt::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.CommandSigns.first() + "help für mehr Informationen.";
    }
}

void CRSM::informModsAboutAliasWish()
{
    foreach(const QString& mod, ircMods)
    {
        sendIrcMessage("Ein neuer Aliaswunsch ist verfügbar. Insgesamt verfügbar: " + QString::number(Config.Auto.Hosting.AliasWishes.size()), mod, false, true, true);
    }
}

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

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")
    {
        sendIrcMessage("Aliaswunsch-Bearbeitung gestoppt.", aliasWishEditor, false, false);
        stopAliasWishEditing();
        return;
    }
    else
    {
        sendIrcMessage("\"" + message + "\" ist keine Antwortmöglichkeit. Antwortmöglichkeiten: [Ja|Nein|Stop]", aliasWishEditor, false, false);
    }
    editAliasWishes();
}

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

QString CRSM::ircActivateIngameChat(bool activated)
{
    if(Config.IRC.UseIngameChat)
    {
        if(Session.IRC.UseIngameChat != activated)
        {
            Session.IRC.UseIngameChat = activated;
            unRegisterIngameChat();
            ircSetIngameChannelTopic();
            return "Ingamechat wurde " + (Session.IRC.UseIngameChat ? QString("") : QString("de")) + "aktiviert.";
        }
        else
        {
            return "Ingamechat ist bereits " + (Session.IRC.UseIngameChat ? QString("") : QString("de")) + "aktiviert.";
        }
    }
    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)
    {
        if(Session.State == CRSMSession::None)
        {
            connection->sendCommand(IrcCommand::createTopic(Config.IRC.IngameChannel, Config.IRC.IngameChannelExtraTopic + "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;
                case CRSMSession::None: // is handled above
                    break;
            }
            connection->sendCommand(IrcCommand::createTopic(Config.IRC.IngameChannel, Config.IRC.IngameChannelExtraTopic + "Aktuelles Szenario: " + Session.Scenario.name + " | " + statusText + " | Ingamechat ist " + (Session.IRC.UseIngameChat ? "" : "de") + "aktiviert."));
        }
    }
}

void CRSM::setSessionState(CRSMSession::SessionState state)
{
    Session.State = state;
    ircSetIngameChannelTopic();
}

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

void CRSM::addCommandGroup(const QString &name, int interfaces, UserType userType, const QString &shortDescription, const QString &longDescription, CmdFunction defaultFunc)
{
    const QString& nName = name.trimmed().toLower();
    if(!cmdGroups.contains(nName)) cmdGroups.append(nName);
    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;
}

QStringList CRSM::guessCmd(const QString& name, ClientInterface interface)
{
    int minDistance = -1;
    QString minDistanceCmd;
    QStringList minDistanceCmds;

    auto applyDistance = [&name, &minDistance, &minDistanceCmd, &minDistanceCmds](const QString& cmdName)
    {
        int distance = Util::damerauLevenshteinDistance(name, cmdName);
        if(minDistance == -1 || distance < minDistance)
        {
            minDistance = distance;
            minDistanceCmd = cmdName;
            minDistanceCmds.clear();
        }
        else if(minDistance == distance && !minDistanceCmds.contains(cmdName))
        {
            minDistanceCmds.append(cmdName);
        }
    };

    for(const auto& cmd : cmds)
    {
        if(cmd.interfaces & interface)
        {
            applyDistance(cmd.name);
        }
    }

    for(const auto& alias : Config.CRSM.CommandAlias.keys())
    {
        applyDistance(alias);
    }

    if(!minDistanceCmds.contains(minDistanceCmd))
    {
        minDistanceCmds.append(minDistanceCmd);
    }

    if(minDistanceCmds.length() == 1 && minDistance >= std::min(3, name.length() - 1))
    {
        minDistanceCmds.clear();
    }
    return minDistanceCmds;
}

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

CmdFunctionRef* CRSM::findCommand(QStringList&& cmd, ClientInterface interface, QString &realCmd, QStringList& corrections)
{
    if(cmd.length() > 0)
    {
        QString cmdPart = cmd.join(' ').toLower();
        realCmd = cmdPart;
        substituteCommandAlias(cmdPart);
        if(cmdExists(cmdPart, interface))
        {
            return &cmds[cmdPart];
        }
        else
        {
            removeCommandSuffixes(cmdPart);
            substituteCommandAlias(cmdPart);
            if(cmdExists(cmdPart, interface))
            {
                return &cmds[cmdPart];
            }
            else
            {
                const QStringList& guesses = guessCmd(cmdPart, interface);
                cmd.removeLast();
                if(const auto result = findCommand(std::move(cmd), interface, realCmd, corrections); result)
                {
                    return result;
                }

                if(guesses.length() == 1)
                {
                    QString guess = guesses.first();
                    substituteCommandAlias(guess);
                    if(cmdExists(guess, interface))
                    {
                        return &cmds[guess];
                    }
                }
                else if(guesses.length() > 1)
                {
                    corrections.append(guesses);
                }
                return nullptr;
            }
        }
    }
    else
    {
        return nullptr;
    }
}

bool CRSM::cmd(const QString& cmd, const ClientInfo &client, QStringList& corrections)
{
    Log.commandLog(cmd, client, false);
    CmdFunctionRef* cmdPtr;
    QString realCmd = cmd;
    if((cmdPtr = findCommand(cmd, client.interface, realCmd, corrections)) != nullptr)
    {
        CmdFunctionRef cmdRef = *cmdPtr;
        QString args = cmd.mid(realCmd.length()).trimmed();
        removeCommandSuffixes(args);
        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, true);
}

UserType CRSM::clientUserType(const ClientInfo &client)
{
    switch(client.interface)
    {
        case Clonk:
            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();

    addCommandGroup("admin", Clonk/* | IRC disabled because of abuse */, 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.", "", &CRSM::admin);
    addCommand("admin set", &CRSM::admin, Clonk /* | IRC disabled because of abuse */, 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 get", &CRSM::getAdmin, Clonk | IRC | Management, User, "Fragt den aktuellen Rundenadmin ab.");
    addCommand("admin afk", &CRSM::afkAdmin, Clonk /* | IRC disabled because of abuse */ | Management, User, "Gibt den Rundenadmin frei, wenn er nicht in den nächsten " + QString::number(Config.Hosting.AfkAdminTime) + "s reagiert.");
    addCommand("admin ingame", &CRSM::ingameadmin, IRC | Management, Admin, "Legt den Ingame-Rundenadmin fest.", "<Ingame-Nick¦PC-Name>");
    addCommand("admin clear", &CRSM::noadmin, Clonk | IRC | Management, Admin, "Entzieht dem (IRC-)Rundenadmin seine Rechte, damit jemand anders Rundenadmin sein kann.");

    addCommandGroup("client", Clonk | IRC | Management, User, "Verwaltet die verbundenen Clients.");
    addCommand("client list", &CRSM::clientlist, IRC | Management, User, "Listet alle verbundenen Clients auf."); // TODO: optional player list
    addCommand("client kick", &CRSM::passToClonkPcNameGrouped, Clonk | IRC | Management, Admin, "Kickt den angegebenen Client.", "<PC-Name¦Chatnick>");
    addCommand("client observer", &CRSM::passToClonkPcNameGrouped, Clonk | IRC | Management, Admin, "Der angegebene Client muss zuschauen.", "<PC-Name¦Chatnick>");
    addCommand("client deactivate", &CRSM::passToClonkPcNameGrouped, Clonk | IRC | Management, Admin, "Deaktiviert den angegebenen Client.", "<PC-Name¦Chatnick>");
    addCommand("client activate", &CRSM::passToClonkPcNameGrouped, Clonk | IRC | Management, Admin, "Aktiviert den angegebenen Client.", "<PC-Name¦Chatnick>");

    addCommandGroup("queue", Clonk | IRC | Management, User, "Zeigt die nächsten " + QString::number(Config.Hosting.UserListLength) + " Szenarien auf der Warteliste.", "", &CRSM::queue);
    addCommand("queue list", &CRSM::queue, Clonk | IRC | Management, User, "Zeigt die nächsten " + QString::number(Config.Hosting.UserListLength) + " Szenarien auf der Warteliste.");
    addCommand("queue skip", &CRSM::skip, Clonk | IRC | Management, User, "Entfernt das nächste (eigene) Szenario (oder das auf [Warteschlangenposition]) aus der Wunschliste.", "[Warteschlangenposition]");
    addCommand("queue clear", &CRSM::clear, Clonk | IRC | Management, Moderator, "Löscht die Wunschliste.");

    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] <[Rundenordner[.c4f]/]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("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("abort", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Bricht einen laufenden Countdown ab.");
    addCommand("start", &CRSM::passToClonkNumericOrEmpty, Clonk | IRC | Management, Admin, "Startet den Countdown.", "[Countdownzeit in s]");
    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("script", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Führt das angegebene Script aus.", "<Script>");
    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::nodebug, Clonk | IRC | Management, User, "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("ctrlmode", Clonk | IRC | Management, Admin, "Ändert den Netzwerkmodus.");
    addCommand("ctrlmode async", &CRSM::passToClonkCtrlMode, Clonk | IRC | Management, Admin, "Aktiviert den asynchronen Netzwerkmodus.");
    addCommand("ctrlmode central", &CRSM::passToClonkCtrlMode, Clonk | IRC | Management, Admin, "Aktiviert den zentralen Netzwerkmodus.");
    addCommand("ctrlmode decentral", &CRSM::passToClonkCtrlMode, Clonk | IRC | Management, Admin, "Aktiviert den dezentralen Netzwerkmodus.");

    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 teamdist", &CRSM::passToClonk, Clonk | IRC | Management, Admin, "Ändert die Teamverteilung.", "<none¦free¦host¦random¦randominv>");
    addCommand("set raw", &CRSM::setRaw, Clonk | IRC | Management, Moderator, "Setzt beliebige /set-Werte.", "<Option> [Wert]");

    addCommandGroup("server", Clonk | IRC | Management, Moderator, "Verwaltet den eigentlichen Clonk-Server.");
    addCommand("server quit", &CRSM::next, Clonk | IRC | Management, Moderator, "Versucht das aktuelle Szenario zu überspringen, indem der Clonk-Server beendet wird.");
    addCommand("server 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.CommandSigns.first() + "server quit nicht funktioniert.");

    addCommand("modinfo", &CRSM::modinfo, IRC | Management, Moderator, "Listet alle Moderatoren auf.");

    addCommandGroup("alias", Clonk | IRC | Management, User, "Die alias-Befehlsgruppe erlaubt das Verwalten der Szenarioaliase.");
    addCommand("alias wish", &CRSM::aliaswish, Clonk | IRC, User, "Deponiert den Wunsch, <Alias> als Alias für <Szenario> einzutragen. Ein Moderator entscheidet darüber.", "<Alias> = <Szenario>");
    addCommand("alias add", &CRSM::newalias, Clonk | IRC | Management, Moderator, "Trägt <Alias> als Alias für <Szenario> ein.", "<Alias> = <Szenario>");
    addCommand("alias wishes", &CRSM::aliaswishes, IRC | Management, Moderator, "Zum geführten Bearbeiten der Aliaswünsche.");
    addCommand("alias delete", &CRSM::deletealias, Clonk | IRC | Management, Moderator, "Entfernt den <Alias>.", "<Alias>");


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

        addCommand("admin irc", &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 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>");
        addCommand("irc raw", &CRSM::ircRaw, IRC | Management, Moderator, "Sendet, analog zu /QUOTE oder /RAW, eine <Rohnachricht> an den IRC-Server.", "<Rohnachricht>");

        if(Config.DCC.Use)
        {
            addCommandGroup("dcc", IRC, User, "Die dcc-Befehlsgruppe bietet die Möglichkeit zum Steuern eines DCC-Chats.");
            addCommand("dcc connect", &CRSM::dccConnect, IRC, User, "Sendet eine DCC-Chat-Verbindungsanfrage.");
            addCommand("dcc disconnect", &CRSM::dccDisconnect, IRC, User, "Schließt die zum Nick zugewiesene DCC-Verbindung, falls vorhanden.");
            addCommand("dcc identify", &CRSM::dccIdentify, IRC, User, "Mit dem Befehl wird eine neu geöffnete DCC-Verbindung einem Benutzer zugewiesen.", "<Verbindungs-ID>");
        }
    }

    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.CommandSigns.first() + "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.");
    addCommandGroup("packs scenoptions", Management, UserType::Max, "Über die packs scenoptions-Befehlsgruppe werden zusätzliche Clonk-Argumente für einzelne Szenarien/Rundenordner verwaltet.");
    addCommand("packs scenoptions get", &CRSM::packsScenOptionsGet, Management, UserType::Max, "Fragt die Clonk-Argumente nur für <Szenario> ab.", "<Szenario>");
    addCommand("packs scenoptions all", &CRSM::packsScenOptionsGet, Management, UserType::Max, "Fragt die Clonk-Argumente ab, die im Endeffekt für <Szenario> gültig sind.", "<Szenario>");
    addCommand("packs scenoptions set", &CRSM::packsScenOptionsSet, Management, UserType::Max, "Setzt die Clonk-Argumente für <Szenario> auf [Argumente], entfernt sie, wenn keine Argumente angegeben sind.", "<Szenario> [Argumente]");

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

void CRSM::respond(const ClientInfo &client, const QString &message, const RespondType type, bool allowDCCNotice)
{
    switch(client.interface)
    {
    case Clonk:
        control.serverMessage(message);
        break;
    case IRC:
        foreach(const QString line, message.split('\n', Qt::SkipEmptyParts))
        {
            switch(type)
            {
                case RespondType::Normal:
                case RespondType::Private:
                    sendIrcMessage(line, type == Normal ? client.target : client.nick, false, false);
                    break;
                case RespondType::Notice:
                case RespondType::PrivateNotice:
                    sendIrcMessage(line, type == Notice ? client.target : client.nick, false, true, allowDCCNotice);
                    break;
            }
        }
        break;
    case Management:
        client.management.socket->write(message.toUtf8());
        break;
    case Auto: //just to avoid the compiler warning
        break;
    }
    Log.commandLog(message, client, true);
    if(clientUserType(client) == Moderator)
    {
        Log.modLog(message, client, clientModName(client), true);
    }
}

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

void CRSM::setIngameAdmin(const ClientInfo &client, const QString& newAdmin)
{
    if(newAdmin == Config.Auto.Volatile.Clonk.ServerNick || newAdmin == Config.Auto.Volatile.Clonk.ServerPCName)
    {
        respond(client, "Der Server kann nicht als Rundenadmin eingetragen werden!\n");
        return;
    }

    ClientInfo info;
    QString msg = findClientByName(info, newAdmin);

    if(!msg.isEmpty())
    {
        respond(client, msg);
        return;
    }

    if(Session.Clonk.Admin == info)
    {
        respond(client, info.toString() + " ist bereits Rundenadmin.\n");
        return;
    }

    Session.Clonk.Admin = info;

    afkAdminTimer.stop();
    Session.AfkAdmin = false;
    respond(client, Session.Clonk.Admin.toString() + " wurde als Rundenadmin eingetragen.\n");
}

void CRSM::out(const QString &text)
{
    if(text.isEmpty())
    {
        return;
    }
    Log.log(text);
    bool buffer = true;

    foreach(const ManagementConnection& conn, managementConnections)
    {
        if(!conn.noLogging)
        {
            conn.socket->write(text.toUtf8());
            buffer = false;
        }
    }

    if(buffer)
    {
        outputBuffer.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);
    }
}

void CRSM::announceInfo(const QString &info, bool useOutgameChannel)
{
    out(info);
    if(Config.IRC.Use)
    {
        if(useOutgameChannel)
        {
            sendIrcMessage(info, Config.IRC.Channel, false, false);
        }
        if(Config.IRC.UseIngameChat)
        {
            sendIrcMessage(info, Config.IRC.IngameChannel, false, false);
        }
    }
}

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 ClientInfo& client, const QString& reason)
{
    control.kick(client, reason);
}

void CRSM::prepareAndConnectIrc()
{
    connection = new IrcConnection(Config.IRC.Server);
    connection->setPort(Config.IRC.Port);
    connection->setUserName(Config.IRC.User.isEmpty() ? Config.IRC.Nick : Config.IRC.User);
    connection->setNickName(Config.IRC.Nick);
    connection->setRealName(Config.IRC.RealName);
    connection->setReconnectDelay(Config.IRC.ReconnectDelay);
    connection->setPassword(Config.IRC.Password);
    connection->setSecure(Config.IRC.SSL);

    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();
    announceInfo("Der Rundenadmin war zu lange AFK und wurde freigegeben.", false);
    Session.AfkAdmin = false;
}

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);

    if(Config.Clonk.Server.Watchdog.Interval > 0 && Config.Clonk.Server.Watchdog.Timeout > 0 && Session.State == CRSMSession::Running)
    {
        watchDogString.clear();
        watchdog();
    }
    else
    {
        watchDogTimer.stop();
    }

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

    out(Log.setLogFolder(Config.Logging.Folder));
    out(Log.setMainLog(Config.Logging.MainLog));
    Log.setTimestampFormat(Config.Logging.TimestampFormat);

    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 doesn't exist!\n");
    }
    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(Config.IRC.IngameChannel.isEmpty())
        {
            Config.IRC.UseIngameChat = false;
        }
        if(connection == nullptr)
        {
            prepareAndConnectIrc();
        }
        else
        {
            if(connection->isConnected())
            {
                if(connection->nickName() != Config.IRC.Nick)
                {
                    connection->sendCommand(IrcCommand::createNick(Config.IRC.Nick));
                }
                connection->sendCommand(IrcCommand::createJoin(Config.IRC.IngameChannel));
            }
        }
        if(connection != nullptr)
        {
            connection->setCtcpReplies({{"VERSION", Config.IRC.CtcpVersion}, {"SOURCE", "Currently unavailable"}, {"CLIENTINFO", "CLIENTINFO PING TIME VERSION"}});
        }
    }
    else
    {
        Config.DCC.Use = false;
        Config.IRC.UseIngameChat = false;
        if(connection != nullptr)
        {
            connection->quit(Config.IRC.QuitMessage);
        }
    }

    if(Config.DCC.Use)
    {
        if(!dccServer.isListening())
        {
            dccServer.listen(QHostAddress::Any, Config.DCC.ListenPort);
        }
    }
    else
    {
        dccServer.close();
    }

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

    updateNextAutoScens();

    foreach(const QString& key, Config.CRSM.CommandAlias.keys())
    {
        const QString& lKey = key.toLower();
        if(lKey != key)
        {
            Config.CRSM.CommandAlias[lKey] = Config.CRSM.CommandAlias[key];
            Config.CRSM.CommandAlias.remove(key);
        }
    }

    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)
{
    if(userType == Moderator)
    {

        Log.modLog(func.name + " " + args, client, clientModName(client), false);
    }
    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;
    }
}

int CRSM::findWishFromUser(const ClientInfo &client)
{
    int i = 0;
    foreach(const ScenarioSettings& wish, userlist)
    {
        if(wish.wishClient == client)
        {
           return i;
        }
        ++i;
    }
    return -1;
}

QString CRSM::getCommand(const QString &message)
{
    foreach(const QString& commandSign, Config.CRSM.CommandSigns)
    {
        if(message.startsWith(commandSign))
        {
            return message.mid(commandSign.length());
        }
    }
    return QString();
}

bool CRSM::isChannelName(const QString &name)
{
    if(connection == nullptr || name.length() < 1)
    {
        return false;
    }
    else
    {
        const QStringList& channelTypes = connection->network()->channelTypes();
        return channelTypes.contains(name.at(0));
    }
}

void CRSM::removeCommandSuffixes(QString& command)
{
    foreach(const QString& suffix, Config.CRSM.CommandSuffixes)
    {
        if(command.endsWith(suffix))
        {
            command.chop(suffix.length());
            break;
        }
    }
}

void CRSM::substituteCommandAlias(QString &command)
{
    while(Config.CRSM.CommandAlias.contains(command))
    {
        command = Config.CRSM.CommandAlias.value(command);
    }
}

QString CRSM::clientModName(const ClientInfo &client)
{
    switch(client.interface)
    {
    case IRC:
        return Config.IRC.Moderators.value(client.nick);
    case Management:
        return client.management.name;
    case Auto: default:
        return QString();
    }
}

void CRSM::sendIrcMessage(const QString& message, const QString& target, bool action, bool notice, bool noticeOrDCC)
{
    QTcpSocket* dccSocket = nullptr;
    notice = notice || noticeOrDCC;
    bool query = !isChannelName(target);
    Log.ircLog(message, (query ? target : connection->nickName()), query, target, action, notice, query);
    if(action)
    {
        connection->sendCommand(IrcCommand::createCtcpAction(target, message));
    }
    else if(notice)
    {
        if(noticeOrDCC && dccNickConnections.contains(target))
        {
         dccSocket = dccNickConnections[target].socket;
        }
        else
        {
            connection->sendCommand(IrcCommand::createNotice(target, message));
        }
    }
    else
    {
        if(query && dccNickConnections.contains(target))
        {
            dccSocket = dccNickConnections[target].socket;
        }
        else
        {
            connection->sendCommand(IrcCommand::createMessage(target, message));
        }
    }

    if(dccSocket)
    {
        dccSocket->write(message.toUtf8());
        dccSocket->write("\n");
    }
}

GreetingSetting::Mode CRSM::greetingSetting(const ClientInfo &client)
{
    if(client.interface == Clonk && Config.CRSM.Greeting.contains(GreetingSetting::clonk()) && !Config.CRSM.Greeting.contains(GreetingSetting::clonk().invert()))
    {
        return GreetingSetting::Normal;
    }
    else if(client.interface == IRC)
    {
        GreetingSetting::Mode nickSetting = GreetingSetting::Unset;
        GreetingSetting::Mode chanSetting = GreetingSetting::Unset;
        GreetingSetting::Mode ircSetting = GreetingSetting::Unset;
        foreach(const GreetingSetting& setting, Config.CRSM.Greeting)
        {
            if(setting.interface == IRC)
            {
                if(setting.target == client.nick)
                {
                    nickSetting = setting.mode;
                }
                else if(setting.target == client.target)
                {
                    chanSetting = setting.mode;
                }
                else if(setting.target.isEmpty())
                {
                    ircSetting = setting.mode;
                }
            }
        }

        if(nickSetting != GreetingSetting::Unset)
        {
            return nickSetting;
        }

        if(chanSetting != GreetingSetting::Unset)
        {
            return chanSetting;
        }

        if(ircSetting != GreetingSetting::Unset)
        {
            return ircSetting;
        }
    }
    return GreetingSetting::Disabled;
}

void CRSM::handleIrcMessage(const ClientInfo &client, QString message, const QString &target, bool privateMessage, bool action, bool own)
{
    if(message.isEmpty())
    {
        return;
    }
    Log.ircLog(message, client.nick, privateMessage, target, action, false);
    if(own)
    {
        return;
    }
    Log.ircUserLog(message, client, true, target, action, false);
    if(client == Session.IRC.Admin)
    {
        checkActivity(Session.IRC.Admin);
    }

    QString command;

    // TODO: compare according to the IRC standard (case-insensitive, what else? maybe libcommuni has something like that already?)
    if(target == Config.IRC.IngameChannel && Session.IRC.UseIngameChat)
    {
        if(action)
        {
            control.serverMessage("[IRC] " + client.nick + " " + message, true);
        }
        else
        {
            control.serverMessage("[IRC]<" + client.nick + "> " + message);
        }
    }
    else if(!action && !(command = getCommand(message)).isEmpty())
    {
        // command is handled afterwards
    }
    else if(privateMessage)
    {
        bool handled = false;
        if(ircMods.contains(client.nick))
        {
            if(aliasWishEditor == client.nick)
            {
                editAliasWishes(message);
                handled = true;
            }
            else if(ircModIOList.contains(client.nick))
            {
                QString writeMessage;
                if(message.at(0) == '\\' || message.at(0) == '/')
                {
                    message[0] = '/';
                }
                else
                {
                    writeMessage = "[IRC]<" + client.nick + "> ";
                }
                writeMessage += message;
                control.serverMessage(writeMessage);
                handled = true;
            }
        }
        if(!handled)
        {
            command = message;
        }
    }

    if(!command.isEmpty())
    {
        bool ret;
        const QString& txt = cmdErrorText(command, client, ret);
        if(!ret)
        {
            respond(client, txt, (privateMessage ? RespondType::PrivateNotice : RespondType::Normal), true);
        }
    }

    if(ircModWatchList.length() > 0)
    {
        QString watchMsg = "<";
        if(!privateMessage)
        {
            watchMsg += target + ":";
        }
        watchMsg += client.nick + "> " + message + "\n";

        foreach(const ClientInfo& client, ircModWatchList)
        {
            respond(client, watchMsg, RespondType::PrivateNotice, true);
        }
    }
}

void CRSM::watchdog()
{
    if(watchDogString.isEmpty())
    {
        watchDogTimer.start(Config.Clonk.Server.Watchdog.Timeout * 1000);
        watchDogString = GetRandomString(20);
        control.watchdog(watchDogString);
    }
    else
    {
        announceInfo("Clonk reagiert nicht und wird beendet.\n");
        processManager->kill();
    }
}

void CRSM::unRegisterIngameChat()
{
    if(Session.IRC.UseIngameChat)
    {
        parser.addTarget(&ingameChat);
    }
    else
    {
        parser.removeTarget(&ingameChat);
    }
}

CMD_FUNCTION_IMPL(help)
    bool recursive = args.startsWith("recursive ") && client.interface == Management;
    ClientInterface interface = client.interface;
    if(recursive)
    {
        const QStringList& options = args.mid(QString("recursive ").length()).split(' ');
        if(options.length() >= 1)
        {
            const QString& interfaceStr = options.first();
            if(interfaceStr == "Clonk")
            {
                interface = Clonk;
            }
            else if(interfaceStr == "IRC")
            {
                interface = IRC;
            }
            else if(interfaceStr == "Management")
            {
                interface = Management;
            }
            else
            {
                respond(client, "Error parsing unknown interface option for recursive help: " + interfaceStr + "\n");
                return SyntaxFail;
            }

            if(options.length() >= 2)
            {
                const QString& typeStr = options.at(1);
                if(typeStr == "User")
                {
                    userType = User;
                }
                else if(typeStr == "Admin")
                {
                    userType = Admin;
                }
                else if(typeStr == "Moderator")
                {
                    userType = Moderator;
                }
                else
                {
                    respond(client, "Error parsing unknown user type option for recursive help: " + typeStr + "\n");
                    return SyntaxFail;
                }
            }
        }
    }
    else if(args.endsWith("recursive") && client.interface == Management)
    {
        recursive = true;
    }
    bool longHelp = recursive || (args == "long");
    if(longHelp && client.interface == IRC)
    {
        respond(client, "Die lange Hilfe ist über IRC nicht verfügbar.\n");
        return Success;
    }
    if(args.isEmpty() || longHelp)
    {
        QString response = "Verfügbare Befehle: ";
        foreach(const CmdFunctionRef& cmd, cmds)
        {
            if(!recursive && cmd.name.contains(' ')) continue;
            if((cmd.interfaces & interface) == interface && ((recursive && userType == cmd.userType) || (!recursive && userType >= cmd.userType)))
            {
                if(longHelp)
                {
                    response += "\n" + Config.CRSM.CommandSigns.first() + 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.CommandSigns.first() + "help <Befehlsname>\n");
//                        "[Sachen in eckigen Klammern sind optional]\n"
//                        "<Sachen in spitzen Klammern sind benötigte Argumente>\n"
//                        "Beim Einsetzen der Argumente werden <> bzw. [] weggelassen.\n");
    }
    else
    {
        QString realCmdName = args.toLower();
        substituteCommandAlias(realCmdName);
        if(cmdExists(realCmdName, client.interface))
        {
            const CmdFunctionRef& cmd = cmds.value(realCmdName);
            respond(client, Config.CRSM.CommandSigns.first() + args + " " + (!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.CommandSigns.first() + "help " + args + " <Unterbefehlsname>):\n ";
                            first = false;
                        }
                        else
                        {
                            response += ", ";
                        }
                        response += cmdName.midRef(args.length() + 1);
                    }
                }
                if(first)
                {
                    respond(client, "Dieser Befehl hat für die aktuelle Berechtigungsstufe keine Unterbefehle.\n");
                }
                else
                {
                    response += "\n";
                    respond(client, response);
                }
            }
        }
        else
        {
            respond(client, "Der Befehl \"" + args + "\" existiert nicht.\n");
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(passToClonk)
    control.rawCommand(args.isEmpty() ? cmd : (cmd + ' ' + args));
    return Success;
}

CMD_FUNCTION_IMPL(passToClonkGrouped)
    control.rawCommand(cmd.split(' ').last() + ' ' + args);
    return Success;
}

CMD_FUNCTION_IMPL(admin)
    if(Session.State == CRSMSession::None)
    {
        respond(client, "Solange nichts gehostet ist, kann es keinen Rundenadmin geben.\n");
        return RightsFail;
    }
    ClientInfo *interfaceAdminPtr = nullptr;
    switch(client.interface)
    {
        case Clonk:
            interfaceAdminPtr = &Session.Clonk.Admin;
            break;
        case IRC:
            interfaceAdminPtr = &Session.IRC.Admin;
            break;
        case Auto: case Management: // no interface specific admin allowed for these interfaces
            return Success;
    }
    ClientInfo& interfaceAdmin = *interfaceAdminPtr;
    bool noLeaveAdmin = userType < Admin && !(Session.Clonk.LeaveAdmins.contains(client) && Session.Clonk.LeaveAdmins.value(client).secsTo(QDateTime::currentDateTime()) < Config.Clonk.Chat.RegainAdminTime);
    if(args.isEmpty() && interfaceAdmin == client)
    {
        respond(client, "Du bist bereits Rundenadmin!\n");
        return Success;
    }
    else if((!Session.IRC.Admin.empty() || !Session.Clonk.Admin.empty()) && noLeaveAdmin)
    {
        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())
    {
        if(!noLeaveAdmin)
        {
            Session.IRC.Admin.clear();
        }
        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); // use ISON?
    }
    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.last().secsTo(QDateTime::currentDateTime()) < Config.Hosting.AfkAdminPreAfkTime) || (!Session.Clonk.Admin.empty() && !Session.Clonk.Admin.antiFloodList.isEmpty() && Session.Clonk.Admin.antiFloodList.last().secsTo(QDateTime::currentDateTime()) < Config.Hosting.AfkAdminPreAfkTime))
    {
        respond(client, "Der Rundenadmin war gerade aktiv.\n");
    }
    else
    {
        Session.AfkAdmin = true;
        if(afkAdminTimer.isActive())
        {
            respond(client, "Der Rundenadmin hat noch " + QString::number((afkAdminTimer.remainingTime() + 500) / 1000) + "s Zeit um zu reagieren.\n");
        }
        else
        {
            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");
            }
            control.alert();
            if(!Session.Clonk.Admin.empty())
            {
                control.serverMessage(Session.Clonk.Admin.nick + "! Wenn du dich nicht in den nächsten " + QString::number(Config.Hosting.AfkAdminTime) + "s meldest, wird der Rundenadmin freigegeben.");
            }
            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(' ', Qt::KeepEmptyParts);
            QString ligaText = "";
            if(argList.first().trimmed() == "--league")
            {
                argList.removeFirst();
                scen.league = true;
                scen.name = argList.join(' ');
                if(!Config.Hosting.DisableLeague)
                {
                    ligaText = " mit Liga";
                }
            }
            if(!(scen.name = scenPath(scen.name)).isEmpty())
            {
                if(scenAllowed(scen, client, userType))
                {
                    userlist << scen;
                    Stats.AddScenarioWish(client, scenarioFileName(scen.name));

                    QString appendText = "";
                    if(scen.league && Config.Hosting.DisableLeague)
                    {
                        appendText = " (Liga wurde am Server deaktiviert)";
                    }
                    respond(client, "Szenario " + scen.name + " " + (Session.State == CRSMSession::None || (Session.Clonk.Clients.size() == 0 && !Session.UserWish) ? "wird jetzt" + ligaText + " gehostet" : "wurde der Warteschlange" + ligaText + " hinzugefügt") + "." + appendText + "\n");
                    if(userlist.length() == 1 && !Session.UserWish && Session.State == CRSMSession::Lobby && 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 || client.dcc)
    {
        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, true);
    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;
    int pos = 0;
    bool ok;
    if(!args.isEmpty())
    {
        pos = args.toInt(&ok) - 1;
        if(!ok || pos < 0)
        {
            respond(client, "Die Warteschlangenposition muss eine positive ganze Zahl sein!\n");
            return SyntaxFail;
        }
        if(pos >= userlist.length())
        {
            if(!autoHost || (pos -= userlist.length()) >= nextAutoScens.length() - userlist.length())
            {
                respond(client, "Die angegebene Position ist höher, als die Warteschlange lang ist.\n");
                return Success;
            }
            else
            {
                if(userType >= Moderator)
                {
                    skipped = nextAutoScens.at(pos).name;
                    nextAutoScens.removeAt(pos);
                    updateNextAutoScens();
                    respond(client, " \"" + skipped + "\" übersprungen.\n"); // without the space in front it is interpreted as a "role play like" message
                    return Success;
                }
                else
                {
                    pos = -2;
                }
            }
        }
        else if(userlist.at(pos).wishClient != client && userType < Moderator)
        {
            pos = -2;
        }
        if(pos == -2)
        {
            respond(client, "Nur Moderatoren dürfen fremde Wünsche entfernen.\n");
            return RightsFail;
        }
    }
    else if(userType < Moderator)
    {
        pos = findWishFromUser(client);
        if(pos == -1)
        {
            respond(client, "Von dir ist kein Wunsch vorhanden.\n");
            return Success;
        }
    }
    if(userlist.length() == 0)
    {
        respond(client, "Warteschlange ist leer!\n");
    }
    else if(!(skipped = skipScen(pos)).isEmpty())
    {
        respond(client, " \"" + skipped + "\" übersprungen.\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, "Warteschlange geleert.\n");
    }
    else
    {
        respond(client, "Warteschlange ist leer!\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(aliaswishes)
    if(aliasWishEditor.isEmpty())
    {
        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.CommandSigns.first() + "help newalias für mehr Informationen.\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(deletealias)
    if(args.isEmpty())
    {
        respond(client, "Zum Entfernen muss ein Aliasname angegeben werden.\n");
        return SyntaxFail;
    }
    else
    {
        if(Config.Hosting.Alias.contains(args))
        {
            QString aliasFor = Config.Hosting.Alias.value(args);
            Config.Hosting.Alias.remove(args);
            respond(client, "Alias \"" + args + "\" für \"" + aliasFor + "\" wurde entfernt.\n");
        }
        else
        {
            respond(client, "Unbekannter Alias: \"" + args + "\"!\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)
    { // FIXME: wrong cmd for passToClonkPcNameGrouped
        respond(client, Config.CRSM.CommandSigns.first() + cmd + " kann nicht auf den Server angewendet werden!\n");
        return Success;
    }
    ClientInfo info;
    QString msg = findClientByName(info, args);

    if(!msg.isEmpty())
    {
        respond(client, msg);
        return Success;
    }

    if(cmd == "kick" && clientUserType(info) > userType)
    {
        respond(client, "Moderatoren können nur von anderen Moderatoren gekickt werden.\n");
        return RightsFail;
    }
    control.rawCommand(cmd + " " + info.pcName);
    return Success;
}

CMD_FUNCTION_IMPL(passToClonkPcNameGrouped)
    return passToClonkPcName(cmd.split(' ').last(), args, client, userType);
}

CMD_FUNCTION_IMPL(passToClonkCtrlMode)
    return passToClonk(cmd.split(' ').last() + "ctrl", "", client, userType);
}

CMD_FUNCTION_IMPL(ircadmin)
    if(args.isEmpty())
    {
        respond(client, "Es wird der Nickname vom zu setzenden Admin benötigt.\n");
        return SyntaxFail;
    }
    ircCheckUserStatus(client, ClientInfo::ircClient(args), &CRSM::ircSetAdmin);
    return Success;
}

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

CMD_FUNCTION_IMPL(noadmin)
    if(Session.IRC.Admin.empty() && Session.Clonk.Admin.empty())
    {
        respond(client, "Es gibt noch keinen Rundenadmin.\n");
    }
    else
    {
        static const QString msg("Rundenadmin wurde freigegeben.");
        Session.IRC.Admin.clear();
        Session.Clonk.Admin.clear();
        respond(client, msg);
        if(client.interface == IRC)
        {
              control.serverMessage(msg);
        }
    }
    return Success;
}

CMD_FUNCTION_IMPL(clientlist)
    if(Session.State == CRSMSession::None)
    {
        respond(client, "Es ist zurzeit nichts gehostet.\n");
        return Success;
    }

    if(Session.Clonk.Clients.isEmpty())
    {
        respond(client, "Keine verbundenen Clients.\n");
        return Success;
    }

    QString response = "Verbundene Clients ((Anzahl Spieler) Chatnick (PC-Name)): ";
    foreach(const ClientInfo& connectedClient, Session.Clonk.Clients)
    {
        response += "(" + QString::number(connectedClient.players.count()) + ") " + connectedClient.toString() + ", ";
    }

    if(!Session.Clonk.Server.players.isEmpty())
    {
        response += "(" + QString::number(Session.Clonk.Server.players.count()) + ") " + Session.Clonk.Server.toString() + ", ";
    }
    else
    {
        response.chop(2);
    }
    respond(client, response + "\n");
    return Success;
}

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

CMD_FUNCTION_IMPL(passToClonkNumericOrEmpty)
    if(args.isEmpty())
    {
        control.rawCommand(cmd);
        return Success;
    }
    else
    {
        return passToClonkNumeric(cmd, args, client, userType);
    }
}

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

CMD_FUNCTION_IMPL(join)
    QStringList argList = args.split(' ');
    if(argList.size() < 1 || argList.first().isEmpty())
    {
        respond(client, "Kein Channel angegeben!\n");
        return SyntaxFail;
    }
    else if(isChannelName(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();
    }
    if(isChannelName(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);
    if(connection != nullptr)
    {
        QString quitMsg = Config.IRC.QuitMessage;
        if(!args.isEmpty())
        {
            quitMsg = args;
        }
        connect(connection, SIGNAL(disconnected()), QCoreApplication::instance(), SLOT(quit()));
        connection->quit(quitMsg);
        QTimer::singleShot(1000, QCoreApplication::instance(), SLOT(quit()));
    }
    else
    {
        QCoreApplication::quit();
    }
    return Success;
}

CMD_FUNCTION_IMPL(exitUpdate)
    control.serverMessage("Der Server Manager wird upgedatet. Befehle funktionieren temporär nicht.");
    return exitDetach(cmd, "Updating...", 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");
    writeFiles();
    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)
    control.setCommand(args);
    return Success;
}

CMD_FUNCTION_IMPL(nodebug)
    if(userType >= Admin || client.interface == Clonk)
    {
        return passToClonk(cmd, args, client, userType);
    }
    else
    {
        rightsFailMessage(client, Admin);
        return RightsFail;
    }
}

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

CMD_FUNCTION_IMPL(getConfigValue)
    try
    {
        respond(client, Config.getConfigValueLine(args));
    }
    catch(const 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(const ConfigException& e)
    {
        respond(client, QString("Fehler beim Setzen: ") + e.what() + "\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(ircSay)
    QStringList parts = args.split(' ', Qt::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(!isChannelName(target))
        {
            ircSayQueryFifos[target].append(message);
            ircCheckUserStatus(client, ClientInfo::ircClient(target), &CRSM::ircSayQuery);
        }
        else
        {
            sendIrcMessage(message, target, false, false);
        }
    }
    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.CommandSigns.first() + cmd + " kann nur mit \"on\" oder \"off\" verwendet werden.\n");
        return SyntaxFail;
    }
    return Success;
}

CMD_FUNCTION_IMPL(ircRaw)
    connection->sendCommand(IrcCommand::createQuote(args));
    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.CommandSigns.first() + "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.CommandSigns.first() + "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.CommandSigns.first() + "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.CommandSigns.first() + "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;
}

CMD_FUNCTION_IMPL(packsScenOptionsGet)
    bool all = cmd == "packs scenoptions all";

    const QString& scen = args.trimmed();
    if(scen.isEmpty())
    {
        respond(client, "Eine Szenarioangabe ist notwendig!\n");
        return SyntaxFail;
    }
    else
    {
        respond(client, "\"" + Packs.getScenarioCmdOptions(scen, all) + "\"\n");
        return Success;
    }
}

CMD_FUNCTION_IMPL(packsScenOptionsSet)
    if(args.trimmed().isEmpty())
    {
        respond(client, "Eine Szenarioangabe ist notwendig!\n");
        return SyntaxFail;
    }

    QStringList argList = Util::splitEscaped(args, ' ');
    QString scen = argList.first();
    argList.removeFirst();

    QString scenOptions;

    if(argList.length() > 0)
    {
        scenOptions = Util::joinEscape(argList, ' ');
    }

    respond(client, Packs.setScenarioCmdOptions(scen, scenOptions));

    return Success;
}

CMD_FUNCTION_IMPL(dccConnect)
    dccChatRequest(client);
    return Success;
}

CMD_FUNCTION_IMPL(dccDisconnect)
    if(dccNickConnections.contains(client.nick))
    {
        QTimer::singleShot(0, dccNickConnections[client.nick].socket, &QTcpSocket::close);
    }
    else
    {
        respond(client, "Diesem Nick ist keine DCC-Verbindung zugewiesen.\n");
    }
    return Success;
}

CMD_FUNCTION_IMPL(dccIdentify)
    if(dccNickConnections.contains(client.nick))
    {
        respond(client, "Diesem Nick ist bereits eine DCC-Verbindung zugewiesen.\n");
        return Success;
    }
    if(args.isEmpty())
    {
        respond(client, "Es wird eine Verbindungs-ID benötigt.\n");
        return SyntaxFail;
    }
    QTcpSocket* socket = dccConnectionIdentifiers.value(args, nullptr);
    if(socket == nullptr)
    {
        respond(client, "Unbekannte bzw. falsche Verbindungs-ID: \"" + args + "\"\n");
    }
    else
    {
        dccConnectionIdentifiers.remove(args);
        DCCConnection conn;
        conn.client = client;
        conn.socket = socket;
        conn.client.dcc = true;
        dccNickConnections.insert(client.nick, conn);
        dccSocketConnections.insert(socket, conn);
        respond(client, "Identifizierung erfolgreich!\n");
        connect(socket, SIGNAL(readyRead()), this, SLOT(newDCCData()));
    }
    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])
        {
            sendIrcMessage(message, subject.nick, false, false);
        }
    }
    ircSayQueryFifos[subject.nick].clear();
}

IRC_CHECK_CALLBACK_IMPL(ircSetAdmin)
    if(status <= 0)
    {
        respond(requester, "IRC-Nutzer " + subject.toString() + " wurde nicht gefunden!\n");
    }
    else
    {
        if(subject.nick == connection->nickName())
        {
            respond(requester, "Der Server kann nicht als Rundenadmin eingetragen werden.\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, true);
            respond(subject, "Bitte bei nächster Gelegenheit mit " + Config.CRSM.CommandSigns.first() + "alias wishes bearbeiten.", RespondType::PrivateNotice, true);
        }
    }
    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);
        }
    }
}