const GuildDataGeneralPacket            = require("../Packets/GuildDataGeneral");
const GuildDataMemberPacket             = require("../Packets/GuildDataMember");
const GuildDataApplicantPacket          = require("../Packets/GuildDataApplicant");
const GuildDataEconomyPacket            = require("../Packets/GuildDataEconomy");
const GuildDataIslandPacket             = require("../Packets/GuildDataIsland");
const GuildDataIslandTowerPacket        = require("../Packets/GuildDataIslandTower");

const LEVELS 					        = require("../Data/levels");

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

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

module.exports = async function (ws, message, player) {
    console.info(player.guild.id, player.guild.ownerID)
    if (!player.guild.id) return console.info("nuh uh GuildDataMessage");

    const applicantsOffline = [];
    const playersOffline = [];
    const packets = [];
    console.info("GuildDataMessage", player.id);
    player.guild.members.forEach(member => {        
        if (!players[member.id]) playersOffline.push(member.id);
        else {
            const onlinePlayer = players[member.id];
            const guildDataMember = {
                id: member.id,
                permission: member.permission,
                isOnline: true,
                pirateLevel: onlinePlayer.pirateLevel,
                name: onlinePlayer.name
            };

            const guildMemberPacket = GuildDataMemberPacket(guildDataMember);
            packets.push(guildMemberPacket);
        };
    });

    if (playersOffline.length) {
        const offlinePlayersQuery = await execute(QUERY_FETCH_GUILD_OFFLINE_MEMBERS, playersOffline);
        if (offlinePlayersQuery.data) {  
            offlinePlayersQuery.data.forEach(offlinePlayer => {
                const guildDataMember = {
                    id: offlinePlayer.id,
                    isOnline: false,
                    pirateLevel: LEVELS.pirateLevel(offlinePlayer.amount),
                    name: offlinePlayer.username
                };

                const guildMemberPacket = GuildDataMemberPacket(guildDataMember);
                packets.push(guildMemberPacket);
            });
        };
    };

    player.guild.requests.forEach(request => {
        const applicantPlayer = players[request.playerID];
        if (!applicantPlayer) applicantsOffline.push(request.playerID);
        else {
            const guildDataApplicant = {
                id: request.playerID,
                pirateLevel: applicantPlayer.pirateLevel,
                username: applicantPlayer.name
            };
            
            const guildDataApplicantPacket = GuildDataApplicantPacket(guildDataApplicant);
            packets.push(guildDataApplicantPacket);
        };
    });

    if (applicantsOffline.length) {
        const offlineApplicantsQuery = await execute(QUERY_FETCH_GUILD_OFFLINE_MEMBERS, applicantsOffline);
        if (offlineApplicantsQuery.data) {  
            offlineApplicantsQuery.data.forEach(offlineApplicant => {
                const guildDataApplicant = {
                    id: offlineApplicant.id,
                    pirateLevel: LEVELS.pirateLevel(offlineApplicant.amount),
                    username: offlineApplicant.username
                };

                const guildDataApplicantPacket = GuildDataApplicantPacket(guildDataApplicant);
                packets.push(guildDataApplicantPacket);
            });
        };
    };

    const guildDataGeneral = {
      level: player.guild.level,
      experience: player.guild.experiencePoints,
      size: {
        current: player.guild.size,
        maximum: player.guild.sizeMaximum
      },
      taxRates: player.guild.taxRates.map(r => r * 100),
      tag: player.guild.tag,
      name: player.guild.name,
      description: player.guild.description,
      timestamps: player.guild.timestamps
    };

    const guildDataGeneralPacket = GuildDataGeneralPacket(guildDataGeneral);
    packets.push(guildDataGeneralPacket);
    console.info(guildDataGeneral)
    const guildDataEconomy = [];
    player.guild.bank.list.each((_, value) => {
        guildDataEconomy.push({
            id: value.id,
            amount: value.amount
        });
    });
    console.info(guildDataEconomy, "guildDataEconomy")
    const guildDataEconomyPacket = GuildDataEconomyPacket(guildDataEconomy);
    packets.push(guildDataEconomyPacket);

    guildIslands.forEach(island => {
        if (player.guild.id !== island.guild.id) return;

        const islandProperties = {
            id: island.id,
            mapID: island.locationMapID,
            position: island.position,
        };

        const guildDataIslandPacket = GuildDataIslandPacket(islandProperties);
        packets.push(guildDataIslandPacket);

        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);
            packets.push(guildDataIslandTowerPacket);
        });
    });

    const guildTopic = Game.getTopic(player.guild.topic);
    player.topics.addItem(player.guild.topic, guildTopic);
    console.info("Sending out general data to", player.id);
    player.map.registerIndividualNetworkPacket(player.id, packets);
};