const AutoModSchema = require('./models/AutoMod');
const LinkSchema = require('./models/Links');
const BadWordSchema = require('./models/BadWord');
const WarnHistorySchema = require('./models/WarnHistory');

const deleteDelay = 5000; // 5000 Millisekunden (5 Sekunden)

async function readBadWords() {
  try {
    const badWords = await BadWordSchema.find();
    return badWords.map((wordDoc) => wordDoc.word);
  } catch (error) {
    console.error('Fehler beim Lesen der Schimpfwörter:', error);
    return [];
  }
}

async function readNotAllowedLinks() {
  try {
    const links = await LinkSchema.find();
    return links.map((linkDoc) => linkDoc.link);
  } catch (error) {
    console.error('Fehler beim Lesen der nicht erlaubten Links:', error);
    return [];
  }
}

function checkExemptRoles(message) {
  const memberRoles = message.member?.roles.cache;
  return memberRoles?.some((role) => ['1169715609878138995'].includes(role.id));
}

function isDiscordInviteLink(link) {
  return link.startsWith('discord.gg/url') || link.startsWith('discord.gg/gangwar');
}

async function importBadWordsFromJson() {
  try {
    const data = await fs.readFile('./src/json/badwords.json', 'utf-8');
    const json = JSON.parse(data);

    await BadWordSchema.deleteMany({});
    const badWordsToInsert = json.badwords.map((word) => ({ word }));
    await BadWordSchema.insertMany(badWordsToInsert);

    console.log('[AutoMod] '.red + 'Schimpfwörter aus JSON importiert.');
  } catch (error) {
    console.error('[AutoMod] '.red + 'Fehler beim Importieren von Schimpfwörtern aus der JSON-Datei:', error);
  }
}

async function importNotAllowedLinksFromJson() {
  try {
    const data = await fs.readFile('./src/json/links.json', 'utf-8');
    const json = JSON.parse(data);

    await LinkSchema.deleteMany({});
    const linksToInsert = json.notallowedLinks.map((link) => ({ link }));
    await LinkSchema.insertMany(linksToInsert);

    console.log('[AutoMod] '.red + 'Nicht erlaubte Links aus JSON importiert.');
    console.log('[AutoMod] '.red + 'AutoMod ist verbunden!');
  } catch (error) {
    console.error('[AutoMod] '.red + 'Fehler beim Importieren von nicht erlaubten Links aus der JSON-Datei:', error);
  }
}

async function logBan(author) {
  const logChannelId = '1180155996639862834';
  const logChannel = await client.channels.fetch(logChannelId);

  if (!logChannel) {
    console.error('Log-Kanal nicht gefunden.');
    return;
  }

  const logEmbed = new EmbedBuilder()
    .setColor('Red')
    .setTitle('Ban durch Auto Mod')
    .setDescription(`:alarm_clock: <@${author.id}> wurde für **Rassismus** gebannt!.`)
    .addFields(
      { name: 'Dauer', value: 'Permanent', inline: true },
      { name: 'Grund', value: 'Rassismus', inline: true },
      { name: 'Falscher Ban?', value: `Überprüfe bitte die Logs <#1180194498010161192>`, inline: false },
    )
    .setFooter({ text: '© RG System' })
    .setTimestamp();

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

async function main() {
  try {
    await importBadWordsFromJson();
    await importNotAllowedLinksFromJson();
  } catch (error) {
    console.error('Fehler beim Initialisieren:', error);
    process.exit(1);
  }

  client.on('messageCreate', async (message) => {
    if (message.author.bot || !message.guild) {
      return;
    }

    const guildId = message.guild.id;
    const memberId = message.author.id;

    try {
      let autoModData = await AutoModSchema.findOne({ guildId, memberId });

      if (!autoModData) {
        autoModData = await AutoModSchema.create({
          guildId,
          memberId,
          warnings: [{ reason: 'Anti-Link / Schimpfwort', moderatorId: 'System', timestamp: Date.now() }],
        });
      }

      const notAllowedLinks = await readNotAllowedLinks();
      const containsLink = notAllowedLinks.some((link) => message.content.includes(link));

      const containsDiscordInviteLink = isDiscordInviteLink(message.content);

      const badWords = await readBadWords();
      const containsBadWord = badWords.some((word) => message.content.toLowerCase().includes(word.toLowerCase()));

      const isExemptRole = checkExemptRoles(message);

      console.log('Nachrichteninhalt:', message.content);

      if (!isExemptRole && (containsLink || containsBadWord || containsDiscordInviteLink)) {
        if (containsBadWord && message.content.toLowerCase().includes('nigga')) {
          try {
            console.log('Lösche Nachricht mit Inhalt:', message.content);
            await message.delete();
          } catch (error) {
            console.error('Fehler beim Löschen der Nachricht:', error.message);
          }

          try {
            const member = await message.guild.members.fetch(memberId);
            await member.ban({ reason: 'Rassismus | Auto Mod System' });

            await logBan(message.author);
          } catch (error) {
            console.error('Fehler beim Sperren des Benutzers:', error.message);
          }

          try {
            const warnHistoryEntry = await WarnHistorySchema.findOne({ guildId, memberId });

            if (!warnHistoryEntry) {
              await WarnHistorySchema.create({
                guildId,
                memberId,
                history: `Warnung für: ${message.content}\n`,
              });
            } else {
              warnHistoryEntry.history += `Warnung für: ${message.content}\n`;
              await warnHistoryEntry.save();
            }

            if (autoModData.warnings.length + 1 === 3) {
              try {
                const member = await message.guild.members.fetch(memberId);
                await member.timeout(86_400_000, 'Dritter Warn');
                autoModData.warnings = 0;
                await autoModData.save();
                console.log('Timeout für Benutzer nach dem dritten Warnen eingeleitet.');

                const logChannelId = '1180155996639862834';
                const logChannel = await client.channels.fetch(logChannelId);

                if (logChannel) {
                  const logEmbed = new EmbedBuilder()
                    .setColor('Red')
                    .setTitle('Timeout durch Auto Mod')
                    .setDescription(`:alarm_clock: <@${message.author.id}> wurde für **Dritter Warn** getimeouted.`)
                    .addFields(
                      { name: 'Dauer', value: '24 Stunden', inline: true },
                      { name: 'Grund', value: 'Dritter Warn', inline: true },
                    )
                    .setFooter({ text: '© RG System' })
                    .setTimestamp();

                  logChannel.send({ embeds: [logEmbed] });
                }
              } catch (error) {
                console.error('Fehler beim Timeout des Benutzers:', error.message);
              }
            } else {
              try {
                const logChannelId = '1180155996639862834';
                const logChannel = await client.channels.fetch(logChannelId);

                if (logChannel) {
                  const logEmbed = new EmbedBuilder()
                    .setColor('Red')
                    .setTitle('Verwarnung durch Auto Mod')
                    .setDescription(`:warning: <@${message.author.id}> hat eine Verwarnung erhalten.`)
                    .addFields(
                      { name: 'Grund', value: 'Verstoß gegen die Regeln', inline: true },
                    )
                    .setFooter({ text: '© RG System' })
                    .setTimestamp();

                  logChannel.send({ embeds: [logEmbed] });
                }
              } catch (error) {
                console.error('Fehler beim Senden der Warnungsnachricht an den Log-Kanal:', error.message);
              }
            }
          } catch (error) {
            console.error('Fehler in der messageCreate-Funktion:', error.message);
          }
        }
      }
    } catch (error) {
      console.error('Fehler in der messageCreate-Funktion:', error.message);
    }
  });
}

main().catch((error) => {
  console.error('Fehler in der Hauptfunktion:', error.message);
});