#include "Core.h"

#include "DFHackVersion.h"

#include "Debug.h"

#include "Internal.h"

#include "LuaTools.h"

#include "MemAccess.h"

#include "modules/DFSDL.h"

#include "modules/Filesystem.h"

#include "modules/Gui.h"

#include "modules/Persistence.h"

#include "modules/World.h"

#include "df/world.h"

#include "df/init.h"

#include <json/json.h>

#include <unordered_map>

namespace DFHack {

DBG_DECLARE(core, persistence, DebugCategory::LINFO);

}

using namespace DFHack;

static std::unordered_map<int, std::multimap<std::string, std::shared_ptr<Persistence::DataEntry>>> store;

static std::unordered_map<size_t, std::shared_ptr<Persistence::DataEntry>> entry_cache;

static uint32_t lastLoadSaveTickCount = 0;

size_t next_entry_id = 0; // goes more positive

int next_fake_df_id = -101; // goes more negative

struct Persistence::DataEntry {

const size_t entry_id;

const int entity_id;

const std::string key;

int fake_df_id;

std::string str_value;

std::array<int, PersistentDataItem::NumInts> int_values;

explicit DataEntry(int entity_id, const std::string &key)

}

explicit DataEntry(int entity_id, Json::Value &json)

}

Json::Value toJSON() const {

}

bool isReferencedBy(const PersistentDataItem & item) {

return item.data.get() == this;

}

};

int PersistentDataItem::entity_id() const {

CHECK_INVALID_ARGUMENT(isValid());

return data->entity_id;

}

const std::string &PersistentDataItem::key() const

{

CHECK_INVALID_ARGUMENT(isValid());

return data->key;

}

std::string &PersistentDataItem::val()

{

CHECK_INVALID_ARGUMENT(isValid());

return data->str_value;

}

const std::string &PersistentDataItem::val() const

{

CHECK_INVALID_ARGUMENT(isValid());

return data->str_value;

}

int &PersistentDataItem::ival(int i)

{

CHECK_INVALID_ARGUMENT(isValid());

CHECK_INVALID_ARGUMENT(i >= 0 && i < (int)NumInts);

return data->int_values.at(i);

}

int PersistentDataItem::ival(int i) const

}

const std::string & PersistentDataItem::get_str() {

static const std::string empty;

return isValid() ? val() : empty;

}

bool PersistentDataItem::isValid() const

}

int PersistentDataItem::fake_df_id() {

}

void Persistence::Internal::clear(color_ostream& out) {

CoreSuspender suspend;

store.clear();

entry_cache.clear();

next_entry_id = 0;

next_fake_df_id = -101;

}

static std::string filterSaveFileName(std::string s) {

}

static std::filesystem::path getSavePath(const std::string &world) {

return Filesystem::getBaseDir() / "save" / world;

}

static std::filesystem::path getSaveFilePath(const std::string &world, const std::string &name) {

return getSavePath(world) / ("dfhack-" + filterSaveFileName(name) + ".dat");

}

struct LastLoadSaveTickCountUpdater {

};

void Persistence::Internal::save(color_ostream& out) {

Core &core = Core::getInstance();

if (!core.isWorldLoaded())

return;

CoreSuspender suspend;

LastLoadSaveTickCountUpdater tickCountUpdater;

// write status

{

auto file = std::ofstream(getSaveFilePath("current", "status"));

file << "DF version: " << core.p->getDescriptor()->getVersion() << std::endl;

file << "DFHack version: " << Version::dfhack_version() << " (" << Version::git_commit(true) << ")" << std::endl;

file << "Tagged release: " << (Version::is_release() ? "yes" : "no") << std::endl;

file << "Pre-release: " << (Version::is_prerelease() ? "yes" : "no") << std::endl;

if (strlen(Version::dfhack_run_url())) {

file << "Build url: " << Version::dfhack_run_url() << std::endl;

}

if (df::global::world and df::global::version) {

file << std::endl;

file << "World name: " << World::getWorldName() << " (" << World::getWorldName(true) << ")" << std::endl;

file << "World generated in version: " << df::global::world->original_save_version << std::endl;

file << "World last saved in version: " << df::global::world->save_version << std::endl;

file << "World loaded in version: " << *df::global::version << std::endl;

}

}

// write entity data

for (auto & entity_store_entry : store) {

int entity_id = entity_store_entry.first;

Json::Value json(Json::arrayValue);

for (auto & entries : entity_store_entry.second) {

if (entries.second == nullptr)

continue;

json.append(entries.second->toJSON());

}

std::string name = (entity_id == Persistence::WORLD_ENTITY_ID) ?

"world" : "entity-" + int_to_string(entity_id);

auto file = std::ofstream(getSaveFilePath("current", name));

file << json;

}

// write perf counters

{

auto file = std::ofstream(getSaveFilePath("current", "perf-counters"));

color_ostream_wrapper wrapper(file);

Lua::CallLuaModuleFunction(wrapper, "script-manager", "print_timers");

}

}

static bool get_entity_id(const std::string & fname, int & entity_id) {

}

static void add_entry(std::multimap<std::string, std::shared_ptr<Persistence::DataEntry>> & entity_store_entry,

}

static void add_entry(int entity_id, std::shared_ptr<Persistence::DataEntry> entry) {

add_entry(store[entity_id], entry);

}

static bool load_file(const std::filesystem::path & path, int entity_id) {

}

void Persistence::Internal::load(color_ostream& out) {

CoreSuspender suspend;

LastLoadSaveTickCountUpdater tickCountUpdater;

clear(out);

std::string world_name = World::ReadWorldFolder();

std::filesystem::path save_path = getSavePath(world_name);

std::vector<std::filesystem::path> files;

if (0 != Filesystem::listdir(save_path, files)) {

DEBUG(persistence,out).print("not loading state; save directory doesn't exist: '%s'\n", save_path.c_str());

return;

}

bool found = false;

for (auto & fname : files) {

int entity_id = Persistence::WORLD_ENTITY_ID;

if (fname != "dfhack-world.dat" && !get_entity_id(fname.string(), entity_id))

continue;

found = true;

std::filesystem::path path = save_path / fname;

if (!load_file(path, entity_id))

out.printerr("Cannot load data from: '%s'\n", path.c_str());

}

if (found)

return;

// new file formats not found; attempt to load legacy file

const std::filesystem::path legacy_fname = getSaveFilePath(world_name, "legacy-data");

if (Filesystem::exists(legacy_fname)) {

int synthesized_entity_id = Persistence::WORLD_ENTITY_ID;

if (World::IsSiteLoaded())

synthesized_entity_id = World::GetCurrentSiteId();

load_file(legacy_fname, synthesized_entity_id);

}

}

static bool is_good_entity_id(int entity_id) {

return entity_id == Persistence::WORLD_ENTITY_ID || entity_id >= 0;

}

PersistentDataItem Persistence::addItem(int entity_id, const std::string &key) {

}

PersistentDataItem Persistence::getByKey(int entity_id, const std::string &key, bool *added) {

}

bool Persistence::deleteItem(const PersistentDataItem &item) {

}

void Persistence::getAll(std::vector<PersistentDataItem> &vec, int entity_id) {

}

void Persistence::getAllByKeyRange(std::vector<PersistentDataItem> &vec, int entity_id,

}

void Persistence::getAllByKey(std::vector<PersistentDataItem> &vec, int entity_id, const std::string &key) {

}

uint32_t Persistence::getUnsavedSeconds() {

uint32_t durMS = Core::getInstance().p->getTickCount() - lastLoadSaveTickCount;

return durMS / 1000;

}