import hooks;
import statuses;
from statuses import StatusHook;
import artifacts;
import planet_effects;
import tile_resources;
from bonus_effects import BonusEffect;
import listed_values;
from resources import MoneyType;

#section server
from empire import Creeps;
from objects.Artifact import createArtifact;
#section all

//ArtifactOnDestroy(<Type>, <Destroy Chance> = 0)
// Create an artifact of <Type> if the object gets destroyed.
class ArtifactOnDestroy : StatusHook {
	Document doc("When the object carrying this status is destroyed, spawn an artifact at its position.");
	Argument type(AT_Artifact, doc="Type of artifact to spawn.");
	Argument destroy_chance(AT_Decimal, "0", doc="Chance that the artifact is destroyed instead of dropping from the ship.");

#section server
	void onObjectDestroy(Object& obj, Status@ status, any@ data) {
		if(randomd() > arguments[1].decimal) {
			auto@ type = getArtifactType(arguments[0].integer);
			vec3d pos = obj.position + random3d(type.physicalSize * 4.0, type.physicalSize * 12.0);
			auto@ artifact = createArtifact(pos, type);
			if(obj.region !is null)
				artifact.orbitAround(obj.region.position);
		}
	}
#section all
};


//BombardEffect()
//	Applies the bombardment status on a planet
class BombardEffect : StatusHook {
	Document doc("Applies the bombardment effect on a planet.");

#section server
	void onAddStack(Object& obj, Status@ status, StatusInstance@ instance, any@ data) {
		Planet@ pl = cast<Planet>(obj);
		if(pl !is null)
			pl.modBombardment(1);
	}
	
	void onRemoveStack(Object& obj, Status@ status, StatusInstance@ instance, any@ data) {
		Planet@ pl = cast<Planet>(obj);
		if(pl !is null)
			pl.modBombardment(-1);
	}
#section all
};

//ReduceProductionPerStack(<Per Stack> = 1)
// Reduces any non-money income by <Per Stack> per stack.
class ReduceProductionPerStack : StatusHook {
	Document doc("Reduce random non-money incomes by a pressure-equivalent amount for every stack of this status.");
	Argument per_stack(AT_Decimal, "1", doc="Amount of pressure-equivalent income to remove per stack.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		if(!obj.isPlanet)
			return;
		array<double> current(TR_COUNT, 0.0);

		data.store(@current);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		if(!obj.isPlanet)
			return;
		array<double>@ current;
		data.retrieve(@current);
		for(uint i = 1; i < TR_COUNT; ++i) {
			if(current[i] > 0)
				obj.modResource(i, +current[i]);
		}
		@current = null;
		data.store(@current);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(!obj.isPlanet)
			return true;
		double target = arguments[0].decimal * double(status.stacks);
		double currentTotal = 0.0;
		array<double>@ current;
		data.retrieve(@current);
		for(uint i = 1; i < TR_COUNT; ++i) {
			double prod = obj.getResourceProduction(i);
			double cur = current[i];
			if(prod < 0) {
				if(cur > 0) {
					double amt = min(-prod, cur);
					obj.modResource(i, +amt);
					prod += amt;
					cur -= amt;
				}
			}
			currentTotal += cur;
		}
		if(currentTotal < target - 0.001) {
			uint base = randomi(0, TR_COUNT-1);
			for(uint i = 0; i < TR_COUNT-1 && currentTotal < target; ++i) {
				uint index = 1 + (base + i) % (TR_COUNT-1);
				double prod = obj.getResourceProduction(index);
				double cur = current[index];
				if(prod > 0) {
					double amt = min(prod, target - currentTotal);
					obj.modResource(index, -amt);
					currentTotal += amt;
					current[index] += amt;
				}
			}
		}
		else if(currentTotal > target + 0.001) {
			uint base = randomi(0, TR_COUNT-1);
			for(uint i = 0; i < TR_COUNT-1 && currentTotal > target; ++i) {
				uint index = 1 + (base + i) % (TR_COUNT-1);
				double prod = obj.getResourceProduction(index);
				double cur = current[index];
				if(cur > 0) {
					double amt = min(cur, currentTotal - target);
					obj.modResource(index, +amt);
					currentTotal -= amt;
					current[index] -= amt;
				}
			}
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		array<double>@ current;
		data.retrieve(@current);
		for(uint i = 1; i < TR_COUNT; ++i)
			file << current[i];
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		array<double> current(TR_COUNT, 0.0);
		data.store(@current);
		for(uint i = 1; i < TR_COUNT; ++i)
			file >> current[i];
	}
#section all
};

//ApplyToFlagships()
// Only apply this status to flagships.
class ApplyToFlagships : StatusHook {
	Document doc("When this status is added to a system, it applies to flagships only.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		return obj !is null && obj.isShip && obj.hasLeaderAI;
	}
};

class ApplyToPlanets : StatusHook {
	Document doc("When this status is added to a system, it applies to planets only.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		return obj !is null && obj.isPlanet;
	}
};

class ApplyToUncolonizedPlanets : StatusHook {
	Document doc("When this status is added to a system, it applies to uncolonized planets only.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		return obj !is null && obj.isPlanet && (obj.owner is null || !obj.owner.valid);
	}
};

class ApplyToColonizedPlanets : StatusHook {
	Document doc("When this status is added to a system, it applies to colonized planets only.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		return obj !is null && obj.isPlanet && (obj.owner !is null && obj.owner.valid);
	}
};

tidy final class RepeatStacks : StatusHook {
	Document doc("Repeat a generic hook for every stack present.");
	Argument code(AT_Hook, "status_effects::IStatusHook", doc="Hook to repeat.");
	Argument per_stack(AT_Integer, "1", doc="Amount of times to repeat per stack.");
	Argument max_repeats(AT_Integer, "0", doc="If set to more than 0, the hook will never repeat more than that amount of times.");

	IStatusHook@ hook;

	bool instantiate() override {
		@hook = cast<IStatusHook>(parseHook(arguments[0].str, "status_effects::"));
		if(hook is null) {
			error("RepeatStacks(): could not find inner hook: "+escape(arguments[0].str));
			return false;
		}
		return StatusHook::instantiate();
	}

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		array<any> datlist;
		data.store(@datlist);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) {
		array<any>@ datlist;
		data.retrieve(@datlist);
		if(datlist is null)
			return true;

		uint oldCnt = datlist.length;
		uint newCnt = per_stack.integer * status.stacks;
		if(max_repeats.integer > 0 && newCnt > uint(max_repeats.integer))
			newCnt = max_repeats.integer;
		for(uint i = newCnt; i < oldCnt; ++i)
			hook.onDestroy(obj, status, datlist[i]);
		datlist.length = newCnt;
		for(uint i = oldCnt; i < newCnt; ++i)
			hook.onCreate(obj, status, datlist[i]);
		for(uint i = 0; i < newCnt; ++i)
			hook.onTick(obj, status, datlist[i], time);
		return true;
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		array<any>@ datlist;
		data.retrieve(@datlist);
		if(datlist is null)
			return;
		for(uint i = 0, cnt = datlist.length; i < cnt; ++i)
			hook.onDestroy(obj, status, datlist[i]);
		datlist.length = 0;
		@datlist = null;
		data.store(@datlist);
	}

	bool onOwnerChange(Object& obj, Status@ status, any@ data, Empire@ prevOwner, Empire@ newOwner) override {
		array<any>@ datlist;
		data.retrieve(@datlist);
		if(datlist is null)
			return true;
		for(uint i = 0, cnt = datlist.length; i < cnt; ++i)
			hook.onOwnerChange(obj, status, datlist[i], prevOwner, newOwner);
		return true;
	}

	bool onRegionChange(Object& obj, Status@ status, any@ data, Region@ prevRegion, Region@ newRegion) override {
		array<any>@ datlist;
		data.retrieve(@datlist);
		if(datlist is null)
			return true;
		for(uint i = 0, cnt = datlist.length; i < cnt; ++i)
			hook.onRegionChange(obj, status, datlist[i], prevRegion, newRegion);
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		array<any>@ datlist;
		data.retrieve(@datlist);
		uint cnt = 0;
		if(datlist is null) {
			file << cnt;
			return;
		}

		cnt = datlist.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			hook.save(status, datlist[i], file);
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		array<any> datlist;
		uint cnt = 0;
		file >> cnt;
		datlist.length = cnt;
		for(uint i = 0; i < cnt; ++i)
			hook.load(status, datlist[i], file);
		data.store(@datlist);
	}
#section all
};

tidy final class TriggerCreate : StatusHook {
	BonusEffect@ eff;
	Argument hook(AT_Hook, "bonus_effects::BonusEffect", doc="Hook to call.");

	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("TriggerCreate(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return StatusHook::instantiate();
	}

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		eff.activate(obj, obj.owner);
	}
#section all
};

class ConditionSinglePressureType : StatusHook {
	Document doc("This condition can only be on planets with a primary resource with a single pressure type.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasResources)
			return false;
		auto@ type = getResource(obj.primaryResourceType);
		if(type is null)
			return false;

		uint count = 0;
		for(uint i = 0, cnt = type.tilePressure.length; i < cnt; ++i) {
			if(type.tilePressure[i] > 0)
				count += 1;
		}
		return count == 1;
	}
};

class ConditionBiome : StatusHook {
	Document doc("This condition can only be on planets that have a particular biome.");
	Argument biome(AT_PlanetBiome, doc="Biome to check for.");

#section server
	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasSurfaceComponent)
			return false;
		return obj.hasBiome(biome.integer);
	}
#section all
};

class ConditionMaxLevel : StatusHook {
	Document doc("This effect only applies on planets with resources at or below a maximum level.");
	Argument max_level(AT_Integer, doc="Highest level this can apply to.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasResources)
			return false;
		auto@ type = getResource(obj.primaryResourceType);
		if(type is null)
			return false;
		return int(type.level) <= max_level.integer;
	}
};

class ConditionMinLevel : StatusHook {
	Document doc("This effect only applies on planets with resources at or above a minimum level.");
	Argument min_level(AT_Integer, doc="Lowest level this can apply to.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasResources)
			return false;
		auto@ type = getResource(obj.primaryResourceType);
		if(type is null)
			return false;
		return int(type.level) >= min_level.integer;
	}
};

class ConditionDLC : StatusHook {
	Document doc("This condition can only be generated when a dlc is present.");
	Argument dlc(AT_Custom, doc="DLC to check for.");

	bool activated = false;
	bool instantiate() override {
		if(!StatusHook::instantiate())
			return false;
		activated = hasDLC(dlc.str);
		return true;
	}

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		return activated;
	}
};

class ConditionMinPressure : StatusHook {
	Document doc("This effect only applies on planets with resources with at least a certain amount of pressure.");
	Argument min_pressure(AT_Integer, doc="Least amount of pressure this can apply to.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasResources)
			return false;
		auto@ type = getResource(obj.primaryResourceType);
		if(type is null)
			return false;
		return type.totalPressure >= min_pressure.integer;
	}
};

class ConditionMaxPressure : StatusHook {
	Document doc("This effect only applies on planets with resources up to a certain amount of pressure.");
	Argument max_pressure(AT_Integer, doc="Maximum amount of pressure this can apply to.");

	bool shouldApply(Empire@ emp, Region@ region, Object@ obj) const override {
		if(!obj.hasResources)
			return false;
		auto@ type = getResource(obj.primaryResourceType);
		if(type is null)
			return false;
		return type.totalPressure <= max_pressure.integer;
	}
};

tidy final class TriggerColonized : StatusHook {
	BonusEffect@ eff;
	Argument hook(AT_Hook, "bonus_effects::BonusEffect", doc="Hook to call.");

	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("TriggerColonized(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return StatusHook::instantiate();
	}

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(!obj.isPlanet)
			return false;

		Empire@ owner = obj.owner;
		if(owner is null || !owner.valid)
			return true;
		if(obj.population < 0.9999)
			return true;

		eff.activate(obj, owner);
		return false;
	}
#section all
};

class VisibleToOriginEmpire : StatusHook {
	Document doc("The object is always visible to the origin empire of this status.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(status.originEmpire !is null)
			obj.donatedVision |= status.originEmpire.mask;
		return true;
	}
#section all
};

class GivesVisionToOriginEmpire : StatusHook {
	Document doc("The object gives vision in the system it is in to the origin empire of this status.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		Region@ reg = obj.region;
		if(status.originEmpire !is null && reg !is null)
			reg.grantVision(status.originEmpire);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		Region@ reg = obj.region;
		if(status.originEmpire !is null && reg !is null)
			reg.revokeVision(status.originEmpire);
	}

	bool onRegionChange(Object& obj, Status@ status, any@ data, Region@ prevRegion, Region@ newRegion) override {
		if(status.originEmpire !is null && prevRegion !is null)
			prevRegion.revokeVision(status.originEmpire);
		if(status.originEmpire !is null && newRegion !is null)
			newRegion.grantVision(status.originEmpire);
		return true;
	}
#section all
};

tidy final class RoamSystems : StatusHook {
	Document doc("Roam through systems, triggering a bonus hook for each visited.");
	Argument hook(AT_Hook, "bonus_effects::BonusEffect");
	Argument origin_empires(AT_Boolean, "False", doc="Whether to only visit empires that are related to the origin object.");

#section server
	BonusEffect@ eff;
	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("RoamOccupiedSystems(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return StatusHook::instantiate();
	}

	void onCreate(Object& obj, Status@ status, any@ data) override {
		if(status.originObject !is null) {
			obj.addGotoOrder(status.originObject, true);
			if(origin_empires.boolean) {
				uint mask = 0;
				if(status.originObject.isRegion)
					mask = cast<Region>(status.originObject).PlanetsMask;
				else {
					Empire@ owner = status.originObject.owner;
					if(owner !is null)
						mask = owner.mask;
				}
				data.store(mask);
			}
		}
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(!obj.valid)
			return false;
		if(obj.orderCount == 0) {
			//Trigger for this system
			Region@ reg = obj.region;
			if(reg !is null)
				eff.activate(obj.region, status.originEmpire);

			//Find next system to go to
			if(reg is null) {
				if(status.originObject is null || !status.originObject.isRegion)
					return false;
				obj.addGotoOrder(status.originObject, true);
			}

			uint mask = ~0;
			if(origin_empires.boolean)
				data.retrieve(mask);
			auto@ sys = getSystem(reg);
			array<SystemDesc@> poss;
			for(uint i = 0, cnt = sys.adjacent.length; i < cnt; ++i) {
				auto@ other = getSystem(sys.adjacent[i]);
				if(mask == ~0 || other.object.PlanetsMask & mask != 0)
					poss.insertLast(other);
			}

			SystemDesc@ target;
			if(poss.length == 0) {
				if(sys.adjacent.length == 0) {
					if(status.originObject is null || !status.originObject.isRegion)
						return false;
					obj.addGotoOrder(status.originObject, true);
					return true;
				}
				else {
					@target = getSystem(sys.adjacent[randomi(0, sys.adjacent.length-1)]);
				}
			}
			else {
				@target = poss[randomi(0, poss.length-1)];
			}

			obj.addGotoOrder(target.object, true);
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		uint mask = 0;
		data.retrieve(mask);
		file << mask;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		uint mask = 0;
		file >> mask;
		data.store(mask);
	}
#section all
};

class RemoveOnOwnerChange : StatusHook {
	Document doc("This status is removed when the object changes owners.");

#section server
	bool onOwnerChange(Object& obj, Status@ status, any@ data, Empire@ prevOwner, Empire@ newOwner) override {
		return false;
	}
#section all
};

class IsTriggerStatus : StatusHook {
	Document doc("This status is removed immediately after triggering.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		return false;
	}
#section all
};

class RemoveIfInCombat : StatusHook {
	Document doc("Remove this status when the object is in combat.");
	Argument timer(AT_Decimal, "0", doc="Time to wait after creation of the status before checking for combat.");
	Argument skip_timer_nocombat(AT_Boolean, "True", doc="Whether to skip the wait timer if the ship was not in combat when the status was created.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		double delay = timer.decimal;
		if(skip_timer_nocombat.boolean && !obj.inCombat)
			delay = 0;
		data.store(delay);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		double delay = 0;
		data.retrieve(delay);

		if(delay > 0) {
			delay -= time;
			data.store(delay);
		}
		else {
			if(obj.inCombat)
				return false;
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		double delay = 0;
		data.retrieve(delay);
		file << delay;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		double delay = 0;
		file >> delay;
		data.store(delay);
	}
#section all
};

class RemoveOnAttackOrder : StatusHook {
	Document doc("Remove the status when the ship receives an attack order.");
	Argument remove_when_range(AT_Boolean, "True", doc="Only remove the status when in range.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(!obj.hasLeaderAI)
			return true;
		Object@ targ = obj.getAttackTarget();
		if(targ is null)
			return true;
		if(!remove_when_range.boolean)
			return false;
		return obj.getAttackDistance() > obj.getEngagementRange() + obj.radius + targ.radius;
	}
#section all
};

class EnergyMaintenance : StatusHook {
	Document doc("This status requires an amount of energy per second in maintenance, or it will fail.");
	Argument amount(AT_Decimal, "0", doc="Base amount of energy per second it costs.");
	Argument per_shipsize(AT_Decimal, "0", doc="When on a ship, increase the energy per second by the ship design size multiplied by this.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		double amt = amount.decimal;
		if(per_shipsize.decimal != 0 && obj.isShip)
			amt += cast<Ship>(obj).blueprint.design.size * per_shipsize.decimal;

		if(obj.owner !is null)
			obj.owner.modEnergyUse(amt);
		data.store(amt);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		double amt = 0;
		data.retrieve(amt);

		if(obj.owner !is null)
			obj.owner.modEnergyUse(-amt);
	}

	bool onOwnerChange(Object& obj, Status@ status, any@ data, Empire@ prevOwner, Empire@ newOwner) override {
		double amt = 0;
		data.retrieve(amt);
		if(prevOwner !is null)
			prevOwner.modEnergyUse(-amt);
		if(newOwner !is null)
			newOwner.modEnergyUse(amt);
		return true;
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(obj.owner !is null && obj.owner.EnergyShortage)
			return false;
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

class ConstructOrbital : StatusHook {
	Document doc("This status automatically constructs the orbital it is on over time.");
	Argument duration(AT_Decimal, doc="Time that the orbital takes before it finishes construction.");
	Argument remove_status(AT_Boolean, "True", doc="Whether to remove this status after the construction finishes.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		double timer = 0;
		data.store(timer);

		if(obj.isOrbital)
			cast<Orbital>(obj).setDisabled(true);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		if(obj.isOrbital)
			cast<Orbital>(obj).setDisabled(false);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		double timer = 0;
		data.retrieve(timer);

		if(timer < duration.decimal) {
			timer += time;
			data.store(timer);

			if(obj.isOrbital)
				cast<Orbital>(obj).setBuildPct(timer / duration.decimal);

			if(timer >= duration.decimal) {
				if(obj.isOrbital)
					cast<Orbital>(obj).setDisabled(false);
				if(remove_status.boolean)
					return false;
			}
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		double time = 0;
		data.retrieve(time);
		file << time;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		double time = 0;
		file >> time;
		data.store(time);
	}
#section all
};

class AbandonOnDisableIfSameOrigin : StatusHook {
	Document doc("If this status has the same origin empire as the object's owner, abandon the planet when it gets disabled.");

#section server
	void onDestroy(Object& obj, Status@ status, any@ data) override {
		if(obj.hasSurfaceComponent) {
			if(obj.owner is status.originEmpire)
				obj.forceAbandon();
		}
	}
#section all
};

class ForcePopulationToStacks : StatusHook {
	Document doc("Force the planet to always have the same amount of population as this status' stack count.");
	Argument factor(AT_Decimal, "1.0", doc="Multiplication factor to stack count.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(obj.hasSurfaceComponent) {
			double curPop = obj.population;
			double targPop = double(status.stacks) * factor.decimal;
			if(curPop != targPop)
				obj.addPopulation(targPop - curPop);
		}
		return true;
	}
#section all
};

tidy final class EnabledData {
	bool enabled = false;
	any data;
};

tidy final class OnOriginEmpire : StatusHook {
	EmpireEffect@ eff;

	Document doc("Apply an effect on the origin empire of the status, if it has one.");
	Argument hookID("Hook", AT_Hook, "empire_effects::EmpireEffect");
	Argument allow_same(AT_Boolean, "True", doc="Whether to also apply the effect if the origin empire is the object's current owner.");

	bool instantiate() override {
		@eff = cast<EmpireEffect>(parseHook(hookID.str, "empire_effects::", required=false));
		if(eff is null) {
			error("OnOriginEmpire(): could not find inner hook: "+escape(hookID.str));
			return false;
		}
		return StatusHook::instantiate();
	}

	bool check(Object& obj, Status@ status) {
		if(status.originEmpire is null)
			return false;
		if(!allow_same.boolean && obj.owner is status.originEmpire)
			return false;
		return true;
	}

	void onCreate(Object& obj, Status@ status, any@ data) {
		EnabledData enab;
		data.store(@enab);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) {
		EnabledData@ enab;
		data.retrieve(@enab);
		if(enab !is null && enab.enabled)
			eff.disable(status.originEmpire, enab.data);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) {
		EnabledData@ enab;
		data.retrieve(@enab);

		bool shouldEnable = check(obj, status);
		if(enab.enabled != shouldEnable) {
			if(shouldEnable) {
				eff.enable(status.originEmpire, enab.data);
				enab.enabled = true;
			}
			else {
				eff.disable(status.originEmpire, enab.data);
				enab.enabled = false;
			}
		}

		if(enab.enabled)
			eff.tick(status.originEmpire, enab.data, time);
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) {
		EnabledData@ enab;
		data.retrieve(@enab);

		file << enab.enabled;
		if(enab.enabled)
			eff.save(enab.data, file);
	}

	void load(Status@ status, any@ data, SaveFile& file) {
		EnabledData enab;
		data.store(@enab);

		file >> enab.enabled;
		if(enab.enabled)
			eff.load(enab.data, file);
	}
};

tidy final class TriggerWithOriginEmpire : StatusHook {
	Document doc("Trigger the effect with the empire set to the origin empire of this status.");
	Argument hookID(AT_Hook, "bonus_effects::BonusEffect", doc="Hook to call.");

	BonusEffect@ hook;

	bool instantiate() override {
		if(hookID.str != "bonus_effects::BonusEffect")
			@hook = cast<BonusEffect>(parseHook(hookID.str, "bonus_effects::"));
		return StatusHook::instantiate();
	}

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		if(hook !is null)
			hook.activate(obj, status.originEmpire);
	}
#section all
};

tidy final class RemoveOnWarWithOriginEmpire : StatusHook {
	Document doc("This status is removed when the empire goes to war with the origin empire.");
	Argument trigger_owner(AT_Hook, "bonus_effects::EmpireTrigger", doc="Hook to call on the owner empire when it happens.");
	Argument trigger_origin(AT_Hook, "bonus_effects::EmpireTrigger", doc="Hook to call on the origin empire when it happens.");

	BonusEffect@ ownerHook;
	BonusEffect@ originHook;

	bool instantiate() override {
		if(trigger_owner.str != "bonus_effects::EmpireTrigger")
			@ownerHook = cast<BonusEffect>(parseHook(trigger_owner.str, "bonus_effects::"));
		if(trigger_origin.str != "bonus_effects::EmpireTrigger")
			@originHook = cast<BonusEffect>(parseHook(trigger_origin.str, "bonus_effects::"));
		return StatusHook::instantiate();
	}

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(status.originEmpire is null)
			return true;
		if(obj.owner.isHostile(status.originEmpire)) {
			if(ownerHook !is null)
				ownerHook.activate(obj, obj.owner);
			if(originHook !is null)
				originHook.activate(obj, status.originEmpire);
			return false;
		}
		return true;
	}
#section all
};

class GivePlanetIncomeToOriginEmpire : StatusHook {
	Document doc("Give a percentage of this planet's income to the origin empire.");
	Argument percentage(AT_Decimal, doc="Percentage of planet income to give.");
	Argument allow_same(AT_Boolean, "False", doc="Whether to also apply the effect if the origin empire is the object's current owner.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) {
		int amount = 0;
		data.store(amount);
	}

	void onDestroy(Object& obj, Status@ status, any@ data) {
		int amount = 0;
		data.retrieve(amount);

		if(amount != 0 && status.originEmpire !is null)
			status.originEmpire.modTotalBudget(-amount, MoT_Misc);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) {
		if(status.originEmpire is null)
			return true;

		int curAmount = 0;
		data.retrieve(curAmount);

		int newAmount = 0;
		if(obj.owner !is status.originEmpire || allow_same.boolean) {
			if(obj.hasSurfaceComponent)
				newAmount = max(double(obj.income) * percentage.decimal, 0.0);
		}

		if(newAmount != curAmount) {
			status.originEmpire.modTotalBudget(newAmount - curAmount, MoT_Misc);
			data.store(newAmount);
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) {
		int amount = 0;
		data.retrieve(amount);
		file << amount;
	}

	void load(Status@ status, any@ data, SaveFile& file) {
		int amount = 0;
		file >> amount;
		data.store(amount);
	}
#section all
};

class OnlyOriginEmpireCanCapture : StatusHook {
	Document doc("While this status is active, only the origin empire can capture the planet through siege.");
	Argument allow_same(AT_Boolean, "True", doc="Whether to allow the protection even if the owner is the same as the origin.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) {
		uint mask = ~0;
		if(status.originEmpire !is null) {
			if(allow_same.boolean || obj.owner !is status.originEmpire)
				mask &= ~status.originEmpire.mask;
		}
		if(mask != 0 && obj.hasSurfaceComponent)
			obj.protectFrom(mask);
		return true;
	}

	void onDestroy(Object& obj, Status@ status, any@ data) {
		if(obj.hasSurfaceComponent)
			obj.clearProtectedFrom();
	}
#section all
};

class SiegeFromOrigin : StatusHook {
	Document doc("This status is considered equivalent to a sieging fleet in orbit for the origin empire of the status.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(status.originEmpire !is null) {
			obj.fakeSiege(status.originEmpire.mask);
			if(obj.getLoyaltyFacing(status.originEmpire) <= 0)
				obj.annex(status.originEmpire);
		}
		return true;
	}

	void onDestroy(Object& obj, Status@ status, any@ data) {
		if(status.originEmpire !is null)
			obj.clearFakeSiege(status.originEmpire.mask);
	}
#section all
};

class RemoveIfNotWar : StatusHook {
	Document doc("Remove this status if the owner is not at war with the status origin empire.");

#section server
	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		if(status.originEmpire !is null) {
			if(!status.originEmpire.isHostile(obj.owner))
				return false;
		}
		return true;
	}
#section all
};

class RemoveIfNoRemnantsInSystem : StatusHook {
	Document doc("Remove this status if there are no remnants in the system.");
	Argument timer(AT_Decimal, "30", doc="Don't remove the status for this amount of time after it is created.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		double delay = timer.decimal;
		data.store(delay);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		double delay = 0;
		data.retrieve(delay);

		if(delay > 0) {
			delay -= time;
			data.store(delay);
		}
		else {
			Region@ reg = obj.region;
			if(reg !is null && reg.getStrength(Creeps) <= 0)
				return false;
		}
		return true;
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		double delay = 0;
		data.retrieve(delay);
		file << delay;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		double delay = 0;
		file >> delay;
		data.store(delay);
	}
#section all
};

class ProduceNativePressurePct : StatusHook {
	Document doc("Produce a percentage of the native resource's pressure.");
	Argument base(AT_Decimal, "0", doc="Percentage to produce.");
	Argument per_stack(AT_Decimal, "0", doc="Percentage to add per stack.");

#section server
	void onCreate(Object& obj, Status@ status, any@ data) override {
		double pct = 0.0;
		data.store(pct);
	}

	bool onTick(Object& obj, Status@ status, any@ data, double time) override {
		double prevPct = 0.0;
		data.retrieve(prevPct);

		double newPct = base.decimal;
		newPct += per_stack.decimal * status.stacks;

		if(newPct != prevPct) {
			auto@ resource = getResource(obj.primaryResourceType);
			if(resource is null) {
				newPct = 0.0;
			}
			else {
				for(uint i = 0; i < TR_COUNT; ++i) {
					double prev = double(resource.tilePressure[i]) * prevPct;
					double cur = double(resource.tilePressure[i]) * newPct;
					if(prev != cur)
						obj.modResource(i, cur - prev);
				}
			}

			data.store(newPct);
		}

		return true;
	}

	void onDestroy(Object& obj, Status@ status, any@ data) override {
		double pct = 0;
		data.retrieve(pct);

		auto@ resource = getResource(obj.primaryResourceType);
		if(resource !is null) {
			for(uint i = 0; i < TR_COUNT; ++i) {
				double prev = double(resource.tilePressure[i]) * pct;
				obj.modResource(i, -prev);
			}
		}
	}

	void save(Status@ status, any@ data, SaveFile& file) override {
		double pct = 0;
		data.retrieve(pct);
		file << pct;
	}

	void load(Status@ status, any@ data, SaveFile& file) override {
		double pct = 0;
		file >> pct;
		data.store(pct);
	}
#section all
};

tidy final class OnRemoveStatusAttribLT : StatusHook {
	Document doc("When this status is removed and an attribute is lower than a specified value, trigger the effect.");
	Argument attribute(AT_EmpAttribute, doc="Attribute to check.");
	Argument value(AT_Decimal, doc="Value to check.");

	BonusEffect@ eff;
	Argument hook(AT_Hook, "bonus_effects::BonusEffect", doc="Hook to call.");

	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("TriggerCreate(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return StatusHook::instantiate();
	}

#section server
	void onDestroy(Object& obj, Status@ status, any@ data) {
		if(obj.owner.getAttribute(attribute.integer) < value.decimal)
			eff.activate(obj, obj.owner);
	}
#section all
};