LotroDat/src/DatSubsystems/DatLocaleManager.cpp

#include <DatSubsystems/DatLocaleManager.h>
#include <EasyLogging++/easylogging++.h>
#include <DatFile.h>
#include <SubFile.h>

#define DAT_LOCALE_DICT_VERSION 103

namespace LOTRO_DAT {
    DatLocaleManager::DatLocaleManager(DatFile *datFilePtr) : dat(datFilePtr), current_locale_(ORIGINAL) {
    }

    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Инициализация модуля. Должна происходить после инициализации модуля ввода-вывода и файловой системы.
     * Считывает словарь и проверяет корректность (если структура словаря нарушена и основной является локаль PATHCED,
     * то dat файл считается некорреткным (любое обновлене dat файла с активной локалью PATCHED нарушает структуру файла
     * и делает использование в игре невозможным.
     *
     * \warning Не должна вызываться вручную! Автоматически вызывается в функции Initialise класса DatFile
     *
     * Структура словарей локализации:
     * ======== LOCALE DICT STRUCTURE =========
     * 4                                bytes for dict size (in bytes)
     * 4                                bytes for locale version
     * 4                                bytes for .dat file size (with patches)
     * 4                                bytes for header hash
     * 15                               bytes for "Hi from Gi1dor"
     * 4                                bytes for LOCALE mark ("PATC" or "ORIG")
     * 4                                bytes for orig_dict.size()
     * (32 + 4) * orig_dict.size()      bytes for orig_dict data
     * 4                                bytes for patch_dict.size()
     * (32 + 4) * patch_dict.size()     bytes for patch_dict data
     * 4                                bytes for inactive_categories dict
     * 4 * inactive_categories.size()   bytes for inactive_categories data
     * ========================================
     * Помимо этого:
     * 0x128-0x12C - 0, если .dat файл не был изменен библиотекой, обновление клиентом игры не испортит .dat file
     *               1, если активна локаль ORIGINAL, обновление клиентом игры не испортит .dat file
     *               2, если активна локаль PATCHED, обновление клиентом игры может испортить .dat file
     *
     * 0x12C-0x130 - Офсет начала словаря локализации (offset)
     *
     * \warning Если flag != 0 и offset == 0 - то dat файл считается повреждённым. Проверка осуществляется функцией CheckLocaleCorrect
     */

    DatOperationResult<> DatLocaleManager::Init() {
        if (!dat)
            return DatOperationResult<>(ERROR, "LOCALEINIT: no connection with Dat (dat is nullptr)");

        ClearData();

        LOG(INFO) << "Initialising locales...";
        
        if (!CheckLocaleCorrect()) {
            return DatOperationResult<>(ERROR, "LOCALEINIT: Check locale correct failed!");
        }

        BinaryData locale_dict_offset_data(4);
        dat->GetIO().ReadData(locale_dict_offset_data, 4, 0x12C);
        dict_offset_ = locale_dict_offset_data.ToNumber<4>(0);

        BinaryData locale_info(16);
        auto operation = dat->GetIO().ReadData(locale_info, 16, dict_offset_);
        if (!operation.result) {
            ClearData();
            LOG(INFO) << "LOCALEINIT: Locale offset is incorrect, skipping initialization.";
            return DatOperationResult<>(SUCCESS);
        }

        dict_size_ = locale_info.ToNumber<4>(0);
        unsigned dict_version = locale_info.ToNumber<4>(4);
        unsigned patched_file_end = locale_info.ToNumber<4>(8);
        unsigned dat_file_header_hash = locale_info.ToNumber<4>(12);

        if (dict_version != DAT_LOCALE_DICT_VERSION) {
            ClearData();
            LOG(WARNING) << "LOCALEINIT: Locale dictionary version is outdated, skipping initialization.";
            return DatOperationResult<>(SUCCESS);
        }

        if (dat_file_header_hash != dat->GetIO().GetHeaderHash()) {
            ClearData();
            LOG(WARNING) << "LOCALEINIT: Locale header hash does not match real dat file header hash, skipping initialization.";
            return DatOperationResult<>(SUCCESS);
        }

        BinaryData dicts_data = BinaryData((unsigned)dict_size_);
        dat->GetIO().ReadData(dicts_data, dict_size_ - 16, dict_offset_ + 16);

        BinaryData hi_data = dicts_data.CutData(0, 15) + BinaryData("\0", 1);
        std::string hi = std::string((char *) (hi_data.data()));
        if (hi != "Hi from Gi1dor!") {
            ClearData();
            LOG(WARNING) << "LOCALEINIT: couldn't receive Hello, skipping initialization.";
            return DatOperationResult<>(SUCCESS);
        }

        int offset = 15;
        BinaryData current_locale_data = dicts_data.CutData(offset, offset + 4) + BinaryData("\0", 1);
        std::string locale((char *) (current_locale_data.data()));
        if (locale != "PATC" && locale != "ORIG") {
            ClearData();
            LOG(WARNING) << "LOCALEINIT: locale status in dict seems incorrect, skipping initialization.";
            return DatOperationResult<>(SUCCESS);
        }

        current_locale_ = (locale == "PATC" ? PATCHED : ORIGINAL);
        offset += 4;
        
        size_t orig_dict_size = size_t(dicts_data.CutData(offset, offset + 4).ToNumber<4>(0));
        offset += 4;

        for (size_t i = 0; i < orig_dict_size; i++) {
            auto file = SubFile(*dat, dicts_data.CutData(offset, offset + 32));
            file.category = dicts_data.ToNumber<4>(offset + 32);
            orig_dict_[file.file_id()] = file;
            offset += 36;
        }

        size_t patch_dict_size = size_t(dicts_data.CutData(offset, offset + 4).ToNumber<4>(0));
        offset += 4;
        for (size_t i = 0; i < patch_dict_size; i++) {
            auto file = SubFile(*dat, dicts_data.CutData(offset, offset + 32));
            file.category = dicts_data.ToNumber<4>(offset + 32);
            patch_dict_[file.file_id()] = file;
            offset += 36;
        }

        size_t inactive_categories_set_size = size_t(dicts_data.ToNumber<4>(offset));
        offset += 4;
        for (size_t i = 0; i < inactive_categories_set_size; i++) {
            size_t category_id = size_t(dicts_data.ToNumber<4>(offset));
            inactive_categories.insert(category_id);
            offset += 4;
        }

        LOG(INFO) << "There are " << patch_dict_.size() << " files in patch locale dictionary";
        LOG(INFO) << "There are " << orig_dict_.size() << " files in original locale dictionary";
        LOG(INFO) << "There are " << inactive_categories.size() << " categories inactive: ";
        LOG(INFO) << "Successfully finished initialising locales!";

        dat->GetFileSystem().patched_file_end = patched_file_end;
        LOG(INFO) << "Locales initialisation success. Dictionary size is " << dict_size_ << ". Version is "
                  << dict_version << ". Localed .dat size = " << patched_file_end;
        return DatOperationResult<>(SUCCESS);
    }

    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Смена активной локали. Меняет информацию о файлах в файловой системе на соответствующую информацию в локали.
     * \param[in] locale Устанавливаемая локаль
     * \warning Изменения в файловую систему вносятся локально! В dat файл изменения будут записаны во время деинициализации модуля файловой системы
     */

    DatOperationResult<> DatLocaleManager::SetLocale(DatLocaleManager::LOCALE locale) {
        if (dat->GetStatusModule().GetStatus() == DatStatus::E_FREE) {
            dat->GetStatusModule().SetStatus(DatStatus::E_COMMITING);
        }

        dat->GetStatusModule().SetDebugMessage("Changing locale to " +
                                               (locale == PATCHED ? std::string(" patched version")
                                                                  : std::string(" original version")));

        LOG(INFO) << "Setting locale to " << (locale == PATCHED ? " PATCHED" : " ORIGINAL");

        if (current_locale_ == locale) {
            LOG(INFO) << "Locale is already " << locale << ", nothing to do.";

            if (dat->GetStatusModule().GetStatus() == DatStatus::E_COMMITING)
                dat->GetStatusModule().SetDefaultStatus();

            return DatOperationResult<>(SUCCESS);
        }

        std::map<long long, SubFile> &dict = GetLocaleDictReference(locale);

        size_t files_total = dict.size();
        size_t files_proceeded = 0;
        dat->GetStatusModule().SetTotalParts(files_total);

        for (const auto &file : dict) {
            ++files_proceeded;
            dat->GetStatusModule().SetFinishedParts(files_proceeded);

            if (CategoryIsInactive(file.second.category) && locale == PATCHED)
                continue;

            long long file_id = file.first;

            auto dict_file_result = dat->GetFileSystem().GetFile(file_id);
            if (dict_file_result.result != SUCCESS) {
                LOG(WARNING) << "Unable to get file with id = " << file_id << "from datFileSystem!";
                dict.erase(file_id);
                continue;
            }

            std::shared_ptr<SubFile> dict_file = dict_file_result.value;

            if (dict_file->MakeHeaderData().CutData(8, 16) == file.second.MakeHeaderData().CutData(8, 16))
                continue;

            dat->GetFileSystem().UpdateFileInfo(file.second);
        }
        current_locale_ = locale;

        if (dat->GetStatusModule().GetStatus() == DatStatus::E_COMMITING)
            dat->GetStatusModule().SetDefaultStatus();

        return DatOperationResult<>(SUCCESS);
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Получение текущей активной локали. Если локали не существуют, понимается, что используется оригинальная (ORIGINAL)
     */

    DatLocaleManager::LOCALE DatLocaleManager::GetCurrentLocale() {
        return current_locale_;
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Деинициализация модуля. Должна происходить перед деинициализацией модулей ввода-вывода и файловой системы.
     */

    DatOperationResult<> DatLocaleManager::DeInit() {
        LOG(INFO) << "Committing locales...";
        auto result = CommitLocales();
        ClearData();
        return result;
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Обновление данных файла в локали
     * \param[in] locale Локаль, для которой файл данных будет обновлён
     * \param[in] file Новые данные файла. Старые данные будут перезаписаны
     */

    void DatLocaleManager::UpdateLocaleFile(DatLocaleManager::LOCALE locale, const SubFile &file) {
        std::map<long long, SubFile> &dict = GetLocaleDictReference(locale);
        dict[file.file_id()] = file;
    }

    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Получение данных файла в локали. Вернёт DatOperationResult.result = ERROR, если файла с таким id не существует.
     * \param[in] file_id id файла, для которого необходимо получить данных
     * \param[in] locale Локаль, данные которой будут получены
     */

    DatOperationResult<SubFile> DatLocaleManager::GetLocaleFile(long long file_id, DatLocaleManager::LOCALE locale) {
        std::map<long long, SubFile> &dict = GetLocaleDictReference(locale);
        if (dict.count(file_id) == 0)
            return DatOperationResult<SubFile>(SubFile(), ERROR,
                                               "GETLOCFILE: cannot get file with id = " + std::to_string(file_id) +
                                               " from dict " + std::to_string(locale));
        return DatOperationResult<SubFile>(dict[file_id], SUCCESS);
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Получение словаря файлов локали
     * \param[in] locale Локаль, данные которой будут получены
     */

    std::map<long long, SubFile> &DatLocaleManager::GetLocaleDictReference(DatLocaleManager::LOCALE locale) {
        return locale == PATCHED ? patch_dict_ : orig_dict_;
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * Выводит информацию о состоянии модуля в файл
     * \param[in] file указатель на объект файла, в конец которого будет напечатана информация
     * \warning Файл file должен быть открыт для записи. После завершения работы функции файл остаётся открытым
     */

    void DatLocaleManager::PrintInformaion(FILE *file) {
        fprintf(file, "========= Locales info ========\n");
        BinaryData locale_offset_data(4);
        dat->GetIO().ReadData(locale_offset_data, 4, 300);
        long long locale_offset = locale_offset_data.ToNumber<4>(0);

        fprintf(file, "Locales' dictionary offset = %lld\n", locale_offset);

        BinaryData locale_status_data(4);
        dat->GetIO().ReadData(locale_status_data, 4, 296);
        long long locale_status = locale_offset_data.ToNumber<4>(0);

        fprintf(file, "Locale status = %lld\n", locale_status);

        if (locale_offset != 0) {
            BinaryData locale_info(16);
            dat->GetIO().ReadData(locale_info, 16, locale_offset);

            long long dict_size = locale_info.ToNumber<4>(0);
            long long dict_version = locale_info.ToNumber<4>(4);

            fprintf(file, "Locales' dictionary size = %lld, version = %lld\n", dict_size, dict_version);
        }

        fprintf(file, "Current locale id = %d\n", current_locale_);
        fprintf(file, "Patch dictionary size = %d\n", patch_dict_.size());
        fprintf(file, "Original dictionary size = %d\n", orig_dict_.size());
    }


    /*!
     * \Author Gi1dor
     * \date 06.07.2018
     * TODO: update descr
     * 
     * Осуществляет проверку корректности dat файла с позиции локалей
     * Файл считается некорректным, если активной является альтернативная локаль, причём нет возможности вернуть оригинальную (блок локалей неверный/повреждён)
     * Байты 0x128-0x12C равны 0, если на момент пользования патчером активна оригинальная локаль, и DatIO::file_size, если нет
     * Отличие значения в 0x128 от 0 и значения в 0x148 => файл ресурсов мог быть повреждён
     */

    bool DatLocaleManager::CheckLocaleCorrect() {
        BinaryData patch_mark_data(4);
        dat->GetIO().ReadData(patch_mark_data, 4, 0x128);
        uint32_t patch_mark = patch_mark_data.ToNumber<4>(0);

        BinaryData locale_offset_data(4);
        dat->GetIO().ReadData(locale_offset_data, 4, 300);
        long long locale_offset = locale_offset_data.ToNumber<4>(0);

        LOG(INFO) << "CHCKLOCALECORRECT: patch mark = " << patch_mark << ", locale_offset =  " << locale_offset;

        if (patch_mark == 0 && locale_offset == 0) {
            LOG(INFO) << "CHCKLOCALECORRECT: No file patch info found, check successfull!";
            return true;
        }

        if (patch_mark == 0 && locale_offset != 0) {
            LOG(ERROR) << "CHCKLOCALECORRECT: Locale dict exists, but patch mark is incorrect!";
            return false;
        }

        if (patch_mark != 0 && locale_offset == 0) {
            LOG(ERROR) << "CHCKLOCALECORRECT: Locale offset is null, but patch mark exists!";
            return false;
        }

        if (patch_mark == 1) {
            LOG(INFO) << "CHCKLOCALECORRECT: Header is fine, patch mark is original, so skipping dat locale dict correctness check";
            return true;
        }

        if (patch_mark != 2) {
            LOG(INFO) << "CHCKLOCALECORRECT: Patch mark is invalid! Found " << patch_mark << ", expected: 0, 1 or 2!";
            return false;
        }

        // for this moment patch_mark is 2, file should be patched and current locale should be PATCHED

        BinaryData locale_dict_header(16 + 15 + 4);
        auto operation = dat->GetIO().ReadData(locale_dict_header, 16 + 15 + 4, locale_offset);

        if (!operation.result) {
            LOG(ERROR) << "CHCKLOCALECORRECT: incorrect locale offset (cannot read data at offset" << locale_offset << ")";
            return false;
        }

        long long dict_version = locale_dict_header.ToNumber<4>(4);
        long long dat_header_hashsum = locale_dict_header.ToNumber<4>(12);
        BinaryData hi_data = locale_dict_header.CutData(16, 16 + 15) + BinaryData("\0", 1);
        std::string hi_string = std::string((char *) (hi_data.data()));

        BinaryData current_locale_data = locale_dict_header.CutData(16 + 15, 16 + 15 + 4) + BinaryData("\0", 1);
        std::string locale_string = std::string((char *) (current_locale_data.data()));

        if (dict_version != DAT_LOCALE_DICT_VERSION) {
            LOG(ERROR) << "CHCKLOCALECORRECT: Locale dict version is incorrect, through patch mark shows, that file was patched. Found version:" << dict_version << " expected: " << DAT_LOCALE_DICT_VERSION;
            return false;
        }

        if (locale_string != "PATC") {
            LOG(ERROR) << "CHCKLOCALECORRECT: Data in locales' dictionary is incorrect (dictionary locale mark is invalid). Found: " << locale_string << " expected: PATC";
            return false;
        }

        if (hi_string != "Hi from Gi1dor!") {
            LOG(ERROR) << "CHCKLOCALECORRECT: Data in locales' dictionary is incorrect (couldn't receive 'Hello').";
            return false;
        }

        if (dat_header_hashsum != dat->GetIO().GetHeaderHash()) {
            LOG(ERROR) << "CHCKLOCALECORRECT: Dat header checksum from header does not match dat header checksum from locale dictionary!";
            return false;
        }

        LOG(INFO) << "CHCKLOCALECORRECT: All checks passed successfully, no errors found!";
        return true;
    }


    /*!
     * \Author Gi1dor
     * \date 11.07.2018
     * Проверка активности категории
     * \returns true, если категория активна и false - если нет
     */

    bool DatLocaleManager::CategoryIsInactive(long long category) {
        return inactive_categories.count(category) > 0;
    }


    /*!
    * \Author Gi1dor
    * \date 11.07.2018
    * Обновляет категорию у файлов в словарях локалей
    */

    void DatLocaleManager::UpdateCategory(long long file_id, long long category) {
        if (orig_dict_.count(file_id))
            orig_dict_[file_id].category = category;
        if (patch_dict_.count(file_id))
            patch_dict_[file_id].category = category;
    }

    /*!
    * \Author Gi1dor
    * \date 21.10.2018
    * Возвращает словарь, состоящий из id категорий, помеченных как неактивные
    */

    const std::set<long long> &DatLocaleManager::GetInactiveCategories() {
        return inactive_categories;
    }

    /*!
     * \Author Gi1dor
     * \date 21.10.2018
     * Записывает словарь. Если ранее словарь не существовал - новый будет записан в конец файла.
     * Для словаря выделяется блок не менее 20мб
     *
     * \warning Не должна вызываться вручную! Автоматически вызывается в функции Deinitialise класса DatFile
     *
     * Структура словарей локализации:
     * ======== LOCALE DICT STRUCTURE =========
     * 4                                bytes for dict size (in bytes)
     * 4                                bytes for locale version
     * 4                                bytes for .dat file size (with patches)
     * 4                                bytes for dat file header hash
     * 15                               bytes for "Hi from Gi1dor"
     * 4                                bytes for LOCALE
     * 4                                bytes for orig_dict.size()
     * (32 + 4) * orig_dict.size()      bytes for orig_dict data
     * 4                                bytes for patch_dict.size()
     * (32 + 4) * patch_dict.size()     bytes for patch_dict data
     * 4                                bytes for inactive_categories dict
     * 4 * inactive_categories.size()   bytes for inactive_categories data
     * ========================================
     * Помимо этого:
     * 0x128-0x12C - 0, если .dat файл не был изменен библиотекой, обновление клиентом игры не испортит .dat file
     *               1, если активна локаль ORIGINAL, обновление клиентом игры не испортит .dat file
     *               2, если активна локаль PATCHED, обновление клиентом игры может испортить .dat file
     *
     * 0x12C-0x130 - Офсет начала словаря локализации
     */

    DatOperationResult<> DatLocaleManager::CommitLocales() {
        if (!dat->Initialized())
            return DatOperationResult<>(SUCCESS);

        if (patch_dict_.empty()) {
            return DatOperationResult<>(SUCCESS);
        }

        dat->GetStatusModule().SetStatus(DatStatus::E_COMMITING);
        dat->GetStatusModule().SetTotalParts(orig_dict_.size() + patch_dict_.size());
        dat->GetStatusModule().SetFinishedParts(0);

        BinaryData binary_data = BinaryData(4 + 4 + 4 + 4 + 14 + 15 + 4
                                            + 4 + (32 + 4) * orig_dict_.size()
                                            + 4 + (32 + 4) * patch_dict_.size()
                                            + 4 + 4 * inactive_categories.size());

        // First 16 bytes will be filled just before writing data to file
        size_t current_size = 16;

        binary_data.Append(BinaryData("Hi from Gi1dor!", 15), current_size);
        current_size += 15;

        binary_data.Append(BinaryData((current_locale_ == ORIGINAL ? "ORIG" : "PATC"), 4), current_size);
        current_size += 4;

        binary_data.Append(BinaryData::FromNumber<4>(orig_dict_.size()), current_size);
        current_size += 4;

        unsigned long long processed_files = 0;

        for (const auto &file : orig_dict_) {
            binary_data.Append(file.second.MakeHeaderData(), current_size);
            current_size += 32;
            binary_data.Append(BinaryData::FromNumber<4>(file.second.category), current_size);
            current_size += 4;
            dat->GetStatusModule().SetFinishedParts(++processed_files);
        }

        binary_data.Append(BinaryData::FromNumber<4>(patch_dict_.size()), current_size);
        current_size += 4;

        for (const auto &file : patch_dict_) {
            binary_data.Append(file.second.MakeHeaderData(), current_size);
            current_size += 32;
            binary_data.Append(BinaryData::FromNumber<4>(file.second.category), current_size);
            current_size += 4;
            dat->GetStatusModule().SetFinishedParts(++processed_files);
        }

        binary_data.Append(BinaryData::FromNumber<4>(inactive_categories.size()), current_size);
        current_size += 4;
        for (auto patch_id : inactive_categories) {
            binary_data.Append(BinaryData::FromNumber<4>(patch_id), current_size);
            current_size += 4;
        }

        // Updating dict offset, if current does not match prerequisites
        if (binary_data.size() > dict_size_ || dict_offset_ == 0) {
            dict_offset_ = dat->GetFileSystem().patched_file_end;
            dict_size_ = std::max(binary_data.size() + 4, 20u * 1024u * 1024u);

            BinaryData nulls(dict_size_);
            dat->GetIO().WriteData(nulls, nulls.size(), dat->GetFileSystem().patched_file_end);
            dat->GetFileSystem().patched_file_end += nulls.size();
            
            dat->GetIO().WriteData(BinaryData::FromNumber<4>(dict_offset_), 4, 0x12C);
        }

        // Updating first 16 bytes
        binary_data.Append(BinaryData::FromNumber<4>(dict_size_), 0);
        binary_data.Append(BinaryData::FromNumber<4>(DAT_LOCALE_DICT_VERSION), 4);
        binary_data.Append(BinaryData::FromNumber<4>(dat->GetFileSystem().patched_file_end), 8);
        binary_data.Append(BinaryData::FromNumber<4>(dat->GetIO().GetHeaderHash()), 12);
        auto operation = dat->GetIO().WriteData(binary_data, binary_data.size(), dict_offset_);

        if (current_locale_ == ORIGINAL) {
            dat->GetIO().WriteData(BinaryData::FromNumber<4>(1), 4, 296);
        } else {
            dat->GetIO().WriteData(BinaryData::FromNumber<4>(2), 4, 296);
        }

        dat->GetStatusModule().SetDefaultStatus();
        LOG(INFO) << "Locales committed successfully";
        return DatOperationResult<>(SUCCESS);
    }

    void DatLocaleManager::ClearData() {
        dict_size_ = 0;
        dict_offset_ = 0;
        orig_dict_.clear();
        patch_dict_.clear();
        inactive_categories.clear();
        current_locale_ = ORIGINAL;
    }

    DatOperationResult<> DatLocaleManager::EnableCategory(long long category) {
        inactive_categories.erase(category);
        dat->GetStatusModule().SetStatus(DatStatus::E_COMMITING);
        
        size_t files_count = patch_dict_.size();
        size_t files_processed = 0;
        dat->GetStatusModule().SetTotalParts(files_count);

        for (const auto& entry : patch_dict_) {
            SubFile file = entry.second;
            ++files_processed;
            dat->GetStatusModule().SetFinishedParts(files_processed);

            if (file.category == category) {
                dat->GetFileSystem().UpdateFileInfo(file);
            }
        }

        dat->GetStatusModule().SetDefaultStatus();
        return DatOperationResult<>(SUCCESS);
    }

    DatOperationResult<> DatLocaleManager::DisableCategory(long long category) {
        inactive_categories.insert(category);
        dat->GetStatusModule().SetStatus(DatStatus::E_COMMITING);
        dat->GetStatusModule().SetFinishedParts(0);

        size_t files_count = orig_dict_.size();
        size_t files_processed = 0;
        dat->GetStatusModule().SetTotalParts(files_count);

        for (const auto& entry : orig_dict_) {
            SubFile file = entry.second;
            ++files_processed;
            dat->GetStatusModule().SetFinishedParts(files_processed);

            if (file.category == category) {
                dat->GetFileSystem().UpdateFileInfo(file);
            }
        }

        dat->GetStatusModule().SetDefaultStatus();
        return DatOperationResult<>(SUCCESS);
    }
}