const libLink = require('link')
const libSpawn = require('spawn')

require('globals')

let lastTime = Game.cpu.getUsed()
function profilingDebug(label, noLog) {
    let current = Game.cpu.getUsed()
    let used = current-lastTime
    if (!noLog) {
        console.log(`${used.toFixed(2)} (${current.toFixed(2)}) [${label}]`)
    }
    lastTime = current
    return used
}

module.exports.loop = function () {
    profilingDebug('Start')
    // Cleanups
    if (!Memory.repairers) {
        Memory.repairers = {}
    }
    if (!Memory.refillers) {
        Memory.refillers = {}
    }
    for (let name in Memory.creeps) {
        if (!Game.creeps[name]) {
            delete Memory.creeps[name];
        }
    }
    libLink.tickInit()
    profilingDebug('Link init')
    libSpawn.tickInit()
    profilingDebug('Spawn init')

    // tickInit
    for (let role of roleModules) {
        role.idling = 0
        if (role.tickInit) {
            role.tickInit()
            profilingDebug(role.name + ' init')
        }
    }

    for (let role of roleModules) {
        if (role.cleanup) {
            role.cleanup()
            profilingDebug(role.name + ' cleanup')
        }
    }

    for (let [id, creep] of Object.entries(Memory.refillers)) {
        let target = Game.getObjectById(id)
        if (!target || target.store.getFreeCapacity(RESOURCE_ENERGY) === 0 || !Game.creeps[creep]) {
            delete Memory.refillers[id]
        }
    }

    for (let [roomName, roomMemory] of Object.entries(Memory.rooms)) {
        let room = Game.rooms[roomName]
        if (!roomMemory.fatigues) {
            roomMemory.fatigues = {}
        }
        for (let [k, v] of Object.entries(roomMemory.fatigues)) {
            let [x, y] = k.split('_')
            x = parseInt(x)
            y = parseInt(y)
            if (room && v > 20) {
                room.createConstructionSite(x, y, STRUCTURE_ROAD)
                roomMemory.fatigues[k] = 0
            }
            if (v > 0) {
                if (Game.time % 20 === 0) {
                    roomMemory.fatigues[k]--
                }
                room.visual.text(roomMemory.fatigues[k], x, y, {size: 0.4})
            }
        }
    }

    let spawn = Game.spawns['Spawn1']
    global.activeRemotes = spawn.room.memory.activeRemotes || []

// Run modules
    for (let link of spawn.room.find(FIND_STRUCTURES, {filter: s => s.structureType === STRUCTURE_LINK})) {
        libLink.tick(link)
    }

    let usedByRole = {}
    let roleCount = {}
    for (let creep of Object.values(Game.creeps)) {
        if (creep.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
            for (let target of creep.pos.findInRange(FIND_DROPPED_RESOURCES, 1)) {
                creep.pickup(target)
            }
            for (let target of creep.pos.findInRange(FIND_TOMBSTONES, 1, {filter: t => t.store[RESOURCE_ENERGY] > 0})) {
                creep.withdraw(target, RESOURCE_ENERGY)
            }
            for (let target of creep.pos.findInRange(FIND_RUINS, 1, {filter: t => t.store[RESOURCE_ENERGY] > 0})) {
                creep.withdraw(target, RESOURCE_ENERGY)
            }
        }
        if (!creep.memory.role) {
            creep.memory.role = 'harvester'
        }
        if (ROLES[creep.memory.role].tick(creep) === 'idle') {
            ROLES[creep.memory.role].idling++
        }

        if (creep.fatigue > 0) {
            if (creep.pos.findInRange(FIND_STRUCTURES, 0, {filter: s => s.structureType === STRUCTURE_ROAD}).length === 0
                && creep.pos.findInRange(FIND_MY_CONSTRUCTION_SITES, 0, {filter: s => s.structureType === STRUCTURE_ROAD}).length === 0) {
                creep.room.memory.fatigues[creep.pos.x + '_' + creep.pos.y] = (creep.room.memory.fatigues[creep.pos.x + '_' + creep.pos.y] || 0) + creep.fatigue

            }
        }
        if (!usedByRole[creep.memory.role]) {
            usedByRole[creep.memory.role] = 0
            roleCount[creep.memory.role] = 0
        }
        usedByRole[creep.memory.role] += profilingDebug(creep.name + ' tick', true)
        roleCount[creep.memory.role]++
    }

    Object.entries(usedByRole).forEach(([role, used]) => console.log(`${used.toFixed(2)} (${(used / roleCount[role]).toFixed(2)}) ${role} (${roleCount[role]})`))
    libSpawn.tick(spawn)
    profilingDebug('spawn tick')

    let towers = spawn.room.find(FIND_STRUCTURES, {filter: structure => structure.structureType === STRUCTURE_TOWER})
    for (let tower of towers) {
        // var closestDamagedStructure = tower.pos.findClosestByRange(FIND_STRUCTURES, {
        //     filter: (structure) => structure.hits < structure.hitsMax
        // });
        // if(closestDamagedStructure) {
        //     tower.repair(closestDamagedStructure);
        // }

        let closestHostile = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
        if (closestHostile) {
            tower.attack(closestHostile);
        }
    }

// for (let [role, values] of Object.entries(ROLES)) {
//     if (values.idling > 0) {
//         console.log(`${values.idling} ${role}s idling`)
//     }
// }

    spawn.room.visual.text(
        `${Game.time}: ${Game.cpu.getUsed().toFixed(1)} / ${Game.cpu.tickLimit} (${Game.cpu.bucket})`,
        1, 1,
        {align: 'left', opacity: 0.8});

    if (Game.cpu.generatePixel && Game.cpu.bucket === 10000) {
        Game.cpu.generatePixel()
    }

    /*
    PathFinder.search(
        new RoomPosition(11, 7, 'E8S4'),
        new RoomPosition(8, 11, 'E9S4'),
        {roomCallback: roomName => {
                let room = Game.rooms[roomName];
                // In this example `room` will always exist, but since
                // PathFinder supports searches which span multiple rooms
                // you should be careful!
                if (!room) return;
                let costs = new PathFinder.CostMatrix;

                room.find(FIND_STRUCTURES).forEach(function(struct) {
                    if (struct.structureType === STRUCTURE_ROAD) {
                        // Favor roads over plain tiles
                        costs.set(struct.pos.x, struct.pos.y, 1);
                    } else if (struct.structureType !== STRUCTURE_CONTAINER &&
                        (struct.structureType !== STRUCTURE_RAMPART ||
                            !struct.my)) {
                        // Can't walk through non-walkable buildings
                        costs.set(struct.pos.x, struct.pos.y, 0xff);
                    }
                });

                return costs;
            }}
        ).path.forEach(el => new RoomVisual(el.roomName).circle(el))
    */
}