#priority init 1000
import saving;
import hooks;
import system_pathing;
import resources;
import tile_resources;
#section server-side
from regions.regions import getRegion;
import SystemDesc@ getSystem(Region@ region) from "game_start";
#section all

export OrbitalModule, OrbitalSection;
export getOrbitalModule, getOrbitalModuleCount;
export OrbitalRequirements;
export OrbitalValues, canBuildOrbital;

array<OrbitalModule@> modules;
dictionary idents;

enum OrbitalValues {
	OV_DRY_Design,
	OV_DRY_Progress,
	OV_DRY_Financed,
	OV_DRY_Free,
	OV_DRY_SetFinanced,
	OV_DRY_ModLabor,
	OV_DRY_ETA,
	OV_PackUp,
	OV_Trade,
	OV_FRAME_Usable,
	OV_FRAME_CostFactor,
	OV_FRAME_LaborFactor,
	OV_FRAME_LaborPenaltyFactor,
	OV_FRAME_Target,
};

bool canBuildOrbital(Object@ obj, const vec3d& pos, bool initial = true) {
	//Find target system
	Region@ target = getRegion(pos);
	if(target is null)
		return false;

	//Cannot build without vision
	if(initial && target.MemoryMask & obj.owner.mask == 0 && target.VisionMask & obj.owner.visionMask == 0)
		return false;

	//Check trade pathing
	if(initial || !obj.isShip) {
		if(obj.region is null)
			return false;
		TradePath path(obj.owner);
		path.generate(getSystem(obj.region), getSystem(target));
		if(!path.isUsablePath)
			return false;
	}
	return true;
}

tidy final class OrbitalModule {
	uint id;
	string ident;
	string name;
	string blurb;
	string description;
	Sprite icon;

	Sprite distantIcon;
	Sprite strategicIcon;
	double iconSize = 0.035;
	const Material@ material;
	const Model@ model;
	double size = 10.0;

	int maintenance = 0;
	int buildCost = 0;
	double laborCost = 0;

	double health = 0;
	double armor = 0;
	double spin = 30.0;
	double mass = -1.0;

	bool isCore = true;
	bool isSolid = true;
	bool isStandalone = true;
	bool isUnique = true;

	bool combatRepair = true;
	bool canFling = true;

	array<IOrbitalEffect@> hooks;
	array<Hook@> ai;

	array<uint> affinities(TR_COUNT, 0);
	array<const ResourceType@> requirements;
	uint totalRequirementCount = 0;

	bool canBuildBy(Object@ obj, bool ignoreCost = true) const {
		if(!isCore)
			return false;
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(!hooks[i].canBuildBy(obj, ignoreCost))
				return false;
		}
		return true;
	}

	bool canBuildAt(Object@ obj, const vec3d& pos) const {
		if(!isCore)
			return false;
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(!hooks[i].canBuildAt(obj, pos))
				return false;
		}
		return true;
	}

	bool canBuild(Object@ obj, const vec3d& pos, bool initial = true) const {
		if(!canBuildBy(obj))
			return false;
		if(!canBuildAt(obj, pos))
			return false;
		if(!canBuildOrbital(obj, pos, initial))
			return false;
		return true;
	}

	bool canBuildOn(Orbital& orbital) const {
		if(isCore)
			return false;
		if(isUnique) {
			if(orbital.hasModule(id))
				return false;
		}
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(!hooks[i].canBuildOn(orbital))
				return false;
		}
		return true;
	}

	bool checkRequirements(OrbitalRequirements@ reqs, bool apply) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(!hooks[i].checkRequirements(reqs, apply)) {
				if(apply) {
					for(uint n = 0; n < i; ++n)
						hooks[n].revertRequirements(reqs);
				}
				return false;
			}
		}
		return true;
	}

	string getTooltip() const {
		string tip = format("[font=Medium][img=$2;32/] $1[/font]\n$3",
			name, getSpriteDesc(icon), description);
		bool reqs = false;
		for(uint i = 0; i < TR_COUNT; ++i) {
			if(affinities[i] > 0) {
				if(!reqs) {
					tip += "\n";
					reqs = true;
				}

				tip += "\n";
				tip += format(locale::ORB_REQ_AFFINITY,
					affinities[i], getTileResourceName(i),
					getTileResourceSpriteSpec(i));
			}
		}
		for(uint i = 0, cnt = requirements.length; i < cnt; ++i) {
			if(!reqs) {
				tip += "\n";
				reqs = true;
			}

			tip += "\n";
			tip += format(locale::ORB_REQ_RESOURCE,
				requirements[i].name, getSpriteDesc(requirements[i].icon));
		}
		return tip;
	}
};

interface IOrbitalEffect {
	void onEnable(Orbital& obj, any@ data) const;
	void onDisable(Orbital& obj, any@ data) const;
	void onCreate(Orbital& obj, any@ data) const;
	void onDestroy(Orbital& obj, any@ data) const;
	void onTick(Orbital& obj, any@ data, double time) const;
	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const;
	void onRegionChange(Orbital& obj, any@ data, Region@ prevRegion, Region@ newRegion) const;
	void onMakeGraphics(Orbital& obj, any@ data, OrbitalNode@ node) const;
	bool checkRequirements(OrbitalRequirements@ reqs, bool apply) const;
	void revertRequirements(OrbitalRequirements@ reqs) const;
	bool canBuildBy(Object@ obj, bool ignoreCost = true) const;
	bool canBuildAt(Object@ obj, const vec3d& pos) const;
	bool canBuildOn(Orbital& obj) const;
	string getBuildError(Object@ obj, const vec3d& pos) const;
	bool shouldDisable(Orbital& obj, any@ data) const;
	bool shouldEnable(Orbital& obj, any@ data) const;
	void save(any@ data, SaveFile& file) const;
	void load(any@ data, SaveFile& file) const;
	void onKill(Orbital& obj, any@ data, Empire@ killedBy) const;
	void write(any@ data, Message& msg) const;
	void read(any@ data, Message& msg) const;
	bool getValue(Player& pl, Orbital& obj, any@ data, uint index, double& value) const;
	bool sendValue(Player& pl, Orbital& obj, any@ data, uint index, double value) const;
	bool getDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@& value) const;
	bool sendDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@ value) const;
	bool getObject(Player& pl, Orbital& obj, any@ data, uint index, Object@& value) const;
	bool sendObject(Player& pl, Orbital& obj, any@ data, uint index, Object@ value) const;
	bool getData(Orbital& obj, string& txt, bool enabled) const;
	bool getCost(Object& obj, string& value, Sprite& icon) const;
	bool consume(Object& obj) const;
	void reverse(Object& obj, bool cancel) const;
};

class OrbitalEffect : Hook, IOrbitalEffect {
	void onEnable(Orbital& obj, any@ data) const {}
	void onDisable(Orbital& obj, any@ data) const {}
	void onCreate(Orbital& obj, any@ data) const {}
	void onDestroy(Orbital& obj, any@ data) const {}
	void onTick(Orbital& obj, any@ data, double time) const {}
	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const {}
	void onRegionChange(Orbital& obj, any@ data, Region@ prevRegion, Region@ newRegion) const {}
	void onMakeGraphics(Orbital& obj, any@ data, OrbitalNode@ node) const {}
	bool checkRequirements(OrbitalRequirements@ reqs, bool apply) const { return true; }
	void revertRequirements(OrbitalRequirements@ reqs) const {}
	bool canBuildBy(Object@ obj, bool ignoreCost) const { return true; }
	bool canBuildAt(Object@ obj, const vec3d& pos) const { return true; }
	bool canBuildOn(Orbital& obj) const { return true; }
	string getBuildError(Object@ obj, const vec3d& pos) const { return ""; }
	bool shouldDisable(Orbital& obj, any@ data) const { return false; }
	bool shouldEnable(Orbital& obj, any@ data) const { return true; }
	void save(any@ data, SaveFile& file) const {}
	void load(any@ data, SaveFile& file) const {}
	void write(any@ data, Message& msg) const {}
	void read(any@ data, Message& msg) const {}
	void onKill(Orbital& obj, any@ data, Empire@ killedBy) const {}
	bool getValue(Player& pl, Orbital& obj, any@ data, uint index, double& value) const { return false; }
	bool sendValue(Player& pl, Orbital& obj, any@ data, uint index, double value) const { return false; }
	bool getDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@& value) const { return false; }
	bool sendDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@ value) const { return false; }
	bool getObject(Player& pl, Orbital& obj, any@ data, uint index, Object@& value) const { return false; }
	bool sendObject(Player& pl, Orbital& obj, any@ data, uint index, Object@ value) const { return false; }
	bool getData(Orbital& obj, string& txt, bool enabled) const { return false; }
	bool getCost(Object& obj, string& value, Sprite& icon) const { return false; }
	bool consume(Object& obj) const { return true; }
	void reverse(Object& obj, bool cancel) const {}
};

tidy final class OrbitalSection : Serializable, Savable {
	const OrbitalModule@ type;
	int id = -1;
	array<any> data;
	bool enabled = true;

	OrbitalSection() {
	}

	OrbitalSection(const OrbitalModule@ type) {
		@this.type = type;
		data.length = type.hooks.length;
	}

	void write(Message& msg) {
		msg.writeSmall(type.id);
		msg.writeSmall(id);
		msg.writeBit(enabled);
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].write(data[i], msg);
	}

	void read(Message& msg) {
		@type = getOrbitalModule(msg.readSmall());
		id = msg.readSmall();
		enabled = msg.readBit();
		data.length = type.hooks.length;
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].read(data[i], msg);
	}

	OrbitalSection(SaveFile& file) {
		load(file);
	}

	void save(SaveFile& file) {
		file << id;
		file.writeIdentifier(SI_Orbital, type.id);
		file << enabled;
		if(enabled) {
			for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
				type.hooks[i].save(data[i], file);
		}
	}

	void load(SaveFile& file) {
		file >> id;
		@type = getOrbitalModule(file.readIdentifier(SI_Orbital));
		file >> enabled;
		data.length = type.hooks.length;
		if(enabled) {
			for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
				type.hooks[i].load(data[i], file);
		}
	}

	void enable(Orbital& obj) {
		enabled = true;
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onEnable(obj, data[i]);
	}

	void disable(Orbital& obj) {
		enabled = false;
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onDisable(obj, data[i]);
	}

	void create(Orbital& obj) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onCreate(obj, data[i]);
	}

	void destroy(Orbital& obj) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onDestroy(obj, data[i]);
	}

	void tick(Orbital& obj, double time) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onTick(obj, data[i], time);
	}

	void ownerChange(Orbital& obj, Empire@ prevOwner, Empire@ newOwner) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onOwnerChange(obj, data[i], prevOwner, newOwner);
	}

	void regionChange(Orbital& obj, Region@ prevRegion, Region@ newRegion) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onRegionChange(obj, data[i], prevRegion, newRegion);
	}

	void makeGraphics(Orbital& obj, OrbitalNode@ node) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onMakeGraphics(obj, data[i], node);
	}

	bool shouldDisable(Orbital& obj) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i) {
			if(type.hooks[i].shouldDisable(obj, data[i]))
				return true;
		}
		return false;
	}

	void kill(Orbital& obj, Empire@ killedBy) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i)
			type.hooks[i].onKill(obj, data[i], killedBy);
	}

	bool shouldEnable(Orbital& obj) {
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i) {
			if(!type.hooks[i].shouldEnable(obj, data[i]))
				return false;
		}
		return true;
	}

	string getData(Orbital& obj) const {
		string txt;
		for(uint i = 0, cnt = type.hooks.length; i < cnt; ++i) {
			if(type.hooks[i].getData(obj, txt, enabled))
				return txt;
		}
		return txt;
	}
};

const OrbitalModule@ getOrbitalModule(uint id) {
	if(id >= modules.length)
		return null;
	return modules[id];
}

const OrbitalModule@ getOrbitalModule(const string& ident) {
	OrbitalModule@ mod;
	if(idents.get(ident, @mod))
		return mod;
	return null;
}

uint getOrbitalModuleCount() {
	return modules.length;
}

void saveIdentifiers(SaveFile& file) {
	for(uint i = 0, cnt = modules.length; i < cnt; ++i) {
		auto type = modules[i];
		file.addIdentifier(SI_Orbital, type.id, type.ident);
	}
}

tidy final class OrbitalRequirements {
	array<const ResourceType@> available;
	array<bool> used;
	array<uint> tmp;

	void init(const array<Resource>& list) {
		uint cnt = list.length;
		available.length = 0;
		used.length = 0;
		available.reserve(cnt);
		used.reserve(cnt);
		for(uint i = 0; i < cnt; ++i) {
			if(list[i].usable) {
				available.insertLast(list[i].type);
				used.insertLast(false);
			}
		}
	}

	void init(const array<Resource@>& list) {
		uint cnt = list.length;
		available.length = 0;
		used.length = 0;
		available.reserve(cnt);
		used.reserve(cnt);
		for(uint i = 0; i < cnt; ++i) {
			if(list[i].usable) {
				available.insertLast(list[i].type);
				used.insertLast(false);
			}
		}
	}

	void init(Object& obj, bool direct = false) {
		if(!obj.hasResources) {
			available.length = 0;
			used.length = 0;
			return;
		}
		if(direct) {
			uint cnt = obj.availableResourceCount;
			available.length = 0;
			used.length = 0;
			available.reserve(cnt);
			used.reserve(cnt);
			for(uint i = 0; i < cnt; ++i) {
				if(obj.availableResourceUsable[i]) {
					available.insertLast(getResource(obj.availableResourceType[i]));
					used.insertLast(false);
				}
			}
		}
		else {
			array<Resource> resources;
			resources.syncFrom(obj.getAvailableResources());
			init(resources);
		}
	}

	void _revert() {
		for(uint i = 0, cnt = tmp.length; i < cnt; ++i)
			used[tmp[i]] = false;
		tmp.length = 0;
	}

	bool add(const OrbitalModule@ mod) {
		return check(mod, true);
	}

	bool check(const OrbitalModule@ mod, bool apply = false) {
		tmp.length = 0;
		tmp.reserve(16);

		//First, compute specific resource requirements
		for(uint i = 0, cnt = mod.requirements.length; i < cnt; ++i) {
			bool found = false;
			for(uint n = 0, ncnt = available.length; n < ncnt; ++n) {
				if(used[n])
					continue;
				if(available[n] is mod.requirements[i]) {
					found = true;
					used[n] = true;
					tmp.insertLast(n);
				}
			}
			if(!found) {
				_revert();
				return false;
			}
		}

		//Find matches for affinities
		for(uint i = 0; i < TR_COUNT; ++i) {
			uint amount = mod.affinities[i];
			for(uint c = 0; c < amount; ++c) {
				uint mask = 1<<i;
				uint found = uint(-1);
				bool specif = false;
				for(uint n = 0, ncnt = available.length; n < ncnt; ++n) {
					if(used[n])
						continue;
					auto@ res = available[n];
					for(uint j = 0, jcnt = res.affinities.length; j < jcnt; ++j) {
						uint aff = res.affinities[j];
						if(aff & mask != 0) {
							bool isSpecif = aff == mask;
							if(found == uint(-1) || (isSpecif && !specif)) {
								found = n;
								specif = isSpecif;
							}
						}
					}
				}
				if(found == uint(-1)) {
					_revert();
					return false;
				}

				used[found] = true;
				tmp.insertLast(found);
			}
		}

		//Hook requirements
		if(!mod.checkRequirements(this, apply)) {
			_revert();
			return false;
		}
		if(!apply)
			_revert();
		return true;
	}
};

void addOrbitalModule(OrbitalModule@ mod) {
	mod.id = modules.length;
	modules.insertLast(mod);
	idents.set(mod.ident, @mod);
}

void parseLine(string& line, OrbitalModule@ mod, ReadFile@ file) {
	//Hook line
	auto@ hook = cast<IOrbitalEffect>(parseHook(line, "orbital_effects::", instantiate=false, file=file));
	if(hook !is null)
		mod.hooks.insertLast(hook);
}

int getOrbitalModuleID(const string& ident) {
	auto@ type = getOrbitalModule(ident);
	if(type is null)
		return -1;
	return int(type.id);
}

string getOrbitalModuleIdent(int id) {
	auto@ type = getOrbitalModule(id);
	if(type is null)
		return "";
	return type.ident;
}

void loadOrbitalModules(const string& filename) {
	ReadFile file(filename, true);
	
	string key, value;
	OrbitalModule@ mod;
	
	uint index = 0;
	while(file++) {
		key = file.key;
		value = file.value;
		
		if(file.fullLine) {
			string line = file.line;
			parseLine(line, mod, file);
		}
		else if(key.equals_nocase("Module")) {
			if(mod !is null)
				addOrbitalModule(mod);
			@mod = OrbitalModule();
			mod.ident = value;
		}
		else if(mod is null) {
			file.error("Missing Module: 'ID' line");
		}
		else if(key.equals_nocase("Name")) {
			mod.name = localize(value);
		}
		else if(key.equals_nocase("Blurb")) {
			mod.blurb = localize(value);
		}
		else if(key.equals_nocase("Description")) {
			mod.description = localize(value);
		}
		else if(key.equals_nocase("Icon")) {
			mod.icon = getSprite(value);
		}
		else if(key.equals_nocase("Icon Size")) {
			mod.iconSize = toDouble(value);
		}
		else if(key.equals_nocase("Distant Icon")) {
			mod.distantIcon = getSprite(value);
		}
		else if(key.equals_nocase("Strategic Icon")) {
			mod.strategicIcon = getSprite(value);
		}
		else if(key.equals_nocase("Spin")) {
			mod.spin = toDouble(value);
		}
		else if(key.equals_nocase("Core")) {
			mod.isCore = toBool(value);
		}
		else if(key.equals_nocase("Standalone")) {
			mod.isStandalone = toBool(value);
			if(mod.isStandalone)
				mod.isCore = true;
		}
		else if(key.equals_nocase("Solid")) {
			mod.isSolid = toBool(value);
		}
		else if(key.equals_nocase("Unique")) {
			mod.isUnique = toBool(value);
		}
		else if(key.equals_nocase("Maintenance")) {
			mod.maintenance = toInt(value);
		}
		else if(key.equals_nocase("Build Cost")) {
			mod.buildCost = toInt(value);
		}
		else if(key.equals_nocase("Labor Cost")) {
			mod.laborCost = toDouble(value);
		}
		else if(key.equals_nocase("Health")) {
			mod.health = toDouble(value);
		}
		else if(key.equals_nocase("Armor")) {
			mod.armor = toDouble(value);
		}
		else if(key.equals_nocase("Size")) {
			mod.size = toDouble(value);
		}
		else if(key.equals_nocase("Model")) {
			@mod.model = getModel(value);
		}
		else if(key.equals_nocase("Material")) {
			@mod.material = getMaterial(value);
		}
		else if(key.equals_nocase("Combat Repair")) {
			mod.combatRepair = toBool(value);
		}
		else if(key.equals_nocase("Can Fling")) {
			mod.canFling = toBool(value);
		}
		else if(key.equals_nocase("Mass")) {
			mod.mass = toDouble(value);
		}
		else if(key.equals_nocase("Require Affinity")) {
			array<string>@ parts = value.split(" ");
			if(parts.length != 2) {
				file.error("Invalid affinity requirement: "+value);
				return;
			}
			uint res = getTileResource(parts[1]);
			if(res == TR_NULL) {
				file.error("Invalid affinity resource: "+parts[1]);
				return;
			}

			uint amt = toUInt(parts[0]);
			mod.affinities[res] += amt;
			mod.totalRequirementCount += amt;
		}
		else if(key.equals_nocase("Require Resource")) {
			auto@ res = getResource(value);
			if(res is null) {
				file.error("Invalid resource: "+value);
				return;
			}
			mod.requirements.insertLast(res);
			mod.totalRequirementCount += 1;
		}
		else if(key.equals_nocase("AI")) {
			auto@ hook = parseHook(value, "ai.orbitals::", instantiate=false, file=file);
			if(hook !is null)
				mod.ai.insertLast(hook);
			else
				file.error("Could not find AI hook "+value);
		}
		else {
			string line = file.line;
			parseLine(line, mod, file);
		}
	}
	
	if(mod !is null)
		addOrbitalModule(mod);
}

void preInit() {
	FileList list("data/orbitals", "*.txt", true);
	for(uint i = 0, cnt = list.length; i < cnt; ++i)
		loadOrbitalModules(list.path[i]);
}

void init() {
	auto@ list = modules;
	for(uint i = 0, cnt = list.length; i < cnt; ++i) {
		auto@ type = list[i];
		for(uint n = 0, ncnt = type.hooks.length; n < ncnt; ++n)
			if(!cast<Hook>(type.hooks[n]).instantiate())
				error("Could not instantiate hook: "+addrstr(type.hooks[n])+" in "+type.ident);
		for(uint n = 0, ncnt = type.ai.length; n < ncnt; ++n) {
			if(!type.ai[n].instantiate())
				error("Could not instantiate AI hook: "+addrstr(type.ai[n])+" in orbital "+type.ident);
		}
	}
}