ircnetworkadapter.cpp

//------------------------------------------------------------------------------
// ircnetworkadapter.cpp
//------------------------------------------------------------------------------
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
//------------------------------------------------------------------------------
// Copyright (C) 2010 "Zalewa" <zalewapl@gmail.com>
//------------------------------------------------------------------------------
#include "ircnetworkadapter.h"
#include "irc/configuration/chatnetworkscfg.h"
#include "irc/configuration/ircconfig.h"
#include "irc/entities/ircuserprefix.h"
#include "irc/ops/ircdelayedoperationban.h"
#include "irc/ircchanneladapter.h"
#include "irc/ircglobal.h"
#include "irc/ircisupportparser.h"
#include "irc/ircmessageclass.h"
#include "irc/ircprivadapter.h"
#include "irc/ircrequestparser.h"
#include "irc/ircresponseparser.h"
#include "irc/ircuserinfo.h"
#include "irc/ircuserlist.h"
#include "log.h"
#include <QDateTime>

IRCNetworkAdapter::IRCNetworkAdapter(const IRCNetworkConnectionInfo &connectionInfo)
{
        this->connectionInfo = connectionInfo;
        this->bIsJoining = false;
        this->bEmitAllIRCMessages = false;

        pIrcSocketSignalsAdapter = new IRCSocketSignalsAdapter(this);
        ircISupportParser = new IRCISupportParser();
        ircResponseParser = new IRCResponseParser(this);
        ircClient.connectSocketSignals(pIrcSocketSignalsAdapter);

        QObject::connect(&ircClient, SIGNAL( ircServerResponse(const QString&) ),
                this, SLOT( ircServerResponse(const QString&) ) );

        // Request parser
        QObject::connect(&ircRequestParser, SIGNAL( echoPrivmsg(const QString&, const QString&) ),
                this, SLOT( echoPrivmsg(const QString&, const QString&) ) );

        QObject::connect(&ircRequestParser, SIGNAL( query(const QString&) ),
                this, SLOT( openNewAdapter(const QString&) ) );

        // Response parser begins here.
        QObject::connect(ircResponseParser, SIGNAL( helloClient(const QString&) ),
                this, SLOT( helloClient(const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL(iSupportReceived(QString)),
                SLOT(appendISupportLine(QString)));

        QObject::connect(ircResponseParser, SIGNAL( kick(const QString&, const QString&, const QString&, const QString&) ),
                this, SLOT( kick(const QString&, const QString&, const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL( kill(const QString&, const QString&) ),
                this, SLOT( kill(const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL( modeInfo(const QString&, const QString&, const QString&) ),
                this, SLOT( modeInfo(const QString&, const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL( namesListReceived(const QString&, const QStringList&) ),
                this, SLOT( namesListReceived(const QString&, const QStringList&) ) );

        QObject::connect(ircResponseParser, SIGNAL( namesListEndReceived(const QString&) ),
                this, SLOT( namesListEndReceived(const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL( nicknameInUse(const QString&) ),
                this, SLOT( nicknameInUse(const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL( noSuchNickname(const QString&) ),
                this, SLOT( noSuchNickname(const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL ( parseError(const QString&) ),
                this, SLOT( parseError(const QString&) ) );

        // This connect must be direct as it might interfere with other operations
        // of printing done in the window.
        QObject::connect(ircResponseParser, SIGNAL( print(const QString&, const QString&)),
                this, SLOT(print(const QString&, const QString&) ), Qt::DirectConnection);
        QObject::connect(ircResponseParser,
                SIGNAL(printWithClass(const QString&, const QString&, const IRCMessageClass&)),
                this, SLOT(printWithClass(const QString&, const QString&, const IRCMessageClass&)),
                Qt::DirectConnection);
        QObject::connect(ircResponseParser, SIGNAL(printToNetworksCurrentChatBox(QString, IRCMessageClass)),
                SIGNAL(messageToNetworksCurrentChatBox(QString, IRCMessageClass)));

        QObject::connect(ircResponseParser, SIGNAL ( privMsgReceived(const QString&, const QString&, const QString&) ),
                this, SLOT( privMsgReceived(const QString&, const QString&, const QString&) ) );
        QObject::connect(ircResponseParser, SIGNAL ( privMsgLiteralReceived(QString, QString, IRCMessageClass) ),
                this, SLOT( printMsgLiteral(QString, QString, IRCMessageClass) ) );

        QObject::connect(ircResponseParser, SIGNAL ( sendPongMessage(const QString&) ),
                this, SLOT( sendPong(const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL ( userChangesNickname(const QString&, const QString&) ),
                this, SLOT( userChangesNickname(const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL(userIdleTime(QString, int)),
                this, SLOT(userIdleTime(QString, int)));

        QObject::connect(ircResponseParser, SIGNAL ( userJoinsChannel(const QString&, const QString&, const QString&) ),
                this, SLOT( userJoinsChannel(const QString&, const QString&, const QString&) ) );

        QObject::connect(ircResponseParser,
                SIGNAL(userModeChanged(const QString&, const QString&, const QList<char>&, const QList<char>&)),
                this,
                SLOT(userModeChanged(const QString&, const QString&, const QList<char>&, const QList<char>&)));

        QObject::connect(ircResponseParser, SIGNAL(userNetworkJoinDateTime(QString, QDateTime)),
                this, SLOT(userNetworkJoinDateTime(QString, QDateTime)));

        QObject::connect(ircResponseParser, SIGNAL ( userPartsChannel(const QString&, const QString&, const QString&) ),
                this, SLOT( userPartsChannel(const QString&, const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL ( userQuitsNetwork(const QString&, const QString&) ),
                this, SLOT( userQuitsNetwork(const QString&, const QString&) ) );

        QObject::connect(ircResponseParser, SIGNAL ( whoIsUser(const QString&, const QString&, const QString&, const QString&) ),
                this, SLOT( whoIsUser(const QString&, const QString&, const QString&, const QString&) ) );
}

IRCNetworkAdapter::~IRCNetworkAdapter()
{
        disconnect(gIRCConfig.personal.quitMessage);

        killAllChatWindows();
        delete this->ircResponseParser;
        delete this->ircISupportParser;
        delete this->pIrcSocketSignalsAdapter;
}

void IRCNetworkAdapter::appendISupportLine(const QString &line)
{
        print(line, QString());
        ircISupportParser->appendLine(line);
        ircISupportParser->parse();
}

void IRCNetworkAdapter::banUser(const QString& nickname, const QString& reason, const QString& channel)
{
        IRCDelayedOperationBan *op = new IRCDelayedOperationBan(this, channel, nickname, this);
        op->setReason(reason);
        op->start();
}

QList<IRCAdapterBase*> IRCNetworkAdapter::childrenAdapters()
{
        QList<IRCAdapterBase*> result;
        foreach (IRCChatAdapter *adapter, chatWindows.values())
        {
                result << adapter;
        }
        return result;
}

void IRCNetworkAdapter::connect()
{
        emit titleChange();
        ircClient.connect(connectionInfo.networkEntity.address(), connectionInfo.networkEntity.port());
}

void IRCNetworkAdapter::detachChatWindow(const IRCChatAdapter* pAdapter)
{
        chatWindows.remove(pAdapter->recipient().toLower());
}

void IRCNetworkAdapter::disconnect(const QString& farewellMessage)
{
        sendMessage("/quit " + farewellMessage);
        ircClient.disconnect();
}

void IRCNetworkAdapter::doSendMessage(const QString& message, IRCAdapterBase* pOrigin)
{
        if (pOrigin == NULL)
        {
                pOrigin = this;
        }

        if (!ircClient.isConnected())
        {
                pOrigin->emitError(tr("You are not connected to the network."));
                return;
        }

        IRCRequestParser::IRCRequestParseResult result = ircRequestParser.parse(pOrigin, message);
        QString parsedMessage = ircRequestParser.output();

        switch (result)
        {
                case IRCRequestParser::ErrorInputInsufficientParameters:
                        pOrigin->emitError(tr("Insufficient parameters."));
                        break;

                case IRCRequestParser::ErrorInputNotPrependedWithSlash:
                        emit error(tr("This is a server window. All commands must be prepended with a '/' character."));
                        break;

                case IRCRequestParser::ErrorMessageEmpty:
                        pOrigin->emitError(tr("Attempted to send empty message."));
                        break;

                case IRCRequestParser::ErrorMessageTooLong:
                        pOrigin->emitError(tr("Command is too long."));
                        break;

                case IRCRequestParser::ErrorChatWindowOnly:
                        pOrigin->emitError(tr("Not a chat window."));
                        break;

                case IRCRequestParser::Ok:
                        ircClient.sendMessage(parsedMessage);
                        break;

                case IRCRequestParser::QuitCommand:
                        ircClient.sendMessage(parsedMessage);
                        emit messageWithClass(tr("Quit"), IRCMessageClass::NetworkAction);
                        break;
        }
}

void IRCNetworkAdapter::echoPrivmsg(const QString& recipient, const QString& content)
{
        // We will echo only chat messages for recipients for whom
        // we have windows open.
        if (hasRecipient(recipient))
        {
                const QString& sender = this->myNickname();
                privMsgReceived(recipient, sender, content);
        }
}

IRCChatAdapter* IRCNetworkAdapter::getChatAdapter(const QString& recipient)
{
        IRCChatAdapter* pAdapter = NULL;

        if (recipient.isEmpty())
        {
                emit error("Doomseeker error: getChatAdapter() received empty recipient.");
                return NULL;
        }

        QString recipientLowercase = recipient.toLower();
        if (hasRecipient(recipientLowercase))
        {
                return chatWindows[recipientLowercase];
        }

        return NULL;
}

const IRCChatAdapter* IRCNetworkAdapter::getChatAdapter(const QString& recipient) const
{
        const IRCChatAdapter* pAdapter = NULL;

        if (recipient.isEmpty())
        {
                return NULL;
        }

        QString recipientLowercase = recipient.toLower();
        if (hasRecipient(recipientLowercase))
        {
                return chatWindows[recipientLowercase];
        }

        return NULL;
}

IRCChatAdapter* IRCNetworkAdapter::getOrCreateNewChatAdapter(const QString& recipient)
{
        IRCChatAdapter* pAdapter = NULL;

        if (recipient.isEmpty())
        {
                emit error("Doomseeker error: getOrCreateNewChatAdapter() received empty recipient.");
                return NULL;
        }

        QString recipientLowercase = recipient.toLower();

        if (hasRecipient(recipientLowercase))
        {
                return chatWindows[recipientLowercase];
        }

#ifndef NDEBUG
        Log::instance << QString("IRCNetworkAdapter::getOrCreateNewChatAdapter() Creating new adapter for recipient: %1").arg(recipientLowercase);
#endif

        if (IRCGlobal::isChannelName(recipient))
        {
                pAdapter = new IRCChannelAdapter(this, recipient);
        }
        else
        {
                pAdapter = new IRCPrivAdapter(this, recipient);
        }

        chatWindows.insert(recipientLowercase, pAdapter);
        emit newChatWindowIsOpened(pAdapter);

        return pAdapter;
}

bool IRCNetworkAdapter::hasRecipient(const QString& recipient) const
{
        QString recipientLowercase = recipient.toLower();
        return (chatWindows.find(recipientLowercase) != chatWindows.end());
}

void IRCNetworkAdapter::helloClient(const QString& nickname)
{
        // This method can only be called
        // when network is in joining state.

        connectionInfo.nick = nickname;
        IRCNetworkEntity& network = connectionInfo.networkEntity;

        gLog << tr("IRC: Successfuly registered on network %1 [%2:%3]").arg(network.description(), network.address()).arg(network.port());

        this->bIsJoining = false;

        if (!network.nickservPassword().isEmpty())
        {
                QString messageNickserv = network.nickservCommand();
                messageNickserv = messageNickserv.arg(network.nickservPassword());

                this->sendMessage(messageNickserv);
        }
        foreach (const QString& command, network.autojoinCommands())
        {
                if (!command.trimmed().isEmpty())
                {
                        this->sendMessage(command);
                }
        }

        foreach (const QString& channel, network.autojoinChannels())
        {
                if (IRCGlobal::isChannelName(channel))
                {
                        this->openNewAdapter(channel);
                }
        }

        // Emit this just to be safe.
        emit titleChange();
}

const PatternList &IRCNetworkAdapter::ignoredUsersPatterns() const
{
        return connection().networkEntity.ignoredUsers();
}

void IRCNetworkAdapter::ircServerResponse(const QString& message)
{
        IRCResponseParseResult result = ircResponseParser->parse(message);

        if (this->bEmitAllIRCMessages || !result.wasParsed())
        {
                emit this->message(message.trimmed().replace("\n", "\\n"));
        }

        if (!result.isValid())
        {
                emit this->error(tr("Invalid parse result for mesage: %1").arg(message));
        }
}

bool IRCNetworkAdapter::isAdapterRelated(const IRCAdapterBase* pAdapter) const
{
        if (this == pAdapter)
        {
                return true;
        }

        QList<IRCChatAdapter*> adaptersList = chatWindows.values();
        foreach (IRCChatAdapter* pChatWindow, adaptersList)
        {
                if (pChatWindow == pAdapter)
                {
                        return true;
                }
        }

        return false;
}

bool IRCNetworkAdapter::isMyNickname(const QString& nickname) const
{
        IRCUserInfo myUserInfo(this->connectionInfo.nick, this);
        return (myUserInfo.isSameNickname(nickname));
}

bool IRCNetworkAdapter::isOperator(const QString& nickname, const QString& channel) const
{
        if (IRCGlobal::isChannelName(channel))
        {
                const IRCChannelAdapter* pChannelAdapter = (const IRCChannelAdapter*) this->getChatAdapter(channel);
                if (pChannelAdapter != NULL)
                {
                        return pChannelAdapter->isOperator(nickname);
                }
        }

        return false;
}

void IRCNetworkAdapter::kick(const QString& channel, const QString& byWhom, const QString& whoIsKicked, const QString& reason)
{
        if (hasRecipient(channel))
        {
                IRCChannelAdapter* pAdapter = (IRCChannelAdapter*) this->getOrCreateNewChatAdapter(channel);

                if (isMyNickname(whoIsKicked))
                {
                        this->emitMessageWithClass(tr("You have been kicked from channel %1 by %2 (Reason: %3)").arg(channel, byWhom, reason), IRCMessageClass::ChannelAction);
                        killChatWindow(channel);
                }
                else
                {
                        pAdapter->emitMessageWithClass(tr("%1 was kicked by %2 (%3)").arg(whoIsKicked, byWhom, reason), IRCMessageClass::ChannelAction);
                        pAdapter->removeNameFromCachedList(whoIsKicked);
                }
        }
}

void IRCNetworkAdapter::kill(const QString& victim, const QString& comment)
{
        emit message(QString("Connection for user %1 was killed. (%2)").arg(victim, comment));

        // We need to iterate through EVERY adapter and notify them
        // about this quit.
        // Implementation of each adapter should recognize if this quit actually
        // has anything to do with that adapter.
        QList<IRCChatAdapter*> adaptersList = chatWindows.values();
        foreach (IRCChatAdapter* pAdapter, adaptersList)
        {
                pAdapter->userLeaves(victim, comment, IRCChatAdapter::NetworkKill);
        }
}

void IRCNetworkAdapter::killAllChatWindows()
{
        QList<IRCChatAdapter*> pWindows = chatWindows.values();
        foreach (IRCChatAdapter* pAdapter, pWindows)
        {
                // Make sure that the adapter destructor won't call the
                // detachChatWindow() method or the program will be shot to oblivion.
                pAdapter->setNetwork(NULL);
                delete pAdapter;
        }

        chatWindows.clear();
}

void IRCNetworkAdapter::killChatWindow(const QString& recipient)
{
        if (hasRecipient(recipient))
        {
                IRCChatAdapter* pAdapter = getChatAdapter(recipient);
                chatWindows.remove(recipient.toLower());

                // Make sure that the adapter destructor won't call the
                // detachChatWindow() method or the program will be shot to oblivion.
                pAdapter->setNetwork(NULL);
                delete pAdapter;
        }
}

void IRCNetworkAdapter::modeInfo(const QString& channel, const QString& whoSetThis, const QString& modeParams)
{
        IRCChannelAdapter* pAdapter = (IRCChannelAdapter*) this->getOrCreateNewChatAdapter(channel);
        pAdapter->emitMessageWithClass(tr("%1 sets mode: %2").arg(whoSetThis, modeParams), IRCMessageClass::ChannelAction);
}

void IRCNetworkAdapter::namesListReceived(const QString& channel, const QStringList& names)
{
        if (this->hasRecipient(channel))
        {
                IRCChannelAdapter* pAdapter = (IRCChannelAdapter*) this->getOrCreateNewChatAdapter(channel);
                pAdapter->appendNamesToCachedList(names);
        }
}

void IRCNetworkAdapter::namesListEndReceived(const QString& channel)
{
        if (this->hasRecipient(channel))
        {
                IRCChannelAdapter* pAdapter = (IRCChannelAdapter*) this->getOrCreateNewChatAdapter(channel);
                pAdapter->emitCachedNameListUpdated();
        }
}

void IRCNetworkAdapter::nicknameInUse(const QString& nickname)
{
        emit messageToNetworksCurrentChatBox(tr("Nickname %1 is already taken.").arg(nickname), IRCMessageClass::Error);
        if (this->bIsJoining)
        {
                const QString& altNick = this->connectionInfo.alternateNick;

                if (this->connectionInfo.nick.compare(altNick, Qt::CaseInsensitive) == 0)
                {
                        emit messageWithClass(tr("Both nickname and alternate nickname are taken on this network."), IRCMessageClass::Error);
                }
                else if (altNick.isEmpty())
                {
                        emit messageWithClass(tr("No alternate nickname specified."), IRCMessageClass::Error);
                }
                else
                {
                        this->connectionInfo.nick = altNick;

                        emit messageWithClass(tr("Using alternate nickname %1 to join.").arg(altNick), IRCMessageClass::NetworkAction);
                        QString message = QString("/nick %1").arg(altNick);
                        sendMessage(message);
                }
        }
}

void IRCNetworkAdapter::noSuchNickname(const QString& nickname)
{
        emit messageToNetworksCurrentChatBox(tr("User %1 is not logged in.").arg(nickname), IRCMessageClass::Error);
}

void IRCNetworkAdapter::openNewAdapter(const QString& recipientName)
{
        if (!isConnected() || recipientName.isEmpty())
        {
                return;
        }

        bool bStandardRoutine = !IRCGlobal::isChannelName(recipientName)
                || hasRecipient(recipientName);

        if (bStandardRoutine)
        {
                IRCChatAdapter* pAdapter = this->getOrCreateNewChatAdapter(recipientName);
                pAdapter->emitFocusRequest();
        }
        else if (IRCGlobal::isChannelName(recipientName))
        {
                this->sendMessage("/join " + recipientName);
        }
}

void IRCNetworkAdapter::parseError(const QString& error)
{
        emit this->error(tr("IRC parse error: %1").arg(error));
}

void IRCNetworkAdapter::print(const QString& printWhat, const QString& printWhere)
{
        printWithClass(printWhat, printWhere, IRCMessageClass(IRCMessageClass::Normal));
}

void IRCNetworkAdapter::printWithClass(const QString& printWhat,
        const QString& printWhere, const IRCMessageClass& msgClass)
{
        IRCAdapterBase* pAdapter = this;

        if (!printWhere.isEmpty())
        {
                IRCAdapterBase* pAdapterCandidate = getChatAdapter(printWhere);
                if (pAdapterCandidate != NULL)
                {
                        pAdapter = pAdapterCandidate;
                }
        }

        // In case if the target adapter is unknown, the message will still get
        // printed to this adapter.
        if (pAdapter == NULL)
        {
                this->emitMessageWithClass(tr("FROM %1: %2").arg(printWhere, printWhat), msgClass);
        }
        else
        {
                // If bEmitAllIRCMessages is set to true, the message will be already
                // printed for this adapter in ircServerResponse().
                // There is no need to print it again.
                if ( pAdapter == this && this->bEmitAllIRCMessages )
                {
                        return;
                }

                pAdapter->emitMessageWithClass(printWhat, msgClass);
        }
}

void IRCNetworkAdapter::printToCurrentChatBox(const QString& printWhat, const IRCMessageClass& msgClass)
{
        emit messageToNetworksCurrentChatBox(printWhat, msgClass);
}

void IRCNetworkAdapter::privMsgReceived(const QString& recipient, const QString& sender, const QString& content)
{
        IRCChatAdapter* pAdapter = this->getOrCreateNewChatAdapter(recipient);
        pAdapter->emitChatMessage(sender, content);
}

void IRCNetworkAdapter::printMsgLiteral(const QString& recipient, const QString& content,
        const IRCMessageClass& msgClass)
{
        this->getOrCreateNewChatAdapter(recipient);
        printWithClass(content, recipient, msgClass);
}

void IRCNetworkAdapter::reloadNetworkEntityFromConfig()
{
        ChatNetworksCfg cfg;
        IRCNetworkEntity entity = cfg.network(connectionInfo.networkEntity.description());
        if (entity.isValid())
        {
                setNetworkEntity(entity);
        }
}

void IRCNetworkAdapter::setNetworkEntity(const IRCNetworkEntity &entity)
{
        IRCNetworkEntity oldEntity = connectionInfo.networkEntity;
        connectionInfo.networkEntity = entity;
        if (oldEntity.description() != entity.description())
        {
                emit titleChange();
        }
}

void IRCNetworkAdapter::sendCtcp(const QString &nickname, const QString &command)
{
        QString msg = QString("/PRIVMSG %1 %2%3%2").arg(nickname).arg(QChar(0x1)).arg(command);
        sendMessage(msg);
}

void IRCNetworkAdapter::sendPong(const QString& toWhom)
{
        QString message = QString("/PONG %1").arg(toWhom);
        sendMessage(message);
}

void IRCNetworkAdapter::setChannelMode(const QString& channel, const QString& nickname, const QString& flag, bool bSet)
{
        QString cleanNickname = userPrefixes().cleanNickname(nickname);

        QString flagPrefixed;
        if (bSet)
        {
                flagPrefixed = "+" + flag.trimmed();
        }
        else
        {
                flagPrefixed = "-" + flag.trimmed();
        }

        QString message = QString("/mode %1 %2 %3").arg(channel, flagPrefixed, cleanNickname);
        this->sendMessage(message);
}

QString IRCNetworkAdapter::title() const
{
        return connectionInfo.networkEntity.description() + " ( " + myNickname() + " )";
}

void IRCNetworkAdapter::userChangesNickname(const QString& oldNickname, const QString& newNickname)
{
        if (isMyNickname(oldNickname))
        {
                emit messageToNetworksCurrentChatBox(tr("Updated own nickname to %1.").arg(newNickname),
                        IRCMessageClass::NetworkAction);
                connectionInfo.nick = newNickname;

                emit titleChange();
        }

        QList<IRCChatAdapter*> adaptersList = chatWindows.values();
        foreach (IRCChatAdapter* pAdapter, adaptersList)
        {
                pAdapter->userChangesNickname(oldNickname, newNickname);
        }

        // MAKE SURE TO SEE IF WE HAVE A CHAT WINDOW OPEN WITH THIS
        // USER AND FIX THE KEY IN THE CHAT WINDOW MAP FOR THIS NETWORK!!!
        if (hasRecipient(oldNickname))
        {
                QString oldNicknameLowercase = oldNickname.toLower();
                QString newNicknameLowercase = newNickname.toLower();

                IRCChatAdapter* pAdapter = getChatAdapter(oldNickname);
                chatWindows.remove(oldNicknameLowercase);
                chatWindows.insert(newNicknameLowercase, pAdapter);
        }
}

void IRCNetworkAdapter::userJoinsChannel(const QString& channel, const QString& nickname, const QString& fullSignature)
{
        if (!isMyNickname(nickname))
        {
                if (hasRecipient(channel))
                {
                        IRCChannelAdapter* pChannel = (IRCChannelAdapter*)this->getOrCreateNewChatAdapter(channel);
                        pChannel->userJoins(nickname, fullSignature);
                }
        }
        else
        {
                IRCChannelAdapter* pChannel = (IRCChannelAdapter*)this->getOrCreateNewChatAdapter(channel);
                pChannel->emitFocusRequest();
        }
}

void IRCNetworkAdapter::userIdleTime(const QString &nick, int secondsIdle)
{
        QString msg = tr("Last activity of user %1 was %2 ago.").arg(
                nick, Strings::formatTime(secondsIdle));
        emit messageToNetworksCurrentChatBox(msg, IRCMessageClass::NetworkAction);
}

void IRCNetworkAdapter::userModeChanged(const QString& channel, const QString& nickname,
        const QList<char> &addedFlags, const QList<char> &removedFlags)
{
        if (hasRecipient(channel))
        {
                IRCChatAdapter* pAdapter = this->getOrCreateNewChatAdapter(channel);
                pAdapter->userModeChanges(nickname, addedFlags, removedFlags);
        }
}

void IRCNetworkAdapter::userNetworkJoinDateTime(const QString &nick, const QDateTime &timeOfJoin)
{
        QString msg = tr("%1 joined the network on %2").arg(nick,
                timeOfJoin.toString("yyyy-MM-dd HH:mm:ss"));
        emit messageToNetworksCurrentChatBox(msg, IRCMessageClass::NetworkAction);
}

void IRCNetworkAdapter::userPartsChannel(const QString& channel, const QString& nickname, const QString& farewellMessage)
{
        if (hasRecipient(channel))
        {
                IRCChannelAdapter* pChannel = (IRCChannelAdapter*)getChatAdapter(channel);

                if (isMyNickname(nickname))
                {
                        emit messageWithClass(tr("You left channel %1.").arg(channel), IRCMessageClass::ChannelAction);
                        killChatWindow(channel);
                }
                else
                {
                        pChannel->userLeaves(nickname, farewellMessage, IRCChatAdapter::ChannelPart);
                }
        }
}

const IRCUserPrefix &IRCNetworkAdapter::userPrefixes() const
{
        return ircISupportParser->userPrefixes();
}

void IRCNetworkAdapter::userQuitsNetwork(const QString& nickname, const QString& farewellMessage)
{
        // We need to iterate through EVERY adapter and notify them
        // about this quit.
        // Implementation of each adapter should recognize if this quit actually
        // has anything to do with that adapter.
        QList<IRCChatAdapter*> adaptersList = chatWindows.values();
        foreach (IRCChatAdapter* pAdapter, adaptersList)
        {
                pAdapter->userLeaves(nickname, farewellMessage, IRCChatAdapter::NetworkQuit);
        }
}

void IRCNetworkAdapter::userPing(const QString &nickname, qint64 ping)
{
        qint64 delta = QDateTime::currentMSecsSinceEpoch() - ping;
        emit messageToNetworksCurrentChatBox(
                tr("Ping to user %1: %2ms").arg(nickname).arg(delta),
                IRCMessageClass::Ctcp);
}

void IRCNetworkAdapter::whoIsUser(const QString& nickname, const QString& user, const QString& hostName, const QString& realName)
{
        emit messageToNetworksCurrentChatBox(
                QString("%1 %2 %3 %4").arg(nickname, user, hostName, realName),
                IRCMessageClass::NetworkAction);
}


void IRCSocketSignalsAdapter::connected()
{
        pParent->bIsJoining = true;
        pParent->emitMessageWithClass(tr("Connected. Sending registration messages."), IRCMessageClass::NetworkAction);

        IRCNetworkConnectionInfo& connectionInfo = pParent->connectionInfo;

        QString messagePass = "/PASS %1";
        QString messageNick = "/NICK %1";
        QString messageUser = "/USER %1 %2 %3 :%4";

        IRCNetworkEntity& network = connectionInfo.networkEntity;

        if (!network.password().isEmpty())
        {
                pParent->sendMessage(messagePass.arg(network.password()));
        }

        pParent->sendMessage(messageNick.arg(connectionInfo.nick));
        pParent->sendMessage(messageUser.arg(connectionInfo.nick).arg(connectionInfo.nick).arg(connectionInfo.nick).arg(connectionInfo.realName));
}

void IRCSocketSignalsAdapter::disconnected()
{
        pParent->killAllChatWindows();
        gLog << tr("IRC: Disconnected from network %1").arg(pParent->connectionInfo.networkEntity.description());
        emit pParent->message("Disconnected");
}

void IRCSocketSignalsAdapter::errorReceived(QAbstractSocket::SocketError error)
{
        emit pParent->error(pSocket->errorString());
}

void IRCSocketSignalsAdapter::infoMessage(const QString& message)
{
        gLog << message;
        emit pParent->message(message);
}

void IRCSocketSignalsAdapter::hostLookupError(QHostInfo::HostInfoError errorValue)
{
        switch (errorValue)
        {
                case QHostInfo::HostNotFound:
                        emit pParent->error("Host lookup error: host not found.");
                        break;

                default:
                        emit pParent->error("Unknown host lookup error.");
                        break;
        }
}