storagehelper.cpp

/****************************************************************************
 *    Copyright (C) 2017-2019 Savoir-faire Linux Inc.                       *
 *   Author: Nicolas Jäger <nicolas.jager@savoirfairelinux.com>             *
 *   Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>           *
 *   Author: Kateryna Kostiuk <kateryna.kostiuk@savoirfairelinux.com>       *
 *   Author: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>         *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or          *
 *   modify it under the terms of the GNU Lesser General Public             *
 *   License as published by the Free Software Foundation; either           *
 *   version 2.1 of the License, or (at your option) any later version.     *
 *                                                                          *
 *   This library 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      *
 *   Lesser 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 "storagehelper.h"

#include "api/profile.h"
#include "api/datatransfer.h"
#include "uri.h"
#include "vcard.h"

#include <account_const.h>
#include <datatransfer_interface.h>

#include <QImage>
#include <QByteArray>
#include <QBuffer>
#include <QJsonObject>
#include <QJsonDocument>

#include <fstream>
#include <thread>
#include <cstring>

namespace lrc
{

namespace authority
{

namespace storage
{

QString getPath()
{
    QDir dataDir(QStandardPaths::writableLocation(
        QStandardPaths::AppLocalDataLocation));
    // Avoid to depends on the client name.
    dataDir.cdUp();
    return dataDir.absolutePath() + "/jami/";
}

std::string
prepareUri(const std::string& uri, api::profile::Type type)
{
    URI uriObject(QString::fromStdString(uri));
    switch (type) {
    case api::profile::Type::SIP:
        return uriObject.format(URI::Section::USER_INFO | URI::Section::HOSTNAME)
            .toStdString();
        break;
    case api::profile::Type::RING:
        return uriObject.format(URI::Section::USER_INFO)
            .toStdString();
        break;
    case api::profile::Type::INVALID:
    case api::profile::Type::PENDING:
    case api::profile::Type::TEMPORARY:
    case api::profile::Type::COUNT__:
    default:
        return uri;
    }
}

std::string
getFormattedCallDuration(const std::time_t duration)
{
    if (duration == 0) return {};
    std::string formattedString;
    auto minutes = duration / 60;
    auto seconds = duration % 60;
    if (minutes > 0) {
        formattedString += std::to_string(minutes) + ":";
        if (formattedString.length() == 2) {
            formattedString = "0" + formattedString;
        }
    } else {
        formattedString += "00:";
    }
    if (seconds < 10) formattedString += "0";
    formattedString += std::to_string(seconds);
    return formattedString;
}

std::string
getCallInteractionString(const std::string& authorUri,
                         const std::time_t& duration)
{
    if (duration < 0) {
        if (authorUri.empty()) {
            return "📞 " + QObject::tr("Outgoing call").toStdString();
        } else {
            return "📞 " + QObject::tr("Incoming call").toStdString();
        }
    } else if (authorUri.empty()) {
        if (duration) {
            return "📞 " + QObject::tr("Outgoing call").toStdString()
                    + " - " + getFormattedCallDuration(duration);
        } else {
            return "🕽 " + QObject::tr("Missed outgoing call").toStdString();
        }
    } else {
        if (duration) {
            return "📞 " + QObject::tr("Incoming call").toStdString()
                    + " - " + getFormattedCallDuration(duration);
        } else {
            return "🕽 " + QObject::tr("Missed incoming call").toStdString();
        }
    }
}

std::string
getContactInteractionString(const std::string& authorUri,
                            const api::interaction::Status& status)
{
    if (authorUri.empty()) {
        return QObject::tr("Contact added").toStdString();
    } else {
        if (status == api::interaction::Status::UNKNOWN) {
            return QObject::tr("Invitation received").toStdString();
        } else if (status == api::interaction::Status::SUCCESS) {
            return QObject::tr("Invitation accepted").toStdString();
        }
    }
    return {};
}

namespace vcard
{
std::string compressedAvatar(const std::string& image);
void setProfile(const std::string& accountId,
                const api::profile::Info& profileInfo,
                const bool overwrite,
                const bool isPeer);

std::string
compressedAvatar(const std::string& image)
{
    QImage qimage;
    const bool ret = qimage.loadFromData(QByteArray::fromBase64(image.c_str()), 0);
    if (!ret) {
        qDebug() << "vCard image loading failed";
        return image;
    }
    QByteArray bArray;
    QBuffer buffer(&bArray);
    buffer.open(QIODevice::WriteOnly);
    qimage.scaled({ 128,128 }).save(&buffer, "JPEG", 90);
    auto b64Img = bArray.toBase64().trimmed();
    return std::string(b64Img.constData(), b64Img.length());
}

std::string
profileToVcard(const api::profile::Info& profileInfo,
               bool compressImage)
{
    using namespace api;
    bool compressedImage = std::strncmp(profileInfo.avatar.c_str(), "/9j/", 4) == 0;
    if (compressedImage && !compressImage) {
        compressImage = false;
    }
    std::string vCardStr = vCard::Delimiter::BEGIN_TOKEN;
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    vCardStr += vCard::Property::VERSION;
    vCardStr += ":2.1";
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    vCardStr += vCard::Property::FORMATTED_NAME;
    vCardStr += ":";
    vCardStr += profileInfo.alias;
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    if (profileInfo.type == profile::Type::RING) {
        vCardStr += vCard::Property::TELEPHONE;
        vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
        vCardStr += "other:ring:";
        vCardStr += profileInfo.uri;
        vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    } else {
        vCardStr += vCard::Property::TELEPHONE;
        vCardStr += ":";
        vCardStr += profileInfo.uri;
        vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    }
    vCardStr += vCard::Property::PHOTO;
    vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
    vCardStr += vCard::Property::BASE64;
    vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
    if (compressImage) {
        vCardStr += vCard::Property::TYPE_JPEG;
        vCardStr += ":";
        vCardStr += compressedImage ? profileInfo.avatar : compressedAvatar(profileInfo.avatar);
    } else {
        vCardStr += compressedImage ? vCard::Property::TYPE_JPEG : vCard::Property::TYPE_PNG;
        vCardStr += ":";
        vCardStr += profileInfo.avatar;
    }
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    vCardStr += vCard::Delimiter::END_TOKEN;
    return vCardStr;
}

void
setProfile(const std::string& accountId,
           const api::profile::Info& profileInfo,
           const bool isPeer)
{
    auto vcard = vcard::profileToVcard(profileInfo);
    auto accountLocalPath = getPath() + QString::fromStdString(accountId) + "/";
    QString filePath;
    QFile file;
    if (isPeer) {
        filePath = accountLocalPath + "profiles/" +
            QString(QByteArray::fromStdString(profileInfo.uri).toBase64()) + ".vcf";
        file.setFileName(filePath);
    } else {
        filePath = accountLocalPath + "profile" + ".vcf";
        file.setFileName(filePath);
    }
    if (!file.open(QIODevice::WriteOnly)) {
        qWarning().noquote() << "Can't open file for writing: " << filePath;
        return;
    }
    QTextStream in(&file);
    in.setCodec("UTF-8");
    in << QString::fromStdString(vcard);
}
} // namespace vcard

std::vector<std::string>
getConversationsWithPeer(Database& db, const std::string& participant_uri)
{
    return db.select("id",
                     "conversations",
                     "participant=:participant",
                     {{":participant", participant_uri}}).payloads;
}

std::vector<std::string>
getPeerParticipantsForConversation(Database& db, const std::string& conversationId)
{
    return db.select("participant",
                     "conversations",
                     "id=:id",
                     { {":id", conversationId} }).payloads;
}

void
createOrUpdateProfile(const std::string & accountId,
              const api::profile::Info & profileInfo,
              const bool isPeer)
{
    if (isPeer) {
        auto contact = storage::buildContactFromProfile(accountId, profileInfo.uri, profileInfo.type);
        if (!profileInfo.alias.empty()) contact.profileInfo.alias = profileInfo.alias;
        if (!profileInfo.avatar.empty()) contact.profileInfo.avatar = profileInfo.avatar;
        vcard::setProfile(accountId, contact.profileInfo, isPeer);
        return;
    }
    vcard::setProfile(accountId, profileInfo, isPeer);
}

std::string
getAccountAvatar(const std::string& accountId)
{
    auto accountLocalPath = getPath() + QString::fromStdString(accountId) + "/";
    QString filePath;
    filePath = accountLocalPath + "profile.vcf";
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "Can't open file: " << filePath;
        return {};
    }
    QTextStream in(&file);
    in.setCodec("UTF-8");
    const auto vCard = lrc::vCard::utils::toHashMap(in.readAll().toUtf8());
    const auto photo = (vCard.find(vCard::Property::PHOTO_PNG) == vCard.end()) ?
        vCard[vCard::Property::PHOTO_JPEG] : vCard[vCard::Property::PHOTO_PNG];
    return photo.toStdString();
}

api::contact::Info
buildContactFromProfile(const std::string & accountId,
                        const std::string& peer_uri,
                        const api::profile::Type& type)
{
    lrc::api::profile::Info profileInfo;
    profileInfo.uri = peer_uri;
    profileInfo.type = type;
    auto accountLocalPath = getPath() + QString::fromStdString(accountId) + "/";
    QString b64filePath;
    b64filePath = accountLocalPath + "profiles/" + QString(QByteArray::fromStdString(peer_uri).toBase64()) + ".vcf";
    QFile file(b64filePath);
    if (!file.open(QIODevice::ReadOnly)) {
        // try non-base64 path
        QString filePath = accountLocalPath + "profiles/" + QString::fromStdString(peer_uri) + ".vcf";
        file.setFileName(filePath);
        if (!file.open(QIODevice::ReadOnly)) {
            qWarning().noquote() << "Can't open file: " << filePath;
            return { profileInfo, "", true, false };
        }
        // rename it
        qWarning().noquote() << "Renaming profile: " << filePath;
        file.rename(b64filePath);
        // reopen it
        if (!file.open(QIODevice::ReadOnly)) {
            qWarning().noquote() << "Can't open file: " << b64filePath;
            return { profileInfo, "", true, false };
        }
    }
    QTextStream in(&file);
    in.setCodec("UTF-8");
    QByteArray vcard = in.readAll().toUtf8();
    const auto vCard = lrc::vCard::utils::toHashMap(vcard);
    const auto alias = vCard[vCard::Property::FORMATTED_NAME];
    const auto photo = (vCard.find(vCard::Property::PHOTO_PNG) == vCard.end()) ?
        vCard[vCard::Property::PHOTO_JPEG] : vCard[vCard::Property::PHOTO_PNG];

    profileInfo.avatar = photo.toStdString();
    profileInfo.alias = alias.toStdString();
    return { profileInfo, "", true, false };
}

std::vector<std::string> getAllConversations(Database & db)
{
    return db.select("id", "conversations", {}, {}).payloads;
}

std::vector<std::string>
getConversationsBetween(Database& db, const std::string& peer1_uri, const std::string& peer2_uri)
{
    auto conversationsForPeer1 = getConversationsWithPeer(db, peer1_uri);
    std::sort(conversationsForPeer1.begin(), conversationsForPeer1.end());
    auto conversationsForPeer2 = getConversationsWithPeer(db, peer2_uri);
    std::sort(conversationsForPeer2.begin(), conversationsForPeer2.end());
    std::vector<std::string> common;

    std::set_intersection(conversationsForPeer1.begin(), conversationsForPeer1.end(),
                          conversationsForPeer2.begin(), conversationsForPeer2.end(),
                          std::back_inserter(common));
    return common;
}

std::string
beginConversationWithPeer(Database& db, const std::string& peer_uri, const bool isOutgoing)
{
    // Add conversation between account and profile
    auto newConversationsId = db.select("IFNULL(MAX(id), 0) + 1",
                                        "conversations",
                                        "1=1",
                                        {}).payloads[0];
    db.insertInto("conversations",
                  {{":id", "id"}, {":participant", "participant"}},
                  {{":id", newConversationsId}, {":participant", peer_uri}});
    api::interaction::Info msg{
        isOutgoing ? "" : peer_uri,
        {},
        std::time(nullptr),
        0,
        api::interaction::Type::CONTACT,
        isOutgoing ? api::interaction::Status::SUCCESS : api::interaction::Status::UNKNOWN,
        isOutgoing
    };
    // Add first interaction
    addMessageToConversation(db, newConversationsId, msg);
    return newConversationsId;
}

void
getHistory(Database& db, api::conversation::Info& conversation)
{
    auto interactionsResult = db.select("id, author, body, timestamp, type, status, is_read, extra_data",
                                        "interactions",
                                        "conversation=:conversation",
                                        {{":conversation", conversation.uid}});
    auto nCols = 8;
    if (interactionsResult.nbrOfCols == nCols) {
        auto payloads = interactionsResult.payloads;
        for (decltype(payloads.size()) i = 0; i < payloads.size(); i += nCols) {
            std::string durationString;
            auto extra_data_str = QString::fromStdString(payloads[i + 7]);
            if (!extra_data_str.isEmpty()) {
                auto jsonData = JSONFromString(extra_data_str);
                durationString = readJSONValue(jsonData, "duration").toStdString();
            }
            auto body = payloads[i + 2];
            auto type = api::interaction::to_type(payloads[i + 4]);
            std::time_t duration = durationString.empty() ? 0 : std::stoi(durationString);
            auto status = api::interaction::to_status(payloads[i + 5]);
            if (type == api::interaction::Type::CALL) {
                body = getCallInteractionString(payloads[i + 1], duration);
            } else if(type == api::interaction::Type::CONTACT) {
                body = getContactInteractionString(payloads[i + 1], status);
            }
            auto msg = api::interaction::Info({
                    payloads[i + 1],
                    body,
                    std::stoi(payloads[i + 3]),
                    duration,
                    type,
                    status,
                    (payloads[i + 6] == "1" ? true : false)
                });
            conversation.interactions.emplace(std::stoull(payloads[i]), std::move(msg));
            conversation.lastMessageUid = std::stoull(payloads[i]);
        }
    }
}

int
addMessageToConversation(Database& db,
                         const std::string& conversationId,
                         const api::interaction::Info& msg)
{
    return db.insertInto("interactions", {
            { ":author", "author" },
            { ":conversation", "conversation" },
            { ":timestamp", "timestamp" },
            { ":body", "body" },
            { ":type", "type" },
            { ":status", "status" },
            { ":is_read", "is_read" }
        }, {
            { ":author", msg.authorUri},
            { ":conversation", conversationId},
            { ":timestamp", std::to_string(msg.timestamp)},
            { ":body", msg.body},
            { ":type", to_string(msg.type)},
            { ":status", to_string(msg.status)},
            { ":is_read", msg.isRead ? "1" : "0" }
        });
}

int
addOrUpdateMessage(Database& db,
                   const std::string& conversationId,
                   const api::interaction::Info& msg,
                   const std::string& daemonId)
{
    // Check if profile is already present.
    auto msgAlreadyExists = db.select("id",
                                      "interactions",
                                      "author=:author AND daemon_id=:daemon_id",
                                      { {":author", msg.authorUri},
                                      { ":daemon_id", daemonId } }).payloads;
    if (msgAlreadyExists.empty()) {
        return db.insertInto("interactions", {
                {":author", "author"},
                {":conversation", "conversation"},
                {":timestamp", "timestamp"},
                {":body", "body"},
                {":type", "type"},
                {":status", "status"},
                {":daemon_id", "daemon_id"}
            }, {
                {":author", msg.authorUri.empty() ? "" : msg.authorUri},
                {":conversation", conversationId},
                {":timestamp", std::to_string(msg.timestamp)},
                {msg.body.empty() ? "" : ":body", msg.body},
                {":type", to_string(msg.type)},
                {daemonId.empty() ? "" : ":daemon_id", daemonId},
                {":status", to_string(msg.status)}
            });
    } else {
        // already exists @ id(msgAlreadyExists[0])
        auto id = msgAlreadyExists[0];
        std::string extra_data;
        if (msg.type == api::interaction::Type::CALL) {
            auto duration = std::max(msg.duration, static_cast<std::time_t>(0));
            auto extra_data_str = getInteractionExtraDataById(db, id);
            auto extra_data_JSON = JSONFromString(QString::fromStdString(extra_data_str));
            writeJSONValue(extra_data_JSON, "duration", QString::number(duration));
            extra_data = stringFromJSON(extra_data_JSON).toStdString();
        }
        db.update("interactions",
                  { "body=:body, extra_data=:extra_data" },
                  { {msg.body.empty() ? "" : ":body", msg.body},
                  { extra_data.empty() ? "" : ":extra_data", extra_data } },
                  "id=:id", { {":id", id} });
        return std::stoi(id);
    }

}
int
addDataTransferToConversation(Database& db,
                              const std::string& conversationId,
                              const api::datatransfer::Info& infoFromDaemon)
{
    return db.insertInto("interactions", {
            {":author", "author"},
            {":conversation", "conversation"},
            {":timestamp", "timestamp"},
            {":body", "body"},
            {":type", "type"},
            {":status", "status"},
            {":is_read", "is_read"}
        }, {
            {":author", infoFromDaemon.isOutgoing ? "" : infoFromDaemon.peerUri},
            {":conversation", conversationId},
            {":timestamp", std::to_string(std::time(nullptr))},
            {":body", infoFromDaemon.path},
            {":type", infoFromDaemon.isOutgoing ?
                    "DATA_TRANSFER" :
                    "DATA_TRANSFER"},
            {":status", "TRANSFER_CREATED"},
            {":is_read", "0"}
        });
}

void addDaemonMsgId(Database& db,
                    const std::string& interactionId,
                    const std::string& daemonId)
{
    db.update("interactions",
              "daemon_id=:daemon_id",
              {{":daemon_id", daemonId}},
              "id=:id", {{":id", interactionId}});
}

std::string getDaemonIdByInteractionId(Database& db, const std::string& id)
{
    auto ids = db.select("daemon_id",
                         "interactions",
                         "id=:id",
                         {{":id", id}}).payloads;
    return ids.empty() ? "" : ids[0];
}

std::string getInteractionIdByDaemonId(Database& db, const std::string& daemon_id)
{
    auto ids = db.select("id",
                         "interactions",
                         "daemon_id=:daemon_id",
                         {{":daemon_id", daemon_id}}).payloads;
    return ids.empty() ? "" : ids[0];
}

std::string getInteractionExtraDataById(Database& db, const std::string& id,
                                        const std::string& key)
{
    auto extra_datas = db.select("extra_data",
                                 "interactions",
                                 "id=:id",
                                 { {":id", id} }).payloads;
    if (key.empty()) {
        return extra_datas.empty() ? "" : extra_datas[0];
    }
    std::string value;
    auto extra_data_str = QString::fromStdString(extra_datas[0]);
    if (!extra_data_str.isEmpty()) {
        value = readJSONValue(JSONFromString(extra_data_str), QString::fromStdString(key))
            .toStdString();
    }
    return value;
}

void updateInteractionBody(Database& db, unsigned int id,
                           const std::string& newBody)
{
    db.update("interactions", "body=:body",
              {{":body", newBody}},
              "id=:id", {{":id", std::to_string(id)}});
}

void updateInteractionStatus(Database& db, unsigned int id,
                             api::interaction::Status newStatus)
{
    db.update("interactions",
              { "status=:status" },
              {{":status", api::interaction::to_string(newStatus)}},
              "id=:id", {{":id", std::to_string(id)}});
}

void setInteractionRead(Database& db, unsigned int id)
{
    db.update("interactions",
              { "is_read=:is_read" },
              { {":is_read", "1"} },
              "id=:id", { {":id", std::to_string(id)} });
}

std::string
conversationIdFromInteractionId(Database& db, unsigned int interactionId)
{
    auto result = db.select("conversation",
                            "interactions",
                            "id=:id",
                            {{":id", std::to_string(interactionId)}});
    if (result.nbrOfCols == 1 && result.payloads.size()) {
        return result.payloads[0];
    }
    return {};
}

void clearHistory(Database& db,
                  const std::string& conversationId)
{
    db.deleteFrom("interactions",
                  "conversation=:conversation",
                  {{":conversation", conversationId}});
}

void clearInteractionFromConversation(Database& db,
                                      const std::string& conversationId,
                                      const uint64_t& interactionId)
{
    db.deleteFrom("interactions",
                  "conversation=:conversation AND id=:id",
                  {{":conversation", conversationId},
                  {":id", std::to_string(interactionId)}});
}

void clearAllHistory(Database& db)
{
    db.truncateTable("interactions");
}

void
deleteObsoleteHistory(Database& db, long int date)
{
    db.deleteFrom("interactions", "timestamp<=:date", { {":date", std::to_string(date)} });
}

void
removeContact(Database& db, const std::string& contactUri)
{
    // Get common conversations
    auto conversations = getConversationsWithPeer(db, contactUri);
    // Remove conversations + interactions
    for (const auto& conversationId: conversations) {
        // Remove conversation
        db.deleteFrom("conversations", "id=:id", {{":id", conversationId}});
        // clear History
        db.deleteFrom("interactions", "conversation=:id", {{":id", conversationId}});
    }
}

int
countUnreadFromInteractions(Database& db, const std::string& conversationId)
{
    return db.count("is_read",
                    "interactions",
                    "is_read=:is_read AND conversation=:id",
                    {{":is_read", "0"}, {":id", conversationId}});
}

uint64_t
getLastTimestamp(Database& db)
{
    auto timestamps = db.select("MAX(timestamp)", "interactions", "1=1", {}).payloads;
    auto result = std::time(nullptr);
    try {
        if (!timestamps.empty() && !timestamps[0].empty()) {
            result = std::stoull(timestamps[0]);
        }
    } catch (const std::out_of_range& e) {
        qDebug() << "storage::getLastTimestamp, stoull throws an out_of_range exception: " << e.what();
    } catch (const std::invalid_argument& e) {
        qDebug() << "storage::getLastTimestamp, stoull throws an invalid_argument exception: " << e.what();
    }
    return result;
}

namespace {
QString stringFromJSON(const QJsonObject& json)
{
    QJsonDocument doc(json);
    return QString::fromLocal8Bit(doc.toJson(QJsonDocument::Compact));
}

QJsonObject
JSONFromString(const QString& str)
{
    QJsonObject json;
    QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8());

    if (!doc.isNull()) {
        if (doc.isObject()) {
            json = doc.object();
        } else {
            qDebug() << "Document is not a JSON object: " << str;
        }
    } else {
        qDebug() << "Invalid JSON: " << str;
    }
    return json;
}

QString JSONStringFromInitList(const std::initializer_list<QPair<QString, QJsonValue>> args)
{
    QJsonObject jsonObject(args);
    return stringFromJSON(jsonObject);
}

QString
readJSONValue(const QJsonObject& json, const QString& key)
{
    if (!json.isEmpty() && json.contains(key) && json[key].isString()) {
        if (json[key].isString()) {
            return json[key].toString();
        }
    }
    return {};
}

void
writeJSONValue(QJsonObject& json, const QString& key, const QString& value)
{
    json[key] = value;
}
}

//================================================================================
// This section provides migration helpers from ring.db
// to per-account databases yielding a file structure like:
//
// { local_storage } / jami
// └──{ account_id }
// ├── config.yml
// ├── contacts
// ├── export.gz
// ├── incomingTrustRequests
// ├── knownDevicesNames
// ├── history.db < --conversations and interactions database
// ├── profile.vcf < --account vcard
// ├── profiles < --account contact vcards
// │   │──{ contact_uri }.vcf
// │   └── ...
// ├── ring_device.crt
// └── ring_device.key
//================================================================================
namespace migration {

enum class msgFlag {
    IS_INCOMING,
    IS_OUTGOING,
    IS_CONTACT_ADDED,
    IS_INVITATION_RECEIVED,
    IS_INVITATION_ACCEPTED,
    IS_TEXT
};

std::string profileToVcard(const lrc::api::profile::Info&, const std::string&);
uint64_t getTimeFromTimeStr(const std::string&) noexcept;
std::pair<msgFlag, uint64_t> migrateMessageBody(const std::string&,
                                                const lrc::api::interaction::Type&);
std::vector<std::string> getPeerParticipantsForConversationId(lrc::Database&,
                                                              const std::string&,
                                                              const std::string&);
void migrateAccountDb(const QString&,
                      std::shared_ptr<lrc::Database>,
                      std::shared_ptr<lrc::Database>);

namespace interaction {

static inline api::interaction::Type
to_type(const std::string& type)
{
    if (type == "TEXT")
        return api::interaction::Type::TEXT;
    else if (type == "CALL")
        return api::interaction::Type::CALL;
    else if (type == "CONTACT")
        return api::interaction::Type::CONTACT;
    else if (type == "OUTGOING_DATA_TRANSFER")
        return api::interaction::Type::DATA_TRANSFER;
    else if (type == "INCOMING_DATA_TRANSFER")
        return api::interaction::Type::DATA_TRANSFER;
    else
        return api::interaction::Type::INVALID;
}

static inline std::string
to_migrated_status_string(const std::string& status)
{
    if (status == "FAILED")
        return "FAILURE";
    else if (status == "SUCCEED")
        return "SUCCESS";
    else if (status == "READ")
        return "SUCCESS";
    else if (status == "UNREAD")
        return "SUCCESS";
    else
        return status;

}

} // namespace interaction

std::string
profileToVcard(const api::profile::Info& profileInfo,
               const std::string& accountId = {})
{
    using namespace api;
    bool compressedImage = std::strncmp(profileInfo.avatar.c_str(), "/9g=", 4) == 0;;
    std::string vCardStr = vCard::Delimiter::BEGIN_TOKEN;
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    vCardStr += vCard::Property::VERSION;
    vCardStr += ":2.1";
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    if (!accountId.empty()) {
        vCardStr += vCard::Property::UID;
        vCardStr += ":";
        vCardStr += accountId;
        vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    }
    vCardStr += vCard::Property::FORMATTED_NAME;
    vCardStr += ":";
    vCardStr += profileInfo.alias;
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    if (profileInfo.type == profile::Type::RING) {
        vCardStr += vCard::Property::TELEPHONE;
        vCardStr += ":";
        vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
        vCardStr += "other:ring:";
        vCardStr += profileInfo.uri;
        vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    } else {
        vCardStr += vCard::Property::TELEPHONE;
        vCardStr += profileInfo.uri;
        vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    }
    vCardStr += vCard::Property::PHOTO;
    vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
    vCardStr += "ENCODING=BASE64";
    vCardStr += vCard::Delimiter::SEPARATOR_TOKEN;
    vCardStr += compressedImage ? "TYPE=JPEG:" : "TYPE=PNG:";
    vCardStr += profileInfo.avatar;
    vCardStr += vCard::Delimiter::END_LINE_TOKEN;
    vCardStr += vCard::Delimiter::END_TOKEN;
    return vCardStr;
}

uint64_t
getTimeFromTimeStr(const std::string& str) noexcept
{
    uint64_t minutes = 0, seconds = 0;
    std::size_t delimiterPos = str.find(":");
    if (delimiterPos != std::string::npos) {
        try {
            minutes = std::stoull(str.substr(0, delimiterPos));
            seconds = std::stoull(str.substr(delimiterPos + 1));
        } catch (const std::exception&) {
            return 0;
        }
    }
    return minutes * 60 + seconds;
}

std::pair<msgFlag, uint64_t>
migrateMessageBody(const std::string& body, const api::interaction::Type& type)
{
    uint64_t duration{ 0 };
    // check in english and local to determine the direction of the call
    static QString emo = "Missed outgoing call";
    static QString lmo = QObject::tr("Missed outgoing call");
    static QString eo  = "Outgoing call";
    static QString lo  = QObject::tr("Outgoing call");
    static QString eca = "Contact added";
    static QString lca = QObject::tr("Contact added");
    static QString eir = "Invitation received";
    static QString lir = QObject::tr("Invitation received");
    static QString eia = "Invitation accepted";
    static QString lia = QObject::tr("Invitation accepted");
    auto qstrBody = QString::fromStdString(body);
    switch (type) {
    case api::interaction::Type::CALL:
        {
        bool en_missedOut   = qstrBody.contains(emo);
        bool en_out         = qstrBody.contains(eo);
        bool loc_missedOut  = qstrBody.contains(lmo);
        bool loc_out        = qstrBody.contains(lo);
        bool outgoingCall   = en_missedOut || en_out || loc_missedOut || loc_out;
        std::size_t dashPos = body.find("-");
        if (dashPos != std::string::npos) {
            duration = getTimeFromTimeStr(body.substr(dashPos + 2));
        }
        return std::make_pair(msgFlag(outgoingCall),
                              duration);
        }
        break;
    case api::interaction::Type::CONTACT:
        if (qstrBody.contains(eca) || qstrBody.contains(lca)) {
            return std::make_pair(msgFlag::IS_CONTACT_ADDED, 0);
        } else if (qstrBody.contains(eir) || qstrBody.contains(lir)) {
            return std::make_pair(msgFlag::IS_INVITATION_RECEIVED, 0);
        } else if (qstrBody.contains(eia) || qstrBody.contains(lia)) {
            return std::make_pair(msgFlag::IS_INVITATION_ACCEPTED, 0);
        }
        break;
    case api::interaction::Type::INVALID:
    case api::interaction::Type::TEXT:
    case api::interaction::Type::DATA_TRANSFER:
    case api::interaction::Type::COUNT__:
    default:
        return std::make_pair(msgFlag::IS_TEXT, 0);
    }
    return std::make_pair(msgFlag::IS_OUTGOING, 0);
}

std::vector<std::string>
getPeerParticipantsForConversationId(Database& db, const std::string& profileId, const std::string& conversationId)
{
    return db.select("participant_id",
        "conversations",
        "id=:id AND participant_id!=:participant_id",
        { {":id", conversationId}, {":participant_id", profileId} }).payloads;
}

void
migrateAccountDb(const QString& accountId,
                 std::shared_ptr<Database> db,
                 std::shared_ptr<Database> legacyDb)
{
    using namespace lrc::api;
    using namespace migration;

    auto accountLocalPath = getPath() + accountId + "/";

    using namespace DRing::Account;
    MapStringString accountDetails = ConfigurationManager::instance().
        getAccountDetails(accountId.toStdString().c_str());
    bool isRingAccount = accountDetails[ConfProperties::TYPE] == "RING";
    std::map<std::string, std::string> profileIdUriMap;
    std::map<std::string, std::string> convIdPeerUriMap;
    std::string accountProfileId;

    // 1. profiles_accounts
    // migrate account's avatar/alias from profiles table to {data_dir}/profile.vcf
    std::string accountUri;
    if (isRingAccount) {
        accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME].contains("ring:") ?
            accountDetails[DRing::Account::ConfProperties::USERNAME].toStdString().substr(std::string("ring:").size()) :
            accountDetails[DRing::Account::ConfProperties::USERNAME].toStdString();
    } else {
        accountUri = accountDetails[DRing::Account::ConfProperties::USERNAME].toStdString();
    }

    auto accountProfileIds = legacyDb->select(
        "profile_id", "profiles_accounts",
        "account_id=:account_id AND is_account=:is_account",
        { {":account_id", accountId.toStdString()},
        {":is_account", "true"} }).payloads;
    if (accountProfileIds.size() != 1) {
        return;
    }
    accountProfileId = accountProfileIds[0];
    auto accountProfile = legacyDb->select(
        "photo, alias",
        "profiles", "id=:id",
        { {":id", accountProfileId} }).payloads;
    profile::Info accountProfileInfo;
    // if we can not find the uri in the database
    // (in the case of poorly kept SIP account uris),
    // than we cannot migrate the conversations and vcard
    if (!accountProfile.empty()) {
        accountProfileInfo = { accountUri, accountProfile[0], accountProfile[1],
            isRingAccount ? profile::Type::RING : profile::Type::SIP };
    }
    auto accountVcard = profileToVcard(accountProfileInfo, accountId.toStdString());
    auto profileFilePath = accountLocalPath + "profile" + ".vcf";
    QFile file(profileFilePath);
    if (!file.open(QIODevice::WriteOnly)) {
        throw std::runtime_error("Can't open file: " + profileFilePath.toStdString());
    }
    QTextStream(&file) << QString::fromStdString(accountVcard);

    // 2. profiles
    // migrate profiles from profiles table to {data_dir}/{uri}.vcf
    // - for JAMI, the scheme and the hostname is omitted
    // - for SIP, the uri is must be stripped of prefix and port
    // e.g. 3d1112ab2bb089370c0744a44bbbb0786418d40b.vcf
    //      username.vcf or username@hostname.vcf

    // only select non-account profiles
    auto profileIds = legacyDb->select(
        "profile_id", "profiles_accounts",
        "account_id=:account_id AND is_account=:is_account",
        { {":account_id", accountId.toStdString()},
        {":is_account", "false"} }).payloads;
    for (const auto& profileId : profileIds) {
        auto profile = legacyDb->select(
            "uri, alias, photo, type", "profiles",
            "id=:id",
            { {":id", profileId} }).payloads;
        if (profile.empty()) {
            continue;
        }
        profile::Info profileInfo{ profile[0], profile[2], profile[1] };
        auto uri = URI(QString::fromStdString(profile[0]));
        auto profileUri = uri.userinfo();
        if (!isRingAccount && uri.hasHostname()) {
            profileUri += "@" + uri.hostname();
        }
        // insert into map for use during the conversations table migration
        profileIdUriMap.insert(std::make_pair(profileId, profileUri.toStdString()));
        auto vcard = profileToVcard(profileInfo);
        // make sure the directory exists
        QDir dir(accountLocalPath + "profiles");
        if (!dir.exists())
            dir.mkpath(".");
        profileFilePath = accountLocalPath + "profiles/" + profileUri + ".vcf";
        QFile file(profileFilePath);
        // if we catch duplicates here, skip the profile because
        // the previous db structure does not guarantee unique uris
        if (file.exists()) {
            qWarning() << "Profile file already exits: " << profileFilePath;
            continue;
        }
        if (!file.open(QIODevice::WriteOnly)) {
            qWarning() << "Can't open file: " << profileFilePath;
            continue;
        }
        QTextStream(&file) << QString::fromStdString(vcard);
    }

    // 3. conversations
    // migrate old conversations table ==> new conversations table
    // a) participant_id INTEGER becomes participant TEXT (the uri of the participant)
    //    use the selected non-account profiles
    auto conversationIds = legacyDb->select(
        "id", "conversations",
        "participant_id=:participant_id",
        { {":participant_id", accountProfileId} }).payloads;
    if (conversationIds.empty()) {
        return;
    }
    for (auto conversationId : conversationIds) {
        // only one peer pre-groupchat
        auto peerProfileId = getPeerParticipantsForConversationId(*legacyDb, accountProfileId, conversationId);
        if (peerProfileId.empty()) {
            continue;
        }
        auto it = profileIdUriMap.find(peerProfileId.at(0));
        // we cannot insert in the conversations table without a uri
        if (it == profileIdUriMap.end()) {
            continue;
        }
        convIdPeerUriMap.insert(std::make_pair(conversationId, it->second));
        try {
            db->insertInto("conversations",
                { {":id", "id"} ,
                {":participant", "participant"} },
                { { ":id", conversationId } ,
                { ":participant", it->second } });
        } catch (const std::runtime_error& e) {
            qWarning() << "Couldn't migrate conversation: " << e.what();
            continue;
        }
    }

    // 4. interactions
    auto allInteractions = legacyDb->select(
        "account_id, author_id, conversation_id, \
         timestamp, body, type, status, daemon_id",
        "interactions",
        "account_id=:account_id",
        { {":account_id", accountProfileId} });
    auto interactionIt = allInteractions.payloads.begin();
    while (interactionIt != allInteractions.payloads.end()) {
        auto author_id = *(interactionIt + 1);
        auto convId = *(interactionIt + 2);
        auto timestamp = *(interactionIt + 3);
        auto body = *(interactionIt + 4);
        auto type = interaction::to_type(*(interactionIt + 5));
        auto statusStr = *(interactionIt + 6);
        auto daemonId = *(interactionIt + 7);

        auto it = profileIdUriMap.find(author_id);
        if (it == profileIdUriMap.end() && author_id != accountProfileId) {
            std::advance(interactionIt, allInteractions.nbrOfCols);
            continue;
        }
        // migrate body+type ==> msgFlag+duration
        auto migratedMsg = migrateMessageBody(body, type);
        auto profileUri = it == profileIdUriMap.end() ? "" : it->second;
        // clear author uri if outgoing
        switch (migratedMsg.first) {
        case msgFlag::IS_OUTGOING:
        case msgFlag::IS_CONTACT_ADDED:
            profileUri.clear();
            break;
        case msgFlag::IS_INCOMING:
        case msgFlag::IS_INVITATION_RECEIVED:
        case msgFlag::IS_INVITATION_ACCEPTED:
        {
            // try to set profile uri using the conversation id
            auto it = convIdPeerUriMap.find(convId);
            if (it == convIdPeerUriMap.end()) {
                std::advance(interactionIt, allInteractions.nbrOfCols);
                continue;
            }
            profileUri = it->second;
            break;
        }
        case msgFlag::IS_TEXT:
        default:
            break;
        }
        // Set all read, call and datatransfer, and contact added
        // interactions to a read state
        bool is_read = statusStr != "UNREAD"
            || type == api::interaction::Type::CALL
            || type == api::interaction::Type::CONTACT;
        // migrate status
        if (migratedMsg.first == msgFlag::IS_INVITATION_RECEIVED) {
            statusStr = "UNKNOWN";
        }
        std::string extra_data = migratedMsg.second == 0 ? "" :
            JSONStringFromInitList({
                    qMakePair(QString("duration"),
                    QJsonValue(QString::number(migratedMsg.second)))
                })
            .toStdString();
        if (accountUri == profileUri)
            profileUri.clear();
        auto typeStr = api::interaction::to_string(type);
        try {
            db->insertInto("interactions", {
                {":author", "author"},
                {":conversation", "conversation"},
                {":timestamp", "timestamp"},
                {":body", "body"},
                {":type", "type"},
                {":status", "status"},
                {":is_read", "is_read"},
                {":daemon_id", "daemon_id"},
                {":extra_data", "extra_data"}
            }, {
                {":author", profileUri},
                {":conversation", convId},
                {":timestamp", timestamp},
                {migratedMsg.first != msgFlag::IS_TEXT ? "" : ":body", body},
                {":type", api::interaction::to_string(type)},
                {":status", interaction::to_migrated_status_string(statusStr)},
                {":is_read", is_read ? "1" : "0" },
                {daemonId.empty() ? "" : ":daemon_id", daemonId},
                {extra_data.empty() ? "" : ":extra_data", extra_data }
            });
        } catch (const std::runtime_error& e) {
            qWarning() << e.what();
        }
        std::advance(interactionIt, allInteractions.nbrOfCols);
    }
    qDebug() << "Done";
}

} // namespace migration

std::vector<std::shared_ptr<Database>>
migrateIfNeeded(const QStringList& accountIds,
                MigrationCb& willMigrateCb,
                MigrationCb& didMigrateCb)
{
    using namespace lrc::api;
    using namespace migration;

    std::vector<std::shared_ptr<Database>> dbs(accountIds.size());

    if (!accountIds.size()) {
        qDebug() << "No accounts to migrate";
        return dbs;
    }

    auto appPath = getPath();

    // ring -> jami path migration
    QDir dataDir(appPath);
    // create data directory if not created yet
    dataDir.mkpath(appPath);
    QDir oldDataDir(appPath);
    oldDataDir.cdUp();
    oldDataDir = oldDataDir
        .absolutePath()
#if defined(_WIN32)
        +"/Savoir-faire Linux/Ring";
#elif defined(__APPLE__)
        +"/ring";
#else
        + "/gnome-ring";
#endif
    QStringList filesList = oldDataDir.entryList();
    QString filename;
    QDir dir;
    bool success = true;
    foreach(filename, filesList) {
        qDebug() << "Migrate " << oldDataDir.absolutePath() << "/" << filename
                 << " to " << dataDir.absolutePath() + "/" + filename;
        if (filename != "." && filename != "..") {
            success &= dir.rename(oldDataDir.absolutePath() + "/" + filename,
                dataDir.absolutePath() + "/" + filename);
        }
    }
    if (success) {
        // Remove old directory if the migration is successful.
#if defined(_WIN32)
        oldDataDir.cdUp();
#endif
        oldDataDir.removeRecursively();
    }

    bool needsMigration = false;
    std::map<QString, bool> hasMigratedData;
    for (const auto& accountId : accountIds) {
        auto hasMigratedDb = QFile(appPath + accountId + "/history.db").exists() &&
                            !QFile(appPath + accountId + "/history.db-journal").exists();
        hasMigratedData.insert(std::make_pair(accountId, hasMigratedDb));
        needsMigration |= !hasMigratedDb;
    }
    if (!needsMigration) {
        // if there's any lingering pre-migration data, remove it
        QFile(dataDir.absoluteFilePath("ring.db")).remove();
        QDir(dataDir.absoluteFilePath("text/")).removeRecursively();
        QDir(dataDir.absoluteFilePath("profiles/")).removeRecursively();
        QDir(dataDir.absoluteFilePath("peer_profiles/")).removeRecursively();
        qDebug() << "No migration required";
        return dbs;
    }

    // A fairly long migration may now occur
    std::thread migrateThread(
        [&appPath, &accountIds, &dbs, &didMigrateCb, &dataDir, &hasMigratedData] {
            // 1. migrate old lrc -> new lrc if needed
            // 2. migrate new lrc db version 1 -> db version 1.1 if needed
            // the destructor of LegacyDatabase will remove 'ring.db' and clean out
            // old lrc files
            std::shared_ptr<Database> legacyDb;
            try {
                legacyDb = lrc::DatabaseFactory::create<LegacyDatabase>(appPath);
            } catch (const std::runtime_error& e) {
                qDebug() << "Exception while attempting to load legacy database: " << e.what();
                if (didMigrateCb)
                    didMigrateCb();
                return;
            }

            // attempt to make a backup of ring.db
            {
                QFile dbFile(dataDir.absoluteFilePath("ring.db"));
                if (dbFile.open(QIODevice::ReadOnly)) {
                    dbFile.copy(appPath + "ring.db.bak");
                }
            }

            // 3. migrate db version 1.1 -> per account dbs version 1
            int index = 0;
            for (const auto& accountId : accountIds) {
                if (hasMigratedData.at(accountId)) {
                    index++;
                    continue;
                }
                qDebug() << "Migrating account: " << accountId << "...";
                // try to remove the transaction journal from a failed migration
                QFile(appPath + accountId + "/history.db-journal").remove();
                try {
                    QSqlDatabase::database().transaction();
                    auto dbName = QString::fromStdString(accountId.toStdString() + "/history");
                    dbs.at(index) = lrc::DatabaseFactory::create<Database>(dbName, appPath);
                    auto& db = dbs.at(index++);
                    migration::migrateAccountDb(accountId, db, legacyDb);
                    QSqlDatabase::database().commit();
                } catch (const std::runtime_error& e) {
                    qWarning().noquote()
                        << "Could not migrate database for account: "
                        << accountId << "\n " << e.what();
                    QSqlDatabase::database().rollback();
                }
            }

            // done
            if (didMigrateCb)
                didMigrateCb();
        });

    // if willMigrateCb blocks, it must be unblocked by didMigrateCb
    if (willMigrateCb)
        willMigrateCb();

    migrateThread.join();

    return dbs;
}

} // namespace database

} // namespace authority

} // namespace lrc