const Discord = require("discord.js");
const client = new Discord.Client({ disableMentions: "everyone" });
const ayarlar = require("./ayarlar.json");
const fs = require("fs");
const moment = require("moment");
const disbut = require("discord-buttons")(client);
require("./util/eventLoader")(client);
const db = require("quick.db");
const croxydb = require("croxydb");
const fetch = require('node-fetch'); 
const { MessageEmbed,MessageAttachment } = require("discord.js");
const ytdl = require('ytdl-core');
const path = require('path');
const EventEmitter = require('events');
EventEmitter.defaultMaxListeners = Infinity;// 15 yerine istediğiniz sayıyı yazabilirsiniz
client.on('error', console.error);
client.on('warn', console.warn);
client.on('debug', console.log); // Daha fazla bilgi almak isterseniz debug kullanabilirsiniz



var prefix = ayarlar.prefix;
let sesid = ayarlar.sesid;
const log = (message) => {
  console.log(`[${moment().format("YYYY-MM-DD HH:mm:ss")}] ${message}`);
};

client.commands = new Discord.Collection();
client.aliases = new Discord.Collection();
fs.readdir("./komutlar/", (err, files) => {
  if (err) console.error(err);
  log(`${files.length} komut yüklenecek.`);
  files.forEach((f) => {
    let props = require(`./komutlar/${f}`);
    log(`Yüklenen komut: ${props.help.name}.`);
    client.commands.set(props.help.name, props);
    props.conf.aliases.forEach((alias) => {
      client.aliases.set(alias, props.help.name);
    });
  });
});
client.reload = (command) => {
  return new Promise((resolve, reject) => {
    try {
      delete require.cache[require.resolve(`./komutlar/${command}`)];
      let cmd = require(`./komutlar/${command}`);
      client.commands.delete(command);
      client.aliases.forEach((cmd, alias) => {
        if (cmd === command) client.aliases.delete(alias);
      });
      client.commands.set(command, cmd);
      cmd.conf.aliases.forEach((alias) => {
        client.aliases.set(alias, cmd.help.name);
      });
      resolve();
    } catch (e) {
      reject(e);
    }
  });
};
client.load = (command) => {
  return new Promise((resolve, reject) => {
    try {
      let cmd = require(`./komutlar/${command}`);
      client.commands.set(command, cmd);
      cmd.conf.aliases.forEach((alias) => {
        client.aliases.set(alias, cmd.help.name);
      });
      resolve();
    } catch (e) {
      reject(e);
    }
  });
};
client.unload = (command) => {
  return new Promise((resolve, reject) => {
    try {
      delete require.cache[require.resolve(`./komutlar/${command}`)];
      let cmd = require(`./komutlar/${command}`);
      client.commands.delete(command);
      client.aliases.forEach((cmd, alias) => {
        if (cmd === command) client.aliases.delete(alias);
      });
      resolve();
    } catch (e) {
      reject(e);
    }
  });
};
const cooldown = new Set();
const greetings = ["sa", "selam", "selam aleyküm", "selamün aleyküm", "selamın aleyküm"];

client.on("message", async (msg) => {
  if (msg.author.bot) return; // Bot mesajlarını yoksay
  
  let i = await db.fetch(`saas_${msg.guild.id}`);
  if (i === "açık") {
    if (greetings.includes(msg.content.toLowerCase())) {
      if (cooldown.has(msg.author.id)) {
        return; // Eğer mesaj sahibi cooldown içindeyse, hiçbir şey yapmadan geri dön
      }
      
      cooldown.add(msg.author.id);
      setTimeout(() => {
        cooldown.delete(msg.author.id);
      }, 5000); // 5 saniye cooldown süresi

      msg.channel.send("<a:PikaHg:1255928140560339015> Aleyküm Selam dostum, **Hoşgeldin!**");
    }
  }
});



client.on("message", (message) => {
  // Botun kendi mesajlarını işlememesi için kontrol
  if (message.author.bot) return;

  // Mesajın içeriğini kontrol etme
  if (message.content === "<@1145755759091662899>") {
    // Embed mesaj oluşturma
    const embed = new Discord.MessageEmbed()
      .setColor('#0099ff')
      .setDescription('<a:yupiiii:1220990675944996865> **• Prefixim : .**\n<a:blue_GhostKissP:1263471538276139058> **• .yardım yazarak komutlarımı kategorileriyle görebilirsin.**')
      .setFooter('MamutBOT', client.user.displayAvatarURL()); // Botun ismi ve avatarı

    message.reply({ embed });
  }
});

// BOTU SESE SOKMA

client.once("ready", () => {
  console.log("Bot is ready!");

  const activities = ["Noldu Mamut", "Reklam Mamut"];
  let currentIndex = 0;
  setInterval(() => {
    
    client.user.setActivity(activities[currentIndex], {
      type: "STREAMING",
      url: "https://twitch.tv/04572093"
    });

    console.log(``);
    // Move to the next activity
    currentIndex = (currentIndex + 1) % activities.length;
  }, 8000); // Change activity every 8 seconds
});


  client.elevation = (message) => {
  if (!message.guild) {
    return;
  }
  let permlvl = 0;
  if (message.member.hasPermission("BAN_MEMBERS")) permlvl = 2;
  if (message.member.hasPermission("ADMINISTRATOR")) permlvl = 3;
  if (message.author.id === ayarlar.sahip) permlvl = 4;
  return permlvl;
};

client.on("message", async (message) => {
  const croxydb = require("croxydb"); //gerekli modül
  if (message.guild) {
    const data1 = croxydb.get("cd1." + message.guild.id);
    const data2 = croxydb.get("cd2." + message.channel.id + message.guild.id);

    if (data1) {
      const blacklist = [
        "oç",
        "amk",
        "ananı sikiyim",
        "ananıskm",
        "piç",
        "Amk",
        "amsk",
        "sikim",
        "sikiyim",
        "orospu çocuğu",
        "piç kurusu",
        "kahpe",
        "orospu",
        "sik",
        "yarrak",
        "Yarrak",
        "amcık",
        "amık",
        "yarram",
        "sikimi ye",
        "mk",
        "mq",
        "aq",
        "amq",
      ];

      let content = message.content.split(" ");

      content.forEach((kelime) => {
        if (blacklist.some((küfür) => küfür === kelime)) {
          if (!message.member.permissions.has("BAN_MEMBERS")) {
            message.delete({ timeout: 1000 });
            message.reply("**Lütfen Küfür Etme!!**");
          }
        }
      });
    }

    if (!data1 && data2) {
      const blacklist = [
        "oç",
        "amk",
        "ananı sikiyim",
        "ananıskm",
        "piç",
        "Amk",
        "amsk",
        "sikim",
        "sikiyim",
        "orospu çocuğu",
        "piç kurusu",
        "kahpe",
        "orospu",
        "sik",
        "yarrak",
        "amcık",
        "amık",
        "yarram",
        "sikimi ye",
        "mk",
        "mq",
        "aq",
        "amq",
      ];

      let content = message.content.split(" ");

      content.forEach((kelime) => {
        if (blacklist.some((küfür) => küfür === kelime)) {
          if (!message.member.permissions.has("BAN_MEMBERS")) {
            message.delete({ timeout: 1000 });
            message.reply("**Lütfen Küfür Etme!!**");
          }
        }
      });
    }
  }
});



// Link engelleme sistemi
client.on("message", (message) => {
  if (message.author.bot) return;

  // Datadaki "Reklam Engel" Kısmını Çağıralım
  let codemarefireklamengel = db.fetch(`mindpala_${message.guild.id}`);

  // Komutlarımıza Geçelim, Eğer Reklam Engel Sistemi Aktif İse Reklam Yapan Kullanıcıya Uyarı Verelim
  if (codemarefireklamengel === "mindpalaktif") {
    // Kullanıcının yetkisini kontrol et
    if (message.member.hasPermission("MANAGE_MESSAGES")) {
      return; // Moderatörlerin mesajlarını silme
    }

    // Reklam Ayarlamaları
    const codemarefireklamliste = [
      ".org",
      ".tr",
      ".space",
      ".funy",
      ".fun",
      ".com",
      ".xyz",
      ".glitch-me",
      ".eueo.org",
      "free.biz",
      ".biz",
      ".free",
      ".blogspot-com",
      ".alan",
      ".com.tr",
      ".sexs",
      ".hub",
      ".dance",
      ".in",
      ".net",
      ".shop",
      ".store",
      ".click",
      ".tech",
      ".best",
      ".college",
      ".me",
      ".site",
      ".online",
      ".art",
      ".host",
      ".baby",
      ".website",
      ".blog",
      ".link",
      ".top",
      ".info",
      ".press",
      ".monster",
      ".services",
    ];
    if (
      codemarefireklamliste.some((codemarefi) =>
        message.content.includes(codemarefi)
      )
    ) {
      // Kullanıcının Mesajını Silelim
      message.delete();

      // Reklam yapan terbiyesize uyarı mesajı atalım ve bu 5 saniye sonra chati kirletmemek açısından silinsin.
      const reklamyasak = new Discord.MessageEmbed()
        .setDescription(
          `${message.author} - **Hey Dostum!. Bu Sunucuda Reklam Yapmana İzin Vermem.**`
        )
        .setColor("#36393F");
      message.channel.send(reklamyasak).then((codemarefisil) => {
        codemarefisil.delete({ timeout: 5000 });
      });
    }
  }
});


client.on("message", async (message) => {
  //Events hatası alıyorsan

  //client.on("messageCreate",async(message) => {

  if (message.author.bot) return;

  let member = [`<@>`];

  let foundInText = false;

  for (var i in member) {
    if (message.author.id === 2) return;

    if (message.content.toLowerCase().includes(member[i].toLowerCase()))
      foundInText = true;
  }

  if (foundInText) {
    message.channel.send(` ${message.author} Bu kullanıcıyı etiketlemek yasak`); //v13 için önerilmeyebilir
  }
});

const allowedUserId = "824626594224013322"; // Kendi Discord kullanıcı ID'nizi buraya yazın

client.on("message", async (message) => {
  if (message.content.startsWith(`${prefix}rolisimdeğiştir`)) {
    // Sadece belirli kullanıcıya izin verme kontrolü

    if (message.author.id !== allowedUserId) {
      return message.reply("Bu komutu kullanmaya yetkiniz yok.");
    }

    // Etiketlenen rolü al

    const roleMention = message.mentions.roles.first();

    if (!roleMention) {
      return message.reply("Lütfen bir rol etiketleyin.");
    }

    // Yeni ismi al

    const newRoleName = message.content
      .slice(prefix.length + "rolisimdeğiştir".length)
      .trim()
      .substring(roleMention.toString().length + 1);

    // Rol ismini değiştir

    try {
      await roleMention.setName(newRoleName);

      message.channel.send(
        `Rolün ismi başarıyla "${newRoleName}" olarak değiştirildi.`
      );
    } catch (error) {
      console.error("Rol ismi değiştirilirken bir hata oluştu:", error);

      message.channel.send("Rol ismi değiştirilirken bir hata oluştu.");
    }
  }
});


//...........................................//
//Main Dosyasına Atılacaktır!

client.on("guildMemberAdd", async (member) => {
  let hgbb = croxydb.get(`cshgbb.${member.guild.id}`);
  let sunucu = member.guild.channels.cache.get(hgbb);

  if (hgbb && sunucu) {
    const background = "https://files.shapes.inc/bcc3f33d.png";
    const text1 = encodeURIComponent(member.user.username);
    const text2 = encodeURIComponent("Sunucuya Hoşgeldin");
    const text3 = encodeURIComponent(`${member.guild.memberCount} Kişi Olduk`);
    const avatar = encodeURIComponent(member.user.displayAvatarURL({ format: "png", size: 4096 }));
    const apiUrl = `https://api.popcat.xyz/welcomecard?background=${background}&text1=${text1}&text2=${text2}&text3=${text3}&avatar=${avatar}`;

    const response = await fetch(apiUrl);
    const buffer = await response.buffer();

    const attachment = new Discord.MessageAttachment(buffer, 'welcomecard.png');
    sunucu.send(`Hoşgeldin, <@${member.user.id}>`, attachment);
  }
});

client.on("guildMemberRemove", async (member) => {
  let hgbb = croxydb.get(`cshgbb.${member.guild.id}`);
  let sunucu = member.guild.channels.cache.get(hgbb);

  if (hgbb && sunucu) {
    const background = "https://files.shapes.inc/bcc3f33d.png";
    const text1 = encodeURIComponent(member.user.username);
    const text2 = encodeURIComponent("Hoşçakal");
    const text3 = encodeURIComponent(`${member.guild.memberCount} Kişi Kaldık`);
    const avatar = encodeURIComponent(member.user.displayAvatarURL({ format: "png", size: 4096 }));
    const apiUrl = `https://api.popcat.xyz/welcomecard?background=${background}&text1=${text1}&text2=${text2}&text3=${text3}&avatar=${avatar}`;

    const response = await fetch(apiUrl);
    const buffer = await response.buffer();

    const attachment = new Discord.MessageAttachment(buffer, 'goodbyecard.png');
    sunucu.send(`Görüşürüz, <@${member.user.id}>`, attachment);
  }
});

const ALLOWED_USER_IDS = ['203007301219516416', '824626594224013322']; 

const SOURCE_GUILD_ID = '1267497526076903437'; // Roller alınacak sunucu ID'si
const TARGET_GUILD_ID = '1266866419124142141';  // Roller aktarılacak sunucu ID'si

const COMMAND_PREFIX = '.';


client.on('message', async message => {
    if (!ALLOWED_USER_IDS.includes(message.author.id)) return;

    if (message.content.startsWith(COMMAND_PREFIX)) {
        const args = message.content.slice(COMMAND_PREFIX.length).trim().split(/ +/);
        const command = args.shift().toLowerCase();

        if (command === 'copyroles') {
            const sourceGuild = client.guilds.cache.get(SOURCE_GUILD_ID);
            const targetGuild = client.guilds.cache.get(TARGET_GUILD_ID);

            if (!sourceGuild) {
                console.log(`Kaynak sunucu bulunamadı: ${SOURCE_GUILD_ID}`);
                return message.channel.send('Kaynak sunucu bulunamadı.');
            }

            if (!targetGuild) {
                console.log(`Hedef sunucu bulunamadı: ${TARGET_GUILD_ID}`);
                return message.channel.send('Hedef sunucu bulunamadı.');
            }

            // Hedef sunucudaki roller
            const targetRoles = targetGuild.roles.cache;

            // Mevcut rollerin silinmesi
            targetRoles.forEach(async role => {
                if (role.name !== '@everyone') {
                    try {
                        await role.delete(`Rol silme işlemi`);
                        console.log(`Rol silindi: ${role.name}`);
                    } catch (error) {
                        console.error(`Rol silinirken hata oluştu: ${error}`);
                    }
                }
            });

            // Kaynak sunucudaki roller
            const sourceRoles = sourceGuild.roles.cache;

            // Roller kopyalanacak
            sourceRoles.forEach(async role => {
                if (role.name === '@everyone') return;

                if (!targetRoles.find(r => r.name === role.name)) {
                    try {
                        await targetGuild.roles.create({
                            data: {
                                name: role.name,
                                color: role.color,
                                permissions: role.permissions,
                                mentionable: role.mentionable
                            },
                            reason: `Rol kopyalama işlemi`
                        });
                        console.log(`Rol oluşturuldu: ${role.name}`);
                    } catch (error) {
                        console.error(`Rol oluşturulurken hata oluştu: ${error}`);
                    }
                }
            });

            message.channel.send('Roller kopyalanıyor ve mevcut roller siliniyor...');
        }
    }
});

const TARGET_CHANNEL_IDS = ['1264152880076820481', '1274384627489833002'];  // Tepki vermek istediğiniz kanal ID'leri
const EMOJI_IDS = ['1263471538276139058', '1248730926830325914'];  // Özel emojilerin ID'leri

client.on('message', async message => {
    // Sadece belirli kanallarda mesajları dinle
    if (TARGET_CHANNEL_IDS.includes(message.channel.id) && !message.author.bot) {
        try {
            // Özel emojilerle tepki ver
            for (const emojiId of EMOJI_IDS) {
                const emoji = client.emojis.cache.get(emojiId);
                if (emoji) {
                    await message.react(emoji);
                } else {
                    console.error(`Emoji not found: ${emojiId}`);
                }
            }
        } catch (error) {
            console.error('Error reacting to the message:', error);
        }
    }
});


client.on('guildMemberAdd', async member => {
    // Sunucunun veritabanında saklanan otomatik rol ID'sini alın
    const roleId = croxydb.get(`autorole_${member.guild.id}`);
    
    // Eğer rol ID'si varsa, rolü ekleyin
    if (roleId) {
        const role = member.guild.roles.cache.get(roleId);
        if (role) {
            try {
                await member.roles.add(role);
                console.log(`Yeni üye ${member.user.tag} kullanıcısına ${role.name} rolü verildi.`);
            } catch (error) {
                console.error('Rol verilirken bir hata oluştu:', error);
            }
        }
    }
});

client.on('message', async (message) => {
    if (message.author.bot) return; // Botların mesajlarına tepki vermemek için

    // Mesajın komutlardan biriyle başlayıp başlamadığını kontrol et
    if (message.content.startsWith('.emojibul ') || message.content.startsWith('.id ')) {
        // Komuta göre kesilecek kısmı ayarla
        const prefix = message.content.startsWith('.emojibul ') ? '.emojibul ' : '.id ';
        const emojiName = message.content.slice(prefix.length).trim();
        
        // Sunucudaki emojileri al
        const emojis = message.guild.emojis.cache;
        
        // Aranan emojiyi bul
        const foundEmoji = emojis.find(emoji => emoji.name === emojiName);

        if (foundEmoji) {
            const emojiText = `<${foundEmoji.animated ? 'a' : ''}:${foundEmoji.name}:${foundEmoji.id}>`;
            
            // Tek bir mesajda hem normal formatta hem de üçlü tırnak işaretleri içinde göster
            message.channel.send(`${emojiText} \n\`\`\`${emojiText}\`\`\``);
        } else {
            message.channel.send('Bu emoji bulunamadı.');
        }
    }
});



client.on('message', async (message) => {
  if (message.author.bot) return; // Bot mesajlarını geç

  // AFK olan kullanıcılara etiket atıldıysa
  const mentionedMembers = message.mentions.members;
  mentionedMembers.forEach(async member => {
    if (db.has(`afk_${member.id}`)) {
      const reason = db.get(`afk_${member.id}`);
      const oldNickname = member.nickname || member.user.username;

 

        message.channel.send(`${member.user.tag} **AFK** olarak ayarlanmıştı. Sebep: \`${reason}\``);
    }
  });
});

        
const OLD_SERVER_ID = '1234611081972809738'; // Eski sunucunun ID'si 
const NEW_SERVER_ID = '1271725887230050335'; // Yeni sunucunun ID'si
const OLD_CATEGORY_ID = '1269961126297468928'; // Eski kategori ID'si
const NEW_CATEGORY_NAME = '- FONKSIYONLAR -'; // Yeni kategori ismi 


client.on('message', async message => {

    if (message.content === '.kanallaryap') {

        if (!message.member.hasPermission('ADMINISTRATOR')) {

            return message.reply('Bu komutu kullanma izniniz yok.');

        }

        const oldServer = client.guilds.cache.get(OLD_SERVER_ID);

        const newServer = client.guilds.cache.get(NEW_SERVER_ID);

        if (!oldServer || !newServer) return message.channel.send('Sunucular bulunamadı');

        const oldCategory = oldServer.channels.cache.get(OLD_CATEGORY_ID);

        if (!oldCategory) return message.channel.send('Eski kategori bulunamadı');

        // Yeni kategori oluşturuluyor

        const newCategory = await newServer.channels.create(NEW_CATEGORY_NAME, { type: 'category' });

        // Eski kategori altındaki kanalların taşınması

        let completedChannels = 0;

        for (const channel of oldCategory.children.values()) {

            if (channel.type === 'text') {

                // Yeni kanalı oluşturma

                const newChannel = await newServer.channels.create(channel.name, { type: 'text', parent: newCategory.id });

                // Eski kanaldaki mesajları yeni kanala taşıma

                let messages = [];

                let lastMessageId;

                while (true) {

                    const options = { limit: 100 };

                    if (lastMessageId) options.before = lastMessageId;

                    const fetchedMessages = await channel.messages.fetch(options);

                    if (fetchedMessages.size === 0) break;

                    messages.push(...fetchedMessages.values());

                    lastMessageId = fetchedMessages.last().id;

                }

                for (const msg of messages.reverse()) {

                    if (msg.content.trim()) {

                        await newChannel.send(msg.content);

                    }

                    if (msg.attachments.size > 0) {

                        for (const attachment of msg.attachments.values()) {

                            await newChannel.send(attachment.url);

                        }

                    }

                }

                completedChannels++;

            }

        }

        // İşlem tamamlandığında sadece bir başarı mesajı gönder

        message.channel.send(`Kanal ve mesajlar başarıyla taşındı! Toplam ${completedChannels} kanal taşındı.`);

    }

});

client.on('message', async message => {
    if (message.content.startsWith(prefix + 'roller')) {
        // Rolü kontrol et
        if (!message.guild) return message.reply('Bu komut sadece sunucularda kullanılabilir.');
   
 // Botun küçük fotoğrafını ve komutu kullanan kişinin büyük fotoğrafını al
        const botAvatar = client.user.displayAvatarURL({ format: 'png', size: 64 });
        const userAvatar = message.author.displayAvatarURL({ format: 'png', size: 2048 });

        // Rolleri al
        const roles = message.guild.roles.cache
            .filter(role => role.name !== '@everyone') // @everyone rolünü hariç tutma
            .sort((a, b) => b.position - a.position) // Rolleri pozisyona göre sırala
            .map(role => {
                // Rolün içinde kaç kişi olduğunu belirle
                const memberCount = role.members.size;
                // Yönetici yetkisi varsa emoji ekle
                const adminEmoji = role.permissions.has('ADMINISTRATOR') ? '<:administrator:1273983829677314090>' : '';
                // Rol bir bot rolü ise emoji ekle
                const botEmoji = role.members.size > 0 && role.members.some(member => member.user.bot) ? '<a:bot:1273984280879693855>' : '';
                return `<@&${role.id}> (${memberCount}) ${adminEmoji} ${botEmoji}`;
            });

        // Sayfa başına kaç rol olacağını belirleyin
        const rolesPerPage = 15; // Sayfa başına rol sayısı
        const pages = Math.ceil(roles.length / rolesPerPage); // Toplam sayfa sayısı

        let currentPage = 1;

        const createPage = (page) => {
            const embed = new Discord.MessageEmbed()
                .setTitle('Sunucusunun Rolleri')
                  .setDescription(`Roller [**${Math.min(rolesPerPage * page, roles.length)}**/**${roles.length}**] \n\n` +
                                roles.slice((page - 1) * rolesPerPage, page * rolesPerPage).join('\n'))
              .setColor('#3498db') // Renk kodunu buraya ekleyin
                .setThumbnail(userAvatar) // Botun küçük fotoğrafı
                .setAuthor(message.guild.name, botAvatar) // Komutu kullanan kişinin büyük fotoğrafı
              

            return embed;
        };

        const messageEmbed = await message.channel.send(createPage(currentPage));
  // Mesajın emoji ile etkileşim için gereken butonlar
        await messageEmbed.react('1273991682291142756'); // Önceki sayfa için sol ok emojisi
        await messageEmbed.react('1273991744194609254'); // Sonraki sayfa için sağ ok emojisi

        const filter = (reaction, user) => {
            return ['1273991682291142756', '1273991744194609254'].includes(reaction.emoji.id) && !user.bot;
        };

        const collector = messageEmbed.createReactionCollector(filter, { time: 60000 }); // 60 saniye zaman aşımı

       collector.on('collect', (reaction, user) => {
            if (reaction.emoji.id === '1273991682291142756') {
                if (currentPage > 1) currentPage--;
            } else if (reaction.emoji.id === '1273991744194609254') {
                if (currentPage < pages) currentPage++;
            }


            messageEmbed.edit(createPage(currentPage));
            reaction.users.remove(message.author.id); // Reaksiyonu kaldır
        });

        collector.on('end', () => {
            messageEmbed.reactions.removeAll(); // Zaman aşımından sonra reaksiyonları temizle
        });
    }
});

client.on('message', async message => {
    if (message.content.startsWith('.category')) {
        if (!message.member.hasPermission('ADMINISTRATOR')) {
            return message.reply('Bu komutu kullanmak için gerekli izne sahip değilsiniz.');
        }

        const args = message.content.slice(1).trim().split(/ +/);
        args.shift(); // Komut kısmını çıkar
        const categoryId = args[0]; // Kategori ID'sini komutla girin
        const emojiPrefix = '📁・'; // Klasör emojisi ve ayraç

        // Kategori ID'sini al
        const category = message.guild.channels.cache.get(categoryId);
        if (!category || category.type !== 'category') {
            return message.reply('Geçerli bir kategori ID\'si girin.');
        }

        // Kategori içindeki kanalları güncelle
        const channels = category.children;
        channels.forEach(async (channel) => {
            if (channel.type === 'text' || channel.type === 'voice') {
                const newName = `${emojiPrefix}${channel.name}`;
                try {
                    await channel.setName(newName);
                } catch (error) {
                    console.error('Kanal adı güncellenirken bir hata oluştu:', error);
                }
            }
        });

        message.reply('Kategori içindeki kanalların isimleri güncellendi.');
    }
});


// Sunucuya eklendiğinde bildirim gönder
client.on('guildCreate', async sunucu => {
    const Eklendim = new Discord.MessageEmbed()
        .setColor('#00FF00') // Yeşil renk
        .setAuthor(sunucu.name, sunucu.iconURL())
        .setDescription('> Bir sunucuya eklendim')
        .addField('<:pusula:1188076379556827146> Sunucu bilgileri', `> ${sunucu} \`(${sunucu.id})\``)
        .addField('<:bannerstory_kraltacicrown:1234901551852814438> Sunucu sahibi bilgileri', `> ${client.users.cache.get(sunucu.ownerID).tag} \`(${sunucu.ownerID})\``)
        .addField('<:sunucu:1188015016692166706> Toplam sunucu sayısı', `> ${client.guilds.cache.size}`)
        .addField('<:members:1264156348921417738> Sunucudaki kullanıcı sayısı', `> ${sunucu.memberCount}`)

    const logChannel = client.channels.cache.get('1147223060592726029'); // LOG_CHANNEL_ID kısmını gerçek log kanal ID'si ile değiştirin
    if (logChannel) logChannel.send(Eklendim);
});


// Sunucudan atıldığında bildirim gönder
client.on('guildDelete', async sunucu => {
    try {
        const Atıldım = new Discord.MessageEmbed()
            .setColor('#FF0000') // Kırmızı renk
            .setAuthor(sunucu.name, sunucu.iconURL())
            .setDescription('> Bir sunucudan atıldım')
            .addField('<:pusula:1188076379556827146> Sunucu bilgileri', `> ${sunucu} \`(${sunucu.id})\``)
            .addField('<:bannerstory_kraltacicrown:1234901551852814438> Sunucu sahibi bilgileri', `> ${client.users.cache.get(sunucu.ownerID).username} \`(${sunucu.ownerID})\``)
            .addField('<:sunucu:1188015016692166706> Toplam sunucu sayısı', `> ${client.guilds.cache.size}`)
            .addField('<:members:1264156348921417738> Sunucudaki kullanıcı sayısı', `> ${sunucu.memberCount}`)
            .setFooter(client.user.username, client.user.displayAvatarURL())
            .setTimestamp();

        const logChannel = client.channels.cache.get('1147223060592726029'); // LOG_CHANNEL_ID kısmını gerçek log kanal ID'si ile değiştirin
        if (logChannel) await logChannel.send(Atıldım);
    } catch (e) {
        console.error(e);
    }
});

// JSON dosyasından isimleri oku ve formatla
function formatName(name) {
  return name
    .split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
    .join(' ');
}

const isimler = JSON.parse(fs.readFileSync('isimler.json', 'utf8')).map(formatName);
const PREFIX = '.'; // Prefix'i tanımla
let originalNicknames = {}; // Üyelerin orijinal isimlerini saklamak için obje

client.on('message', async message => {
  if (!message.content.startsWith(PREFIX) || message.author.bot) return;

  const args = message.content.slice(PREFIX.length).trim().split(/ +/);
  const command = args.shift().toLowerCase();

  if (command === 'isimler') {
    if (!message.member.hasPermission('MANAGE_NICKNAMES')) {
      return message.reply('Bu komutu kullanmak için gerekli izinlere sahip değilsiniz.');
    }

    const guild = message.guild;
    const members = guild.members.cache;

    let index = 0;
    members.forEach(member => {
      if (index >= isimler.length) return; // İsimler bittiğinde işlemi durdur

      // Eski ismi kaydet
      originalNicknames[member.id] = member.nickname || member.user.username;

      member.setNickname(isimler[index])
        .then(() => console.log(`Üye ${member.user.tag} ismi ${isimler[index]} olarak değiştirildi.`))
        .catch(console.error);
      index++;
    });

    // Orijinal isimleri dosyaya kaydet
    fs.writeFileSync('originalNicknames.json', JSON.stringify(originalNicknames, null, 2));

    message.channel.send('İsimler başarıyla değiştirildi.');
  }

  if (command === 'isimlergerial') {
    if (!message.member.hasPermission('MANAGE_NICKNAMES')) {
      return message.reply('Bu komutu kullanmak için gerekli izinlere sahip değilsiniz.');
    }

    // Eski isimleri JSON dosyasından oku
    const oldNicknames = JSON.parse(fs.readFileSync('originalNicknames.json', 'utf8'));

    const guild = message.guild;
    const members = guild.members.cache;

    members.forEach(member => {
      if (oldNicknames[member.id]) {
        member.setNickname(oldNicknames[member.id])
          .then(() => console.log(`Üye ${member.user.tag} ismi eski hali olan ${oldNicknames[member.id]} olarak geri yüklendi.`))
          .catch(console.error);
      }
    });

    message.channel.send('İsimler eski hallerine geri yüklendi.');
  }
});


client.on("guildMemberAdd", async (member) => {
    const tag = croxydb.get(`otoTag_${member.guild.id}`); // Veritabanından tagı al

    if (tag) {
        const newUsername = `${tag} ${member.user.username}`; // Yeni kullanıcı adı

        try {
            await member.setNickname(newUsername); // Kullanıcı adını güncelle
            console.log(`Kullanıcı adı değiştirildi: ${member.user.tag} => ${newUsername}`);
        } catch (error) {
            console.error('Kullanıcı adı değiştirilirken bir hata oluştu:', error);
        }
    }
});


client.login(process.env.token);