TextToPreset.cpp

Go to the documentation of this file.

#include "TextToPreset.h"
 
#include <openssl/evp.h>
#include <openssl/err.h>
 
#include "../../krotos_kwidget/managers/PresetManager.h"
namespace krotos
{
    TextToPreset::TextToPreset() : Thread(ttpThreadName)
    {
        File ggmlDataFile = File(krotos::utils::StringsIntoPath(AssetManager::getPluginDirectory().getFullPathName(),
                                                                "ttpResources", modelFileName));
 
        if (ggmlDataFile.existsAsFile())
        {
            m_modelFileAvailable = true;
        }
        // TODO: set a priority?
        startThread();
}
 
TextToPreset::~TextToPreset() { stopThread(4000); }
 
void TextToPreset::run()
{
    if (!threadShouldExit())
    {
        loadEmbeddings();
    }
}
 
void TextToPreset::clear()
{
    // TODO: check nothing missing here
    m_presetNameAndPresetPathMap.clear();
    m_presetNames.clear();
    m_presetData.clear();
    m_kNN.clear();
}
 
bool TextToPreset::processFileList(Array<File>& filesToProcess)
{
    if (m_modelFileAvailable == false)
    {
        return false;
    }
    
    ScopedLock sl(m_cs);
 
    // clear previously stored data
    clear();
 
    for (File& file : filesToProcess)
    {
        auto success = calculateEmbeddingsForPresetFile(file);
        if (!success || Thread::currentThreadShouldExit())
        {
            return false;
        }
    }
 
    // build KD-Tree index so we can search
    if (!m_presetNames.empty())
    {
        m_kNN.buildIndex();
    }
 
    // append - save embeddings to file
    const auto appendedDataToEmbeddingsFile = appendDataToEmbeddingsFile();
    
    return appendedDataToEmbeddingsFile;
}
 
bool TextToPreset::calculateEmbeddingsForPresetFile(File presetFile)
{
    // map preset name with preset path name
    if (!presetFile.exists())
    {
        return false;
    }
    
    m_presetFile = presetFile;
    m_presetName = m_presetFile.getFileName();
    
    m_presetNameAndPresetPathMap.insert(std::pair<std::string, std::string>(
            m_presetName.toStdString(), m_presetFile.getFullPathName().toStdString()));
 
    // create the preset value tree from the preset file
    ValueTree preset = PresetManager::getValueTreeFromFile(m_presetFile);
 
    // prepare sample paths and sample file names containers for the new training session
    m_samplePaths.clear();
    m_sampleFilenames.clear();
 
    // get the names of all the assets included in the preset
    getPresetAssetNames(preset);
 
    // split asset names to tags
    auto success = assetNamesToTags(true);
 
    return success;
}
 
bool TextToPreset::assetNamesToTags(bool eliminateDuplicates)
{
    // clear preset tags
    m_presetTags.clear();
 
    String presetTagsString;
 
    // if we already have the tags available, skip extracting them
    if (m_presetData.count(m_presetName) > 0)
    {
        m_presetTags = m_presetData[m_presetName].tags;
        presetTagsString = m_presetTags.joinIntoString(", ");
    }
    else
    {
        // extract tags from filenames
        for (auto assetName : m_sampleFilenames)
        {
            if (Thread::currentThreadShouldExit())
            {
                return false;
            }
 
            // break asset name to tokens
            StringArray assetNameTokens;
            assetNameTokens.addTokens(assetName, StringRef(delimiters), StringRef("'"));
 
            // for each token we got see if it belongs to the exclude list
            for (auto token : assetNameTokens)
            {
                if (token.isEmpty() == false && token.containsOnly(ttpNumericalMetadata) == false)
                {
                    // if it does not, we got a tag we can use
                    if (excludeTerms.contains(token.toLowerCase()) == false)
                    {
                        if (token == "FOLEYFeet")
                            token = "FOLYFeet"; // fix for typo in our factory assets
 
                        // if token is valid UCS CatID
                        if (m_UCS->isValid(token))
                        {
                            // unpack token into UCS Category SubCategory
                            // e.g. "MECHLock" -> "MECHANICAL, LOCK"
                            token = m_UCS->getCategorySubCategory(token);
                            token = token.removeCharacters(",");
                        }
                        // so lets add it to the tags array
                        m_presetTags.add(token);
                    }
                }
            }
        }
 
#if AUDIO_METADATA_TAGS
        // also parse the asset wav files, look for extra metadata
        // and if there is any push them in the m_presetTags array as well
        for (auto assetPath : m_samplePaths)
        {
            if (Thread::currentThreadShouldExit())
            {
                return false;
            }
            // convert path to platform path format if needed
            assetPath = AssetManager::convertFilePathString(assetPath);
 
            // create format manager and format reader
            AudioFormatManager formatManager;
            formatManager.registerBasicFormats();
            std::unique_ptr<AudioFormatReader> reader;
 
            // copes with . and ..
            if (assetPath.startsWith(".") == true)
            {
                continue;
            }
 
            // asset files are inclided as .wav in preset files, see if they exist as such
            // if not look for kaf equivalents.
            File assetFile(assetPath);
            if (assetFile.exists() == false)
            {
                assetPath = assetPath.upToFirstOccurrenceOf(".wav", false, true) + ".kaf";
                // copes with . and ..
                if (assetPath.startsWith(".") == true)
                {
                    continue;
                }
                assetFile = File(assetPath);
            }
 
            // analyze wav
            if (assetFile.hasFileExtension(kafFileExtension) == false)
            {
                // new format reader
                reader.reset(formatManager.createReaderFor(AssetManager::convertFilePath(assetPath)));
                if (reader)
                {
                    for (String key : reader->metadataValues.getAllKeys())
                    {
                        if (key == String(wavMetadataFieldInFile))
                        {
                            auto description = reader->metadataValues.getValue(key, "");
                            StringArray tokens;
                            tokens.addTokens(description, ",", StringRef(""));
                            for (auto token : tokens)
                            {
                                // tokens should not be empty or contain any of the terms below, or the file name of the
                                // preset which is included multiple times in wav metadata for several files
                                if (token.isEmpty() == false && token.containsOnly(ttpNumericalMetadata) == false &&
                                    token.containsIgnoreCase("krt") == false &&
                                    token.containsIgnoreCase("krotos") == false && token.startsWith("\\") == false &&
                                    token.contains(m_presetFile.getFileNameWithoutExtension().toLowerCase()) == false)
                                {
                                    if (!excludeTerms.contains(token.toLowerCase()))
                                    {
                                        if (token.startsWith(" "))
                                        {
                                            token = token.fromFirstOccurrenceOf(" ", false, true);
                                        }
                                        m_presetTags.add(token);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                std::array<unsigned char, BUF_SIZE> m_sampleData;
 
                if (assetFile.existsAsFile() == false)
                {
                    continue;
                }
 
                std::ifstream inputFile(assetPath.toStdString(), std::ios::binary);
                if (!inputFile)
                {
                    continue;
                }
 
                // memory block pre-allocated to size of file
                int64 assetFileSize = assetFile.getSize();
                std::unique_ptr<juce::MemoryBlock> outputDataBlock =
                        std::make_unique<juce::MemoryBlock>(assetFile.getSize());
 
                juce::MemoryOutputStream outputDataStream(*outputDataBlock, false);
 
                std::vector<unsigned char> buffer(BUFFER_SIZE);
                std::vector<unsigned char> plaintext(BUFFER_SIZE + EVP_MAX_BLOCK_LENGTH);
 
                std::vector<unsigned char> iv(IV_SIZE);
                inputFile.read(reinterpret_cast<char*>(iv.data()), IV_SIZE);
 
                // encrytion key
                std::string encKey("5128bd6c2bc42ed6835d9d24ee0e7200cc8aeae68e18e9f1ea3f6cd52cc082a8");
 
                // create hex for ecryption key
                getSampleMetadata(encKey, m_data);
 
                // Create cipher context
                EVP_CIPHER_CTX* ctx;
                if (!(ctx = EVP_CIPHER_CTX_new()))
                {
                    jassertfalse;
                }
 
                // Initialise AES 256 CBC cipher
                if (EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, m_data, iv.data()) != 1)
                {
                    jassertfalse;
                }
                auto* thread = Thread::getCurrentThread();
                // Decrypt data
                int len;
                int totalBytesProcessed = 0;
                while (inputFile.read(reinterpret_cast<char*>(buffer.data()), buffer.size()))
                {
                    auto bytesRead = inputFile.gcount();
 
                    if (thread && thread->threadShouldExit())
                    {
                        return false;
                    }
 
                    if (EVP_DecryptUpdate(ctx, plaintext.data(), &len, buffer.data(), static_cast<int>(bytesRead)) != 1)
                    {
                        jassertfalse;
                    }
 
                    outputDataStream.write(reinterpret_cast<char*>(plaintext.data()), len);
                    totalBytesProcessed += len;
                }
 
                // Handle remaining data
                auto remainingBytes = inputFile.gcount();
                if (remainingBytes > 0)
                {
                    if (EVP_DecryptUpdate(ctx, plaintext.data(), &len, buffer.data(),
                                          static_cast<int>(remainingBytes)) != 1)
                        jassertfalse;
 
                    outputDataStream.write(reinterpret_cast<char*>(plaintext.data()), len);
                }
                outputDataStream.flush();
                totalBytesProcessed += len;
                EVP_CIPHER_CTX_free(ctx);
 
                std::unique_ptr<MemoryInputStream> audioDataStream =
                        std::make_unique<MemoryInputStream>(*outputDataBlock, true);
 
                reader.reset(formatManager.createReaderFor(std::move(audioDataStream)));
 
                // TODO: create function for it ?
                if (reader)
                {
                    for (String key : reader->metadataValues.getAllKeys())
                    {
                        if (key == String(wavMetadataFieldInFile))
                        {
                            auto description = reader->metadataValues.getValue(key, "");
                            StringArray tokens;
                            tokens.addTokens(description, ",", StringRef(""));
                            for (auto token : tokens)
                            {
                                // tokens should not be empty or contain any of the terms below, or the file name of the
                                // preset which is included multiple times in wav metadata for several files
                                if (token.isEmpty() == false && token.containsOnly(ttpNumericalMetadata) == false &&
                                    token.containsIgnoreCase("krt") == false &&
                                    token.containsIgnoreCase("krotos") == false && token.startsWith("\\") == false &&
                                    token.containsAnyOf(m_presetName.toLowerCase()) == false)
                                {
                                    if (!excludeTerms.contains(token.toLowerCase()))
                                    {
                                        if (token.startsWith(" "))
                                        {
                                            token = token.fromFirstOccurrenceOf(" ", false, true);
                                        }
                                        m_presetTags.add(token);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
#endif
 
#if PRESET_FILENAME_TAGS
        // split preset name if necessary and push the tokens created into m_presetTags
        StringArray presetNameTokens;
        presetNameTokens.addTokens(m_presetFile.getFileNameWithoutExtension(), " _", StringRef(""));
        for (auto& presetNameToken : presetNameTokens)
        {
            if (presetNameToken.isEmpty() == false && presetNameToken.containsOnly(ttpNumericalMetadata) == false)
            {
                if (!excludeTerms.contains(presetNameToken.toLowerCase()))
                    m_presetTags.add(presetNameToken);
            }
        }
#endif
 
        // add preset name with its tags, and
        // append current preset and its tags to the preset tags value tree
        // eliminate duplicates (optional)
        presetTagsString = m_presetTags.joinIntoString(", ");
        if (eliminateDuplicates == true)
        {
            presetTagsString.clear();
            // Create a container for unique words
            StringArray uniqueTags;
 
            // Iterate through the tags and add unique ones to the container
            for (auto tag : m_presetTags)
            {
                tag = tag.toLowerCase();
                if (!uniqueTags.contains(tag))
                {
                    uniqueTags.add(tag);
                }
            }
 
            // Join the unique words to create a new string
            m_presetTags = uniqueTags;
            presetTagsString = uniqueTags.joinIntoString(", ");
        }
    }
 
    if (Thread::currentThreadShouldExit())
    {
        return false;
    }
 
    // load previously calculated embeddings if they are available
    std::vector<float> embeddings;
    if (m_presetData.count(m_presetName) > 0)
    {
        embeddings = m_presetData[m_presetName].embeddings;
    }
    else
    {
        embeddings = m_sentenceTransformer.encode(presetTagsString.toStdString());
    }
 
    // update map
    Data data(m_presetTags, embeddings);
    m_presetData[m_presetName] = data;
 
    // store embeddings in kNN after calculation
    m_presetNames.push_back(m_presetName);
    m_kNN.addDatasetItem(embeddings);
 
    return true;
}
 
void TextToPreset::getPresetAssetNames(ValueTree& root)
{
    searchForTagAndProperty(root, Identifier("CUSTOMPARAM"), Identifier("SamplePaths"));
}
 
void TextToPreset::searchForTagAndProperty(ValueTree& root, Identifier tag, Identifier property)
{
    int index = 0;
    ValueTree child;
    int numChildrean = root.getNumChildren();
 
    while ((child = root.getChild(index)).isValid())
    {
        if (child.hasType(tag))
        {
            if (child.getProperty(Identifier("id")).toString() == property.toString())
            {
                String samplePath = child.getPropertyAsValue(Identifier("value"), nullptr).toString();
                if (samplePath.isNotEmpty())
                {
                    // samplePath may contain more than one paths and we need to compensate for it
                    m_treatedAssetPaths.clear();
                    m_treatedAssetPaths.addTokens(samplePath, assetPathsDelimiter, StringRef(""));
                    for (auto& currentSamplePath : m_treatedAssetPaths)
                    {
                        auto convertPath = AssetManager::convertFilePath(currentSamplePath);
                        auto dynamicPath = convertPath.getFullPathName().fromFirstOccurrenceOf(AssetManager::getAssetDirectory().getFullPathName(), true, true);
                        auto resultingCurrentSamplePath =  File::addTrailingSeparator(AssetManager::readFactorySamplesPath()) + dynamicPath;
                        String sampleName = File(resultingCurrentSamplePath).getFileName();
                        m_samplePaths.add(resultingCurrentSamplePath);
                        m_sampleFilenames.add(sampleName);
                    }
                }
                return;
            }
            else
            {
                searchForTagAndProperty(child, tag, property);
            }
        }
        else
        {
            searchForTagAndProperty(child, tag, property);
        }
        index++;
    }
    return;
}
 
StringArray TextToPreset::combineSearch(const String& searchTerm, const StringArray& classicResults, const StringArray& ttpResults, std::map<String, std::vector<float>>& embeddingsCache, const size_t& maxResults)
{
    if (!m_modelFileAvailable)
    {
        return classicResults;
    }
 
    StringArray combinedResults;
    std::vector<std::pair<String, float>> scoredResults;
    std::vector<std::vector<float>> combinedEmbeddings;
    std::vector<String> combinedNames;
 
    // Reserve capacity for the maximum number of results
    scoredResults.reserve(maxResults);
    combinedEmbeddings.reserve(maxResults);
    combinedNames.reserve(maxResults);
 
    // Get the query embedding
    auto queryEmbedding = m_sentenceTransformer.encode(searchTerm.toStdString());
 
    // Lambda to get embeddings with caching
    auto getEmbedding = [&embeddingsCache, this](const String& result) -> std::vector<float> {
        if (embeddingsCache.find(result) == embeddingsCache.end())
        {
            embeddingsCache[result] = m_sentenceTransformer.encode(result.toStdString());
        }
        return embeddingsCache[result];
    };
 
    // Encode classic search results and add to combined lists
    for (const auto& result : classicResults)
    {
        if (combinedEmbeddings.size() >= maxResults) break;
        combinedEmbeddings.push_back(getEmbedding(result));
        combinedNames.push_back(result);
    }
 
    // Encode TTP results and add to combined lists
    for (const auto& result : ttpResults)
    {
        if (combinedEmbeddings.size() >= maxResults) break;
        combinedEmbeddings.push_back(getEmbedding(result));
        combinedNames.push_back(result);
    }
 
    // Compute similarity scores for combined results
    for (size_t i = 0; i < combinedNames.size(); ++i)
    {
        float similarity = computeSimilarity(queryEmbedding, combinedEmbeddings[i]);
        scoredResults.push_back({combinedNames[i], similarity});
    }
 
    // Partial sort to get the top maxResults
    std::partial_sort(scoredResults.begin(), scoredResults.begin() + std::min(scoredResults.size(), maxResults), scoredResults.end(), [](const auto& a, const auto& b) {
        return a.second > b.second;
    });
 
    // Collect sorted results
    for (size_t i = 0; i < std::min(scoredResults.size(), maxResults); ++i)
    {
        combinedResults.add(scoredResults[i].first);
    }
 
    return combinedResults;
}
 
float TextToPreset::computeSimilarity(const std::vector<float>& queryEmbedding, const std::vector<float>& resultEmbedding) const
{
    float dotProduct = std::inner_product(queryEmbedding.begin(), queryEmbedding.end(), resultEmbedding.begin(), 0.0f);
    float queryNorm = std::sqrt(std::inner_product(queryEmbedding.begin(), queryEmbedding.end(), queryEmbedding.begin(), 0.0f));
    float resultNorm = std::sqrt(std::inner_product(resultEmbedding.begin(), resultEmbedding.end(), resultEmbedding.begin(), 0.0f));
    
    // Prevent divide by zero
    float denominator = std::max(queryNorm * resultNorm, 1e-8f);
 
    return dotProduct / denominator;
}
 
StringArray TextToPreset::findClosestPresets(String searchTerm, int maxNumPresetsToFind) const
{
    StringArray closestPresets;
    if (!m_presetNames.empty())
    {
        ScopedLock sl(m_cs);
        auto queryEmbedding = m_sentenceTransformer.encode(searchTerm.toStdString());
 
        // embeddings are normalised so search uses cosine similarity
        auto indices = m_kNN.knnQuery(queryEmbedding, maxNumPresetsToFind);
        for (auto index : indices)
        {
            closestPresets.add(m_presetNames[index]);
        }
    }
    return closestPresets;
}
 
template <class T> String TextToPreset::stringify(std::vector<T> numbers)
{
    String stringWithNumbers;
    for (auto& number : numbers)
    {
        stringWithNumbers.append(String(number) + String(", "), 100);
    }
    return stringWithNumbers;
}
 
std::vector<float> TextToPreset::destringify(String stringWithNumbers)
{
    auto values = StringArray::fromTokens(stringWithNumbers, ",", "");
    std::vector<float> numbers;
    for (auto value : values)
    {
        if (value.containsNonWhitespaceChars())
        {
            numbers.push_back(value.getFloatValue());
        }
    }
    return numbers;
}
 
File TextToPreset::createFilePath(String filename)
{
    return utils::StringsIntoPath(AssetManager::getPluginDirectory().getFullPathName(), "ttpResources", filename);
}
 
bool TextToPreset::saveToFile(File file)
{
    DynamicObject* dataset = new DynamicObject();
    Array<var> rows;
 
    for (const auto& element : m_presetData)
    {
        const auto presetName = element.first;
        const auto tags = element.second.tags;
        const auto embeddings = element.second.embeddings;
 
        DynamicObject* metadata = new DynamicObject();
        metadata->setProperty(presetNameField, var(presetName));
 
        Array<var> tagsArray;
        for (auto value : tags)
            tagsArray.add(value);
        metadata->setProperty(tagsNameField, tagsArray);
 
        Array<var> embeddingsArray;
        for (auto value : embeddings)
            embeddingsArray.add(value);
        metadata->setProperty(embeddingsNameField, embeddingsArray);
 
        rows.add(metadata);
        metadata = nullptr;
    }
    dataset->setProperty("PresetsTagEmbeddings", rows);
 
    FileOutputStream stream(file);
    if (stream.openedOk())
    {
        // overwrite an existing file
        stream.setPosition(0);
        stream.truncate();
        JSON::writeToStream(stream, dataset);
        return true;
    }
 
    return false;
}
 
bool TextToPreset::readFromFile(File file)
{
    if (file.existsAsFile() == false)
    {
        return false;
    }
 
    clear();
 
    var parsedJson;
    const Result jsonParseResult = JSON::parse(file.loadFileAsString(), parsedJson);
 
    if (jsonParseResult.failed())
    {
        jassertfalse;
        return false;
    }
 
    var presetTagEmbeddings = parsedJson.getProperty(Identifier("PresetsTagEmbeddings"), 0);
 
    const auto resultSize = presetTagEmbeddings.size();
    for (int i = 0; i < resultSize; ++i)
    {
        auto presetName = presetTagEmbeddings[i].getProperty(Identifier(presetNameField), 0).toString();
        var tagsArray = presetTagEmbeddings[i].getProperty(Identifier(tagsNameField), 0);
        var embeddingsArray = presetTagEmbeddings[i].getProperty(Identifier(embeddingsNameField), 0);
 
        StringArray tags;
        for (int j = 0; j < tagsArray.size(); ++j)
            tags.add(tagsArray[j]);
 
        std::vector<float> embeddings;
        for (int j = 0; j < embeddingsArray.size(); ++j)
            embeddings.push_back(embeddingsArray[j]);
 
        m_kNN.addDatasetItem(embeddings);
 
        Data data(tags, embeddings);
 
        m_presetData.insert(std::make_pair(presetName, data));
        m_presetNames.push_back(presetName);
    }
 
    m_kNN.buildIndex();
 
    return true;
}
 
bool TextToPreset::appendDataToEmbeddingsFile(/*CriticalSection& cs*/)
{
    // clear kNN it will have its indices rebuild after all data is merged
    m_kNN.clear();
    // load existing embedings
    auto embeddingsFile = createFilePath(embeddingsFileName);
 
    std::map<String, Data> presetData;
    std::vector<String> presetNames;
 
    if (embeddingsFile.existsAsFile())
    {
        auto json = JSON::parse(embeddingsFile);
        var result = json.getProperty(Identifier("PresetsTagEmbeddings"), 0);
        for (int i = 0; i < result.size(); ++i)
        {
            auto presetName = result[i].getProperty(Identifier(presetNameField), 0).toString();
            var tagsArray = result[i].getProperty(Identifier(tagsNameField), 0);
            var embeddingsArray = result[i].getProperty(Identifier(embeddingsNameField), 0);
 
            StringArray tags;
            for (int j = 0; j < tagsArray.size(); ++j)
            {
                tags.add(tagsArray[j]);
            }
 
            std::vector<float> embeddings;
            for (int j = 0; j < embeddingsArray.size(); ++j)
            {
                embeddings.push_back(embeddingsArray[j]);
            }
 
            Data data(tags, embeddings);
            presetData[presetName] = data;
            presetNames.push_back(presetName);
        }
    }
    else
    {
        embeddingsFile.create();
    }
 
    // append new ones to the data
    for (const auto& element : m_presetData)
    {
        const auto presetName = element.first;
        const auto tags = element.second.tags;
        const auto embeddings = element.second.embeddings;
        Data data(tags, embeddings);
        presetData[presetName] = data;
        presetNames.push_back(presetName);
    }
 
    // write the new dict to the embeddings file
    DynamicObject* dataset = new DynamicObject();
    Array<var> rows;
 
    for (const auto& element : presetData)
    {
        const auto presetName = element.first;
        const auto tags = element.second.tags;
        const auto embeddings = element.second.embeddings;
 
        DynamicObject* metadata = new DynamicObject();
        metadata->setProperty(presetNameField, var(presetName));
 
        Array<var> tagsArray;
        for (auto value : tags)
            tagsArray.add(value);
        metadata->setProperty(tagsNameField, tagsArray);
 
        Array<var> embeddingsArray;
        for (auto value : embeddings)
            embeddingsArray.add(value);
        metadata->setProperty(embeddingsNameField, embeddingsArray);
 
        rows.add(metadata);
        metadata = nullptr;
    }
    dataset->setProperty("PresetsTagEmbeddings", rows);
 
    // need to have all data loaded and updated in order to perform search
    m_presetData = presetData;
    m_presetNames = presetNames;
 
    TemporaryFile tempEmbeddingsFile(embeddingsFile, TemporaryFile::useHiddenFile);
    if (auto stream = tempEmbeddingsFile.getFile().createOutputStream())
    {
        // overwrite an existing file
        stream->setPosition(0);
        stream->truncate();
        JSON::writeToStream(*stream, dataset);
        stream->flush();
 
        // close the output stream, so we can switch out the temp file.
        stream.reset();
 
        const bool success = tempEmbeddingsFile.overwriteTargetFileWithTemporary();
 
        if (!success)
        {
            // Failed to overwrite!
            jassertfalse;
            return false;
        }
    }
    else
    {
        return false;
    }
 
    readFromFile(embeddingsFile);
 
    return true;
}
 
void TextToPreset::loadEmbeddings()
{
    ScopedLock sl(m_cs);
    // load tags/embeddings if available
    auto presetTagEmbeddingsPath = createFilePath(embeddingsFileName);
    if (presetTagEmbeddingsPath.existsAsFile())
    {
        // clear previously stored data
        readFromFile(presetTagEmbeddingsPath);
 
        // signal to stop the calling thread if it is the Analysis Thread
        Thread* currentThread = getCurrentThread();
        if (currentThread != nullptr)
        {
            if (currentThread->getThreadName() == ttpThreadName)
            {
                signalThreadShouldExit();
            }
        }
    }
}
 
StringArray TextToPreset::performSearch(String query)
{
    if (m_modelFileAvailable == false)
    {
        return StringArray();
    }
 
    // get search term
    String searchTerm = query;
 
    StringArray presetRecommendations;
    bool search = !isThreadRunning();
    if (search)
    {
        // TODO: investigate what should be the maximum and if this exceeds the available presets number is a crash risk
        int maxNumResults = 10;
        presetRecommendations = findClosestPresets(searchTerm, maxNumResults);
    }
    return presetRecommendations;
}
 
DirectoryWatcher::DirectoryWatcher(const File& dirToWatch) : m_directory(dirToWatch)
{
    thread.addTimeSliceClient(this);
    thread.startThread();
}
 
DirectoryWatcher::~DirectoryWatcher()
{
    // Signal thread to exit first so removeTimeSliceClient can return asap.
    thread.signalThreadShouldExit();
    thread.notify();
 
    // Calling stopThread before removeTimeSliceClient can result in a deadlock if the timeout expires and the thread
    // is killed whilst it's still executing. This is because removeTimeSliceClient doesn't return until the thread
    // finishes whatever it's doing. If it's killed, the lock is never released and the call will never return.  By
    // signalling the thread to exit first, it should return at the next possible opportunity.
    thread.removeTimeSliceClient(this);
 
    bool threadExitedSafely = thread.stopThread(2000);
    if (!threadExitedSafely)
    {
        jassertfalse;
    }
}
 
bool DirectoryWatcher::handleContentUpdate()
{
    // scan and load all preset files to a file array
    getAllPresetFiles(m_directory, m_presetFilesArray);
 
    // load embeddings file and load all preset file names into a StringArray
    auto file = m_textToPresetSharedInstance.m_textToPreset->createFilePath(embeddingsFileName);
 
    if (file.existsAsFile())
    {
        auto json = JSON::parse(file);
        var result = json.getProperty(Identifier("PresetsTagEmbeddings"), 0);
        
        for (int i = 0; i < result.size(); ++i)
        {
            if (thread.threadShouldExit())
            {
                return false;
            }
 
            auto presetName = result[i].getProperty(Identifier(presetNameField), 0).toString();
            m_presetsWithEmbeddings.add(presetName);
        }
    }
 
    if (thread.threadShouldExit())
    {
        return false;
    }
 
    // for every preset file loaded, check if there is available embeddings
    // if not add it to an array that will be processed by TTP module
    for (File& file : m_presetFilesArray)
    {
        if (thread.threadShouldExit())
        {
            return false;
        }
 
        // file is new and has no embeddings, so ..
        String filenameToCheck = file.getFileName();
        
        if (m_presetsWithEmbeddings.contains(filenameToCheck) == false && file.getFileExtension() == ".ksp")
        {
            m_presetFilesToProcess.add(file);
        }
    }
 
    if (thread.threadShouldExit())
    {
        return false;
    }
 
    // calculate embeddings for new presets
    const auto fileProcessingSuccessful = m_textToPresetSharedInstance.m_textToPreset->processFileList(m_presetFilesToProcess);
    
    return fileProcessingSuccessful;
}
 
void DirectoryWatcher::getAllPresetFiles(const File& directory, Array<File>& fileArray)
{
    DirectoryIterator iter(directory, true, "*", File::findFilesAndDirectories);
    while (iter.next())
    {
        auto file = iter.getFile();
        if (file.isDirectory())
        {
            getAllPresetFiles(file, fileArray);
        }
        else
        {
            fileArray.add(file);
        }
    }
}
 
int DirectoryWatcher::useTimeSlice()
{
    String dirModificationDate = m_directory.getLastModificationTime().toString(true, true);
    String lastRecordedModificationDate;
 
    File textEmbeddingsStatusFile = m_textToPresetSharedInstance.m_textToPreset->createFilePath(ttpStatusFileName);
    
    File ggmlDataFile = File(utils::StringsIntoPath(AssetManager::getPluginDirectory().getFullPathName(),
                                                            "ttpResources", modelFileName));
 
    if (ggmlDataFile.existsAsFile() == false || thread.threadShouldExit())
    {
        return 5000;
    }
 
    // trigger ttp update if there is no status file
    if (textEmbeddingsStatusFile.exists() == false)
    {
        textEmbeddingsStatusFile.create();
 
        m_dirModificationDate = dirModificationDate;
        bool success = handleContentUpdate();
 
        if (success)
        {
            DynamicObject* ttpStatus = new DynamicObject();
            var ttpStatusObj(ttpStatus);
            ttpStatus->setProperty(ttpStatusDateProperty, var(m_dirModificationDate));
            FileOutputStream stream(textEmbeddingsStatusFile);
            if (stream.openedOk())
            {
                stream.setPosition(0);
                stream.truncate();
                JSON::writeToStream(stream, ttpStatus);
            }
        }
        else
        {
            DBG("TTP embeddings update aborted");
            textEmbeddingsStatusFile.deleteFile();
        }
    }
    else
    {
        // parse ttp status file
        auto ttpStatusJSON = JSON::parse(textEmbeddingsStatusFile);
 
        // get date modified
        m_dirModificationDate = ttpStatusJSON.getProperty(Identifier(ttpStatusDateProperty), String()).toString();
 
        // get embeddings file
        File embeddingsFile = m_textToPresetSharedInstance.m_textToPreset->createFilePath(embeddingsFileName);
 
        // if it differs or if embeddings file does not exist (deleted probably) trigger ttp update
        if ((dirModificationDate != m_dirModificationDate || embeddingsFile.exists() == false) &&
            !thread.threadShouldExit())
        {
 
            m_dirModificationDate = dirModificationDate;
            bool success = handleContentUpdate();
            if (success)
            {
                DynamicObject* ttpStatus = new DynamicObject();
                ttpStatus->setProperty(ttpStatusDateProperty, var(m_dirModificationDate));
                FileOutputStream stream(textEmbeddingsStatusFile);
                if (stream.openedOk())
                {
                    stream.setPosition(0);
                    stream.truncate();
                    JSON::writeToStream(stream, ttpStatus);
                }
            }
        }
    }
    return 5000;
}
} // namespace krotos