squawk/core/handlers/messagehandler.cpp

/*
 * Squawk messenger. 
 * Copyright (C) 2019  Yury Gubich <blue@macaw.me>
 * 
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */

#include "messagehandler.h"
#include "core/account.h"

Core::MessageHandler::MessageHandler(Core::Account* account):
    QObject(),
    acc(account),
    pendingStateMessages(),
    uploadingSlotsQueue()
{
}

void Core::MessageHandler::onMessageReceived(const QXmppMessage& msg)
{
    bool handled = false;
    switch (msg.type()) {
        case QXmppMessage::Normal:
            qDebug() << "received a message with type \"Normal\", not sure what to do with it now, skipping";
            break;
        case QXmppMessage::Chat:
            handled = handleChatMessage(msg);
            break;
        case QXmppMessage::GroupChat:
            handled = handleGroupMessage(msg);
            break;
        case QXmppMessage::Error: {
            std::tuple<bool, QString, QString> ids = getOriginalPendingMessageId(msg.id());
            if (std::get<0>(ids)) {
                QString id = std::get<1>(ids);
                QString jid = std::get<2>(ids);
                RosterItem* cnt = acc->rh->getRosterItem(jid);
                QMap<QString, QVariant> cData = {
                    {"state", static_cast<uint>(Shared::Message::State::error)},
                    {"errorText", msg.error().text()}
                };
                if (cnt != 0) {
                    cnt->changeMessage(id, cData);
                }
                emit acc->changeMessage(jid, id, cData);
                handled = true;
            } else {
                qDebug() << "received a message with type \"Error\", not sure what to do with it now, skipping";
            }
        }
        break;
        case QXmppMessage::Headline:
            qDebug() << "received a message with type \"Headline\", not sure what to do with it now, skipping";
            break;
    }
    if (!handled) {
        logMessage(msg);
    }
}

bool Core::MessageHandler::handleChatMessage(const QXmppMessage& msg, bool outgoing, bool forwarded, bool guessing)
{
    if (msg.body().size() != 0 || msg.outOfBandUrl().size() > 0) {
        Shared::Message sMsg(Shared::Message::chat);
        initializeMessage(sMsg, msg, outgoing, forwarded, guessing);
        QString jid = sMsg.getPenPalJid();
        Contact* cnt = acc->rh->getContact(jid);
        if (cnt == 0) {
            cnt = acc->rh->addOutOfRosterContact(jid);
            qDebug() << "appending message" << sMsg.getId() << "to an out of roster contact";
        }
        if (outgoing) {
            if (forwarded) {
                sMsg.setState(Shared::Message::State::sent);
            }
        } else {
            sMsg.setState(Shared::Message::State::delivered);
        }
        QString oId = msg.replaceId();
        if (oId.size() > 0) {
            QMap<QString, QVariant> cData = {
                {"body", sMsg.getBody()},
                {"stamp", sMsg.getTime()}
            };
            cnt->correctMessageInArchive(oId, sMsg);
            emit acc->changeMessage(jid, oId, cData);
        } else {
            cnt->appendMessageToArchive(sMsg);
            emit acc->message(sMsg);
        }
        
        return true;
    }
    return false;
}

bool Core::MessageHandler::handleGroupMessage(const QXmppMessage& msg, bool outgoing, bool forwarded, bool guessing)
{
    const QString& body(msg.body());
    if (body.size() != 0) {
        
        Shared::Message sMsg(Shared::Message::groupChat);
        initializeMessage(sMsg, msg, outgoing, forwarded, guessing);
        QString jid = sMsg.getPenPalJid();
        Conference* cnt = acc->rh->getConference(jid);
        if (cnt == 0) {
            return false;
        }
        
        std::tuple<bool, QString, QString> ids = getOriginalPendingMessageId(msg.id());
        if (std::get<0>(ids)) {
            QMap<QString, QVariant> cData = {{"state", static_cast<uint>(Shared::Message::State::delivered)}};
            cnt->changeMessage(std::get<1>(ids), cData);
            emit acc->changeMessage(std::get<2>(ids), std::get<1>(ids), cData);
        } else {
            QString oId = msg.replaceId();
            if (oId.size() > 0) {
                QMap<QString, QVariant> cData = {
                    {"body", sMsg.getBody()},
                    {"stamp", sMsg.getTime()}
                };
                cnt->correctMessageInArchive(oId, sMsg);
                emit acc->changeMessage(jid, oId, cData);
            } else {
                cnt->appendMessageToArchive(sMsg);
                QDateTime minAgo = QDateTime::currentDateTimeUtc().addSecs(-60);
                if (sMsg.getTime() > minAgo) {     //otherwise it's considered a delayed delivery, most probably MUC history receipt
                    emit acc->message(sMsg);
                } else {
                    //qDebug() << "Delayed delivery: ";
                }
            }
        }
        
        return true;
    } 
    return false;
}


void Core::MessageHandler::initializeMessage(Shared::Message& target, const QXmppMessage& source, bool outgoing, bool forwarded, bool guessing) const
{
    const QDateTime& time(source.stamp());
    QString id;
#if (QXMPP_VERSION) >= QT_VERSION_CHECK(1, 3, 0)
    id = source.originId();
    if (id.size() == 0) {
        id = source.id();
    }
    target.setStanzaId(source.stanzaId());
    qDebug() << "initializing message with originId:" << source.originId() << ", id:" << source.id() << ", stansaId:" << source.stanzaId();
#else
    id = source.id();
#endif
    target.setId(id);
    QString messageId = target.getId();
    if (messageId.size() == 0) {
        target.generateRandomId();          //TODO out of desperation, I need at least a random ID
        messageId = target.getId();
        qDebug() << "Had do initialize a message with no id, assigning autogenerated" << messageId;
    }
    target.setFrom(source.from());
    target.setTo(source.to());
    target.setBody(source.body());
    target.setForwarded(forwarded);
    
    if (guessing) {
        if (target.getFromJid() == acc->getLogin() + "@" + acc->getServer()) {
            outgoing = true;
        } else {
            outgoing = false;
        }
    }
    target.setOutgoing(outgoing);
    if (time.isValid()) {
        target.setTime(time);
    } else {
        target.setCurrentTime();
    }
    
    QString oob = source.outOfBandUrl();
    if (oob.size() > 0) {
        target.setAttachPath(acc->network->addMessageAndCheckForPath(oob, acc->getName(), target.getPenPalJid(), messageId));
    }
    target.setOutOfBandUrl(oob);
}

void Core::MessageHandler::logMessage(const QXmppMessage& msg, const QString& reason)
{
    qDebug() << reason;
    qDebug() << "- from: " << msg.from();
    qDebug() << "- to: " << msg.to();
    qDebug() << "- body: " << msg.body();
    qDebug() << "- type: " << msg.type();
    qDebug() << "- state: " << msg.state();
    qDebug() << "- stamp: " << msg.stamp();
    qDebug() << "- id: " << msg.id();
#if (QXMPP_VERSION) >= QT_VERSION_CHECK(1, 3, 0)
    qDebug() << "- stanzaId: " << msg.stanzaId();
#endif
    qDebug() << "- outOfBandUrl: " << msg.outOfBandUrl();
    qDebug() << "==============================";
}

void Core::MessageHandler::onCarbonMessageReceived(const QXmppMessage& msg)
{
    handleChatMessage(msg, false, true);
}

void Core::MessageHandler::onCarbonMessageSent(const QXmppMessage& msg)
{
    handleChatMessage(msg, true, true);
}

std::tuple<bool, QString, QString> Core::MessageHandler::getOriginalPendingMessageId(const QString& id)
{
    std::tuple<bool, QString, QString> result({false, "", ""});
    std::map<QString, QString>::const_iterator itr = pendingStateMessages.find(id);
    if (itr != pendingStateMessages.end()) {
        std::get<0>(result) = true;
        std::get<2>(result) = itr->second;

        std::map<QString, QString>::const_iterator itrC = pendingCorrectionMessages.find(id);
        if (itrC != pendingCorrectionMessages.end()) {
            std::get<1>(result) = itrC->second;
            pendingCorrectionMessages.erase(itrC);
        } else {
            std::get<1>(result) = itr->first;
        }

        pendingStateMessages.erase(itr);
    }

    return result;
}

void Core::MessageHandler::onReceiptReceived(const QString& jid, const QString& id)
{
    std::tuple<bool, QString, QString> ids = getOriginalPendingMessageId(id);
    if (std::get<0>(ids)) {
        QMap<QString, QVariant> cData = {{"state", static_cast<uint>(Shared::Message::State::delivered)}};
        RosterItem* ri = acc->rh->getRosterItem(std::get<2>(ids));

        if (ri != 0) {
            ri->changeMessage(std::get<1>(ids), cData);
        }
        emit acc->changeMessage(std::get<2>(ids), std::get<1>(ids), cData);
    }
}

void Core::MessageHandler::sendMessage(const Shared::Message& data, bool newMessage, QString originalId)
{
    if (data.getOutOfBandUrl().size() == 0 && data.getAttachPath().size() > 0) {
        pendingCorrectionMessages.insert(std::make_pair(data.getId(), originalId));
        prepareUpload(data, newMessage);
    } else {
        performSending(data, originalId, newMessage);
    }
}

void Core::MessageHandler::performSending(Shared::Message data, const QString& originalId, bool newMessage)
{
    QString jid = data.getPenPalJid();
    QString id = data.getId();
    qDebug() << "Sending message with id:" << id;
    if (originalId.size() > 0) {
        qDebug() << "To replace one with id:" << originalId;
    }
    RosterItem* ri = acc->rh->getRosterItem(jid);
    bool sent = false;
    if (newMessage && originalId.size() > 0) {
        newMessage = false;
    }
    QDateTime sendTime = QDateTime::currentDateTimeUtc();
    if (acc->state == Shared::ConnectionState::connected) {
        QXmppMessage msg(createPacket(data, sendTime, originalId));
        
        sent = acc->client.sendPacket(msg);
        if (sent) {
            data.setState(Shared::Message::State::sent);
        } else {
            data.setState(Shared::Message::State::error);
            data.setErrorText("Couldn't send message: internal QXMPP library error, probably need to check out the logs");
        }
        
    } else {
        data.setState(Shared::Message::State::error);
        data.setErrorText("You are is offline or reconnecting");
    }
    
    QMap<QString, QVariant> changes(getChanges(data, sendTime, newMessage, originalId));
    
    QString realId;
    if (originalId.size() > 0) {
        realId = originalId;
    } else {
        realId = id;
    }
    if (ri != 0) {
        if (newMessage) {
            ri->appendMessageToArchive(data);
        } else {
            ri->changeMessage(realId, changes);
        }
        if (sent) {
            pendingStateMessages.insert(std::make_pair(id, jid));
            if (originalId.size() > 0) {
                pendingCorrectionMessages.insert(std::make_pair(id, originalId));
            }
        } else {
            pendingStateMessages.erase(id);
            pendingCorrectionMessages.erase(id);
        }
    }
    
    emit acc->changeMessage(jid, realId, changes);
}

QMap<QString, QVariant> Core::MessageHandler::getChanges(Shared::Message& data, const QDateTime& time, bool newMessage, const QString& originalId) const
{
    QMap<QString, QVariant> changes;

    QString oob = data.getOutOfBandUrl();
    Shared::Message::State mstate = data.getState();
    changes.insert("state", static_cast<uint>(mstate));
    if (mstate == Shared::Message::State::error) {
        changes.insert("errorText", data.getErrorText());
    }
    if (oob.size() > 0) {
        changes.insert("outOfBandUrl", oob);
    }
    if (newMessage) {
        data.setTime(time);
    }
    if (originalId.size() > 0) {
        changes.insert("body", data.getBody());
    }
    changes.insert("stamp", time);

    //sometimes (when the image is pasted with ctrl+v)
    //I start sending message with one path, then copy it to downloads directory
    //so, the final path changes. Let's assume it changes always since it costs me close to nothing
    QString attachPath = data.getAttachPath();
    if (attachPath.size() > 0) {
        QString squawkified = Shared::squawkifyPath(attachPath);
        changes.insert("attachPath", squawkified);
        if (attachPath != squawkified) {
            data.setAttachPath(squawkified);
        }
    }

    return changes;
}

QXmppMessage Core::MessageHandler::createPacket(const Shared::Message& data, const QDateTime& time, const QString& originalId) const
{
    QXmppMessage msg(acc->getFullJid(), data.getTo(), data.getBody(), data.getThread());
    QString id(data.getId());

    if (originalId.size() > 0) {
        msg.setReplaceId(originalId);
    }

#if (QXMPP_VERSION) >= QT_VERSION_CHECK(1, 3, 0)
    msg.setOriginId(id);
#endif
    msg.setId(id);
    msg.setType(static_cast<QXmppMessage::Type>(data.getType()));       //it is safe here, my type is compatible
    msg.setOutOfBandUrl(data.getOutOfBandUrl());
    msg.setReceiptRequested(true);
    msg.setStamp(time);

    return msg;
}

void Core::MessageHandler::prepareUpload(const Shared::Message& data, bool newMessage)
{
    if (acc->state == Shared::ConnectionState::connected) {
        QString jid = data.getPenPalJid();
        QString id = data.getId();
        RosterItem* ri = acc->rh->getRosterItem(jid);
        if (!ri) {
            qDebug() << "An attempt to initialize upload in" << acc->name << "for pal" << jid << "but the object for this pal wasn't found, something went terrebly wrong, skipping send";
            return;
        }
        QString path = data.getAttachPath();
        QString url = acc->network->getFileRemoteUrl(path);
        if (url.size() != 0) {
            sendMessageWithLocalUploadedFile(data, url, newMessage);
        } else {
            pendingStateMessages.insert(std::make_pair(id, jid));
            if (newMessage) {
                ri->appendMessageToArchive(data);
            } else {
                QMap<QString, QVariant> changes({
                    {"state", (uint)Shared::Message::State::pending}
                });
                ri->changeMessage(id, changes);
                emit acc->changeMessage(jid, id, changes);
            }
            //this checks if the file is already uploading, and if so it subscribes to it's success, so, i need to do stuff only if the network knows nothing of this file
            if (!acc->network->checkAndAddToUploading(acc->getName(), jid, id, path)) {
                if (acc->um->serviceFound()) {
                    QFileInfo file(path);
                    if (file.exists() && file.isReadable()) {
                        pendingStateMessages.insert(std::make_pair(id, jid));
                        uploadingSlotsQueue.emplace_back(path, id);
                        if (uploadingSlotsQueue.size() == 1) {
                            acc->um->requestUploadSlot(file);
                        }
                    } else {
                        handleUploadError(jid, id, "Uploading file no longer exists or your system user has no permission to read it");
                        qDebug() << "Requested upload slot in account" << acc->name << "for file" << path << "but the file doesn't exist or is not readable";
                    }
                } else {
                    handleUploadError(jid, id, "Your server doesn't support file upload service, or it's prohibited for your account");
                    qDebug() << "Requested upload slot in account" << acc->name << "for file" << path << "but upload manager didn't discover any upload services";
                }
            }
        }
    } else {
        handleUploadError(data.getPenPalJid(), data.getId(), "Account is offline or reconnecting");
        qDebug() << "An attempt to send message with not connected account " << acc->name << ", skipping";
    }
}

void Core::MessageHandler::onUploadSlotReceived(const QXmppHttpUploadSlotIq& slot)
{
    if (uploadingSlotsQueue.size() == 0) {
        qDebug() << "HTTP Upload manager of account" << acc->name << "reports about success requesting upload slot, but none was requested";
    } else {
        const std::pair<QString, QString>& pair = uploadingSlotsQueue.front();
        const QString& mId = pair.second;
        QString palJid = pendingStateMessages.at(mId);
        acc->network->uploadFile({acc->name, palJid, mId}, pair.first, slot.putUrl(), slot.getUrl(), slot.putHeaders());
        
        uploadingSlotsQueue.pop_front();
        if (uploadingSlotsQueue.size() > 0) {
            acc->um->requestUploadSlot(uploadingSlotsQueue.front().first);
        }
    }
}

void Core::MessageHandler::onUploadSlotRequestFailed(const QXmppHttpUploadRequestIq& request)
{
    QString err(request.error().text());
    if (uploadingSlotsQueue.size() == 0) {
        qDebug() << "HTTP Upload manager of account" << acc->name << "reports about an error requesting upload slot, but none was requested";
        qDebug() << err;
    } else {
        const std::pair<QString, QString>& pair = uploadingSlotsQueue.front();
        qDebug() << "Error requesting upload slot for file" << pair.first << "in account" << acc->name << ":" << err;
        handleUploadError(pendingStateMessages.at(pair.second), pair.second, err);
        
        uploadingSlotsQueue.pop_front();
        if (uploadingSlotsQueue.size() > 0) {
            acc->um->requestUploadSlot(uploadingSlotsQueue.front().first);
        }
    }
}

void Core::MessageHandler::onDownloadFileComplete(const std::list<Shared::MessageInfo>& msgs, const QString& path)
{
    QMap<QString, QVariant> cData = {
        {"attachPath", path}
    };
    for (const Shared::MessageInfo& info : msgs) {
        if (info.account == acc->getName()) {
            RosterItem* cnt = acc->rh->getRosterItem(info.jid);
            if (cnt != 0) {
                if (cnt->changeMessage(info.messageId, cData)) {
                    emit acc->changeMessage(info.jid, info.messageId, cData);
                }
            }
        }
    }
}

void Core::MessageHandler::onLoadFileError(const std::list<Shared::MessageInfo>& msgs, const QString& text, bool up)
{
    if (up) {
        for (const Shared::MessageInfo& info : msgs) {
            if (info.account == acc->getName()) {
                handleUploadError(info.jid, info.messageId, text);
            }
        }
    }
}

void Core::MessageHandler::handleUploadError(const QString& jid, const QString& messageId, const QString& errorText)
{
    emit acc->uploadFileError(jid, messageId, "Error requesting slot to upload file: " + errorText);
    pendingStateMessages.erase(messageId);
    pendingCorrectionMessages.erase(messageId);
    requestChangeMessage(jid, messageId, {
        {"state", static_cast<uint>(Shared::Message::State::error)},
        {"errorText", errorText}
    });
}

void Core::MessageHandler::onUploadFileComplete(const std::list<Shared::MessageInfo>& msgs, const QString& url, const QString& path)
{
    for (const Shared::MessageInfo& info : msgs) {
        if (info.account == acc->getName()) {
            RosterItem* ri = acc->rh->getRosterItem(info.jid);
            if (ri != 0) {
                Shared::Message msg = ri->getMessage(info.messageId);
                msg.setAttachPath(path);
                sendMessageWithLocalUploadedFile(msg, url, false);
            } else {
                qDebug() << "A signal received about complete upload to" << acc->name << "for pal" << info.jid << "but the object for this pal wasn't found, something went terrebly wrong, skipping send";
            }
        }
    }
}

void Core::MessageHandler::sendMessageWithLocalUploadedFile(Shared::Message msg, const QString& url, bool newMessage)
{
    msg.setOutOfBandUrl(url);
    if (msg.getBody().size() == 0) {    //not sure why, but most messages do that
        msg.setBody(url);               //they duplicate oob in body, some of them wouldn't even show an attachment if you don't do that
    }                                   
    performSending(msg, pendingCorrectionMessages.at(msg.getId()), newMessage);
    //TODO removal/progress update
}

static const std::set<QString> allowedToChangeKeys({
    "attachPath",
    "outOfBandUrl",
    "state",
    "errorText"
});

void Core::MessageHandler::requestChangeMessage(const QString& jid, const QString& messageId, const QMap<QString, QVariant>& data)
{
    RosterItem* cnt = acc->rh->getRosterItem(jid);
    if (cnt != 0) {
        bool allSupported = true;
        QString unsupportedString;
        for (QMap<QString, QVariant>::const_iterator itr = data.begin(); itr != data.end(); ++itr) {    //I need all this madness
            if (allowedToChangeKeys.count(itr.key()) != 1) {                                            //to not allow this method
                allSupported = false;                                                                   //to make a message to look like if it was edited
                unsupportedString = itr.key();                                                          //basically I needed to control who exaclty calls this method
                break;                                                                                  //because the underlying tech assumes that
            }                                                                                           //the change is initiated by user, not by system
        }
        if (allSupported) {
            cnt->changeMessage(messageId, data);
            emit acc->changeMessage(jid, messageId, data);
        } else {
            qDebug() << "A request to change message" << messageId << "of conversation" << jid << "with following data" << data;
            qDebug() << "only limited set of dataFields are supported yet here, and" << unsupportedString << "isn't one of them, skipping";
        }
    }
}

void Core::MessageHandler::resendMessage(const QString& jid, const QString& id)
{
    RosterItem* cnt = acc->rh->getRosterItem(jid);
    if (cnt != 0) {
        try {
            Shared::Message msg = cnt->getMessage(id);
            if (msg.getState() == Shared::Message::State::error) {
                if (msg.getEdited()){
                    QString originalId = msg.getId();
                    msg.generateRandomId();
                    sendMessage(msg, false, originalId);
                } else {
                    sendMessage(msg, false);
                }
            } else {
                qDebug() << "An attempt to resend a message to" << jid << "by account" << acc->getName() << ", but this message seems to have been normally sent, this method was made to retry sending failed to be sent messages, skipping";
            }
        } catch (const Archive::NotFound& err) {
            qDebug() << "An attempt to resend a message to" << jid << "by account" << acc->getName() << ", but this message wasn't found in history, skipping";
        }
    } else {
        qDebug() << "An attempt to resend a message to" << jid << "by account" << acc->getName() << ", but this jid isn't present in account roster, skipping";
    }
}