#include "empire.h"
#include "empire_stats.h"
#include "compat/misc.h"
#include "design/design.h"
#include "main/logging.h"
#include "network/network_manager.h"
#include "main/references.h"
#include "network.h"
#include "assert.h"
#include "util/stat_history.h"
#include <vector>
#include "util/save_file.h"
#include "processing.h"

Empire* defaultEmpire = 0;
Empire* spectatorEmpire = 0;
Empire* playerEmpire = 0;
static std::vector<Empire*> empires;
const StateDefinition* empStates = 0;
static EmpMask nextMask = 2;
static unsigned char nextID = 0;

extern std::vector<SubsystemDef::ModifyStage*> ModifiersByID;

static const vec2i ICON_SIZE(64, 64);
static const vec2i SHEET_PAGE_SIZE(256, 256);
static const unsigned ICONS_PER_SHEET = 9;
static const unsigned ICON_SPACING = 2;

unsigned validEmpireCount;
EmpMask currentVision[32];

Empire* Empire::getDefaultEmpire() {
	return defaultEmpire;
}

Empire* Empire::getSpectatorEmpire() {
	return spectatorEmpire;
}

Empire* Empire::getPlayerEmpire() {
	return playerEmpire;
}

unsigned Empire::getEmpireCount() {
	return empires.size();
}

Empire* Empire::getEmpireByIndex(unsigned index) {
	if(index < empires.size())
		return empires[index];
	else
		return 0;
}

Empire* Empire::getEmpireByID(unsigned char id) {
	if(id == INVALID_EMPIRE)
		return 0;
	if(id == DEFAULT_EMPIRE)
		return defaultEmpire;
	if(id == SPECTATOR_EMPIRE)
		return spectatorEmpire;
	for(unsigned i = 0; i < empires.size(); ++i)
		if(empires[i]->id == id)
			return empires[i];
	return 0;
}

void Empire::setPlayerEmpire(Empire* emp) {
	playerEmpire = emp;
}
	
void* Empire::operator new(size_t size) {
	if(empStates)
		size += empStates->getSize(size);
	return ::operator new(size);
}

void Empire::clearEmpires() {
	for(auto emp = empires.begin(); emp != empires.end(); ++emp)
		delete *emp;
	empires.clear();

	delete defaultEmpire;
	defaultEmpire = 0;
	delete spectatorEmpire;
	spectatorEmpire = 0;
	playerEmpire = 0;

	nextMask = 2;
	nextID = 0;

	memset(currentVision, 0, sizeof(currentVision));
	validEmpireCount = 0;
}

void Empire::initEmpires() {
	if(!defaultEmpire)
		defaultEmpire = new Empire(DEFAULT_EMPIRE);
	if(!spectatorEmpire) {
		spectatorEmpire = new Empire(SPECTATOR_EMPIRE);
		spectatorEmpire->visionMask = ~0;
	}
}

void Empire::registerObject(Object* obj) {
	threads::WriteLock lock(objectLock);
	objects.push_back(obj);
	obj->grab();
}

void Empire::unregisterObject(Object* obj) {
	//TODO: Improve
	threads::WriteLock lock(objectLock);
	for(auto i = objects.begin(), end = objects.end(); i != end; ++i) {
		if(*i == obj) {
			obj->drop();
			objects.erase(i);
			break;
		}
	}
}

unsigned Empire::objectCount() {
	return objects.size();
}

Object* Empire::findObject(unsigned i) {
	threads::ReadLock lock(objectLock);
	if(i < objects.size())
		return objects[i];
	else
		return 0;
}

void Empire::setEmpireStates(const StateDefinition* states) {
	empStates = states;
}

const StateDefinition* Empire::getEmpireStates() {
	return empStates;
}

Empire::Empire(unsigned char ID) : index(-1), background(0), portrait(0), flag(0), flagID(0), player(0), hullIconIndex(0), validEmpIndex(0) {
	if(ID == INVALID_EMPIRE) {
		objects.reserve(1250);
		id = ++nextID;
		mask = nextMask;
		nextMask <<= 1;
	}
	else {
		mask = ID == DEFAULT_EMPIRE ? 1 : 0;
		id = ID;
	}
	visionMask = mask;
	hostileMask = 0;

	unsigned subsysCnt = getSubsystemDefCount();
	subsysData.resize(subsysCnt);
	for(unsigned i = 0; i < subsysCnt; ++i) {
		auto& data = subsysData[i];
		const SubsystemDef* def = getSubsystemDef(i);
		if(def->defaultUnlock)
			data.unlocked = true;
		data.modulesUnlocked.resize(def->modules.size());
		for(unsigned j = 0, jcnt = def->modules.size(); j < jcnt; ++j)
			data.modulesUnlocked[j] = def->modules[j]->defaultUnlock;
	}

	if(valid()) {
		statHistories.resize(getEmpireStatCount());
		for(unsigned i = 0; i < statHistories.size(); ++i)
			statHistories[i] = new StatHistory;
		statLocks.resize(statHistories.size());
	}

	if(empStates) {
		void* mixinMem = this + 1;
		empStates->prepare(mixinMem);
	}

	if(valid()) {
		empires.push_back(this);
		index = empires.size() - 1;
		validEmpIndex = validEmpireCount;
		currentVision[validEmpIndex] = mask;
		++validEmpireCount;
	}

	processing::startEmpireThread(this);
}

bool Empire::valid() {
	return id < UNLISTED_EMPIRE;
}

Empire::~Empire() {
	if(empStates) {
		void* mixinMem = this + 1;
		empStates->unprepare(mixinMem);
	}

	foreach(it, designIds)
		(*it)->drop();
	foreach(it, designClasses)
		delete it->second;
	foreach(it, objects)
		(*it)->drop();
	foreach(it, hullDistantIcons)
		delete *it;
	foreach(it, hullFleetIcons)
		delete *it;
	foreach(it, hullIcons) {
		delete (*it)->material.textures[0];
		delete *it;
	}
	foreach(it, hullImages)
		delete *it;
}

void Empire::cacheVision() {
	if(valid())
		currentVision[validEmpIndex] = visionMask;
}

extern threads::atomic_int remainingMessages;
void Empire::processMessages(unsigned maxMessages) {
	if(messages.empty())
		return;

	if(!processLock.try_lock())
		return;

	while(maxMessages-- && !messages.empty()) {
		msgLock.lock();
		EmpireMessage* msg = nullptr;
		if(!messages.empty()) {
			msg = messages.front();
			messages.pop_front();
		}
		msgLock.release();

		if(msg) {
			msg->process(this);
			delete msg;
		}
		--remainingMessages;
	}

	processLock.release();
}

void Empire::queueMessage(EmpireMessage* msg) {
	if(!msg)
		return;

	msgLock.lock();
	++remainingMessages;
	messages.push_back(msg);
	msgLock.release();
}

void Empire::recordStat(unsigned id, int value) {
	if(id < statHistories.size()) {
		threads::WriteLock lock(statLocks[id]);

		StatHistory* history = statHistories[id];

		StatEntry* entry = history->addStatEntry(unsigned(devices.driver->getGameTime()));
		entry->asInt = value;
	}
}

void Empire::recordStatDelta(unsigned id, int delta) {
	if(id < statHistories.size()) {
		threads::WriteLock lock(statLocks[id]);

		StatHistory* history = statHistories[id];

		unsigned time = unsigned(devices.driver->getGameTime());

		StatEntry* tail = history->getTail();
		if(tail && tail->time == time) {
			tail->asInt += delta;
		}
		else {
			StatEntry* entry = history->addStatEntry(time);
			entry->asInt = entry->prev ? entry->prev->asInt + delta : entry->asInt + delta;
		}
	}
}

void Empire::recordStat(unsigned id, float value) {
	if(id < statHistories.size()) {
		threads::WriteLock lock(statLocks[id]);

		StatHistory* history = statHistories[id];

		StatEntry* entry = history->addStatEntry(unsigned(devices.driver->getGameTime()));
		entry->asFloat = value;
	}
}

void Empire::recordStatDelta(unsigned id, float delta) {
	if(id < statHistories.size()) {
		threads::WriteLock lock(statLocks[id]);

		StatHistory* history = statHistories[id];

		unsigned time = unsigned(devices.driver->getGameTime());

		StatEntry* tail = history->getTail();
		if(tail && tail->time == time) {
			tail->asFloat += delta;
		}
		else {
			StatEntry* entry = history->addStatEntry(time);
			entry->asFloat = entry->prev ? entry->prev->asFloat + delta : entry->asFloat + delta;
		}
	}
}

void Empire::recordEvent(unsigned id, unsigned short type, const std::string& name) {
	if(id < statHistories.size()) {
		threads::WriteLock lock(statLocks[id]);

		StatHistory* history = statHistories[id];

		StatEntry* entry = history->getTail();
		if(!entry)
			entry = history->addStatEntry(unsigned(devices.driver->getGameTime()));
		entry->addEvent(type, name);
	}
}

const StatHistory* Empire::lockStatHistory(unsigned id) {
	if(id < statHistories.size()) {
		statLocks[id].readLock();
		return statHistories[id];
	}
	return 0;
}

void Empire::unlockStatHistory(unsigned id) {
	if(id < statHistories.size())
		statLocks[id].release();
}

bool Empire::addDesign(DesignClass* cls, const Design* design) {
	if(design->hasFatalErrors()) {
		error("Could not add design '%s', design has fatal errors:",
			design->name.c_str());
		for(auto i = design->errors.begin(), end = design->errors.end(); i != end; ++i)
			error("  %s", i->text.c_str());
		return false;
	}

	threads::WriteLock lock(designMutex);
	auto it = designs.find(design->name);
	if(it != designs.end())
		return false;

	design->owner = this;
	design->used = true;
	design->cls = cls;
	design->revision = 1;
	designs.insert(it, std::pair<std::string, const Design*>(design->name, design));
	cls->designs.push_back(design);

	design->grab();
	design->id = designIds.size();
	designIds.push_back(design);

	makeDesignIcon(design);

	if(devices.network->isServer || devices.network->isClient)
		devices.network->sendDesign(this, cls, design);

	return true;
}

bool Empire::changeDesign(const Design* older, const Design* newer, DesignClass* cls) {
	if(newer->hasFatalErrors()) {
		error("Could not update design '%s', new design has fatal errors.",
			newer->name.c_str());
		return false;
	}

	//TODO: Print sensible error messages
	if(older->owner != this || !older->used) {
		error("Could not update design '%s', old design not owned by this empire.",
			newer->name.c_str());
		return false;
	}

	threads::WriteLock lock(designMutex);
	setDesign(older, newer, cls);

	if(devices.network->isServer || devices.network->isClient)
		devices.network->sendDesignUpdate(this, older, newer, cls);

	return true;
}

void Empire::setDesign(const Design* older, const Design* newer, DesignClass* cls) {
	if(older->owner != this)
		return;
	threads::WriteLock lock(designMutex);
	if(older->original != nullptr)
		older = older->original;
	if(cls == nullptr)
		cls = older->cls;
	
	if(newer->id == (unsigned)-1) {
		newer->grab();
		newer->id = designIds.size();
		designIds.push_back(newer);
	}

	newer->owner = this;
	newer->used = true;
	newer->cls = cls;

	makeDesignIcon(newer);

	//Replace indicated older
	older->newer = newer;
	newer->revision = older->revision + 1;

	//Deal with changing name
	if(older->name == newer->name) {
		designs[older->name] = newer;

		if(cls == older->cls) {
			//Replace it in its class
			for(size_t i = 0, cnt = older->cls->designs.size(); i < cnt; ++i) {
				if(older->cls->designs[i]->base() == older) {
					older->cls->designs[i] = newer;
					break;
				}
			}
		}
		else {
			//Remove from previous class
			foreach(it, older->cls->designs) {
				if((*it)->base() == older) {
					older->cls->designs.erase(it);
					break;
				}
			}

			//Add to new class
			cls->designs.push_back(newer);
		}
	}
	else {
		//Remove previous from class
		foreach(it, older->cls->designs) {
			if((*it)->base() == older) {
				older->cls->designs.erase(it);
				break;
			}
		}

		//Also replace the design we're overwriting
		auto it = designs.find(newer->name);
		if(it != designs.end()) {
			const Design* other = it->second->base();
			other->newer = newer;
			newer->revision = std::max(newer->revision, other->revision + 1);

			designs[other->name] = newer;

			if(cls == other->cls) {
				//Replace it in its class too
				bool found = false;
				for(size_t i = 0, cnt = other->cls->designs.size(); i < cnt; ++i) {
					if(other->cls->designs[i]->base() == other) {
						other->cls->designs[i] = newer;
						found = true;
						break;
					}
				}

				if(!found) {
					//Add to new class
					cls->designs.push_back(newer);
				}
			}
			else {
				//Remove from previous class
				foreach(it, other->cls->designs) {
					if((*it)->base() == other) {
						other->cls->designs.erase(it);
						break;
					}
				}

				//Add to new class
				cls->designs.push_back(newer);
			}
		}
		else {
			designs[newer->name] = newer;

			//Add to class as new design
			cls->designs.push_back(newer);
		}
	}
}

const Design* Empire::updateDesign(const Design* dsg, bool onlyOutdated) {
	if(devices.network->isClient)
		return 0;
	if(dsg->owner != this)
		return dsg;
	if(!dsg->updated && !dsg->outdated && onlyOutdated)
		return dsg;

	threads::WriteLock lock(designMutex);

	//Mark all designs in this design path as no longer outdated
	while(true) {
		if(dsg->updated) {
			dsg->outdated = false;
			dsg = dsg->updated;
		}
		else {
			if(onlyOutdated && !dsg->outdated) {
				dsg->grab();
				return dsg;
			}
			dsg->outdated = false;
			break;
		}
	}

	Design::Descriptor desc;
	dsg->toDescriptor(desc);

	const Design* newDesign = new Design(desc);
	if(newDesign->hasFatalErrors()) {
		newDesign->drop();
		dsg->grab();
		return dsg;
	}

	setDesignUpdate(dsg, newDesign);

	if(devices.network->isServer)
		devices.network->sendDesignUpdate(this, dsg, newDesign);

	newDesign->grab();
	return newDesign;
}

void Empire::setDesignUpdate(const Design* dsg, const Design* newDesign) {
	dsg->updated = newDesign;
	newDesign->data = dsg->data;
	newDesign->clientData = dsg->clientData;
	newDesign->serverData = dsg->serverData;
	newDesign->original = dsg->original ? dsg->original.ptr : dsg;
	newDesign->revision = dsg->revision;
	newDesign->obsolete = dsg->obsolete;
	newDesign->distantIcon = dsg->distantIcon;
	newDesign->icon = dsg->icon;
	newDesign->fleetIcon = dsg->fleetIcon;

	if(newDesign->id == (unsigned)-1) {
		newDesign->id = designIds.size();
		designIds.push_back(newDesign); //transfer original ref
	}
	newDesign->owner = this;
	newDesign->used = true;
	newDesign->cls = dsg->cls;

	for(size_t i = 0, cnt = newDesign->cls->designs.size(); i < cnt; ++i) {
		if(newDesign->cls->designs[i]->base() == dsg->base()) {
			newDesign->cls->designs[i] = newDesign;
			break;
		}
	}

	auto it = designs.find(newDesign->name);
	if(it != designs.end()) {
		if(it->second->base() == newDesign->base())
			designs[newDesign->name] = newDesign;
	}
}

void Empire::flagDesignOld(const Design* design) {
	if(devices.network->isClient)
		return;
	//NOTE: This can use a readlock as outdated is only used by updateDesign which can't be writing at the same time
	threads::ReadLock lock(designMutex);
	design->mostUpdated()->outdated = true;
}

const Design* Empire::getDesign(const std::string& name, bool grab) {
	threads::ReadLock lock(designMutex);
	auto it = designs.find(name);
	if(it == designs.end())
		return 0;
	if(grab)
		it->second->grab();
	return it->second;
}

const Design* Empire::getDesign(unsigned id, bool grab) {
	threads::ReadLock lock(designMutex);
	if(id >= (unsigned)designIds.size())
		return 0;
	const Design* dsg = designIds[id];
	if(grab && dsg)
		dsg->grab();
	return dsg;
}

Design* Empire::getDesignMake(unsigned id) {
	threads::WriteLock lock(designMutex);
	unsigned cnt = designIds.size();
	if(id < cnt) {
		if(!designIds[id]) {
			Design* dsg = new Design();
			dsg->id = id;
			designIds[id] = dsg;
		}
		return (Design*)designIds[id];
	}
	else {
		designIds.resize(id+1);
		for(unsigned i = cnt; i < unsigned(id); ++i)
			designIds[i] = 0;
		Design* dsg = new Design();
		dsg->id = id;
		designIds[id] = dsg;
		return dsg;
	}
}

DesignClass* Empire::getDesignClass(int id) {
	threads::ReadLock lock(designMutex);
	if(id < (int)designClassIds.size())
		return designClassIds[id];
	else
		return 0;
}

DesignClass* Empire::getDesignClass(const std::string& name, bool add) {
	{
		threads::ReadLock lock(designMutex);
		auto it = designClasses.find(name);
		if(it != designClasses.end())
			return it->second;
	}

	if(add) {
		threads::WriteLock lock(designMutex);
		DesignClass* cls = new DesignClass;
		cls->id = designClassIds.size();
		designClassIds.push_back(cls);
		cls->name = name;
		designClasses[name] = cls;
		return cls;
	}
	else {
		return 0;
	}
}

void Empire::makeDesignIcon(const Design* design) {
	threads::WriteLock lock(designMutex);

	Image* img;
	render::SpriteSheet* sheet;
	render::SpriteSheet* distantSheet;
	render::SpriteSheet* fleetSheet;

	if(hullIcons.empty() || hullIconIndex >= ICONS_PER_SHEET) {
		hullIconIndex = 0;

		auto* tex = render::RenderDriver::createTexture();

		img = new Image(SHEET_PAGE_SIZE.x, SHEET_PAGE_SIZE.y, FMT_RGBA);
		memset(img->rgba, 0x00, sizeof(Color) * img->width * img->height);

		sheet = new render::SpriteSheet();
		sheet->material = devices.library.getMaterial("ShipIcon");
		sheet->width = ICON_SIZE.x;
		sheet->height = ICON_SIZE.y;
		sheet->spacing = ICON_SPACING;
		sheet->material.textures[0] = tex;
		hullIcons.push_back(sheet);

		distantSheet = new render::SpriteSheet();
		distantSheet->material = devices.library.getMaterial("ShipDistantIcon");
		distantSheet->width = ICON_SIZE.x;
		distantSheet->height = ICON_SIZE.y;
		distantSheet->material.textures[0] = tex;
		distantSheet->spacing = ICON_SPACING;
		hullDistantIcons.push_back(distantSheet);

		fleetSheet = new render::SpriteSheet();
		fleetSheet->material = devices.library.getMaterial("FleetIcon");
		fleetSheet->width = ICON_SIZE.x;
		fleetSheet->height = ICON_SIZE.y;
		fleetSheet->material.textures[0] = tex;
		fleetSheet->spacing = ICON_SPACING;
		hullFleetIcons.push_back(fleetSheet);

		hullImages.push_back(img);
	}
	else {
		sheet = hullIcons[hullIcons.size() - 1];
		distantSheet = hullDistantIcons[hullIcons.size() - 1];
		fleetSheet = hullFleetIcons[hullIcons.size() - 1];
		img = hullImages[hullIcons.size() - 1];
	}

	unsigned perLine = (SHEET_PAGE_SIZE.x - sheet->spacing) / (sheet->width + sheet->spacing);
	vec2i source(hullIconIndex % perLine, hullIconIndex / perLine);
	source.x = source.x * (sheet->width + sheet->spacing) + sheet->spacing;
	source.y = source.y * (sheet->height + sheet->spacing) + sheet->spacing;

	design->makeDistanceMap(*img, source, ICON_SIZE);

	int prior = -hullImages.size() * ICONS_PER_SHEET - hullIconIndex;
	resource::queueTextureUpdate(sheet->material.textures[0], new Image(*img), prior, sheet->material.mipmap);
	design->icon = render::Sprite(sheet, hullIconIndex);
	design->distantIcon = render::Sprite(distantSheet, hullIconIndex);
	design->fleetIcon = render::Sprite(fleetSheet, hullIconIndex);

	hullIconIndex += 1;
}

Empire::SubsystemData* Empire::getSubsystemData(const SubsystemDef* def) {
	if(def->index >= (int)subsysData.size())
		return 0;
	return &subsysData[def->index];
}

static inline void sendDetails(net::Message& msg, Empire& emp) {
	msg << emp.name;
	msg << emp.visionMask;
	msg << emp.hostileMask;
	msg << emp.color;
}

static inline void recvDetails(net::Message& msg, Empire& emp) {
	msg >> emp.name;
	msg >> emp.visionMask;
	msg >> emp.hostileMask;
	msg >> emp.color;
}

void Empire::sendDesign(net::Message& msg, const Design* dsg, bool fromServer) {
	msg.writeSmall(dsg->id);
	if(fromServer)
		dsg->writeData(msg);
	else
		dsg->write(msg);
}

Design* Empire::recvDesign(net::Message& msg, bool fromServer) {
	unsigned id = msg.readSmall();
	Design* dsg = getDesignMake(id);
	if(dsg->initialized)
		return dsg;

	if(fromServer) {
		dsg->initData(msg);
	}
	else {
		dsg->init(msg);
		dsg->used = true;
	}

	return dsg;
}

void Empire::SubsystemData::write(net::Message& msg) {
	msg.writeBit(unlocked);
	msg.writeSmall(modulesUnlocked.size());
	for(size_t i = 0, cnt = modulesUnlocked.size(); i < cnt; ++i)
		msg.writeBit(modulesUnlocked[i]);
	msg.writeSmall(stages.size());
	foreach(it, stages) {
		msg.writeSmall(it->first);
		msg.writeSmall(it->second.stage->index);
		for(size_t i = 0; i < MODIFY_STAGE_MAXARGS; ++i)
			msg << it->second.arguments[i];
	}
}

void Empire::SubsystemData::read(const SubsystemDef* def, net::Message& msg) {
	unlocked = msg.readBit();
	modulesUnlocked.resize(msg.readSmall());
	for(size_t i = 0, cnt = modulesUnlocked.size(); i < cnt; ++i)
		modulesUnlocked[i] = msg.readBit();

	unsigned stageCnt = msg.readSmall();
	stages.clear();
	for(unsigned i = 0; i < stageCnt; ++i) {
		unsigned id = msg.readSmall();
		unsigned index = msg.readSmall();
		if(index >= def->modifiers.size()) {
			assert(false);
			return;
		}

		SubsystemDef::AppliedStage as;
		as.stage = def->modifiers[index];
		for(size_t i = 0; i < MODIFY_STAGE_MAXARGS; ++i)
			msg >> as.arguments[i];

		stages[id] = as;
	}
}

void Empire::writeDelta(net::Message& msg) {
	threads::ReadLock lock(subsystemDataMutex);
	msg.writeAlign();
	auto pos = msg.reserve<unsigned>();
	unsigned amount = 0;
	for(unsigned i = 0, cnt = subsysData.size(); i < cnt; ++i) {
		if(subsysData[i].delta) {
			msg.writeSmall(i);
			subsysData[i].write(msg);
			subsysData[i].delta = false;
			++amount;
		}
	}
	msg.fill<unsigned>(pos, amount);
	for(unsigned i = 0, cnt = statHistories.size(); i < cnt; ++i) {
		auto* stat = lockStatHistory(i);
		if(!stat) {
			msg.write0();
			continue;
		}
		auto* s = stat->getTail();
		if(s) {
			msg.write1();
			msg << s->asInt;
		}
		else {
			msg.write0();
		}
		unlockStatHistory(i);
	}
}

void Empire::readDelta(net::Message& msg) {
	threads::WriteLock lock(subsystemDataMutex);
	msg.readAlign();

	unsigned amount = 0;
	msg >> amount;
	for(unsigned i = 0; i < amount; ++i) {
		unsigned index = msg.readSmall();
		if(index >= subsysData.size()) {
			assert(false);
			return;
		}

		subsysData[index].read(getSubsystemDef(index), msg);
	}

	for(unsigned i = 0, cnt = statHistories.size(); i < cnt; ++i) {
		if(!msg.readBit())
			continue;
		if(statIsint(i))
			recordStat(i, msg.readIn<int>());
		else
			recordStat(i, msg.readIn<float>());
	}
}

void Empire::sendInitial(net::Message& msg) {
	assert(devices.network->isServer);
	
	//Write static data
	msg << id;
	msg << mask;
	
	unsigned shipsetID = shipset ? shipset->id : 0;
	msg << shipsetID;

	//Write other data
	sendDetails(msg, *this);

	//Write designs
	unsigned clsCnt = designClassIds.size();
	msg.writeSmall(clsCnt);
	for(unsigned i = 0; i < clsCnt; ++i) {
		DesignClass* cls = designClassIds[i];
		msg << cls->name;
	}

	unsigned dsgCnt = designIds.size();
	msg.writeSmall(dsgCnt);
	for(unsigned j = 0; j < dsgCnt; ++j) {
		const Design* dsg = designIds[j];
		sendDesign(msg, dsg, true);
	}

	//Write subsystem data
	for(unsigned i = 0, cnt = subsysData.size(); i < cnt; ++i)
		subsysData[i].write(msg);

	for(unsigned i = 0, cnt = statHistories.size(); i < cnt; ++i) {
		auto& stat = *lockStatHistory(i);
		bool isInt = statIsint(i);

		unsigned lastTime = 0;

		int prevInt = 0;
		float fMin = 0.f, fMax = 128.f;

		auto* s = stat.getHead();
		while(s) {
			msg.write1();
			unsigned dT = s->time - lastTime;
			if(dT < 15)
				msg.writeLimited(dT, 0, 15);
			else {
				msg.writeLimited(15, 0, 15);
				msg.writeSmall(dT-15);
			}
			lastTime = s->time;
			if(isInt) {
				msg.writeSignedSmall(s->asInt - prevInt);
				prevInt = s->asInt;
			}
			else {
				float v = s->asFloat;
				if(v >= fMin && v <= fMax) {
					msg.write0();
					msg.writeFixed(v, fMin, fMax, 10);
				}
				else {
					msg.write1();
					msg << v;
					if(v < fMin)
						fMin = v - 64.f - v/16.f;
					if(v > fMax)
						fMax = v + 64.f + v/16.f;
				}
			}

			auto* e = s->evt;
			while(e) {
				msg.write1();
				msg << e->type;
				msg << e->name;
				e = e->next;
			}
			msg.write0();

			s = s->next;
		}
		msg.write0();

		unlockStatHistory(i);
	}
}

Empire* recvEmpireInitial(net::Message& msg) {
	assert(devices.network->isClient);
	Empire* emp = new Empire();
	
	//Receive static data
	msg >> emp->id;
	msg >> emp->mask;

	emp->shipset = getShipset(msg.readIn<unsigned>());

	//Receive other data
	recvDetails(msg, *emp);

	//Receive designs
	unsigned clsCnt = msg.readSmall();
	for(unsigned i = 0; i < clsCnt; ++i) {
		DesignClass* cls = new DesignClass;
		cls->id = emp->designClassIds.size();
		msg >> cls->name;

		emp->designClassIds.push_back(cls);
		emp->designClasses[cls->name] = cls;
	}

	unsigned dsgCnt = msg.readSmall();
	for(unsigned j = 0; j < dsgCnt; ++j) {
		Design* dsg = emp->recvDesign(msg, true);

		if(!dsg->original || dsg->original == dsg) {
			emp->makeDesignIcon(dsg);
		}
		else if(dsg->original) {
			dsg->icon = dsg->original->icon;
			dsg->distantIcon = dsg->original->distantIcon;
			dsg->fleetIcon = dsg->original->fleetIcon;
		}

		if(!dsg->newer && !dsg->updated)
			dsg->cls->designs.push_back(dsg);
		if(!dsg->updated)
			emp->designs[dsg->name] = dsg;
	}

	for(unsigned i = 0, cnt = emp->subsysData.size(); i < cnt; ++i)
		emp->subsysData[i].read(getSubsystemDef(i), msg);

	for(unsigned i = 0, cnt = emp->statHistories.size(); i < cnt; ++i) {
		auto& stat = *(StatHistory*)emp->lockStatHistory(i);
		if(&stat == 0)
			break;
		bool isInt = statIsint(i);

		unsigned lastTime = 0;

		int prevInt = 0;
		float fMin = 0.f, fMax = 128.f;

		while(msg.readBit()) {
			unsigned dT = msg.readLimited(0, 15);
			if(dT == 15)
				dT = msg.readSmall() + 15;

			auto* s = stat.addStatEntry(lastTime + dT);
			lastTime = s->time;

			if(isInt) {
				s->asInt = prevInt + msg.readSignedSmall();
				prevInt = s->asInt;
			}
			else {
				if(!msg.readBit()) {
					s->asFloat = msg.readFixed(fMin, fMax, 10);
				}
				else {
					float v = msg.readIn<float>();
					s->asFloat = v;
					if(v < fMin)
						fMin = v - 64.f - v/16.f;
					if(v > fMax)
						fMax = v + 64.f + v/16.f;
				}
			}

			while(msg.readBit()) {
				unsigned short id = 0;
				std::string text;
				msg >> id >> text;
				s->addEvent(id, text);
			}

			s = s->next;
		}

		emp->unlockStatHistory(i);
	}

	info("Received empire '%s' (%d).",
		emp->name.c_str(), emp->id);

	return emp;
}

Empire::Empire(SaveFile& file) : background(0), portrait(0), flag(0), flagID(0), player(0) {
	file >> id >> index >> name >> mask >> visionMask >> hostileMask >> color;
	file >> backgroundDef >> portraitDef >> flagDef;
	if(file >= SFV_0019)
		file >> flagID;

	if(valid()) {
		validEmpIndex = validEmpireCount;
		currentVision[validEmpIndex] = visionMask;
		++validEmpireCount;
	}

	//Push this empire immediately so designs can locate us
	empires.push_back(this);

	if(empStates) {
		void* mixinMem = this + 1;
		empStates->prepare(mixinMem);
	}

	file.boundary();

	//Load owned objects
	unsigned objectCount = file;
	objects.resize(objectCount);
	for(unsigned i = 0; i < objectCount; ++i)
		file >> objects[i];

	if(file < SFV_0004)
		shipset = getShipset("Original_r3000");
	else
		shipset = getShipset(file.readIdentifier(SI_Shipset));

	if(file >= SFV_0007)
		file >> effectorSkin;

	//Load designs
	unsigned dsgnCount = file;
	designIds.resize(dsgnCount, 0);
	for(unsigned i = 0; i < designIds.size(); ++i) {
		Design* design = new Design(file);
		designIds[i] = design;
		designs[design->name] = design;
		if(i != design->id) {
			//Try and fix old saves. probably futile in most situations.
			design->id = i;
		}
	}

	//Load design classes
	unsigned dsgnClassCount = file;
	designClassIds.reserve(dsgnClassCount);
	for(unsigned i = 0; i < dsgnClassCount; ++i) {
		DesignClass* dsgnClass = new DesignClass;
		dsgnClass->id = designClassIds.size();
		designClassIds.push_back(dsgnClass);
		file >> dsgnClass->name;
		designClasses[dsgnClass->name] = dsgnClass;

		unsigned classDesignCount = file;
		dsgnClass->designs.reserve(classDesignCount);

		for(unsigned j = 0; j < classDesignCount; ++j) {
			int designID = file;
			const Design* dsg = getDesign(designID);
			if(dsg)
				dsgnClass->designs.push_back(dsg);
		}
	}

	//Load design links
	for(unsigned i = 0; i < designIds.size(); ++i) {
		Design* dsg = (Design*)designIds[i];

		unsigned id;
		file >> id;
		if(id < designClassIds.size())
			dsg->cls = designClassIds[id];
		else
			dsg->cls = designClassIds[0];

		file >> id;
		if(id == (unsigned)-1 || id >= designIds.size())
			dsg->newer = nullptr;
		else
			dsg->newer = designIds[id];

		file >> id;
		if(id == (unsigned)-1 || id >= designIds.size())
			dsg->updated = nullptr;
		else
			dsg->updated = designIds[id];

		file >> id;
		if(id == (unsigned)-1 || id >= designIds.size())
			dsg->original = nullptr;
		else
			dsg->original = designIds[id];

		if(!dsg->original || dsg->original == dsg) {
			makeDesignIcon(dsg);
		}
		else if(dsg->original) {
			dsg->icon = dsg->original->icon;
			dsg->distantIcon = dsg->original->distantIcon;
			dsg->fleetIcon = dsg->original->fleetIcon;

			dsg->data = dsg->original->data;
			dsg->clientData = dsg->original->clientData;
			dsg->serverData = dsg->original->serverData;
		}
	}

	file.boundary();

	//Initialize subsystem data
	unsigned subsysCnt = getSubsystemDefCount();
	subsysData.resize(subsysCnt);
	for(unsigned i = 0; i < subsysCnt; ++i) {
		auto& data = subsysData[i];
		const SubsystemDef* def = getSubsystemDef(i);
		if(def->defaultUnlock)
			data.unlocked = true;
		data.modulesUnlocked.resize(def->modules.size());
		for(unsigned j = 0, jcnt = def->modules.size(); j < jcnt; ++j)
			data.modulesUnlocked[j] = def->modules[j]->defaultUnlock;
	}

	//Load subsystem data
	unsigned cnt = file;
	for(unsigned n = 0; n < cnt; ++n) {
		int i = file.readIdentifier(SI_Subsystem);
		if(i == -1)
			throw SaveFileError("Subsystem was removed.");

		SubsystemData& dat = subsysData[i];
		file >> dat.unlocked;
		file >> dat.nextStageId;

		unsigned modCnt = file;
		dat.modulesUnlocked.resize(modCnt);
		for(unsigned j = 0; j < modCnt; ++j)
			dat.modulesUnlocked[j] = (bool)file;

		//Assumptions: empire stages are always
		//from modifiers in the subsystem root,
		//and cannot have formula modifiers.
		// (Currently satisfied)
		const SubsystemDef* def = getSubsystemDef(i);
		unsigned stageCnt = file;
		for(unsigned j = 0; j < stageCnt; ++j) {
			SubsystemDef::AppliedStage stg;
			unsigned id = file;
			unsigned index = 0;
			if(file >= SFV_0015) {
				unsigned uid = (unsigned)file.readIdentifier(SI_SubsystemModifier);
				if(uid < ModifiersByID.size())
					index = ModifiersByID[uid]->index;
				else
					index = (unsigned)-1;
			}
			else
				index = file;
			file.read(stg.arguments, MODIFY_STAGE_MAXARGS * sizeof(float));

			if(index >= def->modifiers.size())
				continue;
			stg.stage = def->modifiers[index];
			dat.stages[id] = stg;
		}
	}
	
	statHistories.resize(getEmpireStatCount());
	statLocks.resize(statHistories.size());
	for(unsigned i = 0; i < statHistories.size(); ++i)
		statHistories[i] = new StatHistory();

	if(file >= SFV_0014) {
		unsigned count = 0;
		file >> count;

		while(count--) {
			std::string name;
			file >> name;

			StatHistory* stat = nullptr;
			StatEntry dummy;
			StatEvent evt;

			auto getEntry = [&](unsigned time) -> StatEntry* {
				if(stat)
					return stat->addStatEntry(time);
				else
					return &dummy;
			};

			auto addEvent = [&](StatEntry* entry, const std::string& text, unsigned short id) {
				if(stat)
					entry->addEvent(id, text);
			};

			unsigned index = getStatID(name);
			if(index < statHistories.size())
				stat = statHistories[index];

			while(true) {
				unsigned time = 0;
				file >> time;
				if(time == 0xffffffff)
					break;

				auto* h = getEntry(time);
				file >> h->asInt;

				while(true) {
					unsigned short evtID = 0;
					file >> evtID;
					if(evtID == 0xffff)
						break;

					std::string text;
					file >> text;
					addEvent(h, text, evtID);
				}
			}
			
		}
	}

	file.boundary();

	bool isPlayer = file;
	if(isPlayer) {
		playerEmpire = this;
		devices.network->currentPlayer.emp = playerEmpire;
		devices.network->currentPlayer.controlMask = playerEmpire->mask;
		devices.network->currentPlayer.viewMask = playerEmpire->mask;
	}

	processing::startEmpireThread(this);
}

void Empire::save(SaveFile& file) {
	file << id << index << name << mask << visionMask << hostileMask << color;
	file << backgroundDef << portraitDef << flagDef << flagID;

	file.boundary();

	//Save owned objects
	file << unsigned(objects.size());
	for(unsigned i = 0; i < objects.size(); ++i) {
		Object* obj = objects[i];
		file << obj;
	}

	if(shipset)
		file.writeIdentifier(SI_Shipset, shipset->id);
	else
		file.writeIdentifier(SI_Shipset, (unsigned)-1);

	file << effectorSkin;

	//Save designs
	file << unsigned(designIds.size());
	for(unsigned i = 0; i < designIds.size(); ++i) {
		designIds[i]->save(file);
	}

	//Save design classes
	file << unsigned(designClassIds.size());
	for(unsigned i = 0; i < designClassIds.size(); ++i) {
		DesignClass* dsgnClass = designClassIds[i];
		file << dsgnClass->name;

		file << unsigned(dsgnClass->designs.size());
		for(unsigned j = 0; j < dsgnClass->designs.size(); ++j)
			file << dsgnClass->designs[j]->id;
	}

	//Save design links
	for(unsigned i = 0; i < designIds.size(); ++i) {
		const Design* dsg = designIds[i];
		file << dsg->cls->id;

		if(dsg->newer)
			file << dsg->newer->id;
		else
			file << (unsigned)-1;

		if(dsg->updated)
			file << dsg->updated->id;
		else
			file << (unsigned)-1;

		if(dsg->original)
			file << dsg->original->id;
		else
			file << (unsigned)-1;
	}

	file.boundary();

	//Save subsystem data
	unsigned cnt = subsysData.size();
	file << cnt;
	for(unsigned i = 0; i < cnt; ++i) {
		SubsystemData& dat = subsysData[i];
		file.writeIdentifier(SI_Subsystem, i);
		file << dat.unlocked;
		file << dat.nextStageId;

		unsigned modCnt = dat.modulesUnlocked.size();
		file << modCnt;
		for(unsigned j = 0; j < modCnt; ++j)
			file << (bool)dat.modulesUnlocked[j];

		//Assumptions: empire stages are always
		//from modifiers in the subsystem root,
		//and cannot have formula modifiers.
		// (Currently satisfied)
		unsigned stageCnt = dat.stages.size();
		file << stageCnt;
		foreach(it, dat.stages) {
			file << it->first;
			auto& stg = it->second;
			file.writeIdentifier(SI_SubsystemModifier, stg.stage->umodifid);
			file.write(stg.arguments, MODIFY_STAGE_MAXARGS * sizeof(float));
		}
	}

	cnt = statHistories.size();
	file << cnt;

	unsigned statID = 0;
	for(auto i = statHistories.begin(), end = statHistories.end(); i != end; ++i, ++statID) {
		StatHistory& stat = **i;

		file << getEmpireStatName(statID);

		auto* s = stat.getHead();
		while(s) {
			file << s->time;
			file << s->asInt;
			auto* e = s->evt;
			while(e) {
				file << e->type;
				file << e->name;
				e = e->next;
			}
			unsigned short evtEnd = 0xffff;
			file << evtEnd;

			s = s->next;
		}

		unsigned statEnd = 0xffffffff;
		file << statEnd;
	}

	file.boundary();
	
	file << (playerEmpire == this);
}

void Empire::saveEmpires(SaveFile& file) {
	file << unsigned(empires.size());

	for(unsigned i = 0; i < empires.size(); ++i)
		empires[i]->save(file);
}

void Empire::loadEmpires(SaveFile& file) {
	initEmpires();
	unsigned empireCount = file;

	for(unsigned i = 0; i < empireCount; ++i)
		new Empire(file);
	if(playerEmpire == nullptr)
		playerEmpire = spectatorEmpire;
}