// Load up the discord.js library
const Discord = require("discord.js");

// This is your client. Some people call it `bot`, some people call it `self`,
// some might call it `cootchie`. Either way, when you see `client.something`, or `bot.something`,
// this is what we're refering to. Your client.
const client = new Discord.Client();

// Here we load the config.json file that contains our token and our prefix values.
const config = require("./config.json");
// config.token contains the bot's token
// config.prefix contains the message prefix.


const ms = require('ms')

client.on("ready", () => {

  // This event will run if the bot starts, and logs in, successfully.
  console.log(`logged into ${client.user.tag}!`);
  // Example of changing the bot's playing game to something useful. `client.user` is what the
  // docs refer to as the "ClientUser".

  // Set the client user's status
  client.user.setStatus('dnd')
  client.user.setPresence({
    game: {
      name: `Discord.js`,
      type: "watching",
      url: "https://www.twitch.tv/monstercat"
    }
  });
});


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

  //so, here is an anti-link thingy. if a user sends, a discord invite OR a website the bot will delete it return a message, yes there is alot but thats okay, so that your server isn't filled with links or discord invites, and if the user who sent it has permissions it does not delete it.
  if (message.content.includes("https://")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }
  if (message.content.includes("http://")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }
  if (message.content.includes("www.")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }


  if (message.content.includes(".gg/")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  if (message.content.includes(".gg /")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  if (message.content.includes(".gg /")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  if (message.content.includes("discord .gg /")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  if (message.content.includes("discord .gg")) {
    if (message.member.hasPermission("BAN_MEMBERS", "KICK_MEMBERS", "MANAGE_SERVER", "MANAGE_ROLES", "MANAGE_CHANNELS")) return;
    console.log(message.author.tag + ` Posted a link in ${message.guild} ` + ` Their ID: ${message.author.id} `)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  // This event will run on every single message received, from any channel or DM.

  // It's good practice to ignore other bots. This also makes your bot ignore itself
  // and not get into a spam loop (we call that "botception").
  if (message.author.bot) return;

  // Also good practice to ignore any message that does not start with our prefix,
  // which is set in the configuration file.
  if (message.content.indexOf(config.prefix) !== 0) return;

  if (message.channel.type === "dm") return; // here, if the a user dm'd the bot the bot will do nothing, this is to prevent your bot from breaking.


  // Here we separate our "command" name, and our "arguments" for the command.
  // e.g. if we have the message "+say Is this the real life?" , we'll get the following:
  // command = say
  // args = ["Is", "this", "the", "real", "life?"]
  const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
  const command = args.shift().toLowerCase();


  if (command === "ban") {
    //here, we see if the message author has permission to ban members, if not we return a message.
    if (!message.member.hasPermission("BAN_MEMBERS")) return message.channel.send("You do not have the following permission:" + `BAN_MEMBERS`)
    //here we return a message, if the bot doesn't have permissions in the message guild if not we return a message.
    if (!message.guild.me.hasPermission("BAN_MEMBERS")) return message.channel.send("I don't have permissions to ban members, permission needed: " + `BAN_MEMBERS`)

    //"message.mentions.members.first()" is a colletion for a mention of a member. so this will be the member who will be banned.
    let member = message.mentions.members.first() || message.guild.members.get(args[0]);
    //here, if the user didn't mention anyone, or stated their id we return a message.
    if (!member) return message.channel.send(`Please either mention a member, or state their id.`)

    //we need to make sure the bot can ban the member, so if the bot cannot ban the mentioned user we return a message.
    if (!member.bannable)
      return message.channel.send("I cannot ban that member.")


    // slice(1) removes the first part, which here should be the user mention or ID
    // join(' ') takes all the various parts to make it a single string.
    let reason = args.slice(1).join(' ');
    if (!reason) reason = "No reason provided";

    // Now, we ban the member.
    member.ban(reason + `(Banned by ${message.author.tag})`)
      //if there is an error we return a message, which rarely happens.
      .catch(error => message.reply(`Sorry ${message.author} I couldn't ban because of : ${error}`));
    //here, the bot says the user was successfully banned.
    message.channel.send(`${member.user.tag} was Succesfully banned.`)
  }

  if (command === "say") {
    // makes the bot say something and delete the message. As an example, it's open to anyone to use.
    // To get the "message" itself we join the `args` back into a string with spaces:
    const sayMessage = args.join(" ");
    // Then we delete the command message (sneaky, right?). The catch just ignores the error with a cute smiley thing.
    message.delete().catch(O_o => {});
    // And we get the bot to say the thing:
    message.channel.send(sayMessage);
  }

  if (command === "purge") {
    //here we see if the bot has permissions to delete messages, if not we return a message.
    if (!message.guild.me.hasPermission("MANAGE_MESSAGES")) return message.channel.send("I don't have permission to delete messages, permission needed: " + `MANAGE_MESSAGES`)
    //here we see if the message author has permissions to delete messages, if not we return a message.
    if (!message.member.hasPermission("MANAGE_MESSAGES")) return message.channel.send("you don't have permission to delete messages, permission needed: " + `MANAGE_MESSAGES`)


    // This command removes all messages from all users in the channel, up to 100.

    // get the delete count, as an actual number.
    const deleteCount = parseInt(args[0], 10);

    //here, if the amount they specify is under 2 or higher than 100 we return a message.
    if (!deleteCount || deleteCount < 2 || deleteCount > 100)
      return message.channel.send("Please provide a number between 2 and 100 for the number of messages to delete");

    // So we get our messages, and delete them. Simple enough, right?
    const fetched = await message.channel.fetchMessages({
      limit: deleteCount
    });
    //now here we delete the messages.
    message.channel.bulkDelete(fetched)
      .catch(error => message.reply(`Couldn't delete messages because of: ${error}`));
  }

  if (command === "ping") {
    // Calculates ping between sending a message and editing it, giving a nice round-trip latency.
    // The second ping is an average latency between the bot and the websocket server (one-way, not round-trip)
    //here we send a message.
    const m = await message.channel.send("Ping?");



    //up top, we sent a message that said: "Ping?" here we edit the message.
    m.edit(`:ping_pong: Pong! ` + Math.round(client.ping) + ` ms!`)
  }

  if (message.content.includes("https://")) {
    console.log("deleted " + message.content + " from " + message.author)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }
  if (message.content.includes("http://")) {
    console.log("deleted " + message.content + " from " + message.author)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }
  if (message.content.includes("www.")) {
    console.log("deleted " + message.content + " from " + message.author)
    message.delete(1);
    message.channel.sendMessage("No links here, " + message.author)
  }

  if (command === "tempmute") {
    //we see if the message author has the "MANAGE_MESSAGES" permission, if they don't we return a message.
    if (!message.member.hasPermission("MANAGE_MESSAGES")) return message.reply("You dont have permission to use this command.");

    if (!message.guild.me.hasPermission("MANAGE_ROLES")) return message.channel.send("I don't have permission to add or remove roles, permission needed: " + `MANAGE_ROLES`)
    //we get the person they're trying to mute.
    let tomute = message.guild.member(message.mentions.users.first() || message.guild.members.get(args[0]));
    //if they didn't specify a member, or don't mention a member we return a message.
    if (!tomute) return message.reply("Please specify a member from either their id, or mention them.");
    //here we see if the person they're trying to mute has permission the bot will return a message, saying I can't mute them.
    if (tomute.hasPermission("MANAGE_MESSAGES")) return message.reply("Can't mute them!");

    //we make a reason string
    let reason = args.slice(2).join(" ");
    //if they don't give a reason it will just be no reason given.
    if (!reason) reason = "no reason provided"
    //this is the mute role it self.
    let muterole = message.guild.roles.find(`name`, "Muted");
    //start of create role so, if a role named "Muted" isn't in the message guild the bot will create one.
    if (!muterole) {
      try {
        muterole = await message.guild.createRole({
          name: "muted",
          color: "#000000",
          permissions: []
        })
        message.guild.channels.forEach(async (channel, id) => {
          await channel.overwritePermissions(muterole, {
            SEND_MESSAGES: false,
            ADD_REACTIONS: false
          });
        });
      } catch (e) {
        console.log(e.stack);
      }
    }
    //end of create role
    let mutetime = args[1];
    if (!mutetime) return message.reply("You didn't specify a time!");

    message.delete().catch(O_o => {});

    try {} catch (e) {
      message.channel.send(`${tomute.user.tag} has been muted for ${mutetime}`)
    }
    //here we add the role to the specifed member.
    await (tomute.addRole(muterole.id));


    message.channel.send(`${tomute.user.tag} has been muted for ${mutetime}.`)

    setTimeout(function () {
      tomute.removeRole(muterole.id);
    }, ms(mutetime));
  }




});
client.login(config.token)
// thank you for reading this, Ryyan#2229 made this.