const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('myDatabase.db');
const { Events, AuditLogEvent, PermissionsBitField , EmbedBuilder } = require('discord.js');
const { getPermissionLevel } = require('../../fonction/getPermissionLevel');

module.exports = {
    name: Events.GuildMemberUpdate,
    async execute(oldMember, newMember, client) {
        const botId = client.user.id;
        const guildId = newMember.guild.id;
        const guild = newMember.guild;
        if (!oldMember.permissions.has(PermissionsBitField.Flags.Administrator) && newMember.permissions.has(PermissionsBitField.Flags.Administrator)) {
        const fetchedLogs = await guild.fetchAuditLogs({
            type: AuditLogEvent.MemberRoleUpdate,
            limit: 1,
        });
        const firstEntry = fetchedLogs.entries.first();
        const user = guild.members.cache.get(`${firstEntry.executor.id}`);
        let data = await new Promise((resolve, reject) => {
            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                if (err) {
                    console.error(err.message);
                    reject(err);
                }
                resolve(row ? JSON.parse(row.value) : {});
            });
        });

        const antiadminConfig = data[guildId]?.antiadmin;
        if (!antiadminConfig || antiadminConfig.type === 'off') {
            return;
        }
        data.whitelist = data.whitelist || {};
        data.whitelist[guildId] = data.whitelist[guildId] || {};
        const whitelist = data.whitelist[guildId];
        const type = antiadminConfig.type;
        const permlevel = await getPermissionLevel(user, client);
        const dangerousPermissions = [
        PermissionsBitField.Flags.Administrator,
        ];
        try {
            if (type === "whitelist") {
                if (permlevel >= 10) return;
                if (whitelist[user.id]) return;
                const member = guild.members.cache.get(newMember.id);
                if (member) {
                    const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
                    await member.roles.remove(rolesToRemove, 'Anti-admin protection');
                }
                punish(user, antiadminConfig.action, guild);
            } else if (type === "owner") {
                if (permlevel >= 10) return;
                const member = guild.members.cache.get(newMember.id);
                if (member) {
                    const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
                    await member.roles.remove(rolesToRemove, 'Anti-admin protection');
                }
                punish(user, antiadminConfig.action, guild);
            } else if (type === "buyer") {
                if (permlevel === 11) return;
                const member = guild.members.cache.get(newMember.id);
                if (member) {
                    const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
                    await member.roles.remove(rolesToRemove, 'Anti-admin protection');
                }
                punish(user, antiadminConfig.action, guild);
            }
        } catch (err) {
        }
    }else {
        const addedRoles = newMember.roles.cache.filter(role => !oldMember.roles.cache.has(role.id));
        const removedRoles = oldMember.roles.cache.filter(role => !newMember.roles.cache.has(role.id));

        if (addedRoles.size === 0 && removedRoles.size === 0) return;
        const fetchedLogs = await guild.fetchAuditLogs({
            type: AuditLogEvent.MemberRoleUpdate,
            limit: 1,
        });
        const firstEntry = fetchedLogs.entries.first();
        const user = guild.members.cache.get(`${firstEntry.executor.id}`);
        if (user.id === newMember.client.user.id) return;

        let data = await new Promise((resolve, reject) => {
            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                if (err) {
                    console.error(err.message);
                    reject(err);
                }
                resolve(row ? JSON.parse(row.value) : {});
            });
        });

        const antiRoleConfig = data[guildId]?.antirole;
        if (!antiRoleConfig || antiRoleConfig.type === 'off') {
            return;
        }
        data.whitelist = data.whitelist || {};
        data.whitelist[guildId] = data.whitelist[guildId] || {};
        const whitelist = data.whitelist[guildId];
        const type = antiRoleConfig.type;
        const permlevel = await getPermissionLevel(user, newMember.client);
        try {
            if (type === "whitelist") {
                if (permlevel >= 10) return;
                if (whitelist[user.id]) return;
                punish(user, antiRoleConfig.action, guild);
                await removeAddedRoles(newMember, addedRoles);
                await addRemovedRoles(newMember, removedRoles);
                await sendlog(user, antiRoleConfig.action, guild, data);
            } else if (type === "owner") {
                if (permlevel >= 10) return;
                punish(user, antiRoleConfig.action, guild);
                await removeAddedRoles(newMember, addedRoles);
                await addRemovedRoles(newMember, removedRoles);
                await sendlog(user, antiRoleConfig.action, guild, data);
            } else if (type === "buyer") {
                if (permlevel === 11) return;
                punish(user, antiRoleConfig.action, guild);
                await removeAddedRoles(newMember, addedRoles);
                await addRemovedRoles(newMember, removedRoles);
                await sendlog(user, antiRoleConfig.action, guild, data);
            }
        } catch (err) {
            console.error(err);
        }

    }
}
};

async function punish(user, action, guild) {
    switch (action) {
        case 'ban':
            await guild.members.ban(user, { reason: 'Anti-admin protection' });
            break;
        case 'kick':
            await guild.members.kick(user, 'Anti-admin protection');
            break;
        case 'derank':
            const dangerousPermissions = [
                PermissionsBitField.Flags.Administrator,
                PermissionsBitField.Flags.ManageGuild,
                PermissionsBitField.Flags.ManageRoles,
                PermissionsBitField.Flags.ManageChannels,
                PermissionsBitField.Flags.KickMembers,
                PermissionsBitField.Flags.BanMembers,
                PermissionsBitField.Flags.ManageWebhooks,
                PermissionsBitField.Flags.MuteMembers,
                PermissionsBitField.Flags.MentionEveryone,
                PermissionsBitField.Flags.ManageEvents,
                PermissionsBitField.Flags.ManageThreads,
            ];
            const member = guild.members.cache.get(user.id);
            if (member) {
                const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
                await member.roles.remove(rolesToRemove, 'Anti-admin protection');
            }
            break;
        case 'nothing':
            break;
    }
}
async function removeAddedRoles(member, addedRoles) {
    await member.roles.remove(addedRoles, 'Anti-role protection');
}

async function addRemovedRoles(member, removedRoles) {
    await member.roles.add(removedRoles, 'Anti-role protection');
}
async function sendlog(user, action, guild, data) {
    if (!data[guild.id]) {
        data[guild.id] = {};
    }
    const channelid = data[guild.id]?.raidlog;
    if(channelid) {
        const logChannel = guild.channels.cache.get(channelid);
        if (!logChannel) return ;

        const embed = new EmbedBuilder()
        .setDescription(`L'utilisateur <@${user.id}> a ajoutée un role et a été \`${action}\`.`)
        .setColor('#ADD8E6')
        .setTimestamp();

        logChannel.send({ embeds: [embed] });
    }
}