import tile_resources;
import util.formatting;
import int getResourceID(const string&) from "resources";
import string getResourceIdent(int id) from "resources";
import int getAbilityID(const string&) from "abilities";
import string getAbilityIdent(int id) from "abilities";
import int getStatusID(const string&) from "statuses";
import string getStatusIdent(int id) from "statuses";
import int getAttitudeID(const string&) from "attitudes";
import string getAttitudeIdent(int id) from "attitudes";
import int getCargoID(const string&) from "cargo";
import string getCargoIdent(int id) from "cargo";
import int getTraitID(const string&) from "traits";
import string getTraitIdent(int id) from "traits";
import int getRandomEventID(const string&) from "random_events";
import string getRandomEventIdent(int id) from "random_events";
import int getBiomeID(const string&) from "biomes";
import string getBiomeIdent(int id) from "biomes";
import int getOrbitalModuleID(const string&) from "orbitals";
import string getOrbitalModuleIdent(int id) from "orbitals";
import int getConstructionID(const string&) from "constructions";
import string getConstructionIdent(int id) from "constructions";
import int getArtifactID(const string&) from "artifacts";
import string getArtifactIdent(int id) from "artifacts";
import int getBuildingID(const string&) from "buildings";
import string getBuildingIdent(int id) from "buildings";
import int getTechnologyID(const string&) from "research";
import string getTechnologyIdent(int id) from "research";
import int getUnlockTag(const string& ident, bool create = true) from "unlock_tags";
import string getUnlockTagIdent(int id) from "unlock_tags";
import int getObjectStatId(const string& ident, bool create = true) from "object_stats";
import string getObjectStatIdent(int id) from "object_stats";
import string getObjectStatMode(int id) from "object_stats";
import int getObjectStatMode(const string& ident) from "object_stats";
import int getSystemFlag(const string& ident, bool create = true) from "system_flags";
import string getSystemFlagIdent(int id) from "system_flags";
import int getInfluenceCardID(const string& ident) from "influence";
import int getInfluenceVoteID(const string& ident) from "influence";
import int getInfluenceEffectID(const string& ident) from "influence";
import string getInfluenceCardIdent(int id) from "influence";
import string getInfluenceVoteIdent(int id) from "influence";
import string getInfluenceEffectIdent(int id) from "influence";
import hook_globals;
import attributes;
import saving;

export ArgumentType, Argument, REF_ARG;
export Document, EMPTY_DEFAULT;
export Hook, BlockHook, parseHook;
export TargetType, Targets, Target;
export parseTarget;
export makeHookInstance;
export EmpireResource, empResources;

// {{{ Arguments
enum ArgumentType {
	AT_Integer,
	AT_Decimal,
	AT_Boolean,
	AT_TileResource,
	AT_PlanetResource,
	AT_Ability,
	AT_Range,
	AT_Position,
	AT_Position2D,
	AT_Locale,
	AT_PassFail,
	AT_Target,
	AT_TargetSpec,
	AT_EmpAttribute,
	AT_AttributeMode,
	AT_Status,
	AT_Cargo,
	AT_Subsystem,
	AT_Trait,
	AT_OrbitalModule,
	AT_Artifact,
	AT_Technology,
	AT_Global,
	AT_SysVar,
	AT_Sprite,
	AT_Color,
	AT_Hook,
	AT_Model,
	AT_Material,
	AT_Selection,
	AT_PlanetBiome,
	AT_Construction,
	AT_TileResourceSpec,
	AT_Building,
	AT_InfluenceCard,
	AT_InfluenceVote,
	AT_InfluenceEffect,
	AT_CreepCamp,
	AT_RandomEvent,
	AT_Anomaly,
	AT_ObjectType,
	AT_VariableDef,
	AT_ValueDef,
	AT_File,
	AT_UnlockTag,
	AT_ObjectStat,
	AT_ObjectStatMode,
	AT_SystemFlag,
	AT_Custom,
	AT_VarArgs,
	AT_EmpireResource,
	AT_Attitude,
};

enum EmpireResource {
	ER_Money,
	ER_Influence,
	ER_Energy,
	ER_Research,
	ER_Defense,
	ER_FTL,
	ER_COUNT
};

string[] empResources = {
	"Money",
	"Influence",
	"Energy",
	"Research",
	"Defense",
	"FTL"
};

const string EMPTY_DEFAULT = "-";
const string SEP_UNDER = "_";
Argument REF_ARG;
final class Argument {
	ArgumentType type = AT_Custom;
	string argName;
	string str;
	string doc;
	int integer;
	int integer2;
	double decimal;
	double decimal2;
	vec3d position;
	vec3d position2;
	bool boolean;
	bool isRange = false;
	bool filled = false;

	Argument() {
	}

	Argument(ArgumentType Type, const string& def = "", const string& doc = "") {
		type = Type;
		if(def.length != 0) {
			if(def == EMPTY_DEFAULT)
				parse("");
			else
				parse(def);
		}
		if(doc.length != 0)
			this.doc = doc;
	}

	Argument(ArgumentType AType, ArgumentType Type, const string& doc = "", bool required = false) {
		type = AType;
		integer = int(Type);
		boolean = required;
		if(doc.length != 0)
			this.doc = doc;
	}

	Argument(const string& name, ArgumentType Type, const string& defaultValue = "", const string& doc = "") {
		type = Type;
		argName = name;
		boolean = defaultValue.length != 0;
		if(boolean)
			parse(defaultValue);
		if(doc.length != 0)
			this.doc = doc;
	}

	Argument(TargetType Type, const string& def = "", const string& doc = "") {
		type = AT_Target;
		integer2 = int(Type);
		boolean = def.length != 0;
		filled = boolean;
		if(def != EMPTY_DEFAULT)
			str = def;
		if(doc.length != 0)
			this.doc = doc;
	}

	Argument(const string& name, TargetType Type, const string& def = "", const string& doc = "") {
		type = AT_Target;
		argName = name;
		integer2 = int(Type);
		boolean = def.length != 0;
		filled = boolean;
		if(def != EMPTY_DEFAULT)
			str = def;
		if(doc.length != 0)
			this.doc = doc;
	}

	double fromRange() const {
		if(!isRange)
			return decimal;
		return randomd(decimal, decimal2);
	}

	double fromSys(const Subsystem@ sys = null, Object@ efficiencyObj = null) const {
		if(sys is null || integer < 0)
			return decimal;
		double value = decimal;
		if(sys.has(SubsystemVariable(integer)))
			value = sys.variable(SubsystemVariable(integer));
		if(efficiencyObj !is null && efficiencyObj.isShip) {
			Ship@ ship = cast<Ship>(efficiencyObj);
			auto@ status = ship.blueprint.getSysStatus(sys.index);
			if(status !is null)
				value *= double(status.workingHexes) / double(sys.hexCount);
		}
		return value;
	}

	double fromShipEfficiencySum(Object@ efficiencyObj = null) const {
		if(integer < 0)
			return decimal;
		double value = decimal;
		if(efficiencyObj !is null && efficiencyObj.isShip) {
			Ship@ ship = cast<Ship>(efficiencyObj);
			value = ship.blueprint.getEfficiencySum(SubsystemVariable(integer));
		}
		return value;
	}

	void set(double value) {
		decimal = value;
		if(isRange)
			decimal2 = value;
	}

	void set(double value, double value2) {
		decimal = value;
		decimal2 = value2;
	}

	vec3d fromPosition() const {
		if(!isRange)
			return position;
		return vec3d(randomd(position.x, position2.x),
				randomd(position.y, position2.y),
				randomd(position.z, position2.z));
	}

	void set(const vec3d& pos) {
		position = pos;
		if(isRange)
			position2 = pos;
	}

	void set(const vec2d& pos) {
		position = vec3d(pos.x, pos.y, 0);
		if(isRange)
			position2 = position;
	}

	vec2d fromPosition2D() const {
		if(!isRange)
			return vec2d(position.x, position.y);
		return vec2d(randomd(position.x, position2.x),
				randomd(position.y, position2.y));
	}

	Target@ fromTarget(Targets@ targets) const {
		if(uint(integer) >= targets.targets.length)
			return null;
		return targets.targets[integer];
	}

	const Target@ fromConstTarget(const Targets@ targets) const {
		if(uint(integer) >= targets.targets.length)
			return null;
		return targets.targets[integer];
	}

	bool parseRange(double& value, double& value2, const string& str) {
		if(str[0] == '$') {
			value = config::get(str.substr(1));
			value2 = value;
			return false;
		}
		int pos = str.findFirst(":");
		if(pos == -1) {
			value = toDouble(str);
			value2 = value;
			return false;
		}
		else {
			value = toDouble(str.substr(0, pos));
			value2 = toDouble(str.substr(pos+1));
			return true;
		}
	}

	bool instantiate() {
		switch(type) {
			case AT_PlanetResource:
				if(str.length != 0) {
					integer = getResourceID(str);
					if(integer == -1) {
						error(" Error: Unknown planetary resource: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Status:
				if(str.length != 0) {
					integer = getStatusID(str);
					if(integer == -1) {
						error(" Error: Unknown status: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Attitude:
				if(str.length != 0) {
					integer = getAttitudeID(str);
					if(integer == -1) {
						error(" Error: Unknown attitude: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Cargo:
				if(str.length != 0) {
					integer = getCargoID(str);
					if(integer == -1) {
						error(" Error: Unknown cargo: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Trait:
				if(str.length != 0) {
					integer = getTraitID(str);
					if(integer == -1) {
						error(" Error: Unknown trait: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_RandomEvent:
				if(str.length != 0) {
					integer = getRandomEventID(str);
					if(integer == -1) {
						error(" Error: Unknown random event: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_PlanetBiome:
				if(str.length != 0) {
					integer = getBiomeID(str);
					if(integer == -1) {
						error(" Error: Unknown biome: "+str);
						return false;
					}
				}
				else {
					integer = -1;
				}
			break;
			case AT_Construction:
				if(str.length != 0) {
					integer = getConstructionID(str);
					if(integer == -1) {
						error(" Error: Unknown construction: "+str);
						return false;
					}
				}
				else {
					integer = -1;
				}
			break;
			case AT_Artifact:
				if(str.length != 0) {
					integer = getArtifactID(str);
					if(integer == -1) {
						error(" Error: Unknown artifact: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Building:
				if(str.length != 0) {
					integer = getBuildingID(str);
					if(integer == -1) {
						error(" Error: Unknown building: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Technology:
				if(str.length != 0) {
					integer = getTechnologyID(str);
					if(integer == -1) {
						error(" Error: Unknown technology: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_OrbitalModule:
				if(str.length != 0) {
					integer = getOrbitalModuleID(str);
					if(integer == -1) {
						error(" Error: Unknown orbital: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_Ability:
				if(str.length != 0) {
					integer = getAbilityID(str);
					if(integer == -1) {
						error(" Error: Unknown ability: "+str);
						return false;
					}
					str = "";
				}
				else {
					integer = -1;
				}
			break;
			case AT_InfluenceCard:
				if(str.length != 0) {
					integer = getInfluenceCardID(str);
					if(integer == -1) {
						error(" Error: Unknown influence card type: "+str);
						return false;
					}
				}
				else {
					integer = -1;
				}
			break;
			case AT_InfluenceVote:
				if(str.length != 0) {
					integer = getInfluenceVoteID(str);
					if(integer == -1) {
						error(" Error: Unknown influence vote type: "+str);
						return false;
					}
				}
				else {
					integer = -1;
				}
			break;
			case AT_InfluenceEffect:
				if(str.length != 0) {
					integer = getInfluenceEffectID(str);
					if(integer == -1) {
						error(" Error: Unknown influence effect type: "+str);
						return false;
					}
				}
				else {
					integer = -1;
				}
			break;
		}
		return true;
	}

	bool parse(const string& value) {
		filled = true;
		str = value;
		switch(type) {
			case AT_Integer:
				integer = toInt(value);
				return true;
			case AT_Boolean:
				if(value[0] == '$')
					boolean = config::get(value.substr(1)) != 0.0;
				else if(value[0] == '!' && value[1] == '$')
					boolean = config::get(value.substr(2)) == 0.0;
				else
					boolean = toBool(value);
				return true;
			case AT_PassFail:
				boolean = value.equals_nocase("pass");
				return true;
			case AT_Decimal:
				if(value[0] == '$')
					decimal = config::get(value.substr(1));
				else
					decimal = toDouble(value);
				return true;
			case AT_Global:
				integer = int(getGlobal(value).id);
				return true;
			case AT_UnlockTag:
				integer = getUnlockTag(value);
				return true;
			case AT_ObjectStat:
				integer = getObjectStatId(value);
				return true;
			case AT_SystemFlag:
				integer = getSystemFlag(value);
				return true;
			case AT_TileResource:
				integer = getTileResource(value);
				if(integer == TR_NULL) {
					error(" Error: Unknown tile resource: "+value);
					return false;
				}
				return true;
			case AT_EmpAttribute:
				if(value.length == 0)
					integer = -1;
				else
					integer = int(getEmpAttribute(value, true));
				str = value;
				return true;
			case AT_AttributeMode:
				integer = int(getAttributeMode(value));
				if(integer == int(AC_INVALID)) {
					error(" Error: Unknown empire attribute mode: "+value);
					return false;
				}
				return true;
			case AT_ObjectStatMode:
				integer = int(getObjectStatMode(value));
				return true;
			case AT_PlanetResource:
				if(value.equals_nocase("null")) {
					integer = -1;
					return true;
				}
				str = value;
				return true;
			case AT_Status:
			case AT_Attitude:
			case AT_Cargo:
			case AT_Trait:
			case AT_RandomEvent:
			case AT_PlanetBiome:
			case AT_Construction:
			case AT_Artifact:
			case AT_Building:
			case AT_Technology:
			case AT_OrbitalModule:
			case AT_Ability:
				str = value;
				return true;
			case AT_Subsystem:
				{
					auto@ def = getSubsystemDef(value);
					if(def is null)
						return false;
					integer = int(def.index);
					return true;
				}
			case AT_Range:
				isRange = parseRange(decimal, decimal2, value);
				return true;
			case AT_Position: {
				string fname;
				array<string> args;
				if(!funcSplit(value, fname, args, true)
					|| args.length != 3 || fname.length != 0) {
					error(" Error: Invalid position spec: "+value);
					return false;
				}
				if(parseRange(position.x, position2.x, args[0]))
					isRange = true;
				if(parseRange(position.y, position2.y, args[1]))
					isRange = true;
				if(parseRange(position.z, position2.z, args[2]))
					isRange = true;
			} return true;
			case AT_Position2D: {
			  string fname;
			  array<string> args;
			  if(!funcSplit(value, fname, args, true)
				  || args.length != 2 || fname.length != 0) {
				  error(" Error: Invalid 2d position spec: "+value);
				  return false;
			  }
			  if(parseRange(position.x, position2.x, args[0]))
				  isRange = true;
			  if(parseRange(position.y, position2.y, args[1]))
				  isRange = true;
			} return true;
			case AT_VarArgs:
				error("Invalid use of variable arguments.");
				return false;
			case AT_Locale:
				str = localize(value);
				return true;
			case AT_Target:
				str = value;
				return true;
			case AT_SysVar: {
				integer = -1;
				decimal = 0;
				string val = value;
				int colon = val.findLast(":");
				if(colon != -1) {
					decimal = toDouble(val.substr(colon+1));
					val = val.substr(0, colon).trimmed();
				}
				if(val.startswith_nocase("sys.")) {
					integer = getSubsystemVariable(val.substr(4));
					if(integer == -1) {
						error("Unknown subsystem variable: "+val);
						return false;
					}
				}
				else if(val[0] == '$')
					decimal = config::get(val.substr(1));
				else
					decimal = toDouble(val);
			} return true;
			case AT_EmpireResource:
				integer = empResources.find(value);
				return integer >= 0;
			case AT_Custom:
			default:
				str = value;
				return true;
		}
		return true;
	}

	string output() const {
		switch(type) {
			case AT_Integer:
				return toString(integer, 0);
			case AT_Global:
				return getGlobal(integer).ident;
			case AT_UnlockTag:
				return getUnlockTagIdent(integer);
			case AT_ObjectStat:
				return getObjectStatIdent(integer);
			case AT_SystemFlag:
				return getSystemFlagIdent(integer);
			case AT_Boolean:
				return boolean ? "True" : "False";
			case AT_PassFail:
				return boolean ? "Pass" : "Fail";
			case AT_Decimal:
				return toString(decimal);
			case AT_SysVar:
				return toString(decimal);
			case AT_TileResource:
				return getTileResourceIdent(integer);
			case AT_PlanetResource:
				return getResourceIdent(integer);
			case AT_Status:
				return getStatusIdent(integer);
			case AT_Attitude:
				return getAttitudeIdent(integer);
			case AT_Cargo:
				return getCargoIdent(integer);
			case AT_Trait:
				return getTraitIdent(integer);
			case AT_RandomEvent:
				return getRandomEventIdent(integer);
			case AT_PlanetBiome:
				return getBiomeIdent(integer);
			case AT_Construction:
				return getConstructionIdent(integer);
			case AT_Artifact:
				return getArtifactIdent(integer);
			case AT_Building:
				return getBuildingIdent(integer);
			case AT_Technology:
				return getTechnologyIdent(integer);
			case AT_OrbitalModule:
				return getOrbitalModuleIdent(integer);
			case AT_Ability:
				return getAbilityIdent(integer);
			case AT_InfluenceCard:
				return getInfluenceCardIdent(integer);
			case AT_InfluenceVote:
				return getInfluenceVoteIdent(integer);
			case AT_InfluenceEffect:
				return getInfluenceEffectIdent(integer);
			case AT_VarArgs:
				return "...";
			case AT_Range:
				if(isRange)
					return toString(decimal)+":"+toString(decimal2);
				else
					return toString(decimal);
			case AT_Position: {
				string output = "(";
				if(position.x == position2.x)
					output += toString(position.x);
				else
					output += toString(position.x)+":"+toString(position2.x);
				output += ", ";
				if(position.y == position2.y)
					output += toString(position.y);
				else
					output += toString(position.y)+":"+toString(position2.y);
				output += ", ";
				if(position.z == position2.z)
					output += toString(position.z);
				else
					output += toString(position.z)+":"+toString(position2.z);
				output += ")";
				return output;
			}
			case AT_Position2D: {
				string output = "(";
				if(position.x == position2.x)
					output += toString(position.x);
				else
					output += toString(position.x)+":"+toString(position2.x);
				output += ", ";
				if(position.y == position2.y)
					output += toString(position.y);
				else
					output += toString(position.y)+":"+toString(position2.y);
				output += ")";
				return output;
			}
			case AT_Target:
				return str;
			case AT_Locale:
				return str;
			case AT_EmpAttribute:
				if(integer == -1)
					return "";
				return getEmpAttributeIdent(integer);
			case AT_AttributeMode:
				return getAttributeModeIdent(integer);
			case AT_ObjectStatMode:
				return getObjectStatMode(integer);
			case AT_EmpireResource:
				if(integer >= 0 && uint(integer) < empResources.length)
					return empResources[integer];
				else
					return empResources[0];
			case AT_Custom:
			default:
				return str;
		}
		return "";
	}
};

final class Document {
	string text;
	bool hidden = false;

	Document(const string& txt) {
		this.text = txt;
	}

	Document(const string& txt, bool hidden) {
		this.text = txt;
		this.hidden = hidden;
	}
};

// }}}
// {{{ Hooks
class Hook {
	array<Argument@> arguments;
	Document@ documentation;
	uint requiredArguments = 0;
	string filePosition;

	//Adding arguments to this hook
	void argument(ArgumentType type) {
		arguments.insertLast(Argument(type));
		++requiredArguments;
	}

	void argument(ArgumentType type, const string& defaultValue) {
		arguments.insertLast(Argument(type, defaultValue, ""));
	}

	void argument(const string& argName, ArgumentType type) {
		arguments.insertLast(Argument(argName, type));
		++requiredArguments;
	}

	void argument(const string& argName, ArgumentType type, const string& defaultValue) {
		arguments.insertLast(Argument(argName, type, defaultValue));
	}

	void varargs(ArgumentType type, bool required = false) {
		Argument arg(AT_VarArgs);
		arg.integer = int(type);
		arg.boolean = required;
		arguments.insertLast(arg);
		if(required)
			++requiredArguments;
	}

	void target(const string& argName, TargetType type) {
		Argument arg(AT_Target);
		arg.integer2 = int(type);
		arg.boolean = false;
		arguments.insertLast(arg);
		++requiredArguments;
	}

	void target(const string& argName, TargetType type, const string& defaultValue) {
		Argument arg(AT_Target);
		arg.integer2 = int(type);
		arg.boolean = true;
		arg.str = defaultValue;
		arguments.insertLast(arg);
	}

	string formatHook() {
		string txt;
		txt = getClass(this).name;
		txt += "(";
		for(uint i = 0, cnt = arguments.length; i < cnt; ++i) {
			if(i != 0)
				txt += ", ";
			txt += arguments[i].output();
		}
		txt += ")";
		return txt;
	}

	string formatDeclaration() {
		string txt;
		txt = getClass(this).name;
		txt += "(";
		for(uint i = 0, cnt = arguments.length; i < cnt; ++i) {
			if(i != 0)
				txt += ", ";
			auto@ arg = arguments[i];
			txt += "<"+arg.argName+">";
			if(arg.filled && arg.type != AT_Hook)
				txt += " = "+arg.output();
		}
		txt += ")";
		return txt;
	}

	//Parse arguments from strings
#section server
	bool init(Design& design, Subsystem& subsystem, StringList& arglist, DoubleList& values) const {
		array<string> args;
		for(uint i = 0, cnt = arglist.length; i < cnt; ++i)
			args.insertLast(arglist[i]);
		initClass();
		if(!parse("--", args)) {
			printError("Error in hook "+formatHook());
			return false;
		}
		for(uint i = 0, cnt = min(values.length, arguments.length); i < cnt; ++i) {
			switch(arguments[i].type) {
				case AT_Decimal: arguments[i].decimal = values[i]; break;
				case AT_Integer: arguments[i].integer = values[i]; break;
				case AT_Range: arguments[i].decimal = values[i]; arguments[i].decimal2 = values[i]; break;
			}
		}
		if(!instantiate()) {
			printError("Error in hook "+formatHook());
			return false;
		}
		return true;
	}
#section all

	void printError(const string& message) {
		if(filePosition.length != 0)
			error(filePosition);
		error(message);
	}

	bool parse(const string& name, array<string>& args) {
		if(args.length < requiredArguments) {
			printError(" Error: mismatched argument count, expected "+arguments.length+" arguments.");
			return false;
		}
		bool inNamed = false;
		uint i = 0;
		for(uint cnt = arguments.length, acnt = args.length; i < cnt && i < acnt; ++i) {
			int eqPos = args[i].findFirst("=");
			int brkPos = args[i].findFirst("(");
			if(eqPos != -1 && (brkPos == -1 || eqPos < brkPos)) {
				//Named argument
				uint index = uint(-1);
				inNamed = true;
				string name = args[i].substr(0, eqPos).trimmed();
				string value = args[i].substr(eqPos+1).trimmed();
				for(uint n = 0; n < cnt; ++n) {
					if(arguments[n].argName.equals_nocase(name)) {
						index = n;
						break;
					}
				}

				if(index == uint(-1)) {
					printError(" Error: Could not find argument with name: "+name);
					return false;
				}
				else {
					if(!arguments[index].parse(value))
						return false;
				}
			}
			else {
				//Positional argument
				if(inNamed) {
					printError(" Error: positional arguments cannot follow named ones.");
					return false;
				}
				//Variable arguments
				if(arguments[i].type == AT_VarArgs) {
					auto varType = ArgumentType(arguments[i].integer);
					arguments.removeAt(i);
					for(uint n = i; n < acnt; ++n) {
						Argument arg(varType);
						if(!arg.parse(args[n]))
							return false;
						arguments.insertLast(arg);
					}
				}
				//Normal arguments
				else if(!arguments[i].parse(args[i])) {
					printError("Error in arguments.");
					return false;
				}
			}
		}
		if(i < requiredArguments) {
			if(arguments[i].type != AT_VarArgs || arguments[i].boolean) {
				printError(" Error: mismatched argument count, expected "+arguments.length+" arguments.");
				return false;
			}
		}
		for(uint i = 0, cnt = requiredArguments; i < cnt; ++i) {
			if(!arguments[i].filled) {
				printError(" Error: no value for argument "+i+" ("+arguments[i].argName+")");
				return false;
			}
		}
		return true;
	}

	//Pluck arguments from class
	void initClass() {
		auto@ argClass = getClass(REF_ARG);
		auto@ thisClass = getClass(this);
		for(uint i = 0, cnt = thisClass.memberCount; i < cnt; ++i) {
			auto@ ptr = thisClass.getMember(this, i);
			auto@ mem = cast<Argument>(ptr);
			if(mem is null) {
				if(cast<Document>(ptr) !is null)
					@documentation = cast<Document>(ptr);
				continue;
			}
			if(mem.argName.length == 0) {
				mem.argName = thisClass.memberName[i];
				if(mem.argName.findFirst(SEP_UNDER) != -1) {
					array<string>@ splt = mem.argName.split(SEP_UNDER);
					mem.argName = "";
					for(uint i = 0, cnt = splt.length; i < cnt; ++i) {
						splt[i][0] = uppercase(splt[i][0]);
						if(i != 0)
							mem.argName += " ";
						mem.argName += splt[i];
					}
				}
				else {
					mem.argName[0] = uppercase(mem.argName[0]);
				}
			}
			arguments.insertLast(mem);
			if(mem.type == AT_VarArgs) {
				if(mem.boolean)
					++requiredArguments;
			}
			else if(!mem.filled) {
				++requiredArguments;
			}
		}
	}

	//Called when the hook is first created in its type
	bool instantiate() {
		for(uint i = 0, cnt = arguments.length; i < cnt; ++i)
			if(!arguments[i].instantiate())
				return false;
		return true;
	}

	//Figure out target arguments
	bool initTargets(Targets@ targets) {
		uint targCnt = targets.targets.length;
		for(uint i = 0, cnt = arguments.length; i < cnt; ++i) {
			auto@ arg = arguments[i];
			if(arg.type != AT_Target)
				continue;

			//Find the target index
			uint index = uint(-1);
			for(uint n = 0; n < targCnt; ++n) {
				if(targets.targets[n].name.equals_nocase(arg.str)) {
					index = n;
					break;
				}
			}

			if(index >= targets.targets.length) {
				if(arg.boolean) {
					arg.integer = -1;
					continue;
				}
				printError("Could not find target: "+arg.str);
				return false;
			}

			//Check for type
			auto@ targ = targets.targets[index];
			if(arg.integer2 != int(TT_Any)) {
				if(targ.type != TargetType(arg.integer2)) {
					printError("Target "+targ.name+" is not of appropriate type.");
					return false;
				}
			}
			else {
				arg.integer2 = int(targ.type);
			}

			//Record index
			arg.integer = int(index);
		}
		return true;
	}
};

class BlockHook : Hook {
	int indent = 0;
	array<Hook@> inner;

	BlockHook@ getInside(int indent, const string& line) {
		if(inner.length > 0) {
			BlockHook@ block = cast<BlockHook@>(inner[inner.length - 1]);
			if(block !is null) {
				@block = block.getInside(indent, line);
				if(block !is null)
					return block;
			}
		}
		if(indent > this.indent)
			return this;
		return null;
	}

	void addHook(Hook@ hook) {
		inner.insertLast(hook);
	}

	bool prepare(Argument@& arg) const {
		return true;
	}

	bool feed(Argument@& arg, Hook@& hook, uint& num) const {
		if(num >= inner.length)
			return false;

		@hook = inner[num];
		num += 1;
		return true;
	}
};
// }}}
// {{{ Targets
enum TargetType {
	TT_Empire,
	TT_Object,
	TT_Side,
	TT_Card,
	TT_Vote,
	TT_Effect,
	TT_String,
	TT_Point,
	TT_ID,
	TT_Any,
	TT_Custom,
	
	TT_COUNT
};

TargetType getTargetType(const string& str) {
	if(str.equals_nocase("empire"))
		return TT_Empire;
	if(str.equals_nocase("object"))
		return TT_Object;
	if(str.equals_nocase("side"))
		return TT_Side;
	if(str.equals_nocase("card"))
		return TT_Card;
	if(str.equals_nocase("vote"))
		return TT_Vote;
	if(str.equals_nocase("id"))
		return TT_ID;
	if(str.equals_nocase("effect"))
		return TT_Effect;
	if(str.equals_nocase("text"))
		return TT_String;
	if(str.equals_nocase("point"))
		return TT_Point;
	return TT_Custom;
}

const array<string> TARGET_TYPE_NAMES = {
	"Empire", "Object", "Side", "Card", "Vote",
	"Effect", "Text", "Point", "ID", "Any", "Custom"};

final class Target : Serializable, Savable {
	TargetType type = TT_Custom;
	bool filled = false;
	string name;

	Empire@ emp;
	Object@ obj;
	string str;
	bool side;
	int id;
	vec3d point;

	Target() {
	}

	Target(TargetType Type) {
		type = Type;
	}

	string format(bool pretty = true) const {
		if(!filled)
			return locale::CARD_GENERIC;
		switch(type) {
			case TT_Empire:
				if(emp !is null && playerEmpire !is null && playerEmpire.valid && playerEmpire.ContactMask & emp.mask == 0)
					return "???";
				if(pretty)
					return formatEmpireName(emp);
				else if(emp is null)
					return locale::CARD_GENERIC;
				else
					return emp.name;
			case TT_Object:
				if(pretty)
					return formatObject(obj);
				else if(obj is null)
					return locale::CARD_GENERIC;
				else
					return obj.name;
			case TT_Side: return side ? locale::SUPPORT : locale::OPPOSE;
			case TT_String: case TT_Custom: return str;
			case TT_Point: return ""+point;
		}
		return "...";
	}

	bool opEquals(const Target& other) const {
		if(type != other.type)
			return false;
		if(filled != other.filled)
			return false;
		if(filled) {
			switch(type) {
				case TT_Empire: return emp is other.emp;
				case TT_Object: return obj is other.obj;
				case TT_Side: return side == other.side;
				case TT_String: case TT_Custom: return str == other.str;
				case TT_Vote: case TT_Card: case TT_Effect: case TT_ID:
					return id == other.id;
				case TT_Point: return point == other.point;
			}
			return false;
		}
		else {
			return true;
		}
	}

	//Networking
	void writeData(Message& msg, TargetType Type) {
		msg << filled;
		if(filled) {
			switch(Type) {
				case TT_Empire: msg << emp; break;
				case TT_Object: msg << obj; break;
				case TT_Side: msg << side; break;
				case TT_Point: msg << point; break;
				case TT_String: case TT_Custom: msg << str; break;
				case TT_Vote: case TT_Card: case TT_Effect: case TT_ID:
					msg << id; break;
			}
		}
	}

	void write(Message& msg) {
		uint Type = type;
		msg.writeLimited(type, TT_COUNT-1);
		msg << name;
		writeData(msg, type);
	}

	void readData(Message& msg, TargetType Type) {
		msg >> filled;
		if(filled) {
			switch(Type) {
				case TT_Empire: msg >> emp; break;
				case TT_Object: msg >> obj; break;
				case TT_Side: msg >> side;break;
				case TT_Point: msg >> point; break;
				case TT_String: case TT_Custom: msg >> str; break;
				case TT_Vote: case TT_Card: case TT_Effect: case TT_ID:
					msg >> id; break;
			}
		}
	}

	void read(Message& msg) {
		type = TargetType(msg.readLimited(TT_COUNT-1));
		msg >> name;
		readData(msg, type);
	}

	//Saving
	void saveData(SaveFile& file, TargetType Type) {
		file << filled;
		switch(Type) {
			case TT_Empire: file << emp; break;
			case TT_Object: file << obj; break;
			case TT_Side: file << side; break;
    		case TT_Point: file << point; break;
			case TT_String: case TT_Custom: file << str; break;
			case TT_Vote: case TT_Card: case TT_Effect: case TT_ID:
				file << id; break;
		}
	}

	void save(SaveFile& file) {
		uint Type = type;
		file << Type;
		file << name;
		saveData(file, type);
	}

	void loadData(SaveFile& file, TargetType Type) {
		file >> filled;
		switch(Type) {
			case TT_Empire: file >> emp; break;
			case TT_Object: file >> obj; break;
			case TT_Side: file >> side; break;
			case TT_Point: file >> point; break;
			case TT_String: case TT_Custom: file >> str; break;
			case TT_Vote: case TT_Card: case TT_Effect: case TT_ID:
				file >> id; break;
		}
	}

	void load(SaveFile& file) {
		uint Type = 0;
		file >> Type;
		type = TargetType(Type);
		file >> name;
		loadData(file, type);
	}
};

final class Targets : Serializable, Savable {
	array<Target> targets;

	//Empty list of targets
	Targets() {
	}

	//Add a new target
	Target@ add(const string& name, TargetType type) {
		targets.length = targets.length+1;
		Target@ targ = targets[targets.length-1];
		targ.type = type;
		targ.name = name;
		return targ;
	}

	Target@ add(TargetType type, bool fill = false) {
		targets.length = targets.length+1;
		Target@ targ = targets[targets.length-1];
		targ.type = type;
		targ.filled = fill;
		return targ;
	}

	//Copy existing targets
	Targets(const Targets@ other) {
		targets = other.targets;
	}

	void set(const Targets@ other) {
		targets = other.targets;
	}

	//Get a target variable
	Target@ get(const string& name) {
		for(uint i = 0, cnt = targets.length; i < cnt; ++i) {
			if(targets[i].name == name)
				return targets[i];
		}
		return null;
	}

	Target@ fill(const string& name) {
		auto@ targ = get(name);
		if(targ !is null)
			targ.filled = true;
		return targ;
	}

	Target@ fill(uint index) {
		auto@ targ = targets[index];
		if(targ !is null)
			targ.filled = true;
		return targ;
	}

	int getIndex(const string& name) {
		for(uint i = 0, cnt = targets.length; i < cnt; ++i) {
			if(targets[i].name == name)
				return int(i);
		}
		return -1;
	}

	string format(const string& text, bool pretty = true) const {
		array<string> args;
		formatInto(args, pretty);
		return ::format(text, args);
	}

	void formatInto(array<string>& args, bool pretty = true) const {
		for(uint i = 0, cnt = targets.length; i < cnt; ++i)
			args.insertLast(targets[i].format(pretty));
	}

	string format(bool pretty = true) const {
		string targs = "";
		for(uint i = 0, cnt = targets.length; i < cnt; ++i) {
			if(i != 0)
				targs += ", ";
			targs += targets[i].format(pretty);
		}
		return targs;
	}

	//Check equality of target values
	bool opEquals(const Targets& other) const {
		if(other.targets.length != targets.length)
			return false;
		for(uint i = 0, cnt = targets.length; i < cnt; ++i) {
			if(targets[i] != other.targets[i])
				return false;
		}
		return true;
	}

	//Quick access
	const Target@ opIndex(uint index) const {
		if(index >= targets.length)
			return null;
		return targets[index];
	}

	Target@ opIndex(uint index) {
		if(index >= targets.length)
			return null;
		return targets[index];
	}

	Target@ opIndex(const string& name) {
		return get(name);
	}

	const Target@ opIndex(const string& name) const {
		return get(name);
	}

	uint get_length() const {
		return targets.length;
	}

	//Networking
	Targets(Message& msg) {
		read(msg);
	}

	Targets(Message& msg, const Targets@ def) {
		readData(msg, def);
	}

	void write(Message& msg) {
		uint cnt = targets.length;
		msg.writeSmall(cnt);
		for(uint i = 0; i < cnt; ++i)
			msg << targets[i];
	}

	void read(Message& msg) {
		uint cnt = msg.readSmall();
		targets.length = cnt;
		for(uint i = 0; i < cnt; ++i)
			msg >> targets[i];
	}

	void writeData(Message& msg, const Targets@ def) {
		for(uint i = 0, cnt = def.targets.length; i < cnt; ++i)
			targets[i].writeData(msg, def.targets[i].type);
	}

	void readData(Message& msg, const Targets@ def) {
		set(def);
		for(uint i = 0, cnt = def.targets.length; i < cnt; ++i)
			targets[i].readData(msg, def.targets[i].type);
	}

	//Saving
	Targets(SaveFile& file) {
		load(file);
	}

	Targets(SaveFile& file, const Targets@ def) {
		loadData(file, def);
	}

	void save(SaveFile& file) {
		uint cnt = targets.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			file << targets[i];
	}

	void load(SaveFile& file) {
		uint cnt = 0;
		file >> cnt;
		targets.length = cnt;
		for(uint i = 0; i < cnt; ++i)
			file >> targets[i];
	}

	void saveData(SaveFile& file, const Targets@ def) {
		for(uint i = 0, cnt = def.targets.length; i < cnt; ++i)
			targets[i].saveData(file, def.targets[i].type);
	}

	void loadData(SaveFile& file, const Targets@ def) {
		set(def);
		for(uint i = 0, cnt = def.targets.length; i < cnt; ++i)
			targets[i].loadData(file, def.targets[i].type);
	}
};
//}}}
//{{{ Parser
Hook@ parseHook(array<Hook@>& list, int indent, const string& line, const string& defaultNamespace) {
	BlockHook@ inBlock;
	if(list.length != 0) {
		@inBlock = cast<BlockHook>(list[list.length-1]);
		if(inBlock !is null)
			@inBlock = inBlock.getInside(indent, line);
	}

	Hook@ hook = parseHook(line, defaultNamespace);
	BlockHook@ newBlock = cast<BlockHook>(hook);
	if(newBlock !is null)
		newBlock.indent = indent;

	if(hook !is null) {
		if(inBlock !is null)
			inBlock.addHook(hook);
		else
			list.insertLast(hook);
	}
	return hook;
}

void error(ReadFile@ file, const string& message) {
	if(file !is null)
		file.error(message);
	else
		error(message);
}

Hook@ parseHook(const string& line, const string& defaultNamespace, bool required = true, bool instantiate = true, ReadFile@ file = null) {
	array<string> args;
	string name;

	//Deal with version handling
	string parseLine = line;
	int lastBrkt = line.findLast(")");
	int hashPos = line.findLast("#");
	if(hashPos != -1 && hashPos > lastBrkt) {
		int ltPos = line.findLast("#version<");
		if(ltPos != -1) {
			if(line.length <= uint(ltPos+9) || line[ltPos+9] == '=') {
				error(file, "ERROR: Unknown hook tag: "+parseLine.substr(hashPos));
			}
			else {
				int cmpVersion = toInt(line.substr(ltPos+9))-1;
				if(isLoadedSave) {
					if(START_VERSION >= cmpVersion)
						return null;
				}
				else {
					if(SV_CURRENT >= cmpVersion)
						return null;
				}
				parseLine = parseLine.substr(0, hashPos);
			}
		}
		else {
			int gtePos = line.findLast("#version>=");
			if(gtePos != -1) {
				int cmpVersion = toInt(line.substr(gtePos+10))-1;
				if(isLoadedSave && START_VERSION < cmpVersion)
					return null;
				parseLine = parseLine.substr(0, hashPos);
			}
			else {
				error(file, "ERROR: Unknown hook tag: "+parseLine.substr(hashPos));
			}
		}
	}

	//Parse the actual hook
	if(!funcSplit(parseLine, name, args)) {
		error(file, "Invalid hook: "+escape(parseLine.trimmed()));
		return null;
	}

	bool hasNamespace = true;
	if(name.findFirst("::") == -1) {
		name = defaultNamespace + name;
		hasNamespace = false;
	}
	AnyClass@ cls = getClass(name.trimmed());
	if(!hasNamespace)
		name = name.substr(defaultNamespace.length);
	if(cls is null) {
		if(required && (!hasNamespace || (isServer && !isShadow)) && !isScriptDebug)
			error(file, "Could not find hook class: "+escape(name.trimmed())+" in "+escape(line.trimmed()));
		return null;
	}

	Hook@ hook = cast<Hook>(cls.create());
	if(hook is null) {
		if(required && (!hasNamespace || (isServer && !isShadow)) && !isScriptDebug)
			error(file, "Could not find hook class: "+escape(name.trimmed())+" in "+escape(line.trimmed()));
		return null;
	}
	hook.initClass();
	if(!hook.parse(name, args)) {
		error(file, "Invalid arguments to hook: "+escape(line.trimmed()));
		return null;
	}
	if(instantiate && !hook.instantiate()) {
		error(file, "Could not instantiate hook: "+escape(line.trimmed()));
		return null;
	}

	if(file !is null)
		hook.filePosition = file.position();
	return hook;
}

Hook@ makeHookInstance(const string& line, const string& defaultNamespace, const string& enforceType = "") {
	string name;

	int pos = line.findFirst("(");
	if(pos == -1)
		name = line;
	else
		name = line.substr(0, pos);

	if(name.findFirst("::") == -1)
		name = defaultNamespace + name;

	AnyClass@ cls = getClass(name.trimmed());
	if(cls is null)
		return null;

	if(enforceType.length != 0) {
		AnyClass@ checkType = getClass(enforceType);
		if(checkType !is null && !cls.implements(checkType))
			return null;
	}

	Hook@ hook = cast<Hook>(cls.create());
	if(hook is null)
		return null;

	hook.initClass();
	return hook;
}

Target@ parseTarget(Targets@ targets, const string& line, bool allowCustom = false) {
	int pos = line.findFirst("=");
	if(pos == -1) {
		error("Invalid target spec: "+escape(line));
		return null;
	}

	string name = line.substr(0, pos).trimmed();
	string type = line.substr(pos+1).trimmed();
	
	TargetType tt = getTargetType(type);
	if(!allowCustom && tt == TT_Custom) {
		error("Invalid target type: "+escape(type));
		return null;
	}

	return targets.add(name, tt);
}
//}}}