const EntityNewPacket                           = require("../Packets/EntityNew");
const EntityDiePacket                           = require("../Packets/EntityDie");
const GuildIslandCapturedPacket                 = require("../Packets/GuildIslandCaptured");
const AttackInformationPacket                   = require("../Packets/AttackInformation");
const AttackerInformationPacket                 = require("../Packets/AttackerInformation");
const AttackingPacket                           = require("../Packets/Attacking");
const HealthChangedPacket                       = require("../Packets/HealthChanged");
const HealthChangedAuthorlessPacket             = require("../Packets/HealthChangedAuthorless");
const GuildDataIslandTowerDestroyedPacket       = require("../Packets/GuildDataIslandTowerDestroyed");
const GuildDataIslandTowerHealthChangedPacket   = require("../Packets/GuildDataIslandTowerHealthChanged");
const GuildDataIslandCapturedPacket             = require("../Packets/GuildDataIslandCaptured");
const GuildDataIslandTowerBuiltPacket           = require("../Packets/GuildDataIslandTowerBuilt");
const WorldMapGuildEntryPacket                  = require("../Packets/WorldMapGuildEntry");
const GuildDataIslandPacket                     = require("../Packets/GuildDataIsland");
const GuildDataIslandTowerPacket                = require("../Packets/GuildDataIslandTower");

const schemeTower                               = require("../Data/schemeTower");
const queries                                   = require("../Data/queries");
const { QUERY_FETCH_GUILD_TOWERS, QUERY_UPDATE_GUILD_ISLAND_TOWER_DEAD, QUERY_UPDATE_GUILD_ISLAND_TOWER_UPGRADE, QUERY_UPDATE_GUILD_ISLAND_TOWER_DEFAULT, QUERY_DELETE_GUILD_ISLAND_DAMAGES, QUERY_UPDATE_GUILD_ISLAND_AUTHOR, QUERY_UPDATE_GUILD_ISLAND_DAMAGES } = queries;

const constants                                 = require("../Data/constants");
const { EVENTS }                                = constants;
const { EVENT_ATTACK_STARTED, EVENT_HEALTH_CHANGED_AUTHORLESS, EVENT_ATTACKING, EVENT_ATTACK_BAR, EVENT_DIE, EVENT_GUILD_ISLAND_CAPTURE, EVENT_GUILD_ISLAND_TOWER_BUILT, EVENT_GUILD_ISLAND_TOWER_HEALTH_CHANGED } = EVENTS;

const Tower 						            = require("../Game/Tower");
const Game                                      = require("../Game/Game");
const { guildIslands }                          = Game;

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

    const allTowersMap = towers.data;
    if (!allTowersMap) return;

    let order = 0;
    let previousIslandID = 0;

    for (let i = 0, length = allTowersMap.length; i < length; i++) {
        const tower = allTowersMap[i];
        const scheme = schemeTower[tower.entityTypeID];
        if (!scheme) continue;

        const island = guildIslands.find(island => island.id === tower.guildIslandID);

        if (previousIslandID !== island.id) order = 0;
        previousIslandID = island.id;

        const towerInstance = new Tower({
            id: tower.id,
            order: ++order,
            entityTypeID: tower.entityTypeID,
            island,
            map,
            maximumHitpoint: scheme.maximumHitpoints,
            currentHitpoint: tower.currentHitpoints,
            position: { 
                x: tower.positionX,
                y: tower.positionY
            },
            attackCallback: globalAttackCallback,
            dieCallback: globalDieCallback
        });
    
        const packet = EntityNewPacket.tower(towerInstance.getProperties());
        map.registerNetworkPacket(towerInstance.id, packet);
        
        towerInstance.on(EVENT_DIE, function (data, id) {
            const packet = EntityDiePacket(data[0]);
            this.map.registerNetworkPacket(id, [packet], [1]);
            
            const packet_2 = GuildDataIslandTowerDestroyedPacket(data[1]);
            const topic = Game.getTopic(this.island.guild.topic);
            topic.push(packet_2);

            execute(QUERY_UPDATE_GUILD_ISLAND_TOWER_DEAD, [0, Tower.getID(this.id)]);
        });

        towerInstance.on(EVENT_ATTACK_STARTED, function (data, author) {
            const packet = AttackInformationPacket(data);
            this.map.registerIndividualNetworkPacket(author, packet);
        });

        towerInstance.on(EVENT_HEALTH_CHANGED_AUTHORLESS, function (data, author) {
            const packet = HealthChangedAuthorlessPacket(data);
            this.map.registerNetworkPacket(this.id, packet, [1]);
        });

        towerInstance.on(EVENT_ATTACK_BAR, function (data, author) {
            const packet = AttackerInformationPacket(data);
            this.map.registerIndividualNetworkPacket(author, packet);
        });

        towerInstance.on(EVENT_ATTACKING, function (data, author) {
            const packet = AttackingPacket(data[1]);
            const packet_2 = HealthChangedPacket(data[0]);
            this.map.registerNetworkPacket(author, [packet, packet_2], [1, 1]);
        });

        towerInstance.on("_", function (data) {
            execute(QUERY_UPDATE_GUILD_ISLAND_DAMAGES, [data.damage, data.guildIslandID, data.guildID, data.damage]);
        });
        
        towerInstance.on(EVENT_GUILD_ISLAND_TOWER_HEALTH_CHANGED, function (data, author) {
            const topic = Game.getTopic(this.island.guild.topic);
            const packet = GuildDataIslandTowerHealthChangedPacket(data);
            topic.push(packet);
        });
        
        towerInstance.on(EVENT_GUILD_ISLAND_TOWER_BUILT, async function (data, author) {
            await execute(QUERY_UPDATE_GUILD_ISLAND_TOWER_UPGRADE, [this.entityTypeID, this.hp.maximum, Tower.getID(this.id)]);

            const topic = Game.getTopic(this.island.guild.topic);
            const packet = GuildDataIslandTowerBuiltPacket(data);
            topic.push(packet);
        });

        towerInstance.on(EVENT_GUILD_ISLAND_CAPTURE, async function (data, author) {
            const packet = GuildIslandCapturedPacket(data.packet);
            app.publish(this.map.id.toString(), packet, true, true);

            if (data.database.oldID !== data.database.newID) {
                const packet_2 = GuildDataIslandCapturedPacket({
                    guildIslandID: this.island.id
                });

                const topicOld = Game.getTopic(data.topicOld);
                topicOld.push(packet_2);

                const islandProperties = {
                    id: this.island.id,
                    mapID: this.map.id,
                    position: this.island.position,
                };
        
                const guildDataIslandPacket = GuildDataIslandPacket(islandProperties);

                const topicNew = Game.getTopic(data.topicNew);
                topicNew.push(guildDataIslandPacket);

                this.island.towers.forEach(tower => {
                    const towerProperties = {
                        entityTypeID: tower.entityTypeID,
                        id: tower.id,
                        guildIslandID: island.id,
                        order: tower.order,
                        hp: {
                            current: tower.hp.current
                        },
                        isRepairing: tower.isRepairing()
                    };
        
                    const guildDataIslandTowerPacket = GuildDataIslandTowerPacket(towerProperties);
                    topicNew.push(guildDataIslandTowerPacket);
                });
            };

            const packet_3 = WorldMapGuildEntryPacket({
                locationMapID: this.map.id,
                index: this.island.index,
                bufferTag: this.island.guild.tag
            });

            Game.maps.forEach(map => app.publish(map.id.toString(), packet_3, true, true));

            let dbConnection = null;

            try {
                dbConnection = await db.getConnection();
                await dbConnection.beginTransaction();

                await execute(QUERY_UPDATE_GUILD_ISLAND_TOWER_DEFAULT, [5000, this.island.id]);
                await execute(QUERY_DELETE_GUILD_ISLAND_DAMAGES, [this.island.id]);
                await execute(QUERY_UPDATE_GUILD_ISLAND_AUTHOR, [data.database.newID, this.island.id]);
                
                await dbConnection.commit();
            } catch {
                await dbConnection.rollback();
            } finally {
                dbConnection.release();
            };
        });
    };
};