var roleHarvester = require('role_harvester');
var roleUpgrader = require('role_upgrader');
var roleBuilder = require('role_builder');
var roleRepairer = require('role_repairer');
var roleGuard = require('role_guard');
var roleBase = require('role_base');

const roleMap = {
    harvester: roleHarvester,
    upgrader: roleUpgrader,
    builder: roleBuilder,
    repairer: roleRepairer,
	streltsy: roleGuard
};

function calculateCreepCounts(room){
	var creepCounts = {
		"harvester" : 3,
		"builder" : 1,
		"upgrader" : 1,
		"repairer" : 1,
		"streltsy" : 0
	};

	// 2 harvesters per source by default
	creepCounts.harvester = room.find(FIND_SOURCES).length * 2;

	if(room.memory.containers == 0){

		// -1 harvester until at least a container built in order
		// to reduce congestion
		creepCounts.harvester -= 1;
	}

	// streltsy cost 400 energy, and thus cant be built
	// you have at least 2 extensions (300+50+50)
	// i guess there wouldnt be a big difference since
	// they wouldnt spawn anyways, but whatever
	if(room.memory.extensions >= 2){
		creepCounts.streltsy += 2;
	}

	if(room.memory.extensions >= 3){
		creepCounts.builder += 1;
	}


	room.memory.creepCounts = creepCounts;
}

function calculateCreepBodies(room){
	var creepBodies = {
		// 200 base cost
		"harvester" : [WORK, CARRY, MOVE],
		"builder" : [WORK, CARRY, MOVE],
		"upgrader" : [WORK, CARRY, MOVE],
		"repairer" : [WORK, CARRY, MOVE],
		
		// 400 base cost
		"streltsy" : [MOVE, MOVE, RANGED_ATTACK, RANGED_ATTACK]
	};

	// 450 cost
	if(room.memory.extensions >= 3){
		creepBodies.harvester = [MOVE, MOVE, WORK, WORK, WORK, CARRY];
	}

	// 400 cost
	// but only want the upgrading to scale up when have a bunch
	// of extra energy
	if(room.memory.extensions >= 10){
		creepBodies.upgrader = [MOVE, MOVE, WORK, WORK, CARRY, CARRY];
	}

	room.memory.creepBodies = creepBodies;
}

function runRole(creep){
	const role = roleMap[creep.memory.role];

	if(typeof role.run === 'function'){
		role.run(creep);
	} else {
		console.log('Unknown or undefined role: ' + creep.memory.role);
	}
}

function spawnCreeps(spawn){
	calculateCreepCounts(spawn.room);
    for(const [role, count] of Object.entries(spawn.room.memory.creepCounts)){
        var roleCreeps = _.filter(Game.creeps, (creep) => creep.memory.role == role);
    
        if(roleCreeps.length < count && !spawn.spawning) {
			calculateCreepBodies(spawn.room);
			if(typeof roleMap[role].spawn === 'function')
				roleMap[role].spawn(spawn);
			else
				roleBase.spawn(spawn, roleMap[role].name);
            break;
        }
    }
}

module.exports = { runRole, spawnCreeps};