roommodel.cpp

#include "roommodel.h"

#include <QGuiApplication>

#include <QMetaType>
#include <QSharedPointer>
#include <QtMath>

#include <QDebug>

#include "client.h"
#include "debug_out.h"

Q_DECLARE_METATYPE(std::vector<mtx::events::collections::TimelineEvents>);
Q_DECLARE_METATYPE(std::vector<mtx::events::collections::StateEvents>);
Q_DECLARE_METATYPE(QSharedPointer<Room>);

using namespace mtx::events;
namespace {
template <class T> std::string eventUrl(const Event<T> &) { return ""; }
template <class T> auto eventUrl(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.url) {
    return e.content.url;
}
template <class T> std::string eventBody(const Event<T> &) { return ""; }
template <class T> auto eventBody(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.body) {
    return e.content.body;
}

template <class T> uint64_t eventHeight(const Event<T> &) { return -1; }
template <class T> auto eventHeight(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.h) {
    return e.content.info.h;
}
template <class T> uint64_t eventWidth(const Event<T> &) { return -1; }
template <class T> auto eventWidth(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.w) {
    return e.content.info.w;
}

template <class T> double eventPropHeight(const mtx::events::RoomEvent<T> &e) {
    auto w = eventWidth(e);
    if (w == 0)
        w = 1;
    return eventHeight(e) / (double)w;
}

std::string eventBody(const StateEvent<state::Topic> &e) { return e.content.topic; }
std::string eventBody(const StateEvent<state::Name> &e) { return e.content.name; }
std::string eventBody(const StateEvent<state::Member> &e) {
    switch (e.content.membership) {
    case state::Membership::Invite:
        return QCoreApplication::translate("Room", "member_invited: %1 %2")
            .arg(QString::fromStdString(e.state_key))
            .arg(QString::fromStdString(e.content.display_name))
            .toStdString();
    case state::Membership::Ban:
        return QCoreApplication::translate("Room", "member_banned: %1 %2")
            .arg(QString::fromStdString(e.state_key))
            .arg(QString::fromStdString(e.content.display_name))
            .toStdString();
    case state::Membership::Leave:
        return QCoreApplication::translate("Room", "member_left: %1")
            .arg(QString::fromStdString(e.state_key))
            .toStdString();
    case state::Membership::Knock:
        return QCoreApplication::translate("Room", "member_knocked: %1 %2")
            .arg(QString::fromStdString(e.state_key))
            .arg(QString::fromStdString(e.content.display_name))
            .toStdString();
    case state::Membership::Join:
    default:
        return QCoreApplication::translate("Room", "member_joined: %1 %2")
            .arg(QString::fromStdString(e.state_key))
            .arg(QString::fromStdString(e.content.display_name))
            .toStdString();
    }
}

template <class T> std::string eventFormattedBody(const Event<T> &) { return ""; }
template <class T> auto eventFormattedBody(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.formatted_body) {
    auto temp = e.content.formatted_body;
    if (!temp.empty()) {
        auto pos = temp.find("<mx-reply>");
        if (pos != std::string::npos)
            temp.erase(pos, std::string("<mx-reply>").size());
        pos = temp.find("</mx-reply>");
        if (pos != std::string::npos)
            temp.erase(pos, std::string("</mx-reply>").size());
        return temp;
    } else
        return e.content.body;
}

template <class T> auto eventUserId(const mtx::events::RoomEvent<T> &e) -> std::string { return e.sender; }
template <class T> auto eventTimestamp(const mtx::events::Event<T> &e) -> uint64_t { return 0; }
template <class T> auto eventTimestamp(const mtx::events::RoomEvent<T> &e) -> uint64_t { return e.origin_server_ts; }

// template <class T> auto eventEventId(const mtx::events::Event<T> &e) -> std::string { return ""; }
template <class T> auto eventEventId(const mtx::events::RoomEvent<T> &e) -> std::string { return e.event_id; }

template <class T>::EventType::Type toRoomEventType(const Event<T> &e) {
    using mtx::events::EventType;
    switch (e.type) {
    case EventType::RoomKeyRequest:
        return ::EventType::KeyRequest;
    case EventType::RoomAliases:
        return ::EventType::Aliases;
    case EventType::RoomAvatar:
        return ::EventType::Avatar;
    case EventType::RoomCanonicalAlias:
        return ::EventType::CanonicalAlias;
    case EventType::RoomCreate:
        return ::EventType::Create;
    case EventType::RoomEncrypted:
        return ::EventType::Encrypted;
    case EventType::RoomEncryption:
        return ::EventType::Encryption;
    case EventType::RoomGuestAccess:
        return ::EventType::GuestAccess;
    case EventType::RoomHistoryVisibility:
        return ::EventType::HistoryVisibility;
    case EventType::RoomJoinRules:
        return ::EventType::JoinRules;
    case EventType::RoomMember:
        return ::EventType::Member;
    case EventType::RoomMessage:
        return ::EventType::UnknownMessage;
    case EventType::RoomName:
        return ::EventType::Name;
    case EventType::RoomPowerLevels:
        return ::EventType::PowerLevels;
    case EventType::RoomTopic:
        return ::EventType::Topic;
    case EventType::RoomTombstone:
        return ::EventType::Tombstone;
    case EventType::RoomRedaction:
        return ::EventType::Redaction;
    case EventType::RoomPinnedEvents:
        return ::EventType::PinnedEvents;
    case EventType::Sticker:
        return ::EventType::Sticker;
    case EventType::Tag:
        return ::EventType::Tag;
    case EventType::Unsupported:
    default:
        return ::EventType::Unsupported;
    }
}

::EventType::Type toRoomEventType(const Event<mtx::events::msg::Audio> &e) { return ::EventType::AudioMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Emote> &e) { return ::EventType::EmoteMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::File> &e) { return ::EventType::FileMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Image> &e) { return ::EventType::ImageMessage; }
// ::EventType::Type toRoomEventType(const Event<mtx::events::msg::Location> &e) { return
// ::EventType::LocationMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Notice> &e) { return ::EventType::NoticeMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Text> &e) { return ::EventType::TextMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Video> &e) { return ::EventType::VideoMessage; }
} // namespace

Room::Room(QObject *parent) : loadingOlderMessages(false) {
    Q_UNUSED(parent);
    connect(this, &Room::newEvents, this, &Room::addEvents, Qt::QueuedConnection);
    connect(this, &Room::newTags, this, &Room::setTags, Qt::QueuedConnection);
    connect(this, &Room::newUnreadState, this, &Room::setUnread, Qt::QueuedConnection);
    connect(this, &Room::lastReadSig, this, &Room::lastReadSlot, Qt::AutoConnection);
    connect(this, &Room::markReadSig, this, &Room::markReadSlot, Qt::AutoConnection);
    this->moveToThread(QGuiApplication::instance()->thread());
}

std::string Room::name() const {
    if (!name_.isEmpty()) {
        return name_.toStdString();
    }
    if (!canonical_alias_.isEmpty()) {
        return canonical_alias_.toStdString();
    }
    std::string heroes;
    for (const auto &m : members) {
        if (!heroes.empty())
            heroes += ", ";
        if (m != http::client().user_id().to_string()) {
            std::string hero_name = memberInfos.at(m).display_name;
            heroes += hero_name.empty() ? m : hero_name;
        }
    }

    if (!heroes.empty()) {
        return heroes;
    }

    return QCoreApplication::translate("Room", "Empty Room").toStdString();
}

void Room::addEvents(std::vector<mtx::events::collections::StateEvents> state,
                     std::vector<mtx::events::collections::TimelineEvents> timeline, std::string prev_batch,
                     std::string next_batch) {
    qDebug() << "p: " << QString::fromStdString(prev_batch);
    qDebug() << "n: " << QString::fromStdString(next_batch);
    qDebug() << "tp: " << QString::fromStdString(this->prev_batch);
    qDebug() << "tn: " << QString::fromStdString(this->next_batch);

    using namespace mtx::events;
    if (this->prev_batch == next_batch) {
        qDebug() << "New events at beginning of timeline";
        for (const auto &event : timeline) {
            std::string event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, event);
            if (!event_id.empty() && eventIds.count(event_id)) {
                for (int i = 0; i < (int)this->events.size(); i++) {
                    if (std::visit([](const auto &e) -> std::string { return eventEventId(e); }, this->events[i]) ==
                        event_id) {
                        beginRemoveRows(QModelIndex(), i, i);
                        this->events.erase(this->events.begin() + i);
                        endRemoveRows();
                        break;
                    }
                }
            }
        }

        if (!timeline.empty()) {
            beginInsertRows(QModelIndex(), (int)0, (int)timeline.size() - 1);
            this->events.insert(this->events.begin(), timeline.begin(), timeline.end());
            endInsertRows();
        }
        this->prev_batch = prev_batch;
    } else {
        auto applyEvent = [this](const auto &e) {
            this->eventIds.insert(e.event_id);

            if constexpr (std::is_same_v<StateEvent<state::Aliases>, std::decay_t<decltype(e)>>) {
                if (this->canonical_alias_.isEmpty() && !e.content.aliases.empty())
                    this->canonical_alias_ = QString::fromStdString(e.content.aliases.front());
            } else if constexpr (std::is_same_v<StateEvent<state::Avatar>, std::decay_t<decltype(e)>>) {
                this->avatar_url_ = QString::fromStdString(e.content.url);
            } else if constexpr (std::is_same_v<StateEvent<state::CanonicalAlias>, std::decay_t<decltype(e)>>) {
                this->canonical_alias_ = QString::fromStdString(e.content.alias);
            } else if constexpr (std::is_same_v<StateEvent<state::Create>, std::decay_t<decltype(e)>>) {
                this->members.insert(e.content.creator);
            } else if constexpr (std::is_same_v<StateEvent<state::Encryption>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<StateEvent<state::GuestAccess>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<StateEvent<state::HistoryVisibility>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<StateEvent<state::JoinRules>, std::decay_t<decltype(e)>>) {
                this->join_rule = e.content.join_rule;
            } else if constexpr (std::is_same_v<StateEvent<state::Member>, std::decay_t<decltype(e)>>) {
                switch (e.content.membership) {
                case state::Membership::Join:
                case state::Membership::Invite:
                    this->members.insert(e.state_key);
                    this->memberInfos[e.state_key] =
                        MemberInfo{e.content.avatar_url, e.content.display_name, e.state_key};
                    break;
                case state::Membership::Knock:
                    this->memberInfos[e.state_key] =
                        MemberInfo{e.content.avatar_url, e.content.display_name, e.state_key};
                    break;
                case state::Membership::Ban:
                case state::Membership::Leave:
                    this->members.erase(e.state_key);
                    break;
                }
            } else if constexpr (std::is_same_v<StateEvent<state::Name>, std::decay_t<decltype(e)>>) {
                this->name_ = QString::fromStdString(e.content.name);
                emit roomNameChanged(name_);
            } else if constexpr (std::is_same_v<StateEvent<state::PinnedEvents>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<StateEvent<state::PowerLevels>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<StateEvent<state::Topic>, std::decay_t<decltype(e)>>) {
                this->topic_ = QString::fromStdString(e.content.topic);
            } else if constexpr (std::is_same_v<StateEvent<state::Tombstone>, std::decay_t<decltype(e)>>) {
                this->replacement_room_ = QString::fromStdString(e.content.replacement_room);
            } else if constexpr (std::is_same_v<EncryptedEvent<msg::Encrypted>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RedactionEvent<msg::Redaction>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<Sticker, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Redacted>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Audio>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Emote>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::File>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Image>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Notice>, std::decay_t<decltype(e)>>) {
            }

            else if constexpr (std::is_same_v<RoomEvent<msg::Text>, std::decay_t<decltype(e)>>) {
            } else if constexpr (std::is_same_v<RoomEvent<msg::Video>, std::decay_t<decltype(e)>>) {
            }

            auto body = QString::fromStdString(eventBody(e));
            if (!body.isEmpty()) {
                this->msgInfo.body = body;
                this->msgInfo.userid = QString::fromStdString(e.sender);
                // QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUserId(e); }, e));
                this->msgInfo.datetime = QDateTime::fromMSecsSinceEpoch(e.origin_server_ts);
            }
        };

        for (const mtx::events::collections::StateEvents &e : state)
            std::visit(applyEvent, e);
        // applyEvent(e.subset<mtx::events::StateEvent<mtx::events::state::Aliases>,
        //                    mtx::events::StateEvent<mtx::events::state::Avatar>,
        //                    mtx::events::StateEvent<mtx::events::state::CanonicalAlias>,
        //                    mtx::events::StateEvent<mtx::events::state::Create>,
        //                    mtx::events::StateEvent<mtx::events::state::Encryption>,
        //                    mtx::events::StateEvent<mtx::events::state::GuestAccess>,
        //                    mtx::events::StateEvent<mtx::events::state::HistoryVisibility>,
        //                    mtx::events::StateEvent<mtx::events::state::JoinRules>,
        //                    mtx::events::StateEvent<mtx::events::state::Member>,
        //                    mtx::events::StateEvent<mtx::events::state::Name>,
        //                    mtx::events::StateEvent<mtx::events::state::PinnedEvents>,
        //                    mtx::events::StateEvent<mtx::events::state::PowerLevels>,
        //                    mtx::events::StateEvent<mtx::events::state::Tombstone>,
        //                    mtx::events::StateEvent<mtx::events::state::Topic>>());

        for (const mtx::events::collections::TimelineEvents &e : timeline)
            std::visit(applyEvent, e);

        if (!timeline.empty()) {
            qDebug() << "New events at end of timeline";
            beginInsertRows(QModelIndex(), (int)this->events.size(), (int)this->events.size() + timeline.size() - 1);
            this->events.insert(this->events.end(), timeline.begin(), timeline.end());
            endInsertRows();
        }
        this->next_batch = next_batch;
    }
    if (this->prev_batch.empty())
        this->prev_batch = prev_batch;
    if (this->next_batch.empty())
        this->next_batch = next_batch;
}

void Room::fetchOlderMessages() {
    if (this->loadingOlderMessages.exchange(true)) {
        qDebug() << "Already loading older messages";
        return;
    }
    mtx::http::MessagesOpts opts = {};
    opts.from = this->prev_batch;
    opts.limit = 100;
    opts.room_id = this->id;
    http::client().messages(opts, [this](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
        if (err) {
            qDebug() << "failed to retrieve messages: " << *err;
            this->loadingOlderMessages = false;
            return;
        }

        emit newEvents({}, {res.chunk.rbegin(), res.chunk.rend()}, res.end, res.start);
        this->loadingOlderMessages = false;
    });
}

void Room::sendTextMessage(QString message) {
    using mtx::events::EventType;

    mtx::events::msg::Text text;
    text.body = message.trimmed().toStdString();

    http::client().send_room_message<msg::Text, EventType::RoomMessage>(
        this->id, http::client().generate_txn_id(), text,
        [this](const mtx::responses::EventId &res, mtx::http::RequestErr err) {
            if (err) {
                qDebug() << "failed to send message: " << *err;
                return;
            }

            qDebug() << "send event as: $" << QString::fromStdString(res.event_id.to_string());
        });
}

QHash<int, QByteArray> Room::roleNames() const {
    QHash<int, QByteArray> roles;
    roles[Type] = "Type";
    roles[Body] = "Body";
    roles[FormattedBody] = "FormattedBody";
    roles[UserId] = "UserId";
    roles[UserName] = "UserName";
    roles[Timestamp] = "Timestamp";
    roles[Url] = "Url";
    roles[Height] = "Height";
    roles[Width] = "Width";
    roles[ProportionalHeight] = "ProportionalHeight";
    return roles;
}

int Room::rowCount(const QModelIndex &parent) const { return (int)events.size(); }

QVariant Room::data(const QModelIndex &index, int role) const {
    if (index.row() > (int)events.size() || index.row() < 0)
        return QVariant();

    auto event = events.at(index.row());
    switch (role) {

    case Type:
        return std::visit([](const auto &e) -> ::EventType::Type { return toRoomEventType(e); }, event);
    case Body:
        return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventBody(e); }, event));
    case FormattedBody:
        return QString::fromStdString(
            std::visit([](const auto &e) -> std::string { return eventFormattedBody(e); }, event));
    case UserId:
        return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUserId(e); }, event));
    case UserName:
        return QString::fromStdString(std::visit(
            [this](const auto &e) -> std::string {
                try {
                    return this->memberInfos.at(eventUserId(e)).display_name;
                } catch (...) {
                    return "";
                }
            },
            event));
    case Timestamp:
        return QDateTime::fromMSecsSinceEpoch(
            std::visit([](const auto &e) -> uint64_t { return eventTimestamp(e); }, event));
    case Url:
        return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUrl(e); }, event));
    case Height:
        return std::visit([](const auto &e) -> uint64_t { return eventHeight(e); }, event);
    case Width:
        return std::visit([](const auto &e) -> uint64_t { return eventWidth(e); }, event);
    case ProportionalHeight:
        return std::visit([](const auto &e) -> double { return eventPropHeight(e); }, event);
    default:
        return QVariant();
    }
}

QString Room::userIdToUserName(QString id) {
    try {
        return QString::fromStdString(this->memberInfos.at(id.toStdString()).display_name);
    } catch (...) {
        return "";
    }
}

// from nheko
QColor Room::userColor(QString id, QColor background) {
    if (userColors.count(id))
        return userColors.at(id);

    auto luminance = [](const QColor &col) -> qreal {
        int colRgb[3] = {col.red(), col.green(), col.blue()};
        qreal lumRgb[3];

        for (int i = 0; i < 3; i++) {
            qreal v = colRgb[i] / 255.0;
            v <= 0.03928 ? lumRgb[i] = v / 12.92 : lumRgb[i] = qPow((v + 0.055) / 1.055, 2.4);
        }

        auto lum = lumRgb[0] * 0.2126 + lumRgb[1] * 0.7152 + lumRgb[2] * 0.0722;

        return lum;
    };

    auto computeContrast = [](const qreal &one, const qreal &two) -> qreal {
        auto ratio = (one + 0.05) / (two + 0.05);

        if (two > one) {
            ratio = 1 / ratio;
        }

        return ratio;
    };

    auto hashQString = [](const QString &input) {
        unsigned hash = 0;

        for (int i = 0; i < input.length(); i++) {
            hash = input.at(i).digitValue() + ((hash << 5) - hash);
        }

        return (int)hash;
    };

    const qreal backgroundLum = luminance(background);

    // Create a color for the input
    auto hash = hashQString(id);
    // create a hue value based on the hash of the input.
    auto userHue = qAbs(hash % 360);
    // start with moderate saturation and lightness values.
    auto sat = 220;
    auto lightness = 125;

    // converting to a QColor makes the luminance calc easier.
    QColor inputColor = QColor::fromHsl(userHue, sat, lightness);

    // calculate the initial luminance and contrast of the
    // generated color.  It's possible that no additional
    // work will be necessary.
    auto lum = luminance(inputColor);
    auto contrast = computeContrast(lum, backgroundLum);

    // If the contrast doesn't meet our criteria,
    // try again and again until they do by modifying first
    // the lightness and then the saturation of the color.
    while (contrast < 5) {
        // if our lightness is at it's bounds, try changing
        // saturation instead.
        if (lightness == 242 || lightness == 13) {
            qreal newSat = qBound(26.0, sat * 1.25, 242.0);

            inputColor.setHsl(userHue, qFloor(newSat), lightness);
            auto tmpLum = luminance(inputColor);
            auto higherContrast = computeContrast(tmpLum, backgroundLum);
            if (higherContrast > contrast) {
                contrast = higherContrast;
                sat = newSat;
            } else {
                newSat = qBound(26.0, sat / 1.25, 242.0);
                inputColor.setHsl(userHue, qFloor(newSat), lightness);
                tmpLum = luminance(inputColor);
                auto lowerContrast = computeContrast(tmpLum, backgroundLum);
                if (lowerContrast > contrast) {
                    contrast = lowerContrast;
                    sat = newSat;
                }
            }
        } else {
            qreal newLightness = qBound(13.0, lightness * 1.25, 242.0);

            inputColor.setHsl(userHue, sat, qFloor(newLightness));

            auto tmpLum = luminance(inputColor);
            auto higherContrast = computeContrast(tmpLum, backgroundLum);

            // Check to make sure we have actually improved contrast
            if (higherContrast > contrast) {
                contrast = higherContrast;
                lightness = newLightness;
                // otherwise, try going the other way instead.
            } else {
                newLightness = qBound(13.0, lightness / 1.25, 242.0);
                inputColor.setHsl(userHue, sat, qFloor(newLightness));
                tmpLum = luminance(inputColor);
                auto lowerContrast = computeContrast(tmpLum, backgroundLum);
                if (lowerContrast > contrast) {
                    contrast = lowerContrast;
                    lightness = newLightness;
                }
            }
        }
    }

    userColors[id] = inputColor;

    return inputColor;
}

void Room::markRead(int index) { emit markReadSig(index); }
void Room::markReadSlot(int index) {
    qDebug() << "called";
    if (index < 0 || index >= (int)events.size())
        return;

    auto event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, events[index]);
    http::client().read_event(id, event_id, [](mtx::http::RequestErr e) {
        if (e)
            qDebug() << "Error marking event as read: " << *e;
    });
    lastRead_ = event_id;

    qDebug() << "marked " << QString::fromStdString(event_id) << " as read";
}

int Room::lastRead() { return emit lastReadSig(); }
int Room::lastReadSlot() {
    qDebug() << "called";
    if (lastRead_.empty())
        return 0;

    for (size_t index = events.size(); index > 0; index--) {
        auto event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, events[index - 1]);
        if (event_id == lastRead_)
            return index - 1;
    }

    qWarning() << "Last read event " << QString::fromStdString(lastRead_) << " not found in events";
    return 0;
}