const { Client, GatewayIntentBits, ActivityType } = require('discord.js');
const config = require('./config.json');
const blacklist = require('./blacklistSchema.js');
const logchan = require('./logchan.js');
const whitelist = require('./bypass.js');
const mongoose = require('mongoose');
const { readdirSync } = require('fs');

const mongoURL = config.MONGOCONNECT;
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.GuildMessageReactions
  ]
});

client.config = config;
client.cache = new Map();
client.commands = new Map();
client.buttons = new Map();
client.Selects = new Map();
client.on('ready', async () => {
  console.log('Ready!');
  const blacklistedUsers = await blacklist.find();
  let allUsers = [];

  client.guilds.cache.forEach(guild => {
    guild.members.fetch().then(members => {
      members.forEach(member => {
        if (member.user.bot) return;
        allUsers.push(member);
      });
      const amount = blacklistedUsers.length;
      const customStatus = [
        `Protecting ${client.guilds.cache.size} servers`,
        `Protecting ${client.users.cache.size} Users`,
        `Blacklisted ${amount} users`
      ];
      setInterval(() => {
        client.user.setActivity(customStatus[Math.floor(Math.random() * customStatus.length)], {
          type: ActivityType.Playing
        });
      }, 10000);
    }).catch(err => {
      console.error(err);
      sendErrorToLogChannel(err);
    });
  });
});

client.login(config.TOKEN);

const commandsFiles = readdirSync('./commands').filter(file => file.endsWith('.js'));
for (const file of commandsFiles) {
  const command = require(`./commands/${file}`);
  let data = command.data.toJSON();
  client.commands.set(data.name, command);
}

const handlersFiles = readdirSync('./Handlers').filter(file => file.endsWith('.js'));
for (const file of handlersFiles) {
  require(`./Handlers/${file}`)(client);
}

client.on('interactionCreate', async interaction => {
  if (interaction.isCommand()) {
    const command = client.commands.get(interaction.commandName);
    if (command) {
      try {
        await command.execute(interaction, client);
      } catch (error) {
        console.error(error);
        sendErrorToLogChannel(error);
       // await interaction.reply({ content: 'There was an error while executing this command!', ephemeral: true });
      }
    }
  } else if (interaction.isButton()) {
    const button = client.buttons.get(interaction.customId);
    if (button) {
      try {
        await button.execute(interaction, client);
      } catch (error) {
        console.error(error);
        sendErrorToLogChannel(error);
      //  await interaction.reply({ content: 'There was an error while executing this button!', ephemeral: true });
      }
    }
  } else if (interaction.isStringSelectMenu()) {
    const select = client.Selects.get(interaction.customId);
    if (select) {
      try {
        await select.execute(interaction, client);
      } catch (error) {
        console.error(error);
        sendErrorToLogChannel(error);
       // await interaction.reply({ content: 'There was an error while executing this select menu!', ephemeral: true });
      }
    }
  }
});
const channel = config.LogChannel;
console.log(channel)

async function checkBlacklistedUsers() {
  for (const [id, guild] of client.guilds.cache) {
    const allMembers = await guild.members.fetch();

    allMembers.forEach(async (member) => {
      try {
        const data = await blacklist.findOne({
          User: member.user.id,
        });
        const whitelistData = await whitelist.findOne({
          Guild: guild.id,
          User: member.user.id,
        });
        const guildlogchan = await logchan.findOne({
          Guild: guild.id,
        });

        if (data && !whitelistData) {
            try{
          (await member.send(`You have been blacklisted from ${guild.name} for ${data.Reason}`)).then(() => {
            member.ban({
                reason: `Blacklisted from ${guild.name} for ${data.Reason}`,
            });
            }).catch(err => {
                console.error(err);
                sendErrorToLogChannel(err);
                member.ban({
                    reason: `Blacklisted from ${guild.name} for ${data.Reason}`,
                });
            });
            } catch (err) {
                console.error(err);
                sendErrorToLogChannel(err);
            }
          const channel = config.LogChannel;
          const logChannel = client.channels.cache.get(guildlogchan.Channel);
          console.log(channel)
          console.log(logChannel)
          client.channels.cache.get(channel).send(`${member.user.username} has been banned from ${guild.name} for ${data.Reason}`);
          logChannel.send(`${member.user.username} has been banned from your guild for ${data.Reason}`);
        }
      } catch (err) {
        console.error(err);
        sendErrorToLogChannel(err);
      }
    });
  }
}

setInterval(checkBlacklistedUsers, 3000);

if (!mongoURL) {
  console.log('No mongoURL was provided, please provide one in the .env file.');
} else {
  mongoose.connect(mongoURL, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  }).then(() => {
    console.log('Connected to MongoDB!');
  }).catch((error) => {
    console.error('Failed to connect to MongoDB:', error);
    sendErrorToLogChannel(error);
  });
}

function sendErrorToLogChannel(error) {
  let logChannel = client.channels.cache.get(config.LogChannel);
    logChannel.send(`An error occurred:\n\`\`\`${error.stack}\`\`\``);
}