MuditaOS/module-apps/apps-common/models/SongsRepository.cpp

// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include "SongsRepository.hpp"

#include <algorithm>
#include <log/log.hpp>
#include <service-audio/AudioServiceAPI.hpp>
#include <service-audio/AudioServiceName.hpp>
#include <time/ScopedTime.hpp>
#include <service-audio/AudioMessage.hpp>
#include <module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp>
#include <module-db/queries/multimedia_files/QueryMultimediaFilesGet.hpp>

#include <filesystem>

namespace constants
{
    inline constexpr auto cacheMaxSize{30};
    inline constexpr auto cacheThreshold{10};
} // namespace constants

namespace app::music
{
    ServiceAudioTagsFetcher::ServiceAudioTagsFetcher(ApplicationCommon *application) : application(application)
    {}

    std::optional<tags::fetcher::Tags> ServiceAudioTagsFetcher::getFileTags(const std::string &filePath) const
    {
        return tags::fetcher::fetchTags(filePath);
    }

    SongsRepository::SongsRepository(ApplicationCommon *application,
                                     std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
                                     const std::vector<std::string> &pathPrefixes)
        : app::AsyncCallbackReceiver{application}, application{application},
          tagsFetcher(std::move(tagsFetcher)), pathPrefixes{pathPrefixes}
    {}

    void SongsRepository::initCache()
    {
        auto query =
            std::make_unique<db::multimedia_files::query::GetLimitedByPaths>(pathPrefixes, 0, constants::cacheMaxSize);
        auto task = app::AsyncQuery::createFromQuery(std::move(query), db::Interface::Name::MultimediaFiles);
        musicFilesModelCache.recordsOffset = 0;

        task->setCallback([this](auto response) {
            auto result = dynamic_cast<db::multimedia_files::query::GetLimitedResult *>(response);

            if (result == nullptr) {
                return false;
            }

            return initCacheCallback(result->getResult(), result->getCount());
        });
        task->execute(application, this);
    }

    void SongsRepository::getMusicFilesList(const std::uint32_t offset,
                                            const std::uint32_t limit,
                                            const OnGetMusicFilesListCallback &callback)
    {
        musicFilesViewCache.records.clear();
        getMusicFilesList(pathPrefixes, offset, limit, callback);
    }

    void SongsRepository::getMusicFilesListByPaths(const std::uint32_t offset,
                                                   const std::uint32_t limit,
                                                   const OnGetMusicFilesListCallback &callback)
    {

        musicFilesViewCache.records.clear();
        for (const auto &pathPrefix : pathPrefixes) {
            getMusicFilesList({pathPrefix}, offset, limit, callback);
        }
    }

    std::size_t SongsRepository::getCachedFileIndex(const std::string &filePath) const
    {
        const auto it = std::find_if(musicFilesModelCache.records.begin(),
                                     musicFilesModelCache.records.end(),
                                     [filePath](const auto &musicFile) { return musicFile.fileInfo.path == filePath; });

        if (it != musicFilesModelCache.records.end()) {
            return std::distance(musicFilesModelCache.records.begin(), it);
        }

        return std::numeric_limits<size_t>::max();
    }

    std::optional<db::multimedia_files::MultimediaFilesRecord> SongsRepository::getCachedViewEntryByFilePath(
        const std::string &filePath) const
    {
        const auto it = std::find_if(musicFilesViewCache.records.begin(),
                                     musicFilesViewCache.records.end(),
                                     [filePath](const auto &musicFile) { return musicFile.fileInfo.path == filePath; });

        if (it != musicFilesViewCache.records.end()) {
            return *it;
        }

        return std::nullopt;
    }

    std::string SongsRepository::getNextFilePath(const std::string &filePath) const
    {
        const auto currentIndex = getCachedFileIndex(filePath);

        if (currentIndex == std::numeric_limits<size_t>::max() ||
            currentIndex >= musicFilesModelCache.records.size() - 1) {
            return "";
        }
        return musicFilesModelCache.records[currentIndex + 1].fileInfo.path;
    }

    std::string SongsRepository::getPreviousFilePath(const std::string &filePath) const
    {
        const auto currentIndex = getCachedFileIndex(filePath);

        if (currentIndex == std::numeric_limits<size_t>::max() || currentIndex == 0 ||
            currentIndex > musicFilesModelCache.records.size()) {
            return "";
        }
        return musicFilesModelCache.records[currentIndex - 1].fileInfo.path;
    }

    std::uint32_t SongsRepository::calculateOffset()
    {
        if (musicFilesViewCache.recordsCount < constants::cacheMaxSize) {
            return 0;
        }
        else if (musicFilesViewCache.recordsOffset < constants::cacheThreshold) {
            return 0;
        }
        else if (musicFilesViewCache.recordsOffset >
                 musicFilesViewCache.recordsCount - (constants::cacheMaxSize - constants::cacheThreshold)) {
            return musicFilesViewCache.recordsCount - constants::cacheMaxSize;
        }
        else {
            return musicFilesViewCache.recordsOffset - constants::cacheThreshold;
        }
    }

    void SongsRepository::updateRepository(const std::string &filePath)
    {
        const auto currentIndex = getCachedFileIndex(filePath);

        if (currentIndex == std::numeric_limits<size_t>::max()) {
            updateMusicFilesList(
                calculateOffset(),
                constants::cacheMaxSize,
                [this](const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                       unsigned int repoRecordsCount,
                       std::uint32_t offset) { return newDataCallback(records, repoRecordsCount, offset); });
        }
        else if (currentIndex > musicFilesModelCache.records.size() - constants::cacheThreshold) {
            updateMusicFilesList(
                musicFilesModelCache.recordsOffset + musicFilesModelCache.records.size() + 1,
                constants::cacheThreshold,
                [this](const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                       unsigned int repoRecordsCount,
                       std::uint32_t offset) { return newBackDataCallback(records, repoRecordsCount, offset); });
        }
        else if (currentIndex < constants::cacheThreshold) {
            updateMusicFilesList(
                musicFilesModelCache.recordsOffset > constants::cacheThreshold
                    ? musicFilesModelCache.recordsOffset - constants::cacheThreshold
                    : 0,
                musicFilesModelCache.recordsOffset > constants::cacheThreshold ? constants::cacheThreshold
                                                                               : musicFilesModelCache.recordsOffset,
                [this](const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                       unsigned int repoRecordsCount,
                       std::uint32_t offset) { return newFrontDataCallback(records, repoRecordsCount, offset); });
        }
    }

    void SongsRepository::updateMusicFilesList(std::uint32_t offset,
                                               std::uint32_t limit,
                                               const OnUpdateMusicFilesListCallback &callback)
    {
        auto query = std::make_unique<db::multimedia_files::query::GetLimitedByPaths>(pathPrefixes, offset, limit);
        auto task  = app::AsyncQuery::createFromQuery(std::move(query), db::Interface::Name::MultimediaFiles);

        task->setCallback([offset, callback](auto response) {
            auto result = dynamic_cast<db::multimedia_files::query::GetLimitedResult *>(response);

            if (result == nullptr) {
                return false;
            }

            return callback(result->getResult(), result->getCount(), offset);
        });
        task->execute(application, this);
    }

    bool SongsRepository::initCacheCallback(const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                                            unsigned int repoRecordsCount)
    {
        musicFilesModelCache.records.clear();
        for (auto &record : records) {
            musicFilesModelCache.records.push_back(record);
        }
        musicFilesModelCache.recordsOffset = 0;
        musicFilesModelCache.recordsCount  = repoRecordsCount;

        return true;
    }

    bool SongsRepository::newDataCallback(const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                                          unsigned int repoRecordsCount,
                                          std::uint32_t offset)
    {
        musicFilesModelCache.records.clear();
        for (auto &record : records) {
            musicFilesModelCache.records.push_back(record);
        }
        musicFilesModelCache.recordsOffset = offset;
        musicFilesModelCache.recordsCount  = repoRecordsCount;

        return true;
    }

    bool SongsRepository::newBackDataCallback(const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                                              unsigned int repoRecordsCount,
                                              std::uint32_t offset)
    {
        for (auto &record : records) {
            musicFilesModelCache.records.push_back(record);
            musicFilesModelCache.records.erase(musicFilesModelCache.records.begin(),
                                               musicFilesModelCache.records.begin() + 1);
            musicFilesModelCache.recordsOffset++;
        }
        musicFilesModelCache.recordsCount = repoRecordsCount;

        return true;
    }

    bool SongsRepository::newFrontDataCallback(const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
                                               unsigned int repoRecordsCount,
                                               std::uint32_t offset)
    {
        auto iterator = 0;
        for (auto &record : records) {
            musicFilesModelCache.records.insert(musicFilesModelCache.records.begin() + iterator, record);
            musicFilesModelCache.records.pop_back();
            iterator++;
        }
        musicFilesModelCache.recordsOffset = offset;
        musicFilesModelCache.recordsCount  = repoRecordsCount;

        return true;
    }

    std::optional<db::multimedia_files::MultimediaFilesRecord> SongsRepository::getRecord(
        const std::string &filePath) const
    {
        if (const auto index = getCachedFileIndex(filePath); index != std::numeric_limits<size_t>::max()) {
            return musicFilesModelCache.records[index];
        }
        return getCachedViewEntryByFilePath(filePath);
    }

    void SongsRepository::getMusicFilesList(const std::vector<std::string> &paths,
                                            const std::uint32_t offset,
                                            const std::uint32_t limit,
                                            const OnGetMusicFilesListCallback &callback)
    {

        auto taskCallback = [this, callback, offset](auto response) {
            auto result = dynamic_cast<db::multimedia_files::query::GetLimitedResult *>(response);
            if (result == nullptr) {
                return false;
            }
            for (auto &record : result->getResult()) {
                musicFilesViewCache.records.push_back(record);
            }
            musicFilesViewCache.recordsOffset = offset;
            musicFilesViewCache.recordsCount  = result->getCount();

            if (callback) {
                callback(musicFilesViewCache.records, musicFilesViewCache.recordsCount);
            }
            return true;
        };
        auto query = std::make_unique<db::multimedia_files::query::GetLimitedByPaths>(
            std::vector<std::string>{paths}, offset, limit);
        auto task = app::AsyncQuery::createFromQuery(std::move(query), db::Interface::Name::MultimediaFiles);
        task->setCallback(taskCallback);
        task->execute(application, this);
    }
} // namespace app::music