#include "include/map.as"

#section server
import saving;
import map_loader;
import util.design_designer;
from empire import Creeps;
from game_start import generateNewSystem, SystemGenerateHook;
import object_creation;
import ship_groups;
import map_systems;
import statuses;
from remnant_designs import spawnRemnantFleet, loadRemnantDesigns;

class Room {
	vec3d position;
	SystemData@ core;
	uint circle = 0;
	double angle = 0;
	array<SystemData@> systems;
	array<uint> circles;
	array<Room@> corrids;
};
#section all

enum MapSetting {
	M_SysCount,
	M_SystemSpacing,
	M_Flatten,
};

const uint INITIAL_EXPANSE = 3;
const double REMNANT_FACTOR = 2.0;

class ExpanseMap : Map {
	ExpanseMap() {
		super();

		name = locale::EXPANSE_MAP;
		description = locale::EXPANSE_MAP_DESC;

		sortIndex = -120;
		eatsPlayers = true;

		color = 0x5273ffff;
		icon = "maps/Expanse/expanse.png";
	}

#section client
	void makeSettings() {
		Toggle(locale::FLATTEN, M_Flatten, false, halfWidth=true);
		Number(locale::SYSTEM_SPACING, M_SystemSpacing, DEFAULT_SPACING, decimals=0, step=1000, min=MIN_SPACING, halfWidth=true);
		Description(locale::EXPANSE_MAP_TEXT, lines=3);
	}

#section server
	array<Room@> rooms;

	void preGenerate() {
		Map::preGenerate();
		radius *= 3.0;
	}

	void generateRegions() {
		radius /= 3.0;
		Map::generateRegions();
	}

	void placeSystems() {
		//Generate remnant homeworld
		loadMap("maps/Expanse/coreMap.txt").generate(this);

		//Generate base clusters
		double spacing = modSpacing(getSetting(M_SystemSpacing, DEFAULT_SPACING));
		bool flatten = getSetting(M_Flatten, 0.0) != 0.0;

		//Calculate amount of 'rooms'
		uint players = estPlayerCount;
		if(players == 0)
			players = 3;

		uint roomCnt = players+1;
		uint corridorLength = 2;
		uint sysPerRoom = 7;
		double roomRadius = spacing * 1.5 * sqrt(double(sysPerRoom)) + spacing;
		double roomHeightVar = flatten ? 0.0 : roomRadius * 0.2;
		double sysHeightVar = flatten ? 0.0 : spacing * 0.25;

		double playerOffset = max(roomRadius / (twopi / double(players)), roomRadius);

		//Generate rooms
		double angle = 0.0;
		double radius = 0.0;
		double angleStep = twopi;
		double anglePct = 0.0;
		double startAngle = randomd(0.0, twopi);

		Room@ circleStart;
		uint circle = 0;
		uint circleCnt = 0;

		for(uint i = 0; i < roomCnt; ++i) {
			Room room;
			room.position = quaterniond_fromAxisAngle(vec3d_up(), angle + startAngle) * vec3d_front(radius);
			if(i != 0)
				room.position.y = randomd(-roomHeightVar, roomHeightVar);
			room.circle = circle;
			room.angle = angle + startAngle;

			rooms.insertLast(room);
			if(i != 0)
				room.corrids.insertLast(rooms[0]);
			++circleCnt;

			//Proceed to next room position
			angle += angleStep;
			if(angle + angleStep > twopi) {
				angle = 0.0;
				radius += playerOffset;
				startAngle = randomd(0.0, twopi);
				angleStep = twopi / max(double(roomCnt - i - 1), 1.0);
				circle += 1;

				circleCnt = 0;
			}
		}

		//Generate systems
		for(uint i = 0; i < roomCnt; ++i) {
			Room@ room = rooms[i];

			//Generate systems
			uint sysCount = sysPerRoom;
			angle = 0.0;
			radius = i == 0 ? 9000 : 0;
			angleStep = twopi;
			if(radius != 0) {
				anglePct = (spacing / (2.0 * pi * radius));
				if(sysCount > 0)
					angleStep = max(anglePct * twopi, twopi / double(sysCount));
			}
			startAngle = randomd(0.0, twopi);
			circle = 0;
			int quality = 0;
			if(i == 0 && roomCnt > estPlayerCount)
				quality = 200;
			for(uint n = 0; n < sysCount; ++n) {
				//Generate system
				vec3d pos = quaterniond_fromAxisAngle(vec3d_up(), angle + startAngle) * vec3d_front(radius);
				if(!flatten)
					pos.y = randomd(-sysHeightVar, sysHeightVar);
				pos += room.position;
				SystemData@ sys = addSystem(pos, quality=quality);
				if(circle == 0 && (i != 0 || roomCnt == estPlayerCount))
					addPossibleHomeworld(sys);
				sys.assignGroup = i;

				room.systems.insertLast(sys);
				room.circles.insertLast(circle);

				//Generate links to previous circle
				if(circle > 0) {
					SystemData@ closest;
					double closestDist = INFINITY;
					SystemData@ second;
					double secondDist = INFINITY;

					for(int j = int(n); j >= 0; --j) {
						if(room.circles[j] < circle-1)
							break;
						if(room.circles[j] > circle-1)
							continue;

						SystemData@ other = room.systems[j];
						double d = other.position.distanceToSQ(sys.position);

						if(d < closestDist) {
							@second = closest;
							secondDist = closestDist;
							closestDist = d;
							@closest = other;
						}
						else if(d < secondDist) {
							@second = other;
							secondDist = d;
						}
					}

					if(closest !is null)
						addLink(sys, closest);
					if(second !is null)
						addLink(sys, second);
				}

				//Proceed to next system position
				angle += angleStep;
				if(angle + angleStep > twopi) {
					angle = 0.0;
					radius += spacing;
					startAngle = randomd(0.0, twopi);

					anglePct = (spacing / (2.0 * pi * radius));
					if(sysCount - n - 1 > 0)
						angleStep = max(anglePct * twopi, twopi / double(sysCount - n - 1));
					circle += 1;
				}
			}

			//Make expanse systems
			if(i != 0) {
				double aStep = min(twopi / double(roomCnt - 1), pi*0.33);
				double minAngle = room.angle - aStep * 0.5;
				double maxAngle = room.angle + aStep * 0.5;
				aStep = (maxAngle - minAngle) / double(INITIAL_EXPANSE);
				for(uint n = 0; n < INITIAL_EXPANSE; ++n) {
					double ang = minAngle + double(n) * aStep + aStep * 0.5;
					double rad = room.position.length + radius;
					vec3d pos = quaterniond_fromAxisAngle(vec3d_up(), ang) * vec3d_front(rad);
					pos.y = room.position.y;
					if(!flatten)
						pos.y += randomd(-spacing*0.5, spacing*0.5);

					auto@ sys = addSystem(pos);
					sys.assignGroup = i;

					ExpanseSystem es;
					es.index = sys.index;
					es.shouldExpand = true;
					es.minAngle = minAngle;
					es.maxAngle = maxAngle;
					es.circle = 0;
					es.radius = rad;
					es.field = i;
					es.position = n;
					es.spacing = spacing;
					es.flatten = flatten;
					trackSystems.insertLast(es);
				}
			}
		}

		//Generate corridors
		for(uint i = 0; i < roomCnt; ++i) {
			Room@ room = rooms[i];

			for(uint n = 0, ncnt = room.corrids.length; n < ncnt; ++n) {
				Room@ other = room.corrids[n];

				//Build corridor between rooms
				vec3d offset = (other.position - room.position);
				double offdist = offset.length;
				double spacStep = spacing / offdist;
				double corStart = roomRadius * 0.5 / offdist;
				double corEnd = 1.0 - corStart;
				uint len = clamp(floor((corEnd - corStart) / spacStep), 1, corridorLength);
				double corStep = (corEnd - corStart) / double(len);
				corStart += corStep * 0.5;

				SystemData@ first, last;
				for(uint x = 0; x < len; ++x) {
					vec3d corPos = room.position + offset * (corStep * x + corStart);
					if(room.circle == other.circle)
						corPos = corPos.normalized(room.position.length - roomRadius * 0.25);

					auto@ sys = addSystem(corPos, quality=200);
					if(last !is null)
						addLink(last, sys);
					@last = sys;
					if(x == 0)
						@first = last;
				}

				//Find systems to link to
				double dist = INFINITY;
				SystemData@ closest;
				for(uint j = 0, jcnt = room.systems.length; j < jcnt; ++j) {
					double d = room.systems[j].position.distanceToSQ(first.position);
					if(d < dist) {
						@closest = room.systems[j];
						dist = d;
					}
				}
				addLink(closest, first);

				dist = INFINITY;
				for(uint j = 0, jcnt = other.systems.length; j < jcnt; ++j) {
					double d = other.systems[j].position.distanceToSQ(last.position);
					if(d < dist) {
						@closest = other.systems[j];
						dist = d;
					}
				}
				addLink(closest, last);
			}
		}
	}

	void createRemnant(SystemDesc@ system, double size, ExpanseSystem@ es = null) {
		int fleetSize = ceil(size / double(es.defenders.length + es.queuedFleets) / 25.0) * 25;

		vec3d pos = system.position;
		vec2d offset = random2d(500, system.radius*0.85);
		pos.x += offset.x;
		pos.z += offset.y;

		auto@ ship = spawnRemnantFleet(pos, fleetSize, 0.4);
		if(es !is null && ship !is null) {
			es.defenders.insertLast(ship);
			if(es.queuedFleets > 0)
				es.queuedFleets--;
		}
	}
	
	void createRemnants(SystemDesc@ system, double size, ExpanseSystem@ es, bool queued = false) {
		es.queuedFleets = max(randomd(pow(size, 0.14), pow(size, 0.24)), 1.0);
		if(queued)
			return;
		
		while(es.queuedFleets > 0)
			createRemnant(system, size, es);
	}

	void setPlanetsLocked(SystemDesc@ system, bool value) {
		auto@ status = getStatusType("BlockedColonization");
		uint plCnt = system.object.planetCount;
		for(uint i = 0, cnt = plCnt; i < cnt; ++i) {
			if(status !is null) {
				if(value)
					system.object.planets[i].addStatus(status.id);
				else
					system.object.planets[i].removeStatusInstanceOfType(status.id);
			}
			else {
				system.object.planets[i].setQuarantined(value);
			}
		}
	}

	ExpanseSystem@ setExpanseSystem(SystemDesc@ sys, double remnantSize) {
		ExpanseSystem es;
		@es.system = sys;
		es.remnantSize = remnantSize;
		es.origin = origin;

		createRemnants(sys, remnantSize, es);
		setPlanetsLocked(sys, true);

		trackSystems.insertLast(es);

		return es;
	}

	array<ExpanseSystem@> trackSystems;

	void init() {
		for(uint i = 0, cnt = trackSystems.length; i < cnt; ++i) {
			auto@ es = trackSystems[i];
			es.origin = origin;
			@es.system = getSystem(systems[0].index + es.index);
			es.remnantSize = 100;
			createRemnants(es.system, es.remnantSize, es);
			setPlanetsLocked(es.system, true);
		}

		setExpanseSystem(getSystem(0), randomd(1200, 1800));
		for(uint i = 0, cnt = rooms[0].systems.length; i < cnt; ++i) {
			auto@ sys = getSystem(systems[0].index + rooms[0].systems[i].index);
			setExpanseSystem(sys, randomd(200, 600));
		}
	}

	void tick(double time) {
		bool madeFleet = false;
		
		for(uint i = 0, cnt = trackSystems.length; i < cnt; ++i) {
			auto@ es = trackSystems[i];
			if(es.system is null)
				continue;
			if(es.queuedFleets > 0) {
				if(!madeFleet) {
					createRemnant(es.system, es.remnantSize, es);
					madeFleet = true;
				}
			}
			else if(es.defended) {
				bool defended = false;
				for(uint n = 0, ncnt = es.defenders.length; n < ncnt; ++n) {
					auto@ defender = es.defenders[n];
					if(defender !is null && defender.valid) {
						defended = true;
						break;
					}
				}

				if(!defended) {
					setPlanetsLocked(es.system, false);
					es.defended = false;
					es.defenders.length = 0;

					if(es.shouldExpand)
						expandSystem(es);
				}
			}
		}
	}

	void expandSystem(ExpanseSystem@ es) {
		//Reveal the two closest systems in the next ring
		for(uint i = 0; i < 2; ++i) {
			bool found = false;
			for(uint n = 0, ncnt = trackSystems.length; n < ncnt; ++n) {
				auto@ other = trackSystems[n];
				if(other.field == es.field && other.circle == es.circle+1 && other.position == es.position+i) {
					found = true;
					break;
				}
			}

			if(found)
				continue;

			ExpanseSystem new;
			new.origin = es.origin;
			new.circle = es.circle+1;
			new.spacing = es.spacing;
			new.position = es.position+i;
			new.flatten = es.flatten;
			new.field = es.field;
			new.minAngle = es.minAngle;
			new.maxAngle = es.maxAngle;
			new.radius = es.radius + es.spacing;
			new.index = generatedSystems.length;
			new.shouldExpand = true;
			new.remnantSize = es.remnantSize * REMNANT_FACTOR;

			double aStep = (new.maxAngle - new.minAngle) / double(INITIAL_EXPANSE + new.circle);
			double ang = new.minAngle + double(new.position) * aStep + aStep * 0.5;

			vec3d pos = quaterniond_fromAxisAngle(vec3d_up(), ang) * vec3d_front(new.radius) + new.origin;
			pos.y = es.system.position.y;

			trackSystems.insertLast(new);

			SystemIniter hook;
			@hook.mp = this;
			@hook.es = new;
			generateNewSystem(pos, 2000.0, hook);
		}
	}

	void initSystem(ExpanseSystem@ es) {
		auto@ desc = es.system;
		const SystemType@ sysType;
		do {
			@sysType = getDistributedSystemType();
		}
		while(sysType.unique != SU_NonUnique);

		SystemData data;
		data.index = es.system.index;
		data.position = es.system.position;
		desc.radius = 250;

		sysType.generate(data, es.system);

		desc.object.InnerRadius = desc.radius;
		desc.object.OuterRadius = desc.radius * 1.5;
		desc.object.radius = desc.object.OuterRadius;
		desc.radius = desc.object.OuterRadius;
		desc.object.getNode().scale = desc.object.radius + 128.0;
		desc.object.getNode().rebuildTransform();

		postGenerateSystem(data, es.system);
		finalizeSystem(data, es.system);

		createRemnants(es.system, es.remnantSize * randomd(0.85, 1.15), es, queued=true);
		setPlanetsLocked(es.system, true);
	}

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

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

		if(file < SV_0107)
			loadRemnantDesigns(file);
	}

#section all
}

#section server
class SystemIniter : SystemGenerateHook {
	ExpanseMap@ mp;
	ExpanseSystem@ es;
	void call(SystemDesc@ desc) {
		@es.system = desc;
		mp.initSystem(es);
	}
}

class ExpanseSystem : Savable {
	uint index = 0;
	uint circle = 0;
	uint position = 0;
	uint field = 0;
	SystemDesc@ system;
	vec3d origin;
	array<Ship@> defenders;
	double minAngle = 0, maxAngle = 0;
	double radius = 0;
	double remnantSize = 0;
	double spacing = 6500;
	bool defended = true;
	bool shouldExpand = false;
	bool flatten = false;
	uint queuedFleets = 0;

	void save(SaveFile& file) {
		file << index << circle;
		file << position << field;
		file << system.index;

		uint cnt = defenders.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			file << defenders[i];
		
		file << minAngle << maxAngle;
		file << radius << remnantSize;
		file << defended << shouldExpand;
		file << spacing << flatten;
		file << origin;
		file << queuedFleets;
	}

	void load(SaveFile& file) {
		file >> index >> circle;
		file >> position >> field;

		uint index = 0;
		file >> index;
		@system = getSystem(index);

		uint cnt = 0;
		file >> cnt;
		defenders.length = cnt;
		for(uint i = 0; i < cnt; ++i)
			file >> defenders[i];
		
		file >> minAngle >> maxAngle;
		file >> radius >> remnantSize;
		file >> defended >> shouldExpand;
		file >> spacing >> flatten;
		file >> origin;
		if(file >= SV_0088)
			file >> queuedFleets;
	}
};
#section all