import empire_ai.weasel.WeaselAI;
import empire_ai.weasel.Planets;
import empire_ai.weasel.Resources;
import empire_ai.weasel.Colonization;
import empire_ai.weasel.Systems;

import planet_levels;
import buildings;

import ai.consider;
from ai.buildings import Buildings, BuildingAI, BuildingUse;
from ai.resources import AIResources, ResourceAI;

interface RaceDevelopment {
	bool shouldBeFocus(Planet& pl, const ResourceType@ resource);
};

class DevelopmentFocus {
	Object@ obj;
	PlanetAI@ plAI;
	int targetLevel = 0;
	int requestedLevel = 0;
	int maximumLevel = INT_MAX;
	array<ExportData@> managedPressure;
	double weight = 1.0;

	void tick(AI& ai, Development& dev, double time) {
		if(targetLevel != requestedLevel) {
			if(targetLevel > requestedLevel) {
				int nextLevel = min(targetLevel, min(obj.resourceLevel, requestedLevel)+1);
				if(nextLevel != requestedLevel) {
					for(int i = requestedLevel+1; i <= nextLevel; ++i)
						dev.resources.organizeImports(obj, i);
					requestedLevel = nextLevel;
				}
			}
			else {
				dev.resources.organizeImports(obj, targetLevel);
				requestedLevel = targetLevel;
			}
		}

		//Remove managed pressure resources that are no longer valid
		for(uint i = 0, cnt = managedPressure.length; i < cnt; ++i) {
			ExportData@ res = managedPressure[i];
			if(res.request !is null || res.obj is null || !res.obj.valid || res.obj.owner !is ai.empire || !res.usable || res.developUse !is obj) {
				if(res.developUse is obj)
					@res.developUse = null;
				managedPressure.removeAt(i);
				--i; --cnt;
			}
		}

		//Make sure we're not exporting our resource
		if(plAI !is null && plAI.resources !is null && plAI.resources.length != 0) {
			auto@ res = plAI.resources[0];
			res.localOnly = true;
			if(res.request !is null && res.request.obj !is res.obj)
				dev.resources.breakImport(res);
		}

		//TODO: We should be able to bump managed pressure resources back to Development for
		//redistribution if we run out of pressure capacity.
	}

	void save(Development& development, SaveFile& file) {
		file << obj;
		development.planets.saveAI(file, plAI);
		file << targetLevel;
		file << requestedLevel;
		file << maximumLevel;
		file << weight;

		uint cnt = managedPressure.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			development.resources.saveExport(file, managedPressure[i]);
	}

	void load(Development& development, SaveFile& file) {
		file >> obj;
		@plAI = development.planets.loadAI(file);
		file >> targetLevel;
		file >> requestedLevel;
		file >> maximumLevel;
		file >> weight;

		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = development.resources.loadExport(file);
			managedPressure.insertLast(data);
		}
	}
};

class Development : AIComponent, Buildings, ConsiderFilter, AIResources {
	RaceDevelopment@ race;
	Planets@ planets;
	Resources@ resources;
	Colonization@ colonization;
	Systems@ systems;

	array<DevelopmentFocus@> focuses;
	array<ExportData@> managedPressure;

	array<ColonizeData@> pendingFocuses;
	array<ColonizeData@> pendingResources;

	array<BuildingRequest@> genericBuilds;
	array<ExportData@> aiResources;

	double aimFTLStorage = 0.0;

	bool managePlanetPressure = true;
	bool manageAsteroidPressure = true;
	bool buildBuildings = true;
	bool colonizeResources = true;

	void create() {
		@planets = cast<Planets>(ai.planets);
		@resources = cast<Resources>(ai.resources);
		@colonization = cast<Colonization>(ai.colonization);
		@systems = cast<Systems>(ai.systems);
		@race = cast<RaceDevelopment>(ai.race);

		//Register specialized building types
		for(uint i = 0, cnt = getBuildingTypeCount(); i < cnt; ++i) {
			auto@ type = getBuildingType(i);
			for(uint n = 0, ncnt = type.ai.length; n < ncnt; ++n) {
				auto@ hook = cast<BuildingAI>(type.ai[n]);
				if(hook !is null)
					hook.register(this, type);
			}
		}
	}

	Empire@ get_empire() {
		return ai.empire;
	}

	Considerer@ get_consider() {
		return cast<Considerer>(ai.consider);
	}

	void registerUse(BuildingUse use, const BuildingType& type) {
		switch(use) {
			case BU_Factory:
				@ai.defs.Factory = type;
			break;
			case BU_LaborStorage:
				@ai.defs.LaborStorage = type;
			break;
		}
	}

	void save(SaveFile& file) {
		file << aimFTLStorage;

		uint cnt = focuses.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ focus = focuses[i];
			focus.save(this, file);
		}

		cnt = managedPressure.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			resources.saveExport(file, managedPressure[i]);

		cnt = pendingFocuses.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			colonization.saveColonize(file, pendingFocuses[i]);

		cnt = pendingResources.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			colonization.saveColonize(file, pendingResources[i]);

		cnt = genericBuilds.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			planets.saveBuildingRequest(file, genericBuilds[i]);

		cnt = aiResources.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			resources.saveExport(file, aiResources[i]);
	}

	void load(SaveFile& file) {
		file >> aimFTLStorage;

		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ focus = DevelopmentFocus();
			focus.load(this, file);

			if(focus.obj !is null)
				focuses.insertLast(focus);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = resources.loadExport(file);
			if(data !is null)
				managedPressure.insertLast(data);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = colonization.loadColonize(file);
			if(data !is null)
				pendingFocuses.insertLast(data);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = colonization.loadColonize(file);
			if(data !is null)
				pendingResources.insertLast(data);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = planets.loadBuildingRequest(file);
			if(data !is null)
				genericBuilds.insertLast(data);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = resources.loadExport(file);
			if(data !is null)
				aiResources.insertLast(data);
		}
	}

	bool requestsFTLStorage() {
		double capacity = ai.empire.FTLCapacity;
		if(aimFTLStorage <= capacity)
			return false;
		if(ai.empire.FTLStored < capacity * 0.5)
			return false;
		return true;
	}

	bool isBuilding(const BuildingType& type) {
		for(uint i = 0, cnt = genericBuilds.length; i < cnt; ++i) {
			if(genericBuilds[i].type is type)
				return true;
		}
		return false;
	}

	bool isLeveling() {
		for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
			if(focuses[i].obj.resourceLevel < uint(focuses[i].targetLevel)) {
				auto@ focus = focuses[i].obj;

				//If all our requirements are resolved, then we can safely assume it will be leveled up
				bool allResolved = true;
				for(uint n = 0, ncnt = resources.requested.length; n < ncnt; ++n) {
					auto@ req = resources.requested[n];
					if(req.obj !is focus)
						continue;
					if(req.beingMet)
						continue;

					if(!req.isColonizing) {
						allResolved = false;
						break;
					}

					if(!colonization.isResolved(req)) {
						allResolved = false;
						break;
					}
				}

				if(!allResolved)
					return true;
			}
		}
		return false;
	}

	bool isBusy() {
		if(pendingFocuses.length != 0)
			return true;
		if(pendingResources.length != 0)
			return true;
		if(isLeveling())
			return true;
		return false;
	}

	bool isFocus(Object@ obj) {
		for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
			if(focuses[i].obj is obj)
				return true;
		}
		return false;
	}

	bool isManaging(ExportData@ res) {
		for(uint i = 0, cnt = managedPressure.length; i < cnt; ++i) {
			if(managedPressure[i] is res)
				return true;
		}
		for(uint i = 0, cnt = aiResources.length; i < cnt; ++i) {
			if(aiResources[i] is res)
				return true;
		}
		for(uint n = 0, ncnt = focuses.length; n < ncnt; ++n) {
			auto@ f = focuses[n];
			if(f.obj is res.obj)
				return true;
			for(uint i = 0, cnt = f.managedPressure.length; i < cnt; ++i) {
				if(f.managedPressure[i] is res)
					return true;
			}
		}
		return false;
	}

	bool isDevelopingIn(Region@ reg) {
		if(reg is null)
			return false;
		for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
			if(focuses[i].obj.region is reg)
				return true;
		}
		return false;
	}

	void start() {
		//Level up the homeworld to level 3 to start with
		for(uint i = 0, cnt = ai.empire.planetCount; i < cnt; ++i) {
			Planet@ homeworld = ai.empire.planetList[i];
			if(homeworld !is null && homeworld.valid) {
				auto@ hwFocus = addFocus(planets.register(homeworld));
				if(homeworld.nativeResourceCount >= 2 || homeworld.primaryResourceLimitLevel >= 3 || cnt == 1)
					hwFocus.targetLevel = 3;
			}
		}
	}

	double idlePenalty = 0;
	void findSomethingToDo() {
		if(idlePenalty > gameTime)
			return;

		double totalChance =
			  ai.behavior.focusDevelopWeight
			+ ai.behavior.focusColonizeNewWeight * sqr(1.0 / double(focuses.length))
			+ ai.behavior.focusColonizeHighTierWeight;
		double roll = randomd(0.0, totalChance);

		//Level up one of our existing focuses
		roll -= ai.behavior.focusDevelopWeight;
		if(roll <= 0) {
			DevelopmentFocus@ levelup;
			double totalWeight = 0.0;
			for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
				auto@ f = focuses[i];
				if(f.weight == 0)
					continue;
				if(f.targetLevel >= f.maximumLevel)
					continue;
				totalWeight += f.weight;
				if(randomd() < f.weight / totalWeight)
					@levelup = f;
			}

			if(levelup !is null) {
				levelup.targetLevel += 1;
				if(log)
					ai.print("Develop chose to level this up to "+levelup.targetLevel, levelup.obj);
				return;
			}
			else {
				if(log)
					ai.print("Develop ran out of things to level up.");
			}
		}

		if(!colonizeResources)
			return;

		//Find a scalable or high tier resource to colonize and turn into a focus
		roll -= ai.behavior.focusColonizeNewWeight * sqr(1.0 / double(focuses.length));
		if(roll <= 0) {
			Planet@ newFocus;
			double totalWeight = 0.0;

			for(uint i = 0, cnt = colonization.potentials.length; i < cnt; ++i) {
				auto@ p = colonization.potentials[i];

				if(p.resource.level < 3 && p.resource.cls !is colonization.scalableClass)
					continue;

				Region@ reg = p.pl.region;
				if(reg is null)
					continue;

				if(colonization.isColonizing(p.pl))
					continue;

				vec2i surfaceSize = p.pl.surfaceGridSize;
				int tiles = surfaceSize.width * surfaceSize.height;
				if(tiles < 144)
					continue;

				auto@ sys = systems.getAI(reg);

				double w = 1.0;
				if(sys.border)
					w *= 0.25;
				if(sys.obj.PlanetsMask & ~ai.mask != 0)
					w *= 0.25;
				if(p.resource.cls is colonization.scalableClass)
					w *= 10.0;

				totalWeight += w;
				if(randomd() < w / totalWeight)
					@newFocus = p.pl;
			}

			if(newFocus !is null) {
				auto@ data = colonization.colonize(newFocus);
				if(data !is null)
					pendingFocuses.insertLast(data);
				if(log)
					ai.print("Colonize to become develop focus", data.target);
				return;
			}
			else {
				if(log)
					ai.print("Develop could not find a scalable or high tier resource to make a focus.");
			}
		}

		if(focuses.length == 0)
			return;

		//Find a high tier resource to import to one of our focuses
		roll -= ai.behavior.focusColonizeHighTierWeight;
		if(roll <= 0) {
			ResourceSpec spec;
			spec.type = RST_Level_Minimum;
			spec.level = 3;
			spec.isLevelRequirement = false;

			auto@ data = colonization.colonize(spec);
			if(data !is null) {
				if(log)
					ai.print("Colonize as free resource", data.target);
				pendingResources.insertLast(data);
				return;
			}
			else {
				if(log)
					ai.print("Develop could not find a high tier resource to colonize as free resource.");
			}
		}

		//Try to find a level 2 resource if everything else failed
		{
			ResourceSpec spec;
			spec.type = RST_Level_Minimum;
			spec.level = 2;
			spec.isLevelRequirement = false;

			if(colonization.shouldQueueFor(spec)) {
				auto@ data = colonization.colonize(spec);
				if(data !is null) {
					if(log)
						ai.print("Colonize as free resource", data.target);
					pendingResources.insertLast(data);
					return;
				}
				else {
					if(log)
						ai.print("Develop could not find a level 2 resource to colonize as free resource.");
				}
			}
		}

		idlePenalty = gameTime + randomd(10.0, 40.0);
	}

	uint bldIndex = 0;
	uint aiInd = 0;
	uint presInd = 0;
	uint chkInd = 0;
	void focusTick(double time) override {
		//Remove any resources we're managing that got used
		for(uint i = 0, cnt = managedPressure.length; i < cnt; ++i) {
			ExportData@ res = managedPressure[i];
			if(res.request !is null || res.obj is null || !res.obj.valid || res.obj.owner !is ai.empire || !res.usable) {
				managedPressure.removeAt(i);
				--i; --cnt;
			}
		}

		//Find new resources that we can put in our pressure manager
		uint avCnt = resources.available.length;
		if(avCnt != 0) {
			uint index = randomi(0, avCnt-1);
			for(uint i = 0, cnt = min(avCnt, 3); i < cnt; ++i) {
				uint resInd = (index+i) % avCnt;
				ExportData@ res = resources.available[resInd];
				if(res.usable && res.request is null && res.obj !is null && res.obj.valid && res.obj.owner is ai.empire && res.developUse is null) {
					if(res.resource.ai.length != 0) {
						if(!isManaging(res))
							aiResources.insertLast(res);
					}
					else if(res.resource.totalPressure > 0 && res.resource.exportable) {
						if(!managePlanetPressure && res.obj.isPlanet)
							continue;
						if(!manageAsteroidPressure && res.obj.isAsteroid)
							continue;
						if(!isManaging(res))
							managedPressure.insertLast(res);
					}
				}
			}
		}

		//Distribute managed pressure resources
		if(managedPressure.length != 0) {
			presInd = (presInd+1) % managedPressure.length;
			ExportData@ res = managedPressure[presInd];

			int pressure = res.resource.totalPressure;

			DevelopmentFocus@ onFocus;
			double bestWeight = 0;
			bool havePressure = ai.empire.HasPressure != 0.0;

			for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
				auto@ f = focuses[i];

				int cap = f.obj.pressureCap;
				if(!havePressure)
					cap = 10000;
				int cur = f.obj.totalPressure;

				if(cur + pressure > 2 * cap)
					continue;

				double w = 1.0;
				if(cur + pressure > cap)
					w *= 0.1;

				if(w > bestWeight) {
					bestWeight = w;
					@onFocus = f;
				}
			}

			if(onFocus !is null) {
				if(res.obj !is onFocus.obj)
					res.obj.exportResourceByID(res.resourceId, onFocus.obj);
				else
					res.obj.exportResourceByID(res.resourceId, null);
				@res.developUse = onFocus.obj;

				onFocus.managedPressure.insertLast(res);
				managedPressure.removeAt(presInd);

				if(log)
					ai.print("Take "+res.resource.name+" from "+res.obj.name+" for pressure", onFocus.obj);
			}
		}

		//Use generic AI distribution hooks
		if(aiResources.length != 0) {
			aiInd = (aiInd+1) % aiResources.length;
			ExportData@ res = aiResources[aiInd];
			if(res.request !is null || res.obj is null || !res.obj.valid || res.obj.owner !is ai.empire || !res.usable) {
				aiResources.removeAt(aiInd);
			}
			else {
				Object@ newTarget = res.developUse;
				if(newTarget !is null) {
					if(!newTarget.valid || newTarget.owner !is ai.empire)
						@newTarget = null;
				}

				for(uint i = 0, cnt = res.resource.ai.length; i < cnt; ++i) {
					auto@ hook = cast<ResourceAI>(res.resource.ai[i]);
					if(hook !is null)
						@newTarget = hook.distribute(this, res.resource, newTarget);
				}

				if(newTarget !is res.developUse) {
					if(res.obj !is newTarget)
						res.obj.exportResourceByID(res.resourceId, newTarget);
					else
						res.obj.exportResourceByID(res.resourceId, null);
					@res.developUse = newTarget;
				}
			}
		}

		//Deal with focuses we're colonizing
		for(uint i = 0, cnt = pendingFocuses.length; i < cnt; ++i) {
			auto@ data = pendingFocuses[i];
			if(data.completed) {
				auto@ focus = addFocus(planets.register(data.target));
				focus.targetLevel = 3;

				pendingFocuses.removeAt(i);
				--i; --cnt;
			}
			else if(data.canceled) {
				pendingFocuses.removeAt(i);
				--i; --cnt;
			}
		}

		for(uint i = 0, cnt = pendingResources.length; i < cnt; ++i) {
			auto@ data = pendingResources[i];
			if(data.completed) {
				planets.requestLevel(planets.register(data.target), data.target.primaryResourceLevel);
				pendingResources.removeAt(i);
				--i; --cnt;
			}
			else if(data.canceled) {
				pendingResources.removeAt(i);
				--i; --cnt;
			}
		}

		//If we're not currently leveling something up, find something else to do
		if(!isBusy())
			findSomethingToDo();

		//Deal with building AI hints
		for(uint i = 0, cnt = genericBuilds.length; i < cnt; ++i) {
			auto@ build = genericBuilds[i];
			if(build.canceled) {
				genericBuilds.removeAt(i);
				--i; --cnt;
			}
			else if(build.built) {
				if(build.getProgress() >= 1.f) {
					if(build.expires < gameTime) {
						genericBuilds.removeAt(i);
						--i; --cnt;
					}
				}
				else
					build.expires = gameTime + 60.0;
			}
		}
		if(buildBuildings) {
			for(uint i = 0, cnt = getBuildingTypeCount(); i < cnt; ++i) {
				bldIndex = (bldIndex+1) % cnt;

				auto@ type = getBuildingType(bldIndex);
				if(type.ai.length == 0)
					continue;

				//If we're already generically building something of this type, wait
				bool existing = false;
				for(uint n = 0, ncnt = genericBuilds.length; n < ncnt; ++n) {
					auto@ build = genericBuilds[n];
					if(build.type is type && !build.built) {
						existing = true;
						break;
					}
				}

				if(existing)
					break;

				@filterType = type;
				@consider.filter = this;

				//See if we should generically build something of this type
				for(uint n = 0, ncnt = type.ai.length; n < ncnt; ++n) {
					auto@ hook = cast<BuildingAI>(type.ai[n]);
					if(hook !is null) {
						Object@ buildOn = hook.considerBuild(this, type);
						if(buildOn !is null && buildOn.isPlanet) {
							auto@ plAI = planets.getAI(cast<Planet>(buildOn));
							if(plAI !is null) {
								if(log)
									ai.print("AI hook generically requested building of type "+type.name, buildOn);

								auto@ req = planets.requestBuilding(plAI, type, expire=ai.behavior.genericBuildExpire);
								if(req !is null)
									genericBuilds.insertLast(req);
								break;
							}
						}
					}
				}
				break;
			}
		}

		//Find planets we've acquired 'somehow' that have scalable resources and should be development focuses
		if(planets.planets.length != 0) {
			chkInd = (chkInd+1) % planets.planets.length;
			auto@ plAI = planets.planets[chkInd];

			if(plAI.resources.length != 0) {
				auto@ res = plAI.resources[0];
				if(res.resource.cls is colonization.scalableClass
					|| focuses.length == 0 && res.resource.level >= 2
					|| (race !is null && race.shouldBeFocus(plAI.obj, res.resource))) {
					if(!isFocus(plAI.obj)) {
						auto@ focus = addFocus(plAI);
						focus.targetLevel = max(1, res.resource.level);
					}
				}
			}
		}
	}

	DevelopmentFocus@ addFocus(PlanetAI@ plAI) {
		DevelopmentFocus focus;
		@focus.obj = plAI.obj;
		@focus.plAI = plAI;
		focus.maximumLevel = getMaxPlanetLevel(plAI.obj);

		focuses.insertLast(focus);
		return focus;
	}

	DevelopmentFocus@ getFocus(Planet& pl) {
		for(uint i = 0, cnt = focuses.length; i < cnt; ++i) {
			if(focuses[i].obj is pl)
				return focuses[i];
		}
		return null;
	}

	void tick(double time) override {
		for(uint i = 0, cnt = focuses.length; i < cnt; ++i)
			focuses[i].tick(ai, this, time);
	}

	const BuildingType@ filterType;
	bool filter(Object@ obj) {
		for(uint i = 0, cnt = genericBuilds.length; i < cnt; ++i) {
			auto@ build = genericBuilds[i];
			if(build.type is filterType && build.plAI.obj is obj)
				return false;
		}
		return true;
	}
};

AIComponent@ createDevelopment() {
	return Development();
}