/*  ##############################
	# Roles: Creep functionality #
	############################## */

module.exports = {

	ROLE_HARVESTER: 0,
	ROLE_MINER: 1,
	ROLE_SUPPLIER: 2,
	ROLE_BUILDER: 3,
	ROLE_UPGRADER: 4,
	ROLE_DEFENDER: 5,
	ROLE_RESERVER: 6,
	ROLE_RESERVED_HARVESTER: 7,

	harvest: function (creep) {
		setupMemory();
		if (creep.memory.harvesting) {
			extractEnergySource();
		}
		else {
			searchTarget();
			var response = performJob();
			handleResponse(response);
		}

		function setupMemory() {
			if (creep.memory.harvesting == undefined) creep.memory.harvesting = true;
			if (creep.memory.counter == undefined) creep.memory.counter = 0;
			if (creep.memory.target == undefined) creep.memory.target = null;
		}

		function extractEnergySource() {
			var result = OK;
			var target = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY)) });
			if (target == null) {
				target = Game.getObjectById(creep.memory.source_id);
				result = creep.harvest(target);
			} else {
				result = creep.withdraw(target, RESOURCE_ENERGY);
			}
			if (result == ERR_NOT_IN_RANGE) {
				creep.moveTo(target);
			}
			if (result == ERR_NOT_ENOUGH_RESOURCES || creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.harvesting = false;
				creep.memory.target = null;
			}
		}

		function searchTarget() {
			if (creep.memory.target == null) {
				var role_type = creep.memory.counter % 10;
				if (role_type == 0) {
					creep.memory.target = creep.room.controller.id;
				}
				else if (role_type < 5) {
					var target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
						filter: (s) => (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0
					});
					if (target != null) creep.memory.target = target.id;
					else creep.memory.counter += 1;
				}
				else if (role_type < 9) {
					var target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
					if (target != null) creep.memory.target = target.id;
					else creep.memory.counter += 1;
				} else {
					var target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
						filter: (s) => (s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax
					});
					if (target != null) creep.memory.target = target.id;
					else creep.memory.counter += 1;
				}
			}
		}

		function performJob() {
			var target = Game.getObjectById(creep.memory.target);
			var response = OK;
			var role_type = creep.memory.counter % 10;
			if (role_type == 0) {
				response = creep.transfer(target, RESOURCE_ENERGY);
			}
			else if (role_type < 5) {
				response = creep.transfer(target, RESOURCE_ENERGY);
				if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
			}
			else if (role_type < 9) {
				response = creep.build(target);
				if (target != null && target.progress == target.progressTotal) creep.memory.target = null;
			} else {
				response = creep.repair(target);
				if (target != null && target.hits == target.hitsMax) creep.memory.target = null;
			}
			return response;
		}

		function handleResponse(response) {
			if (response == ERR_NOT_IN_RANGE) {
				var target = Game.getObjectById(creep.memory.target);
				creep.moveTo(target);
			} else if (response == ERR_FULL || response == ERR_INVALID_TARGET) {
				creep.memory.target = null;
			}
			if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.harvesting = true;
				creep.memory.target = null;
				creep.memory.counter += 1;
			}
		}
	},

	mine: function (creep) {
		var container = Game.getObjectById(creep.memory.container_id);
		if (container != null && creep.pos.isEqualTo(container.pos)) {
			if (creep.memory.source_id == undefined) creep.memory.source_id = creep.pos.findClosestByPath(FIND_SOURCES).id;
			creep.harvest(Game.getObjectById(creep.memory.source_id));
		} else {
			creep.moveTo(Game.getObjectById(creep.memory.container_id));
		}
	},

	supply: function (creep) {
		// Memory creation
		if (creep.memory.restock == undefined) creep.memory.restock = true;
		if (creep.memory.target == undefined) creep.memory.target = null;
		// Job implementation
		if (creep.memory.restock) {
			if (creep.memory.target == null) { // aquire target
				var target = creep.pos.findClosestByPath(FIND_DROPPED_RESOURCES);
				if (target == null) target = creep.pos.findClosestByPath(FIND_TOMBSTONES);
				if (target == null) target = creep.pos.findClosestByPath(FIND_STRUCTURES,
					{
						filter: (s) => (s.structureType == STRUCTURE_CONTAINER
							&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
					});
				if (target == null) target = creep.room.storage;
				if (target != null) creep.memory.target = target.id;
			}
			var target = Game.getObjectById(creep.memory.target);
			if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE || creep.pickup(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (target != null && target.store != null && target.store.getUsedCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
			if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = false;
				creep.memory.target = null;
			}
		} else {
			if (creep.memory.target == null) { // aquire target
				var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
					{ filter: (s) => (s.structureType == STRUCTURE_TOWER && s.store.getUsedCapacity(RESOURCE_ENERGY) < 900) });
				if (structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
					{
						filter: (s) => ((s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION)
							&& s.store.getFreeCapacity(RESOURCE_ENERGY) > s.store.getCapacity(RESOURCE_ENERGY) * 0.1)
					});
				if (structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES,
					{ filter: (s) => ((s.id == "5f3e44e1014017c66fc5df10") && s.store.getFreeCapacity() > 100) });
				if (structure == null) structure = creep.room.storage;
				if (structure == null) return;
				creep.memory.target = structure.id;
			}
			var target = Game.getObjectById(creep.memory.target);
			if (creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
			if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = true;
				creep.memory.target = null;
			}
		}
	},

	build: function (creep) {
		//creep.memory.target = null;

		// Memory creation
		if (creep.memory.restock == undefined) creep.memory.restock = true;
		if (creep.memory.target == undefined) creep.memory.target = null;

		// Job implementation
		if (creep.memory.restock) {
			if (creep.memory.target == null) {
				if (creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
				else {
					var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
						{
							filter: (s) => (s.structureType == STRUCTURE_CONTAINER
								&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
						});
					if (container != null) creep.memory.target = container.id;
				}
			}
			var target = Game.getObjectById(creep.memory.target);
			if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY) * 0.4) creep.memory.target = null;
			if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = false;
				creep.memory.target = null;
			}
		} else {
			if (creep.memory.target == null) { // aquire target
				// constuction
				var structure = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES);

				// buildings
				if (structure == null) {
					var buildings = creep.room.find(FIND_STRUCTURES,
						{ filter: (s) => ((s.structureType != STRUCTURE_RAMPART || s.structureType != STRUCTURE_WALL) && s.hits < s.hitsMax) });
					for (var building in buildings) {
						building = buildings[building];
						if (structure == null || structure.hits > building.hits) structure = building;
					}
				}

				// ramparts and walls
				if (structure == null) {
					var ramparts = creep.room.find(FIND_STRUCTURES,
						{ filter: (s) => ((s.structureType == STRUCTURE_RAMPART || s.structureType == STRUCTURE_WALL) && s.hits < s.hitsMax) });
					for (var ramp in ramparts) {
						ramp = ramparts[ramp];
						if (structure == null || structure.hits > ramp.hits) structure = ramp;
					}
				}
				creep.memory.target = structure.id;
			}
			var target = Game.getObjectById(creep.memory.target);
			if (target == null || target.hits == target.hitsMax) creep.memory.target = null;
			if (creep.build(target) == ERR_NOT_IN_RANGE || creep.repair(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = true;
				creep.memory.target = null;
			}
		}
	},

	upgrade: function (creep) {
		// Memory creation
		if (creep.memory.restock == undefined) creep.memory.restock = true;
		if (creep.memory.target == undefined) creep.memory.target = null;

		// Job implementation
		if (creep.memory.restock) {
			if (creep.memory.target == null) {
				if (creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
				else {
					var container = creep.pos.findClosestByPath(FIND_STRUCTURES,
						{
							filter: (s) => (s.structureType == STRUCTURE_CONTAINER
								&& 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))
						});
					if (container != null) creep.memory.target = container.id;
				}
			}
			var target = Game.getObjectById(creep.memory.target);
			if (creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY) * 0.4) creep.memory.target = null;
			if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = false;
				creep.memory.target = null;
			}
		} else {
			if (creep.memory.target == null) { // aquire target
				var structure = structure = creep.room.controller;
				creep.memory.target = structure.id;
			}
			var target = Game.getObjectById(creep.memory.target);
			if (creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
			if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.restock = true;
				creep.memory.target = null;
			}
		}
	},

	defend: function (creep) {
		if (creep.memory.flag != undefined && Game.flags[creep.memory.flag].room.name != creep.room.name) creep.moveTo(Game.flags[creep.memory.flag]);
		if (creep.memory.target == undefined) creep.memory.target = null;
		if (creep.memory.target == null) {
			var enemy = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS);
			if (enemy != null) creep.memory.target = enemy.id;
		}
		var enemy = Game.getObjectById(creep.memory.target);
		if (enemy != null) {
			creep.say("ATTACK");
			if (creep.attack(enemy) == ERR_NOT_IN_RANGE) creep.moveTo(enemy);
		} else {
			creep.memory.target = null;
		}
	},

	reserve: function (creep) {
		if (Game.flags[creep.memory.target].room != undefined && Game.flags[creep.memory.target].room == creep.room) {
			if (creep.memory.target == "xxx") {
				if (creep.claimController(creep.room.controller) == ERR_NOT_IN_RANGE) {
					creep.moveTo(creep.room.controller);
				}

			} else {

				if (creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE) {
					creep.moveTo(creep.room.controller);
				}

			}
		} else {
			creep.moveTo(Game.flags[creep.memory.target]);
		}
	},

	harvest_reserved: function (creep) {
		creep.memory.home = "SpawnAlpha"
		//memory setup
		if (creep.memory.harvesting == undefined) creep.memory.harvesting = true;
		if (creep.memory.counter == undefined) creep.memory.counter = 0;
		if (creep.memory.target == undefined) creep.memory.target = null;

		if (creep.memory.harvesting) {
			var source = Game.getObjectById(creep.memory.source_id);
			if (source != undefined && creep.room.name == source.room.name) {
				var container = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter: (s) => (s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY)) });
				if (container == null) {
					result = creep.harvest(source);
					if (result == ERR_NOT_IN_RANGE) {
						creep.moveTo(source);
					}
				} else {
					var result = creep.withdraw(container, RESOURCE_ENERGY);
					if (result == ERR_NOT_IN_RANGE) {
						creep.moveTo(container);
					}
				}
				if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
					creep.memory.harvesting = false;
					creep.memory.target = null;
				}
			} else {
				creep.moveTo(source);
			}
		} else {
			if (creep.memory.target == null) {
				switch (creep.memory.counter % 3) {
					case 0: // building
						creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
						if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
						else creep.memory.counter += 1;
						break;
					case 1: // repairing (no walls or ramparts)
						creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES, {
							filter: (s) => (s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax - creep.store.getUsedCapacity(RESOURCE_ENERGY) * 3 / 4
						});
						if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
						else creep.memory.counter += 1;
						break;
					case 2: // suppling
						var home = Game.spawns[creep.memory.home];
						if (creep.room.name == home.room.name) {
							creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, {
								filter: (s) => (s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_STORAGE) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0
							});
							if (creep.memory.target != null) creep.memory.target = creep.memory.target.id;
							else creep.memory.counter += 1;
						} else {
							creep.moveTo(home);
						}
						break;
				}
			}

			var target = Game.getObjectById(creep.memory.target);
			var response = OK;
			switch (creep.memory.counter % 3) {
				case 0: // building
					response = creep.build(target);
					if (target != null && target.progress == target.progressTotal) creep.memory.target = null;
					break;
				case 1: // repairing
					response = creep.repair(target);
					if (target != null && target.hits == target.hitsMax) creep.memory.target = null;
					break;
				case 2: // suppling
					response = creep.transfer(target, RESOURCE_ENERGY);
					if (target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
					break;
			}
			if (response == ERR_NOT_IN_RANGE) {
				creep.moveTo(target);
			} else if (response == ERR_FULL || response == ERR_INVALID_TARGET) {
				creep.memory.target = null;
			}
			if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0) {
				creep.memory.harvesting = true;
				creep.memory.target = null;
				creep.memory.counter += 1;
			}
		}
	}
};