DialogBaker.cpp

#include "DialogBaker.h"
#include "AngelScriptScripting.h"
#include "Dialogs.h"
#include "ScriptSystem.h"
#include "TextPack.h"

FO_USING_NAMESPACE();

class CritterTag
{
};

template<typename TRet, typename... Args>
static auto HasDialogScriptAttribute(ScriptSystem& engine, hstring func_name, string_view attribute) -> bool
{
    auto func = engine.FindFunc<TRet, Args...>(func_name);
    return func && func.HasAttribute(attribute);
}

DialogBaker::DialogBaker(shared_ptr<BakingContext> ctx) :
    BaseBaker(std::move(ctx))
{
    FO_STACK_TRACE_ENTRY();
}

void DialogBaker::BakeFiles(const FileCollection& files, string_view target_path) const
{
    FO_STACK_TRACE_ENTRY();

    // Collect dialog files
    vector<File> filtered_files;

    if (target_path.empty()) {
        for (const auto& file_header : files) {
            if (strex(file_header.GetPath()).get_file_extension() != "fodlg") {
                continue;
            }
            if (_context->BakeChecker && !_context->BakeChecker(file_header.GetPath(), file_header.GetWriteTime())) {
                continue;
            }

            filtered_files.emplace_back(File::Load(file_header));
        }
    }
    else {
        if (strex(target_path).get_file_extension() != "fodlg") {
            return;
        }

        auto file = files.FindFileByPath(target_path);

        if (!file) {
            return;
        }
        if (_context->BakeChecker && !_context->BakeChecker(target_path, file.GetWriteTime())) {
            return;
        }

        filtered_files.emplace_back(std::move(file));
    }

    if (filtered_files.empty()) {
        return;
    }

    // Load dialogs
    auto server_engine = BakerServerEngine(*_context->BakedFiles);
    server_engine.MapEngineType<CritterTag>(server_engine.GetBaseType("Critter"));
    server_engine.MapScriptTypes(&server_engine);
#if FO_ANGELSCRIPT_SCRIPTING
    InitAngelScriptScripting(&server_engine, *_context->Settings, *_context->BakedFiles);
#endif
    const auto dialog_mngr = DialogManager(server_engine);

    size_t errors = 0;
    vector<refcount_ptr<DialogPack>> dialog_packs;

    for (const auto& file : filtered_files) {
        try {
            auto pack = dialog_mngr.ParseDialog(file.GetNameNoExt(), file.GetStr());
            dialog_packs.emplace_back(std::move(pack));
        }
        catch (const DialogParseException& ex) {
            WriteLog("Dialog baking error: {}", ex.what());
            errors++;
        }
    }

    // Verify
    for (const auto& dlg_pack : dialog_packs) {
        for (const auto& speech : dlg_pack->Speeches) {
            if (speech->DlgScriptFuncName) {
                if (!server_engine.CheckFunc<void, CritterTag*, CritterTag*, string&>(speech->DlgScriptFuncName) && //
                    !server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, string&>(speech->DlgScriptFuncName)) {
                    WriteLog("Dialog {} invalid start function {}", dlg_pack->PackId, speech->DlgScriptFuncName);
                    errors++;
                }
            }

            for (const auto& answer : speech->Answers) {
                for (const auto& demand : answer->Demands) {
                    if (demand->Type == DR_SCRIPT) {
                        const bool has_valid_demand = (demand->ValuesCount == 0 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*>(server_engine, demand->AnswerScriptFuncName, "DialogDemand")) || //
                            (demand->ValuesCount == 1 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*, any_t>(server_engine, demand->AnswerScriptFuncName, "DialogDemand")) || //
                            (demand->ValuesCount == 2 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*, any_t, any_t>(server_engine, demand->AnswerScriptFuncName, "DialogDemand")) || //
                            (demand->ValuesCount == 3 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*, any_t, any_t, any_t>(server_engine, demand->AnswerScriptFuncName, "DialogDemand")) || //
                            (demand->ValuesCount == 4 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t>(server_engine, demand->AnswerScriptFuncName, "DialogDemand")) || //
                            (demand->ValuesCount == 5 && HasDialogScriptAttribute<bool, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t, any_t>(server_engine, demand->AnswerScriptFuncName, "DialogDemand"));

                        if (!has_valid_demand) {
                            WriteLog("Dialog {} answer demand invalid function {} (expected [[DialogDemand]])", dlg_pack->PackId, demand->AnswerScriptFuncName);
                            errors++;
                        }
                    }
                }

                for (const auto& result : answer->Results) {
                    if (result->Type == DR_SCRIPT) {
                        const bool found_void_result = (result->ValuesCount == 0 && server_engine.CheckFunc<void, CritterTag*, CritterTag*>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 1 && server_engine.CheckFunc<void, CritterTag*, CritterTag*, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 2 && server_engine.CheckFunc<void, CritterTag*, CritterTag*, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 3 && server_engine.CheckFunc<void, CritterTag*, CritterTag*, any_t, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 4 && server_engine.CheckFunc<void, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 5 && server_engine.CheckFunc<void, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t, any_t>(result->AnswerScriptFuncName));

                        const bool found_int_result = (result->ValuesCount == 0 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 1 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 2 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 3 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 4 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t>(result->AnswerScriptFuncName)) || //
                            (result->ValuesCount == 5 && server_engine.CheckFunc<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t, any_t>(result->AnswerScriptFuncName));

                        const bool valid_void_result = (result->ValuesCount == 0 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 1 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 2 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 3 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 4 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 5 && HasDialogScriptAttribute<void, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult"));

                        const bool valid_int_result = (result->ValuesCount == 0 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 1 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 2 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 3 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 4 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult")) || //
                            (result->ValuesCount == 5 && HasDialogScriptAttribute<int32_t, CritterTag*, CritterTag*, any_t, any_t, any_t, any_t, any_t>(server_engine, result->AnswerScriptFuncName, "DialogResult"));

                        const int32_t found_count = (found_void_result ? 1 : 0) + (found_int_result ? 1 : 0);
                        const int32_t valid_count = (valid_void_result ? 1 : 0) + (valid_int_result ? 1 : 0);

                        if (found_count != 1 || valid_count != 1) {
                            WriteLog("Dialog {} answer result invalid function {} (expected exactly one [[DialogResult]] overload)", dlg_pack->PackId, result->AnswerScriptFuncName);
                            errors++;
                        }
                    }
                }
            }
        }
    }

    if (errors != 0) {
        throw DialogBakerException("Errors during dialogs baking");
    }

    // Write data
    for (const auto& file : filtered_files) {
        _context->WriteData(file.GetPath(), file.GetData());
    }
}

DialogTextBaker::DialogTextBaker(shared_ptr<BakingContext> ctx) :
    BaseBaker(std::move(ctx))
{
    FO_STACK_TRACE_ENTRY();
}

void DialogTextBaker::BakeFiles(const FileCollection& files, string_view target_path) const
{
    FO_STACK_TRACE_ENTRY();

    if (!target_path.empty() && !strex(target_path).get_file_extension().starts_with("fotxt")) {
        return;
    }

    // Collect dialog files
    vector<File> filtered_files;
    uint64_t max_write_time = 0;

    for (const auto& file_header : files) {
        if (strex(file_header.GetPath()).get_file_extension() != "fodlg") {
            continue;
        }

        max_write_time = std::max(max_write_time, file_header.GetWriteTime());
        filtered_files.emplace_back(File::Load(file_header));
    }

    bool something_changed = false;

    if (!filtered_files.empty()) {
        for (const auto& lang_name : _context->Settings->BakeLanguages) {
            if (!_context->BakeChecker || _context->BakeChecker(strex("{}.Dialogs.{}.fotxt-bin", _context->PackName, lang_name), max_write_time)) {
                something_changed = true;
            }
        }
    }

    if (!something_changed) {
        return;
    }

    // Load dialogs
    auto server_engine = BakerServerEngine(*_context->BakedFiles);
    const auto dialog_mngr = DialogManager(server_engine);

    size_t errors = 0;
    vector<refcount_ptr<DialogPack>> dialog_packs;

    for (const auto& file : filtered_files) {
        try {
            auto pack = dialog_mngr.ParseDialog(file.GetNameNoExt(), file.GetStr());
            dialog_packs.emplace_back(std::move(pack));
        }
        catch (const DialogParseException& ex) {
            WriteLog("Dialog text baking error: {}", ex.what());
            errors++;
        }
    }

    // Fill texts
    vector<pair<string, map<string, TextPack>>> lang_packs;

    for (const auto& dlg_pack : dialog_packs) {
        for (const auto& dlg_pack_text : dlg_pack->Texts) {
            const string lang_pack = dlg_pack_text.first;

            if (std::ranges::find_if(_context->Settings->BakeLanguages, [&](auto&& l) { return l == lang_pack; }) == _context->Settings->BakeLanguages.end()) {
                WriteLog(LogType::Warning, "Dialog {} contains unsupported language {}", dlg_pack->PackId, lang_pack);
                continue;
            }

            const auto it = std::ranges::find_if(lang_packs, [&](auto&& l) { return l.first == lang_pack; });

            if (it == lang_packs.end()) {
                auto dialogs_text_pack = map<string, TextPack>();
                dialogs_text_pack.emplace("Dialogs", dlg_pack_text.second);
                lang_packs.emplace_back(lang_pack, std::move(dialogs_text_pack));
            }
            else {
                auto& text_pack = it->second.at("Dialogs");

                if (!text_pack.CheckIntersections(dlg_pack_text.second)) {
                    text_pack.Merge(dlg_pack_text.second);
                }
                else {
                    WriteLog("Dialog {} text intersection detected", dlg_pack->PackId);
                    errors++;
                }
            }
        }
    }

    std::ranges::stable_sort(lang_packs, [&](const auto& l, const auto& r) {
        const auto li = std::ranges::find(_context->Settings->BakeLanguages, l.first);
        const auto ri = std::ranges::find(_context->Settings->BakeLanguages, r.first);
        const auto lrank = li != _context->Settings->BakeLanguages.end() ? static_cast<size_t>(std::distance(_context->Settings->BakeLanguages.begin(), li)) : std::numeric_limits<size_t>::max();
        const auto rrank = ri != _context->Settings->BakeLanguages.end() ? static_cast<size_t>(std::distance(_context->Settings->BakeLanguages.begin(), ri)) : std::numeric_limits<size_t>::max();
        return lrank < rrank;
    });

    TextPack::FixPacks(_context->Settings->BakeLanguages, lang_packs);

    if (errors != 0) {
        throw DialogBakerException("Errors during dialogs text baking");
    }

    // Write data
    for (auto&& [lang_name, text_packs] : lang_packs) {
        if (text_packs.count("Dialogs") == 0) {
            throw DialogBakerException(strex("Dialogs text pack missing for language '{}' after normalization", lang_name));
        }

        auto text_pack_data = text_packs.at("Dialogs").GetBinaryData();
        _context->WriteData(strex("{}.Dialogs.{}.fotxt-bin", _context->PackName, lang_name), text_pack_data);
    }
}