const db = require("./db");

const { Client, GatewayIntentBits, Events } = require("discord.js");

const client = new Client({ intents: Object.values(GatewayIntentBits) });

require("./loader/events.js")(client);
require("./loader/commands.js")(client);


setInterval(() => {
  // vérification des membres vocaux pour leur faire gagner de l'xp
  client.guilds.cache.forEach(guild => {
    guild.members.cache.forEach(member => {
      if (member.user.bot) return;

      const voiceState = member.voice;
      if (!voiceState.channelId) return;

      const guildId = guild.id;

      db.get(
        `SELECT 
          enabled,
          level_announcements_enabled,
          level_announcements_channel_id,
          level_announcements_message,
          xp_courbe_type,
          multiplier_courbe_for_level,
          level_annoncement_every_level,
          level_max,
          role_with_without_type,
          role_with_without_xp,
          salon_with_without_type,
          salon_with_without_xp,
          gain_xp_on_voice,
          gain_voice_xp_lower_bound,
          gain_voice_xp_upper_bound
        FROM levels_config WHERE guild_id = ?`,
        [guildId],
        (err, row) => {
          if (err || !row || !row.enabled || !row.gain_xp_on_voice) return;
          if (row.role_with_without_type === "with") {
            const userRoles = member.roles.cache;
            const requiredRoles = JSON.parse(row.role_with_without_xp || "[]");
            if (!requiredRoles.some(roleId => userRoles.has(roleId))) {
              return; // User has an excluded role
            }
          } else if (row.role_with_without_type === "without") {
            const userRoles = member.roles.cache;
            const excludedRoles = JSON.parse(row.role_with_without_xp || "[]");
            if (excludedRoles.some(roleId => userRoles.has(roleId))) {
              return; // User does not have any of the required roles
            }
          } else if (row.salon_with_without_type === "with") {
            const channelId = voiceState.channelId;
            const requiredChannels = JSON.parse(row.salon_with_without_xp || "[]");
            if (!requiredChannels.includes(channelId)) {
              return; // Not in a required channel
            }
          } else if (row.salon_with_without_type === "without") {
            const channelId = voiceState.channelId;
            const excludedChannels = JSON.parse(row.salon_with_without_xp || "[]");
            if (excludedChannels.includes(channelId)) {
              return; // In an excluded channel
            }
          }

          const minXp = row.gain_voice_xp_lower_bound;
          const maxXp = row.gain_voice_xp_upper_bound;
          const xpToAdd = Math.floor(Math.random() * (maxXp - minXp + 1)) + minXp;

          db.get(
            `SELECT xp, level FROM user_levels WHERE guild_id = ? AND user_id = ?`,
            [guildId, member.id],
            (err, userRow) => {
              if (err) return;

              let newXp;
              let newLevel;

              if (userRow) {
                newXp = userRow.xp + xpToAdd;
                newLevel = userRow.level;
              } else {
                newXp = xpToAdd;
                newLevel = 1;
              }

              // Level up logic
              const multiplier = row.multiplier_courbe_for_level;
              let fonction_courbe;

              if (row.xp_courbe_type === "constante") {
                fonction_courbe = (level) => multiplier;
              } else if (row.xp_courbe_type === "linear") {
                fonction_courbe = (level) => (level) * multiplier;
              } else if (row.xp_courbe_type === "quadratic") {
                fonction_courbe = (level) => (level) * (level) * multiplier;
              } else if (row.xp_courbe_type === "exponential") {
                fonction_courbe = (level) => Math.pow(2, (level - 1)) * multiplier;
              }

              let xpForNextLevel = fonction_courbe(newLevel);
              while (newXp >= xpForNextLevel && (row.level_max === 0 || newLevel < row.level_max)) {
                newXp -= xpForNextLevel;
                newLevel += 1;
                xpForNextLevel = fonction_courbe(newLevel);

                // Announce level up if enabled and meets the criteria
                if (row.level_announcements_enabled && (newLevel % row.level_annoncement_every_level === 0)) {
                  const channel = guild.channels.cache.get(row.level_announcements_channel_id);
                  console.log("Channel for level announcement:", channel);
                  if (channel) {
                    let announcementMsg = row.level_announcements_message;
                    announcementMsg = announcementMsg
                      .replace("{user}", member.user.username)
                      .replace("{mention}", `<@${member.id}>`)
                      .replace("{level}", newLevel)
                      .replace("{level-xp}", xpForNextLevel);
                    channel.send(announcementMsg);
                  }
                }
              }

              db.run(
                `INSERT INTO user_levels (guild_id, user_id, xp, level)
                 VALUES (?, ?, ?, ?)
                 ON CONFLICT(guild_id, user_id) DO UPDATE SET
                   xp = excluded.xp,
                   level = excluded.level`,
                [guildId, member.id, newXp, newLevel]
              );
            }
          );
        }
      );
    });
  });
}, 60 * 1000); // Toutes les minutes


client.login(process.env.BOT_TOKEN);

module.exports = client;