#include "util/random.h"
#include "util/threaded_loader.h"
#include "util/name_generator.h"
#include "render/gl_driver.h"
#include "render/lighting.h"
#include "main/profiler.h"
#include "main/initialization.h"
#include "main/logging.h"
#include "main/input_handling.h"
#include "main/version.h"
#include "main/references.h"
#include "main/console.h"
#include "main/game_platform.h"
#include "os/glfw_driver.h"
#include "scripts/manager.h"
#include "scripts/binds.h"
#include "scripts/context_cache.h"
#include "scripts/script_components.h"
#include "constants.h"
#include "files.h"
#include "threads.h"
#include "processing.h"
#include "general_states.h"
#include "empire.h"
#include "empire_stats.h"
#include "scene/node.h"
#include "scene/mesh_node.h"
#include "scene/plane_node.h"
#include "scene/billboard_node.h"
#include "scene/animation/anim_node_sync.h"
#include "scene/scripted_node.h"
#include "obj/universe.h"
#include "obj/lock.h"
#include "as/as_jit.h"
#include "design/hull.h"
#include "design/design.h"
#include "design/subsystem.h"
#include "design/effect.h"
#include "design/projectiles.h"
#include "ISoundDevice.h"
#include "network/network_manager.h"
#include "str_util.h"
#include "physics/physics_world.h"
#include "util/save_file.h"
#include "save_load.h"
#include "render/lighting.h"
#include <stdio.h>
#include <fstream>

namespace scripts {
	void processEvents();
};

#ifdef _WIN32
	#define USE_JIT
#endif
#ifdef __i386__
	#define USE_JIT
#endif
#ifdef __amd64__
	#define USE_JIT
#endif

GameConfig gameConfig;
bool create_window = true;
bool load_resources = true;
bool watch_resources = false;
bool monitor_files = false;
bool use_sound = true;
bool use_steam = true;
bool isLoadedGame = false;
int SAVE_VERSION = -1, START_VERSION = -1;
bool gameEnding = false;
bool fullscreen = false;
bool cancelAssets = false;
#ifdef USE_JIT
bool useJIT = true;
#else
bool useJIT = false;
#endif
std::string loadSaveName;
std::unordered_set<std::string> dlcList;

//Poor mans steam-independent DLC checks
bool hasDLC(const std::string& name) {
	return dlcList.find(name) != dlcList.end();
}

void checkDLC(const std::string& name, const std::string& hashname) {
	std::string fname("data/dlc/");
	fname += hashname;
	if(fileExists(fname) || (devices.cloud && devices.cloud->hasDLC(name)))
		dlcList.insert(name);
}

void checkDLC() {
	dlcList.clear();
	checkDLC("Heralds", "bb8280a0fdc547ddbd8d3ae3f9242a14");
}

void checkCloudDLC(const std::string& name, const std::string& hashname) {
	std::string fname("data/dlc/");
	fname += hashname;

	if(devices.cloud->hasDLC(name)) {
		if(!fileExists(fname)) {
			makeDirectory("data/dlc/");
			std::fstream file(fname, std::ios_base::out | std::ios_base::binary);
			file << "\n";
			file.close();
		}
		dlcList.insert("Heralds");
	}
	else {
		if(fileExists(fname))
			remove(fname.c_str());
		dlcList.erase(name);
	}
}

void checkCloudDLC() {
	if(!devices.cloud)
		return;

	checkCloudDLC("Heralds", "bb8280a0fdc547ddbd8d3ae3f9242a14");
}

extern const render::Shader* fsShader;

extern std::set<std::string> validPaths;

extern void prepareShaderStateVars();
extern void clearShaderStateVars();
int threadCount;

extern bool queuedModSwitch;
extern std::vector<std::string> modSetup;

template<resource::ResourceType type>
void loadLibraryFile(const std::string& path) {
	devices.library.load(type, path);
}

#define libraryDir(dir, type) devices.mods.listFiles(dir, "*.txt", loadLibraryFile<type>);

bool processQueuedMeshes();

asCJITCompiler* makeJITCompiler() {
#ifdef USE_JIT
	if(!useJIT)
		return 0;
	unsigned flags = 0;
#ifndef PROFILE_EXECUTION
	return new asCJITCompiler(flags | JIT_NO_SUSPEND | JIT_SYSCALL_FPU_NORESET | JIT_ALLOC_SIMPLE | JIT_FAST_REFCOUNT);
#else
	return new asCJITCompiler(flags | JIT_SYSCALL_FPU_NORESET | JIT_ALLOC_SIMPLE | JIT_FAST_REFCOUNT);
#endif
#else
	return 0;
#endif
}

void loadEngineSettings();
Threaded(std::vector<std::function<void()>>*) cleanupFunctions = 0;

threads::Mutex scriptListLock;
std::map<std::string, std::map<std::string, std::string>*> scriptfiles;

void clearScriptList() {
	threads::Lock lock(scriptListLock);
	for(auto i = scriptfiles.begin(), end = scriptfiles.end(); i != end; ++i)
		delete i->second;
	scriptfiles.clear();
}

const std::map<std::string, std::string>& findScripts(const std::string& path) {
	threads::Lock lock(scriptListLock);
	auto*& m = scriptfiles[path];
	if(!m) {
		m = new std::map<std::string, std::string>;
		devices.mods.listFiles(path, *m, "*.as", true);
	}
	return *m;
}

void onScripts(const std::string& path, std::function<void(const std::pair<std::string,std::string>&)> f) {
	auto& scripts = findScripts(path);
	for(auto i = scripts.cbegin(), end = scripts.cend(); i != end; ++i)
		f(*i);
}

threads::Signal scriptPreloads;

threads::threadreturn threadcall PreloadBatch(void* arg) {
	std::string* pPath = (std::string*)arg;
	std::string& path = *pPath;
	auto preload = [](const std::pair<std::string,std::string>& file) {
		if(file.second.find("/include/") == std::string::npos)
			scripts::preloadScript(file.second);
	};
	onScripts(path, preload);
	scriptPreloads.signalDown();
	delete pPath;
	return 0;
}

void initNewThread() {
	//Start up random number generator
	initRandomizer();

	//Initialize thread-local script context cache
	scripts::initContextCache();
}

void cleanupThread() {
	scripts::freeContextCache();
	asThreadCleanup();

	freeRandomizer();

	if(cleanupFunctions) {
		foreach(it, (*cleanupFunctions))
			(*it)();
		delete cleanupFunctions;
		cleanupFunctions = 0;
	}
}

void addThreadCleanup(std::function<void()> func) {
	if(!cleanupFunctions)
		cleanupFunctions = new std::vector<std::function<void()>>();
	cleanupFunctions->push_back(func);
}

bool initGlobal(bool loadGraphics, bool createWindow) {
	//Create the sound device
	try {
		if(use_sound) {
			print("Initializing sound");
			auto* audioDevice = devices.settings.engine.getSetting("sAudioDevice");
			if(audioDevice)
				devices.sound = audio::createAudioDevice(audioDevice->toString().c_str());
			else
				devices.sound = audio::createAudioDevice();
		}
		
		if(!devices.sound)
			devices.sound = audio::createDummyAudioDevice();
	}
	catch(const char* err) {
		error("Sound Error: %s", err);
		devices.sound = audio::createDummyAudioDevice();
	}

	devices.sound->setVolume(0.5f);
	devices.sound->setRolloffFactor(1.f / 10000.f);

	//Safe AS multithreading
	asPrepareMultithread();

	print("Initializing window system");
	devices.driver = os::getGLFWDriver();
	devices.driver->resetTimer();

	//Load engine settings
	print("Loading engine settings");
	loadEngineSettings();

	console.addCommand("fov", [](argList& args) {
		if(devices.render && !args.empty()) {
			double newFOV = toNumber<double>(args[0]);
			if(newFOV > 0.1 && newFOV < 179.9)
				devices.render->setFOV(newFOV);
			else
				console.printLn("FOV must be within 0.1 and 179.9 degrees");
		}
	} );

	console.addCommand("vsync", [](argList& args) {
		if(devices.driver) {
			if(args.empty())
				devices.driver->setVerticalSync(true);
			else if(streq_nocase(args[0],"adaptive"))
				devices.driver->setVerticalSync(-1);
			else
				devices.driver->setVerticalSync(toBool(args[0]));
		}
	} );

	console.addCommand("load", [](argList& args) {
		std::string savePath = devices.mods.getProfile("saves");
		std::string filename = path_join(savePath, args.empty() ? "quicksave.sr2" : args[0]);
		if(!match(filename.c_str(),"*.sr2"))
			filename += ".sr2";

		scripts::scr_loadGame(filename);
	});

	console.addCommand("maxfps", [](argList& args) {
		extern double* maxfps;
		if(!args.empty())
			*maxfps = toNumber<double>(args[0]);
		console.printLn(toString(maxfps,0));
	} );

	console.addCommand("r", [](argList& args) {
		if(devices.scripts.client && !args.empty())
		devices.scripts.client->reload(args[0]);
	} );

	if(load_resources) {
		print("Initializing OpenGL Engine");
		devices.render = render::createGLDriver();
	}
	else {
		devices.render = nullptr;
	}

	create_window = createWindow;

	load_resources = loadGraphics;

	//Create network driver
	devices.network = new NetworkManager();
	auto* netLimit = devices.settings.engine.getSetting("iNetworkRateLimit");
	net::Transport::RATE_LIMIT = (netLimit ? *netLimit : 250) * 1024;

	devices.scripts.client = nullptr;
	devices.scripts.server = nullptr;
	devices.scripts.cache_server = nullptr;
	devices.scripts.cache_shadow = nullptr;
	devices.scripts.menu = nullptr;
	
	devices.engines.client = nullptr;
	devices.engines.server = nullptr;
	devices.engines.menu = nullptr;

	//Check marked DLCs
	checkDLC();

	//Add mod sources
	print("Registering mods");
	devices.mods.registerDirectory("mods");
	devices.mods.registerDirectory(getProfileRoot() + "mods");

	//Shortcut for the scene tree
	if(devices.render)
		devices.scene = &devices.render->rootNode;
	else
		devices.scene = nullptr;
	devices.universe = nullptr;

	//Initialize input handling
	registerInput();

	//Create processing queue
	unsigned cpuCount = devices.driver->getProcessorCount();
	threadCount = std::max(cpuCount+1,1u);
	print("Starting %d threads on %d processors.", threadCount, cpuCount);
	processing::start(threadCount);

	return true;
}

void destroyGlobal() {
	devices.network->disconnect();
	delete devices.network;

	asUnprepareMultithread();

	devices.driver->closeWindow();
	delete devices.driver;
}

void loadLocales(std::string folder, mods::Mod* mod) {
	if(mod->parent != nullptr)
		loadLocales(folder, mod->parent);
	std::map<std::string, std::string> files;
	mod->listFiles(folder, files, "*.txt", true, false);
	foreach(file, files)
		devices.locale.load(file->second);
}

void switchLocale(const std::string& locale) {
	devices.locale.clear();
	foreach(m, devices.mods.activeMods)
		loadLocales("locales/english", *m);
	if(locale != "english") {
		std::string dirname = path_join("locales", locale);
		foreach(m, devices.mods.activeMods)
			loadLocales(dirname, *m);
	}
}

std::string makeModuleName(const std::string& fname) {
	std::string mname;
	std::vector<std::string> components;
	path_split(fname, components);

	for(size_t i = 0, cnt = components.size() - 1; i < cnt; ++i)
		mname += components[i]+".";
	mname += getBasename(fname, false);
	return mname;
}

static threads::Signal jitInit;
void loadServerScripts() {
	std::map<std::string, std::string> scriptfiles;
	double start = devices.driver->getAccurateTime();

	devices.scripts.cache_server = new scripts::Manager(makeJITCompiler());

#ifdef PROFILE_LOCKS
	devices.scripts.cache_server->threadedCallMutex.name = "Server Threaded Call Lock";
	devices.scripts.cache_server->threadedCallMutex.observed = true;
#endif

	devices.scripts.cache_server->addIncludePath("scripts/");
	devices.scripts.cache_server->addIncludePath("scripts/server");
	devices.scripts.cache_server->addIncludePath("scripts/shared");
	devices.scripts.cache_server->addIncludePath("scripts/definitions");
	devices.scripts.cache_server->addIncludePath("maps/");

	scripts::RegisterServerBinds(devices.scripts.cache_server->engine);
	
	auto load = [](const std::pair<std::string,std::string>& file) {
		if(cancelAssets)
			return;
		if(file.second.find("/include/") != std::string::npos)
			return;

		devices.scripts.cache_server->load(
			makeModuleName(file.first),
			file.second);
	};
	
	onScripts("scripts/server", load);
	onScripts("scripts/shared", load);
	onScripts("scripts/definitions", load);
	onScripts("maps", load);

	double load_end = devices.driver->getAccurateTime();
	devices.scripts.cache_server->compile(
		devices.mods.getProfile("as_cache/server"),
		SERVER_SCRIPT_BUILD);

	double compile_end = devices.driver->getAccurateTime();
	print("Server scripts: %dms load, %dms compile",
		int((load_end - start) * 1000.0),
		int((compile_end - load_end) * 1000.0));
}

void loadShadowScripts() {
	std::map<std::string, std::string> scriptfiles;
	double start = devices.driver->getAccurateTime();

	devices.scripts.cache_shadow = new scripts::Manager(makeJITCompiler());

#ifdef PROFILE_LOCKS
	devices.scripts.cache_shadow->threadedCallMutex.name = "Shadow Threaded Call Lock";
	devices.scripts.cache_shadow->threadedCallMutex.observed = true;
#endif

	devices.scripts.cache_shadow->addIncludePath("scripts/");
	devices.scripts.cache_shadow->addIncludePath("scripts/shadow");
	devices.scripts.cache_shadow->addIncludePath("scripts/shared");
	devices.scripts.cache_shadow->addIncludePath("scripts/definitions");
	devices.scripts.cache_shadow->addIncludePath("maps/");

	scripts::RegisterShadowBinds(devices.scripts.cache_shadow->engine);
	
	auto load = [](const std::pair<std::string,std::string>& file) {
		if(cancelAssets)
			return;
		if(file.second.find("/include/") != std::string::npos)
			return;

		devices.scripts.cache_shadow->load(
			makeModuleName(file.first),
			file.second);
	};
	
	onScripts("scripts/shadow", load);
	onScripts("scripts/shared", load);
	onScripts("scripts/definitions", load);
	onScripts("maps", load);

	double load_end = devices.driver->getAccurateTime();
	devices.scripts.cache_shadow->compile(
		devices.mods.getProfile("as_cache/shadow"),
		SERVER_SCRIPT_BUILD);

	double compile_end = devices.driver->getAccurateTime();
	print("Shadow scripts: %dms load, %dms compile",
		int((load_end - start) * 1000.0),
		int((compile_end - load_end) * 1000.0));
}

void loadClientScripts() {
	std::map<std::string, std::string> scriptfiles;
	double start = devices.driver->getAccurateTime();

	devices.scripts.client = new scripts::Manager(makeJITCompiler());
	devices.engines.client = devices.scripts.client->engine;

#ifdef PROFILE_LOCKS
	devices.scripts.client->threadedCallMutex.name = "Client Threaded Call Lock";
	devices.scripts.client->threadedCallMutex.observed = true;
#endif

	scripts::RegisterClientBinds(devices.scripts.client->engine);
	devices.scripts.client->addIncludePath("scripts/");
	devices.scripts.client->addIncludePath("scripts/client");
	devices.scripts.client->addIncludePath("scripts/gui");
	devices.scripts.client->addIncludePath("scripts/shared");
	devices.scripts.client->addIncludePath("scripts/toolkit");
	devices.scripts.client->addIncludePath("scripts/definitions");
	devices.scripts.client->addIncludePath("maps/");
	
	auto load = [](const std::pair<std::string,std::string>& file) {
		if(cancelAssets)
			return;
		if(file.second.find("/include/") != std::string::npos)
			return;

		devices.scripts.client->load(
			makeModuleName(file.first),
			file.second);
	};
	
	onScripts("scripts/client", load);
	onScripts("scripts/gui", load);
	onScripts("scripts/shared", load);
	onScripts("scripts/toolkit", load);
	onScripts("scripts/definitions", load);
	onScripts("maps", load);

	double load_end = devices.driver->getAccurateTime();
	devices.scripts.client->compile(
		devices.mods.getProfile("as_cache/client"),
		CLIENT_SCRIPT_BUILD);

	double compile_end = devices.driver->getAccurateTime();
	print("Client scripts: %dms load, %dms compile",
		int((load_end - start) * 1000.0),
		int((compile_end - load_end) * 1000.0));
}

void bindScripts() {
	//Bind all script binds
	scripts::BindEventBinds();
	bindScriptObjectTypes();
	scripts::bindComponentClasses();
	scene::bindScriptNodeTypes();

	//We cannot actually execute things on
	//the shadow, so don't try to bind things
	bindEffectorHooks(devices.network->isClient);
	bindSubsystemHooks();
	if(!devices.network->isClient) {
		bindEffectHooks();
	}
}

volatile bool idleImageActive = false;
threads::threadreturn threadcall idleProcessImages(void*) {
	idleImageActive = true;
	while(devices.library.hasQueuedImages()) {
		devices.library.processImages(INT_MIN,1);
		threads::sleep(1);
	}
	idleImageActive = false;
	return 0;
}

volatile bool idleSoundsActive = false;
threads::threadreturn threadcall idleProcessSounds(void*) {
	idleSoundsActive = true;
	while(devices.library.hasQueuedSounds()) {
		devices.library.processSounds(INT_MIN,1);
		threads::sleep(1);
	}
	idleSoundsActive = false;
	return 0;
}

volatile bool idleHullsActive = false;
threads::threadreturn threadcall idleComputeHulls(void*) {
	double tstart = devices.driver->getAccurateTime();

	idleHullsActive = true;
	initRandomizer();
	while(!isFinishedComputingHulls() && !cancelAssets) {
		computeHulls(1);
		threads::sleep(1);
	}
	idleHullsActive = false;

	double tend = devices.driver->getAccurateTime();
	print("Finished computing hulls in %gms", (tend-tstart)*1000.0);
	return 0;
}

bool preloading = false;
void startPreload() {
	if(preloading)
		return;

	//Preload things for the game
	Loading::prepare(5, initNewThread, cleanupThread);

	Loading::addTask("ServerScripts", 0, [] {
		loadServerScripts();
	});

	Loading::addTask("ShadowScripts", 0, [] {
		loadShadowScripts();
	});

	Loading::addTask("ClientScripts", 0, [] {
		loadClientScripts();
	});

	Loading::addTask("CleanupScripts", "ServerScripts,ShadowScripts,ClientScripts", [] {
		clearScriptList();
		scripts::clearCachedScripts();
	});

	Loading::addTask("ProcessImages", 0, [] {
		devices.library.processImages(-10);
		threads::createThread(idleProcessImages, 0);
	});

	Loading::addTask("ProcessSounds", 0, [] {
		devices.library.processSounds(-10);
		threads::createThread(idleProcessSounds, 0);
	});

	Loading::addTask("ComputeHulls", 0, [] {
		if(load_resources)
			threads::createThread(idleComputeHulls, 0);
	});

#ifdef DOCUMENT_API
	Loading::addTask("Documentation", "ClientScripts,ServerScripts", [] {
		scripts::documentBinds();
	});
#endif

	preloading = true;
}

bool isPreloading() {
	return preloading;
}

void finishPreload() {
	if(!preloading) {
		startPreload();
		Loading::finalize();
	}

	while(!Loading::finished()) {
		Loading::process();
		devices.driver->handleEvents(1);
	}

	const int priority = -10;
	while(devices.library.processImages(priority)) {}
	while(devices.library.processTextures(priority)) {}
	while(devices.library.processSounds(priority)) {}
	while(devices.library.processMeshes(priority)) {}

	while(!Loading::finished()) {
		Loading::process();
		devices.driver->handleEvents(1);
	}

	Loading::finish();
	preloading = false;
}

namespace resource {
extern threads::Signal unqueuedMeshes;
};
void cancelLoad() {
	cancelAssets = true;

	while(!Loading::finished()) {
		Loading::process();
		devices.driver->handleEvents(1);
	}

	const int priority = INT_MIN;
	while(devices.library.processImages(priority)) {}
	while(idleImageActive) { devices.driver->handleEvents(1); }
	while(devices.library.processTextures(priority)) {}
	while(devices.library.processSounds(priority)) {}
	while(devices.library.processMeshes(priority)) {}
	while(idleSoundsActive) { devices.driver->handleEvents(1); }
	while(idleHullsActive) { devices.driver->handleEvents(1); }
	resource::unqueuedMeshes.wait(0);

	Loading::finish();

	cancelAssets = false;
	preloading = false;
}

void readGameConfig(const std::string& filename) {
	gameConfig.count = 0;
	//delete gameConfig.names;
	//delete gameConfig.values;
	gameConfig.indices.clear();

	std::vector<std::string> names;
	std::vector<double> values;
	DataHandler file;
	file.defaultHandler([&](std::string& key, std::string& value) {
		names.push_back(key);
		values.push_back(toNumber<double>(value));
	});
	file.read(filename);

	gameConfig.count = names.size();
	gameConfig.names = new std::string[gameConfig.count];
	gameConfig.values = new double[gameConfig.count];
	gameConfig.defaultValues = new double[gameConfig.count];

	for(size_t i = 0; i < gameConfig.count; ++i) {
		gameConfig.names[i] = names[i];
		gameConfig.values[i] = values[i];
		gameConfig.defaultValues[i] = values[i];
		gameConfig.indices[names[i]] = i;
	}
}

void resetGameConfig() {
	for(size_t i = 0; i < gameConfig.count; ++i)
		gameConfig.values[i] = gameConfig.defaultValues[i];
}

void readGameConfig(net::Message& msg) {
	for(size_t i = 0; i < gameConfig.count; ++i)
		msg >> gameConfig.values[i];
}

void writeGameConfig(net::Message& msg) {
	for(size_t i = 0; i < gameConfig.count; ++i)
		msg << gameConfig.values[i];
}

void saveGameConfig(SaveFile& file) {
	file << (unsigned)gameConfig.count;
	for(size_t i = 0; i < gameConfig.count; ++i) {
		file << gameConfig.names[i];
		file << gameConfig.values[i];
	}
}

void loadGameConfig(SaveFile& file) {
	unsigned count = 0;
	if(file >= SFV_0003) {
		file >> count;
	}
	else {
		size_t woops = 0;
		file >> woops;
		count = (unsigned)woops;
	}

	for(size_t i = 0; i < count; ++i) {
		std::string name;
		file >> name;

		double value;
		file >> value;

		auto it = gameConfig.indices.find(name);
		if(it != gameConfig.indices.end())
			gameConfig.values[it->second] = value;
	}
}

bool loadPrep(const std::string& fname) {
	if(!scripts::isAccessible(fname))
		return false;

	SaveFileInfo info;
	getSaveFileInfo(fname, info);

	//Check if we need to switch mods
	std::vector<bool> modCheck;
	unsigned modCnt = info.mods.size();
	unsigned activeCnt = devices.mods.activeMods.size();
	modCheck.resize(activeCnt);
	for(unsigned i = 0; i < activeCnt; ++i)
		modCheck[i] = false;

	std::vector<std::string> ids;

	bool shouldSwitch = false;
	for(unsigned i = 0; i < modCnt; ++i) {
		bool found = false;
		auto* mod = devices.mods.getMod(info.mods[i].id);
		if(mod)
			mod = mod->getFallback(info.mods[i].version);

		if(mod == nullptr)
			return false;

		ids.push_back(mod->ident);

		for(unsigned j = 0; j < activeCnt; ++j) {
			if(modCheck[j])
				continue;
			if(devices.mods.activeMods[j] == mod) {
				found = true;
				modCheck[j] = true;
				break;
			}
		}
		if(!found) {
			shouldSwitch = true;
			break;
		}
	}
	for(unsigned i = 0; i < activeCnt; ++i) {
		if(!modCheck[i]) {
			shouldSwitch = true;
			break;
		}
	}

	if(game_running)
		destroyGame();

	//Switch mods if needed
	if(shouldSwitch) {
		::info("Switching mods for savegame...");
		destroyMod();
		initMods(ids);
	}

	//Actually load
	clearGameSettings();
	loadSaveName = fname;
	game_state = GS_Game;
	return true;
}

struct ToggleConsoleBind : profile::Keybind {
	void call(bool pressed) {
		if(!pressed) {
			console.toggle();
		}
	}
};

void initMods(const std::vector<std::string>& mods) {
	auto prevSection = enterSection(NS_Loading);

	//Load global resources
	Loading::prepare(5, initNewThread, cleanupThread);

	Loading::addTask("CloudInit", 0, [] {
#ifndef NSTEAM
			if(use_steam && !devices.cloud)
				devices.cloud = GamePlatform::acquireSteam();
#endif
		} );

	static bool didCloudFiles = false, didCloudMods = false;

	Loading::addTask("CloudMods", "CloudInit", [] {
			if(didCloudMods)
				return;
			didCloudMods = true;

			if(devices.cloud) {
				CloudDownload dl;
				for(unsigned i = 0, cnt = devices.cloud->getDownloadedItemCount(); i < cnt; ++i) {
					if(devices.cloud->getDownloadedItem(i, dl)) {
						validPaths.insert(dl.path);
						auto folderNameEnds = dl.path.find_last_not_of("\\/");
						auto folderNameStarts = dl.path.find_last_of("\\/", folderNameEnds);
						if(folderNameStarts != std::string::npos)
							devices.mods.registerMod(dl.path, dl.path.substr(folderNameStarts+1, folderNameEnds - folderNameStarts));
					}
				}

				checkCloudDLC();
			}
			devices.mods.finalize();
		} );

	Loading::addTask("CloudFiles", "CloudInit", [] {
			if(devices.cloud && !didCloudFiles) {
				didCloudFiles = false;
				devices.cloud->addCloudFolder(getProfileRoot(), "saves");
				devices.cloud->syncCloudFiles(getProfileRoot());
			}
		} );

	Loading::addTask("ModInit", "CloudMods", [&] {
		//Set the mod
		devices.mods.clearMods();
		if(mods.empty()) {
			foreach(mod, devices.mods.mods) {
				if((*mod)->enabled) {
					if(devices.mods.enableMod((*mod)->name))
						info("Loading enabled mod %s", (*mod)->name.c_str());
				}
			}
		}
		else foreach(mod, mods) {
			if(devices.mods.enableMod(*mod))
				info("Loading mod %s", mod->c_str());
		}

		//Initialize the library
		devices.library.prepErrorResources();

		//Load keybind descriptors
		std::vector<std::string> bindfiles;
		devices.mods.resolve("data/keybinds.txt", bindfiles);
		foreach(it, bindfiles)
			devices.keybinds.loadDescriptors(*it);

		//Load keybind values from profile, or set defaults
		std::string bindFile = path_join(devices.mods.getProfile("settings"), "keybinds.txt");
		devices.keybinds.setDefaultBinds();
		if(fileExists(bindFile)) {
			devices.keybinds.loadBinds(bindFile);
		}
		else {
			//Load parent keybinds
			foreach(it, devices.mods.activeMods) {
				mods::Mod* prt = *it;
				while(prt) {
					std::string kfile(prt->getProfile("settings"));
					kfile = path_join(kfile, "keybinds.txt");

					if(fileExists(kfile))
						devices.keybinds.loadBinds(kfile);

					prt = prt->parent;
				}
			}

			devices.keybinds.saveBinds(bindFile);
		}

		//Do console bind
		auto* group = devices.keybinds.getGroup("Global");
		if(group) {
			auto* desc = group->getDescriptor("TOGGLE_CONSOLE");
			if(desc) {
				console.keybind = new ToggleConsoleBind();
				group->addBind(desc->id, console.keybind);
			}
		}

		//Run menu autoexec
		console.executeFile(path_join(getProfileRoot(), "autoexec_menu.txt"));

		//Load the locales
		switchLocale(game_locale);

		//Load setting descriptors
		std::vector<std::string> settingfiles;
		devices.mods.resolve("data/settings.txt", settingfiles);
		foreach(it, settingfiles)
			devices.settings.mod.loadDescriptors(*it);

		//Load setting values from profile, or set defaults
		std::string stFile = path_join(devices.mods.getProfile("settings"), "settings.txt");
		if(fileExists(stFile)) {
			devices.settings.mod.loadSettings(stFile);
		}
		else {
			//Load parent keybinds
			foreach(it, devices.mods.activeMods) {
				mods::Mod* prt = *it;
				while(prt) {
					std::string kfile(prt->getProfile("settings"));
					kfile = path_join(kfile, "settings.txt");

					if(fileExists(kfile))
						devices.settings.mod.loadSettings(kfile);

					prt = prt->parent;
				}
			}

			devices.settings.mod.saveSettings(stFile);
		}
	});

	Loading::addTask("Window", "ModInit", [] {
			if(create_window) {
				os::WindowData windat;
				windat.verticalSync = 1;
				bool cursorCapture = false;

				auto* vsync = devices.settings.engine.getSetting("iVsync");
				if(vsync)
					windat.verticalSync = *vsync;

				extern double ui_scale;
				auto* scale = devices.settings.engine.getSetting("dGUIScale");
				if(scale)
					ui_scale = *scale;

				if(!fullscreen)
					fullscreen = *devices.settings.engine.getSetting("bFullscreen");

				if(fullscreen) {
					windat.mode = os::WM_Fullscreen;

					auto* ovr = devices.settings.engine.getSetting("bOverrideResolution");
					if(ovr)
						windat.overrideMonitor = *ovr;

					unsigned w, h;
					devices.driver->getDesktopSize(w, h);

					auto* screenWidth = devices.settings.engine.getSetting("iFsResolutionX");
					int settingWidth = screenWidth ? *screenWidth : 0;
					windat.width = settingWidth > 0 ? settingWidth : (int)w;
					
					auto* screenHeight = devices.settings.engine.getSetting("iFsResolutionY");
					int settingHeight = screenHeight ? *screenHeight : 0;
					windat.height = settingHeight > 0 ? settingHeight : (int)h;

					auto* fsCapture = devices.settings.engine.getSetting("bFsCursorCapture");
					cursorCapture = fsCapture ? *fsCapture : true;

					auto* mon = devices.settings.engine.getSetting("sMonitor");
					if(mon)
						windat.targetMonitor = mon->toString();
				}
				else {
					auto* screenWidth = devices.settings.engine.getSetting("iResolutionX");
					windat.width = screenWidth ? *screenWidth : 1280;
					
					auto* screenHeight = devices.settings.engine.getSetting("iResolutionY");
					windat.height = screenHeight ? *screenHeight : 720;

					auto* fsCapture = devices.settings.engine.getSetting("bCursorCapture");
					cursorCapture = fsCapture ? *fsCapture : true;
				}

				auto* aa = devices.settings.engine.getSetting("iSamples");
				if(aa)
					windat.aa_samples = *aa;

				auto* ss = devices.settings.engine.getSetting("bSupersample");
				if(ss) {
					extern double scale_3d;
					scale_3d = (bool)*ss ? 2.0 : 1.0;
				}

				auto* refresh = devices.settings.engine.getSetting("iRefreshRate");
				if(refresh)
					windat.refreshRate = *refresh;

				devices.driver->createWindow(windat);
				devices.driver->setCursorLocked(cursorCapture);
				devices.driver->setWindowTitle("Star Ruler 2");

				devices.render->init();

				//We should only make a window once
				create_window = 0;
			}
		}, threads::getThreadID() );
	
	if(load_resources) {
		Loading::addTask("Errors", "Window", [] {
				devices.library.generateErrorResources();
			}, threads::getThreadID() );
	}

	Loading::addTask("EmpireStats", "ModInit", [] {
			loadEmpireStats( devices.mods.resolve("data/stats.txt") );
		} );

	Loading::addTask("ObjectTypes", "ModInit", [] {
			loadStateDefinitions(devices.mods.resolve("data/objects.txt"), "Object");
			prepScriptObjectTypes();
		} );

	Loading::addTask("Generics", "ObjectTypes", [] {
			scripts::initGenericTypes();
			for(unsigned i = 0, cnt = getScriptObjectTypeCount(); i < cnt; ++i) {
				auto* type = getScriptObjectType(i);
				scripts::bindGenericObjectType(type, type->name);
			}
		} );

	Loading::addTask("NodeTypes", "Generics", [] {
			scene::loadScriptNodeTypes(devices.mods.resolve("data/nodes.txt"));
		} );

	Loading::addTask("Components", "Generics", [] {
			devices.mods.listFiles("data/components", "*.txt", [](const std::string& file) {
				scripts::loadComponents(file);
			});
		} );

	Loading::addTask("States", "Components,ObjectTypes", [] {
			resetStateValueTypes();
			addObjectStateValueTypes();
			scripts::addComponentStateValueTypes();
			scripts::addNamespaceState();
			loadStateDefinitions(devices.mods.resolve("data/empire_states.txt"));
			finalizeStateDefinitions();
			Empire::setEmpireStates(&getStateDefinition("Empire"));
			scripts::BindEmpireComponentOffsets();
			scripts::buildEmpAttribIndices();
			setScriptObjectStates();
		} );

	Loading::addTask("GameConfig", "ModInit", [] {
			readGameConfig(devices.mods.resolve("data/game_config.txt"));
		} );

	Loading::addTask("ObjComponentOffsets", "ObjectTypes,Components,States", [] {
			scripts::SetObjectTypeOffsets();
		});

	Loading::addTask("Effects", "ModInit", [] {
			devices.mods.listFiles("data/effects", "*.txt", loadEffectDefinitions, true);
		} );
	Loading::addTask("Effectors", "Effects", [] {
			devices.mods.listFiles("data/effectors", "*.txt", loadEffectorDefinitions, true);
		} );
	Loading::addTask("SubSystems", "Effects,Effectors,GameConfig", [] {
			devices.mods.listFiles("data/subsystems", "*.txt", loadSubsystemDefinitions, true);
			executeSubsystemTemplates();
			finalizeSubsystems();
		} );
	Loading::addTask("Shaders", "ModInit", [] {
			devices.library.clearShaderGlobals();
			libraryDir("data/shaders", resource::RT_Shader);
		});
	Loading::addTask("Materials", "Shaders", [] {
			libraryDir("data/materials", resource::RT_Material);
			devices.mods.listFiles("data/shipsets", "materials.txt", loadLibraryFile<resource::RT_Material>, true);
		});

	if(load_resources) {
		Loading::addTask("CompileShaders", "Shaders,Window", [] {
				devices.library.compileShaders();
			}, threads::getThreadID() );
	}
	
	Loading::addTask("Fonts", "ModInit", [] {
			libraryDir("data/fonts", resource::RT_Font);
		} );

	Loading::addTask("Sounds", "ModInit", [] {
			libraryDir("data/sounds", resource::RT_Sound);
		} );

	Loading::addTask("Particles", "Materials,Sounds", [] {
			devices.mods.listFiles("data/particles", "*.ps", loadLibraryFile<resource::RT_ParticleSystem>, true);
		});

	Loading::addTask("SkinStyles", "Fonts", [] {
			libraryDir("data/skin styles", resource::RT_Skin);
		} );

	Loading::addTask("Events", "Generics", [] {
			devices.mods.listFiles("data/events", "*.txt", [](const std::string& file) {
				scripts::ReadEvents(file);
			});

			scripts::LoadScriptHooks(devices.mods.resolve("data/hooks.txt"));
		} );

	Loading::addTask("MaterialBinds", "Materials,SkinStyles,Particles,SubSystems", [] {
			devices.library.bindSkinMaterials();
			bindSubsystemMaterials();
		} );

	Loading::addTask("ResourceBinds", "Materials,Sounds,Particles", [] {
			bindEffectorResources();
		} );
	
	Loading::addTask("Models", "ModInit", [] {
			libraryDir("data/models", resource::RT_Mesh);
			devices.mods.listFiles("data/shipsets", "models.txt", loadLibraryFile<resource::RT_Mesh>, true);
		} );

	Loading::addTask("Shipsets", "Models,Materials,SubSystems", [] {
			devices.mods.listFiles("data/shipsets", "hulls.txt", loadHullDefinitions, true);
			devices.mods.listFiles("data/shipsets", "shipset.txt", loadShipset, true);
			initAllShipset();
		} );

	if(load_resources) {
		Loading::addTask("ShaderStateVars", "Shaders,ObjectTypes,States", [] {
				prepareShaderStateVars();
			});

		Loading::addTask("ProcessSounds", "Sounds", [] {
				devices.library.processSounds(10);
			});

		Loading::addTask("ProcessImages", "Materials,Fonts,Window", [] {
				devices.library.processImages(10);
			});

		Loading::addTask("ProcessTextures", "ProcessImages,Window", [] {
				devices.library.processTextures(10);
			}, threads::getThreadID() );
				
		Loading::addTask("ProcessModels", "Models,Window,Shipsets", [] {
				devices.library.processMeshes();
			}, threads::getThreadID() );
	}

	Loading::addTask("LocateScripts", "ModInit", [] {
		findScripts("scripts/shared");
		findScripts("scripts/definitions");
		findScripts("maps");
		findScripts("scripts/menu");
		findScripts("scripts/toolkit");
		findScripts("scripts/server");
		findScripts("scripts/client");
	});

	Loading::addTask("PreloadScripts", "LocateScripts", [] {
		scriptPreloads.signal(7);
		threads::createThread(PreloadBatch, new std::string("scripts/shared"));
		threads::createThread(PreloadBatch, new std::string("scripts/definitions"));
		threads::createThread(PreloadBatch, new std::string("scripts/menu"));
		threads::createThread(PreloadBatch, new std::string("maps"));
		threads::createThread(PreloadBatch, new std::string("scripts/toolkit"));
		threads::createThread(PreloadBatch, new std::string("scripts/server"));
		threads::createThread(PreloadBatch, new std::string("scripts/client"));
	});

	Loading::addTask("MenuScripts", "LocateScripts,SkinStyles,Materials,Models,Sounds,SubSystems", [] {
			std::map<std::string, std::string> scriptfiles;
			devices.scripts.menu = new scripts::Manager(makeJITCompiler());
			devices.engines.menu = devices.scripts.menu->engine;

			devices.scripts.menu->addIncludePath("scripts/menu");
			devices.scripts.menu->addIncludePath("scripts/shared");
			devices.scripts.menu->addIncludePath("scripts/toolkin");
			devices.scripts.menu->addIncludePath("scripts/gui");
			devices.scripts.menu->addIncludePath("scripts/definitions");
			devices.scripts.menu->addIncludePath("maps/");

			auto loadScript = [](const std::pair<std::string,std::string>& file) {
				if(file.second.find("/include/") != std::string::npos)
					return;

				devices.scripts.menu->load(
					makeModuleName(file.first),
					file.second);
			};
			
			onScripts("scripts/menu", loadScript);
			onScripts("scripts/toolkit", loadScript);
			onScripts("maps", loadScript);

			scripts::RegisterMenuBinds(devices.scripts.menu->engine);
		
			devices.scripts.menu->compile(
				devices.mods.getProfile("as_cache/menu"),
				MENU_SCRIPT_BUILD);

			devices.scripts.menu->init();
			bindInputScripts(GS_Menu, devices.scripts.menu);
			scripts::BindEventBinds(true);
		} );

	Loading::finalize();

	while(!Loading::finished()) {
		Loading::process();
		devices.driver->handleEvents(1);
	}

	Loading::finish();

	enterSection(prevSection);

	devices.library.bindHotloading();

	startPreload();
	Loading::finalize();
	
	if(devices.scripts.menu)
		devices.scripts.menu->garbageCollect(true);
	if(devices.scripts.client)
		devices.scripts.client->garbageCollect(true);
	if(devices.scripts.server)
		devices.scripts.server->garbageCollect(true);
}

void destroyMod() {
	//Make sure we finish loading, or we could de-initialize while adding resources
	cancelLoad();

	stopProjectiles();

	//End processing
	processing::end();
	processing::clear();

	//Remove input script binds
	clearInputScripts(GS_Menu);

	//Clear any active game
	if(game_running)
		destroyGame();

	clearEmpireStats();

	//Remove script nodes
	scene::clearScriptNodeTypes();

	//Clear keybinds
	devices.keybinds.clear();

	//Destroy skin indices
	gui::skin::clearDynamicIndices();

	//Clear shader state vars
	clearShaderStateVars();

	//Clear resources
	devices.library.clear();
	fsShader = nullptr;

	//Clear menu scripts
	delete devices.scripts.menu;
	devices.scripts.menu = 0;
	devices.engines.menu = 0;
	scripts::resetContextCache(true);

	//Stop playing sounds
	if(devices.sound)
		devices.sound->stopAllSounds();

	//Clear console commands
	console.clearCommands();

	//Clear state definitions (For objects, empires)
	clearStateDefinitions();

	//Clear other definitions
	clearHullDefinitions();
	clearShipsets();
	scripts::ClearEvents();
	scripts::clearComponents();
	clearEffectDefinitions();
	clearEffectorDefinitions();
	clearEffectors();
	clearSubsystemDefinitions();
	Empire::setEmpireStates(0);
}

net::Message game_settings;

void setGameSettings(net::Message& msg) {
	game_settings = msg;
}

void clearGameSettings() {
	game_settings.clear();
}

void passSettings(scripts::Manager* man) {
	auto& modules = man->modules;
	for(auto it = modules.begin(); it != modules.end(); ++it) {
		scripts::Module& mod = *it->second;
		if(mod.callbacks[scripts::SC_game_settings] > 0) {
			game_settings.rewind();
			scripts::Call cl = mod.call(scripts::SC_game_settings);
			cl.push(&game_settings);
			cl.call();
		}
	}
}

void initGame() {
	if(queuedModSwitch) {
		queuedModSwitch = false;
		destroyMod();
		initMods(modSetup);
	}

	//Tell all the clients to start the game
	if(devices.network->isServer)
		devices.network->startSignal();

	//Wait for all the preloading to finish
	finishPreload();

	//Set the correct server engine to use
	if(devices.network->isClient)
		devices.scripts.server = devices.scripts.cache_shadow;
	else
		devices.scripts.server = devices.scripts.cache_server;
	devices.engines.server = devices.scripts.server->engine;

	bindScripts();

	//Initialize default empire
	processing::resume();
	if(!processing::isRunning()) {
		unsigned cpuCount = devices.driver->getProcessorCount();
		threadCount = std::max(cpuCount+1,1u);
		processing::start(cpuCount);
	}
	Empire::initEmpires();

	//Enable projectile processing
	initProjectiles();

	//Create lock groups
	processing::pause();
	initLocks(threadCount);

	Object::GALAXY_CREATION = true;
	processing::resume();

	//Create the universe
	devices.driver->resetGameTime(0.0);
	resetGameTime();
	resetGameConfig();
	devices.universe = new Universe();

	isLoadedGame = false;
	bool loaded = false;

	if(devices.network->isClient) {
		//Tell the server we're ready to receive
		devices.network->signalClientReady();

		//Initialize server scripts
		devices.scripts.server->init();

		//Wait for the galaxy to be received before
		//starting all the scripts
		while(!devices.network->currentPlayer.hasGalaxy) {
			if(!devices.network->client || !devices.network->client->active) {
				devices.scripts.client->init();
				destroyGame();
				clearGameSettings();
				game_state = GS_Menu;
				return;
			}
			game_state = GS_Menu;
			tickMenu();
			game_state = GS_Game;
		}

		//Pass in game settings after objects
		passSettings(devices.scripts.server);
		passSettings(devices.scripts.client);

		//Initialize client scripts
		devices.scripts.client->init();
	}
	else {
		isLoadedGame = !loadSaveName.empty();

		//Create the universe by passing game settings
		passSettings(devices.scripts.server);
		passSettings(devices.scripts.client);
		
		volatile bool done = false;

		if(isLoadedGame) {
			//LoadGame does script init() in the right place
			threads::async([&done,&loaded]() -> int {
				initNewThread();
				pauseProjectiles();
				loaded = loadGame(loadSaveName);
				resumeProjectiles();
				done = true;
				cleanupThread();
				return 0;
			});
		}
		else {
			threads::async([&done]() -> int {
				initNewThread();
				devices.scripts.server->init();
				devices.scripts.client->init();
				done = true;
				cleanupThread();
				return 0;
			});
		}

		while(!done) {
			tickMenu();
			threads::sleep(1);
		}
	}

	loadSaveName.clear();
	if(isLoadedGame && !loaded) {
		game_state = GS_Menu;
		return;
	}

	bindInputScripts(GS_Game, devices.scripts.client);

	//Run console autoexec
	console.executeFile(path_join(getProfileRoot(), "autoexec.txt"));

	//Tell the clients we're ready to transmit galaxies
	Object::GALAXY_CREATION = false;
	devices.network->currentPlayer.emp = Empire::getPlayerEmpire();
	Empire::getPlayerEmpire()->player = &devices.network->currentPlayer;
	if(devices.network->isServer)
		devices.network->signalServerReady();

	game_running = true;

	//Process events that were deferred until client scripts were initialized
	scripts::processEvents();
}

void destroyGame() {
	gameEnding = true;

	stopProjectiles();

	//Wait for all processing jobs to finish
	processing::end();
	processing::clear();

	//Inform the network
	if(devices.network->serverReady)
		devices.network->endGame();

	//Clear game scripts
	if(devices.scripts.server)
		devices.scripts.server->deinit();
	if(devices.scripts.client)
		devices.scripts.client->deinit();

	//Disconnect network interface if multiplayer
	if(devices.network->isClient || devices.network->serverReady)
		devices.network->disconnect();

	//Clear all lights
	render::light::destroyLights();

	//Remove lock groups
	destroyLocks();

	//Remove input script binds
	clearInputScripts(GS_Game);

	//Clear all object IDs
	clearObjects();

	//Destroy universe
	if(devices.universe) {
		devices.universe->destroyAll();
		devices.universe->drop();
		devices.universe = 0;
	}

	if(devices.physics) {
		devices.physics->drop();
		devices.physics = 0;
	}

	if(devices.nodePhysics) {
		devices.nodePhysics->drop();
		devices.nodePhysics = 0;
	}
	
	//Destroy scene
	extern void endAnimation();
	endAnimation();

	extern void clearProjectileBatches();
	clearProjectileBatches();

	devices.scene->destroyTree();

	scene::clearNodeEvents();

	//Delete existing empires
	Empire::clearEmpires();

	scripts::resetContextCache();
	delete devices.scripts.cache_server;
	delete devices.scripts.cache_shadow;
	delete devices.scripts.client;

	devices.scripts.cache_server = 0;
	devices.scripts.cache_shadow = 0;
	devices.scripts.client = 0;
	devices.scripts.server = 0;
	devices.engines.client = 0;
	devices.engines.server = 0;

	gameEnding = false;

	console.clearCommands();
	game_running = false;

	if(devices.network->isClient || devices.network->serverReady)
		devices.network->resetNetState();
}

void loadEngineSettings() {
	//Hardcoded engine settings go here
	{
		profile::SettingCategory* cat = new profile::SettingCategory("Graphics");
		cat->settings.push_back(new NamedGeneric("iSamples", 4));
		cat->settings.push_back(new NamedGeneric("bSupersample", false));
		cat->settings.push_back(new NamedGeneric("iRefreshRate", (int)0));
		cat->settings.push_back(new NamedGeneric("iResolutionX", 1280));
		cat->settings.push_back(new NamedGeneric("iResolutionY", 720));
		cat->settings.push_back(new NamedGeneric("iFsResolutionX", (int)0));
		cat->settings.push_back(new NamedGeneric("iFsResolutionY", (int)0));
		cat->settings.push_back(new NamedGeneric("bFullscreen", true));
		cat->settings.push_back(new NamedGeneric("bOverrideResolution", false));
		cat->settings.push_back(new NamedGeneric("iVsync", 1));
		cat->settings.push_back(new NamedGeneric("sMonitor", ""));
		cat->settings.push_back(new NamedGeneric("bShaderFallback", false));

		auto* guiScale = new NamedGeneric("dGUIScale", 1.0);
		guiScale->flt_min = 0.25;
		guiScale->flt_max = 4.0;
		cat->settings.push_back(guiScale);

		auto* fps = new NamedGeneric("dMaxFPS", 65.0);
		fps->flt_min = 24.0;
		fps->flt_max = 200.0;
		extern double* maxfps;
		maxfps = &fps->flt;
		cat->settings.push_back(fps);

		auto* tq = new NamedGeneric("iTextureQuality", 3);
		tq->num_min = 2;
		tq->num_max = 5;
		cat->settings.push_back(tq);

		auto* sl = new NamedGeneric("iShaderLevel", 3);
		sl->num_min = 1;
		sl->num_max = 4;
		cat->settings.push_back(sl);

		devices.settings.engine.addCategory(cat);
	}

	{
		profile::SettingCategory* cat = new profile::SettingCategory("Sound");
		cat->settings.push_back(new NamedGeneric("sAudioDevice", ""));
		devices.settings.engine.addCategory(cat);
	}

	{
		profile::SettingCategory* cat = new profile::SettingCategory("Input");
		cat->settings.push_back(new NamedGeneric("bCursorCapture", true));
		cat->settings.push_back(new NamedGeneric("bFsCursorCapture", true));
		cat->settings.push_back(new NamedGeneric("iDoubleClickMS", (int)devices.driver->getDoubleClickTime()));
		devices.settings.engine.addCategory(cat);
	}

	{
		profile::SettingCategory* cat = new profile::SettingCategory("General");
		cat->settings.push_back(new NamedGeneric("sLocale", "english"));
		cat->settings.push_back(new NamedGeneric("sAPIToken", ""));

		auto* autosave = new NamedGeneric("dAutosaveMinutes", 3.0);
		autosave->flt_min = 0.0;
		autosave->flt_max = 60.0;
		cat->settings.push_back(autosave);

		auto* count = new NamedGeneric("iAutosaveCount", (int)0);
		count->num_min = 1;
		count->num_max = 10;
		cat->settings.push_back(count);


		cat->settings.push_back(new NamedGeneric("iNetworkRateLimit", (int)250));
		devices.settings.engine.addCategory(cat);
	}

	//Save to profile
	std::string file = path_join(getProfileRoot(), "settings.txt");

	if(fileExists(file))
		devices.settings.engine.loadSettings(file);
	else
		devices.settings.engine.saveSettings(file);

	//Generate new tokens
	{
		auto* token = devices.settings.engine.getSetting("sAPIToken");
		if(token && (token->toString().empty() || token->toString() == "JGeaaKcaaa")) {
			std::string pass;
			do {
				pass.clear();
				uint64_t pw = (uint64_t)sysRandomi() << 32 | (uint64_t)sysRandomi();
				const char* base64 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-+=!~$%#&^*";

				for(unsigned i = 0; i < 10; ++i) {
					auto v = (pw % 64);
					pw >>= 6;
					pass.append(1, base64[v]);
				}
			} while(pass == "JGeaaKcaaa");

			token->setString(pass);
			devices.settings.engine.saveSettings(file);
		}
	}
}