const EntityNewPacket                       = require("../Packets/EntityNew");
const AttackInformationPacket               = require("../Packets/AttackInformation");
const AttackerInformationPacket             = require("../Packets/AttackerInformation");
const EntityDiePacket                       = require("../Packets/EntityDie");

const constants                             = require("../Data/constants");
const { TYPES, EVENTS }                     = constants;
const { ENTITY_TYPE_MONSTER }               = TYPES;
const { EVENT_ATTACK_STARTED, EVENT_DIE, EVENT_ATTACK_BAR } = EVENTS;

const queries                               = require("../Data/queries");
const { QUERY_FETCH_MONSTER_SPAWN }         = queries;

const Monster                               = require("../Game/Monster");

module.exports = async function (map, globalDieCallback, globalRewardCallback, globalAttackCallback) {
    const databaseSpawn = await execute(QUERY_FETCH_MONSTER_SPAWN, [map.id, ENTITY_TYPE_MONSTER]);
    if (databaseSpawn.error) return process.exit();

    const spawns = databaseSpawn.data.reduce((spawns, spawn) => {
        if (!spawns[spawn.id]) {
            spawns[spawn.id] = { 
                id: spawn.id,
                parentEntityTypeId: spawn.parentEntityTypeId, 
                name: spawn.name, 
                minHealth: spawn.minHealth, 
                maxHealth: spawn.maxHealth,
                amount: spawn.amount,
                respawnTime: spawn.respawnTime,
                rewardEntries: []
            };
        };

        if (spawn.categoryId) spawns[spawn.id].rewardEntries.push({ 
            categoryId: spawn.categoryId, 
            itemId: spawn.itemId, 
            min: spawn.min,
            max: spawn.max, 
            chance: spawn.chance, 
            isLastShot: spawn.isLastShot
        });      
    
        return spawns;
    }, {});

    const convertedSpawn = Object.values(spawns);
    map.setupMonsterSpawn(convertedSpawn,
        function monsterNetworkListeners (data) {
                const { monster, monsterSpawnProperties } = data;

                const packet = EntityNewPacket.monster(monsterSpawnProperties);
                map.registerNetworkPacket(monster.id, packet);
  
                monster.on(EVENT_ATTACK_STARTED, function (data, author) {
                    const packet = AttackInformationPacket(data);

                    this.map.registerIndividualNetworkPacket(author, packet);
                });

                monster.on(EVENT_ATTACK_BAR, function (data, author) {
                    const packet = AttackerInformationPacket(data);

                    this.map.registerIndividualNetworkPacket(author, packet);
                });

                monster.on(EVENT_DIE, function (data, author) {
                    const packet = EntityDiePacket(data);
                    
                    this.map.registerNetworkPacket(author, packet, [1]);
                });
        }, globalDieCallback, globalRewardCallback, globalAttackCallback, Monster);
};