اكواد كثير مرة تحتاجها

const http = require('http');
const express = require('express');
const app = express();
app.get("/", (request, response) => {
  response.sendStatus(200);
});
app.listen(process.env.PORT);
setInterval(() => {
  http.get(`http://reus.glitch.me/`);
}, 280000);

// كل البكجات الي ممكن تحتجها في اي بوت
const { Client, RichEmbed } = require("discord.js");
var { Util } = require('discord.js');
const client = new Client({ disableEveryone: true})
const ytdl = require("ytdl-core");
const canvas = require("canvas");
const {prefix, developers, server, author, dev, number} = require('./config')
const Canvas = require("canvas");
const convert = require("hh-mm-ss")
const fetchVideoInfo = require("youtube-info");
const botversion = require('./package.json').version;
const simpleytapi = require('simple-youtube-api')
const moment = require("moment");
const fs = require('fs');
const util = require("util")
const gif = require("gif-search");
const opus = require("node-opus");
const ms = require("ms");
const jimp = require("jimp");
const { get } = require('snekfetch');
const guild = require('guild');
const dateFormat = require('dateformat');//npm i dateformat
const YouTube = require('simple-youtube-api');
const youtube = new YouTube('AIzaSyAdORXg7UZUo7sePv97JyoDqtQVi3Ll0b8');
const hastebins = require('hastebin-gen');
const getYoutubeID = require('get-youtube-id');
const yt_api_key = "AIzaSyDeoIH0u1e72AtfpwSKKOSy3IPp2UHzqi4";
const pretty = require("pretty-ms");
const queue = new Map();
var table = require('table').table
const Discord = require('discord.js');

client.on('ready', () => {
        console.log(`PR TEAM Growing`);
              client.user.setActivity("PR TEAM GROWING", {type: 'WATCHING'});

      });

client.on('message', message=> {
    if (message.author.bot) return;
    if (message.isMentioned(client.user))
    {
    message.channel.send(`**Developed By :** <@${dev}>`)
    }
});






client.on('message', async message => {
if (!message.channel.guild) return;

  let args = message.content.split(" ");
  if(message.content.startsWith(prefix + "mute")) {
    if(!message.member.hasPermission("MANAGE_ROLES")) return message.channel.send('').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    if(!message.guild.member(client.user).hasPermission("MANAGE_ROLES")) return message.channel.send('').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    let mention = message.mentions.members.first();
    if(!mention) return  message.channel.send('').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    if(mention.id === message.author.id) return message.channel.send('**ماتقدر تعطي ميوت لنفسك :x:**').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    if(mention.hasPermission('ADMINISTRATOR')) return message.channel.send(`**ماتقدر تعطي احد اعضاء الادارة ميوت :x:**`);

    if(message.guild.member(mention).roles.find('name', 'Muted')) return message.channel.send(`**:information_source: ${mention.user.username} Already Muted**`);


    if(mention.position >= message.guild.member(message.author).positon) return message.channel.send('**:x:مامعك صلاحية** ').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    if(mention.positon >= message.guild.member(client.user).positon) return message.channel.send('يرجى اعطاء البوت صلاحية **Muted_Members**').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    let duration = args[2];
    if(!duration) message.channel.send(`**:hash: You Can Use ${prefix}mute @user [ Time ] [ Reason] **`).then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    if(isNaN(duration))  message.channel.send('').then(msg => {
      msg.delete(3500);
      message.delete(3500);
    });

    let reason = message.content.split(" ").slice(3).join(" ");
    if(!reason) reason = " [ **No Reason.** ] ";

    let thisEmbed = new Discord.RichEmbed()
    .setAuthor(mention.user.username, mention.user.avatarURL)
    .setTitle('**You Have been Muted !!**')
    .addField('**Server**',[ message.guild.name ])
    .addField('**BY:**', [ message.author ])
    .addField('**Reason:**',reason)
    .addField('**Time:**',duration)

    let role = message.guild.roles.find('name', 'Muted') || message.guild.roles.get(r => r.name === 'Muted');
    if(!role) try {
      message.guild.createRole({
        name: "Muted",
        permissions: 0
      }).then(r => {
        message.guild.channels.forEach(c => {
          c.overwritePermissions(r , {
            SEND_MESSAGES: false,
            READ_MESSAGES_HISTORY: false,
            ADD_REACTIONS: false
          });
        });
      }); //kinggamer حقوق الفا كودز و
    } catch(e) {
      console.log(e.stack);
    }
    mention.addRole(role).then(() => {
      mention.send(thisEmbed);
      message.channel.send(`**:ballot_box_with_check: | ${mention.user.username}  Muted !**`);
      mention.setMute(true); //kinggamer حقوق الفا كودز و
    });
    setTimeout(() => {
      if(duration === 0) return;
      mention.setMute(false);
      mention.removeRole(role)
    },duration * 60000); //kinggamer حقوق الفا كودز و
  }
});




client.on('message', async message => {
    let mention = message.mentions.members.first();
let command = message.content.split(" ")[0];
     command = command.slice(prefix.length);
    let args = message.content.split(" ").slice(1);  //kinggamer حقوق الفا كودز و
if(command === `unmute`) {2
  if(!message.member.hasPermission("MANAGE_ROLES")) return message.channel.sendMessage("**مامعك صلاحية Mute_Members**").then(m => m.delete(5000));
if(!message.guild.member(client.user).hasPermission("MANAGE_ROLES")) return message.reply("**البوت لايمتلك صلاحية Mute_Members**").then(msg => msg.delete(6000))

  let kinggamer = message.guild.member(message.mentions.users.first()) || message.guild.members.get(args[0]);
     if(!kinggamer) return message.channel.send('').then(msg => {
      msg.delete(3500);
      message.delete(3500); //kinggamer حقوق الفا كودز و
    });

  let role = message.guild.roles.find (r => r.name === "Muted");

  if(!role || !kinggamer.roles.has(role.id)) return message.channel.sendMessage(`**:information_source: | ${mention.user.username} is all ready unmuted**`)

  await kinggamer.removeRole(role) //kinggamer حقوق الفا كودز و
  message.channel.sendMessage(`**:ballot_box_with_check: | ${mention.user.username}  UnMuted !**`);

  return;

  }

});

client.on('message', message => {
    if (message.author.bot) return;
if (message.content.startsWith(prefix + 'clear')) { //Codes
    if(!message.channel.guild) return message.reply('? | This Command For Servers Only!');
        if(!message.member.hasPermission('MANAGE_MESSAGES')) return message.channel.send('? | You dont have **MANAGE_MESSAGES** Permission!');
        if(!message.guild.member(client.user).hasPermission('MANAGE_MESSAGES')) return message.channel.send('? | I dont have **MANAGE_MESSAGES** Permission!');
 let args = message.content.split(" ").slice(1)
    let messagecount = parseInt(args);
    if (args > 99) return message.reply("**?? || يجب ان يكون عدد المسح أقل من 100 .**").then(messages => messages.delete(5000))
    if(!messagecount) args = '100';
    message.channel.fetchMessages({limit: messagecount + 1}).then(messages => message.channel.bulkDelete(messages));
    message.channel.send(`\`${args}\` : __عدد الرسائل التي تم مسحها __ `).then(messages => messages.delete(5000));
  }
  }); //Julian

//_____________________________________KICK__BAN____________________________________
//_____________________________________KICK__BAN____________________________________
//_____________________________________KICK__BAN____________________________________

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

  if (message.author.zaid) return;
  if (!message.content.startsWith(prefix)) return;

  let command = message.content.split(" ")[0];
  command = command.slice(prefix.length);

  let args = message.content.split(" ").slice(1);

  if (command == "kick") {
               if(!message.channel.guild) return;

  if(!message.guild.member(message.author).hasPermission("KICK_MEMBERS")) return message.reply("You Don't Have KICK_MEMBERS Permission").then(msg => msg.delete(5000));
  if(!message.guild.member(client.user).hasPermission("KICK_MEMBERS")) return message.reply("I Don't Have KICK_Members Permission");
  let user = message.mentions.users.first();
  let reason = message.content.split(" ").slice(2).join(" ");

  if (message.mentions.users.size < 1) return message.reply("type the user to kick");
  if(!reason) return message.reply (":x: Type the Reason !");
  if (!message.guild.member(user)
  .bannable) return message.reply("I can not kick who are above me :(");

  message.guild.member(user).kick(7, user);

message.channel.send(`**:ballot_box_with_check: | ${user.tag} Kicked from the server !**`)
}
});



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

  if (message.author.zaid) return;
  if (!message.content.startsWith(prefix)) return;

  let command = message.content.split(" ")[0];
  command = command.slice(prefix.length);

  let args = message.content.split(" ").slice(1);

  if (command == "ban") {
             if (!message.channel.guild) return;

  if(!message.guild.member(message.author).hasPermission("BAN_MEMBERS")) return message.reply("**You Dont have permissions.**");
  if(!message.guild.member(client.user).hasPermission("BAN_MEMBERS")) return message.reply("**I Don't Have ` BAN_MEMBERS ` Permission**");
  let user = message.mentions.users.first();

  if (message.mentions.users.size < 1) return message.reply("**Mention the member.**");
  if (!message.guild.member(user)
  .bannable) return message.reply("**The Bot Role must be above the given player role.**");


  message.guild.member(user).ban(7, user);

message.channel.send(`**:ballot_box_with_check: | ${user.tag} Banned from the server !**  `)

}
});





//_____________________________________KVOICE____________________________________
//_____________________________________KVOICE____________________________________
//_____________________________________KVOICE____________________________________

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

    var command = message.content.split(" ")[0];

    if(command == prefix + "kvoice"){

        if (!message.guild.member(message.author).hasPermission('MOVE_MEMBERS') || !message.guild.member(message.author).hasPermission('ADMINISTRATOR')) {
            return message.reply('you do not have permission to perform this action!');
        }

        var member = message.guild.members.get(message.mentions.users.array()[0].id);
        if(!message.mentions.users){
            message.reply("please mention the member")
            return;
        }

    if(!member.voiceChannel){
    message.reply("i can't include voice channel for member!")
    return;
    }
              message.guild.createChannel('voicekick', 'voice').then(c => {
                member.setVoiceChannel(c).then(() => {
                    c.delete(305).catch(console.log)




      });
     });
    }
});



//_______________________________________ROLES____________________________________
//_______________________________________ROLES____________________________________
//_______________________________________ROLES____________________________________


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

    var args = message.content.split(' ').slice(1);
    var msg = message.content.toLowerCase();
    if( !message.guild ) return;
    if( !msg.startsWith( prefix + 'role' ) ) return;
    if( msg.toLowerCase().startsWith( prefix + 'roleremove' ) ){

        if(!message.member.hasPermission('ADMINISTRATOR')) return;
        if( !args[0] ) return message.channel.send( '**:x: | Please put the person to be Withdrawal the rank**.' );
        if( !args[1] ) return message.channel.send( '**:x: | Please place the rank to be withdrawn from the person**.' );
        var role = msg.split(' ').slice(2).join(" ").toLowerCase();
        var role1 = message.guild.roles.filter( r=>r.name.toLowerCase().indexOf(role)>-1 ).first();
        if( !role1 ) return message.channel.send( '**:x: | Please place the rank to be withdrawn from the person**.' );
        if( message.mentions.members.first() ){
            message.mentions.members.first().removeRole( role1 );
            return message.channel.send('**? Removed Role**  __'+role1.name+'__ **From** __'+args[0]+'__.');
        }
        if( args[0].toLowerCase() == "all" ){
            if(!message.member.hasPermission('ADMINISTRATOR')) return;
            message.guild.members.forEach(m=>m.removeRole( role1 ))
            return    message.channel.send('**? Removed role** __ '+role1.name+'__ **From all**.');
        } else if( args[0].toLowerCase() == "bots" ){
            message.guild.members.filter(m=>m.user.bot).forEach(m=>m.removeRole(role1))
            return    message.channel.send('**? Removed role** __ '+role1.name+'__ **From Bots**.');
        } else if( args[0].toLowerCase() == "humans" ){
            message.guild.members.filter(m=>!m.user.bot).forEach(m=>m.removeRole(role1))
            return    message.channel.send('**? Removed role** __ '+role1.name+'__ **From Humans**.');
        }
    } else {
        if(!message.member.hasPermission('ADMINISTRATOR')) return;
        if( !args[0] ) return message.channel.send( '**:x: | Please put the person to be given the rank**.' ); //rank
        if( !args[1] ) return message.channel.send( '**:x: | Please specify the role to be given to the person**.' ); // Person
        var role = msg.split(' ').slice(2).join(" ").toLowerCase();
        var role1 = message.guild.roles.filter( r=>r.name.toLowerCase().indexOf(role)>-1 ).first();
        if( !role1 ) return message.channel.send( '**:x: | Please specify the role to be given to the person**.' );if( message.mentions.members.first() ){
            message.mentions.members.first().addRole( role1 );
            return message.channel.send('**?** __'+args[0]+' __  **was given role** __ '+role1.name+'__ .');
        }
        if( args[0].toLowerCase() == "all" ){
            if(!message.member.hasPermission('ADMINISTRATOR')) return;
            message.guild.members.forEach(m=>m.addRole( role1 ))
            return    message.channel.send('**? All was given role** __'+role1.name+' __ .');
        } else if( args[0].toLowerCase() == "bots" ){
            if(!message.member.hasPermission('ADMINISTRATOR')) return;
            message.guild.members.filter(m=>m.user.bot).forEach(m=>m.addRole(role1))
            return    message.channel.send('**? Bots was given role** __'+role1.name+' __ .');
        } else if( args[0].toLowerCase() == "humans" ){
            if(!message.member.hasPermission('ADMINISTRATOR')) return;
            message.guild.members.filter(m=>!m.user.bot).forEach(m=>m.addRole(role1))
            return    message.channel.send('**? Humans was given role** __'+role1.name+' __ .');
        }
    }
});








//______________________________HCHANNEL__________________________________
//______________________________HCHANNEL__________________________________
//______________________________HCHANNEL__________________________________



client.on('ready', () => {
  console.log('I am ready!');
  });

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

      if(message.content === prefix + "hchannel") {
if (!message.channel.guild) return;
      if(!message.member.hasPermission('ADMINISTRATOR')) return message.reply('You Dont Have Perms :x:');
             message.channel.overwritePermissions(message.guild.id, {
             READ_MESSAGES: false
 })
              message.channel.send('Channel Hided Successfully ! :white_check_mark:  ')
 }
});


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

      if(message.content === prefix + "schannel") {
if (!message.channel.guild) return;
      if(!message.member.hasPermission('ADMINISTRATOR')) return message.reply(':x:');
             message.channel.overwritePermissions(message.guild.id, {
             READ_MESSAGES: true
 })
              message.channel.send('Done  ')
 }
});



//______________________________MUTEC__________________________________
//______________________________MUTEC__________________________________
//______________________________MUTEC__________________________________


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

       if(message.content === prefix + "mutec") {
                           if (!message.channel.guild) return;

   if(!message.member.hasPermission('MANAGE_MESSAGES')) return message.reply(' **You Dont Have Perms**');
              message.channel.overwritePermissions(message.guild.id, {
            SEND_MESSAGES: false

              }).then(() => {
                  message.reply("**:white_check_mark: Success Has Been Locked Channel**")
              });
                }
    if(message.content === prefix + "unmutec") {
                        if (!message.channel.guild) return;

   if(!message.member.hasPermission('MANAGE_MESSAGES')) return message.reply('**You Dont Have Perms**');
              message.channel.overwritePermissions(message.guild.id, {
            SEND_MESSAGES: true

              }).then(() => {
                  message.reply("**:white_check_mark: Success Has Been UnLocked Channel**")
              });
    }

});







//______________________________MOVE__________________________________
//______________________________MOVE__________________________________
//______________________________MOVE__________________________________


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

if (!message.channel.guild) return;
if(message.content.startsWith(prefix + 'move')) {
 if (message.member.hasPermission("MOVE_MEMBERS")) {
 if (message.mentions.users.size === 0) {
 return message.channel.send("``Use : " +prefix+ "move @User``")
}
if (message.member.voiceChannel != null) {
 if (message.mentions.members.first().voiceChannel != null) {
 var authorchannel = message.member.voiceChannelID;
 var usermentioned = message.mentions.members.first().id;
var embed = new Discord.RichEmbed()
 .setTitle("Succes!")
 .setColor("#000000")
 .setDescription(`? You Have Moved <@${usermentioned}> To Your Channel`)
var embed = new Discord.RichEmbed()
.setTitle(`You are Moved in ${message.guild.name}`)
 .setColor("RANDOM")
.setDescription(`**<@${message.author.id}> Moved You To His Channel!\nServer --> ${message.guild.name}**`)
 message.guild.members.get(usermentioned).setVoiceChannel(authorchannel).then(m => message.channel.send(embed))
message.guild.members.get(usermentioned).send(embed)
} else {
message.channel.send("`You Cant Move"+ message.mentions.members.first() +" `The User Should Be In channel To Move It`")
}
} else {
 message.channel.send("**``You Should Be In Room Voice To Move SomeOne``**")
}
} else {
message.react("?")
 }}});


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

    if(message.content.startsWith(prefix + 'mvall')) {
     if (!message.member.hasPermission("MOVE_MEMBERS")) return message.channel.send('**:x: You Dont Have Perms `MOVE_MEMBERS`**');
       if(!message.guild.member(client.user).hasPermission("MOVE_MEMBERS")) return message.reply("**:x: I Dont Have Perms `MOVE_MEMBERS`**");
    if (message.member.voiceChannel == null) return message.channel.send(`**You Have To Be In Room Voice**`)
     var author = message.member.voiceChannelID;
     var m = message.guild.members.filter(m=>m.voiceChannel)
     message.guild.members.filter(m=>m.voiceChannel).forEach(m => {
     m.setVoiceChannel(author)
     })
     message.channel.send(`**:white_check_mark: Success Moved All To Your Channel**`)


     }
       });




//__________________________________DC,DR_________________________________
//__________________________________DC,DR_________________________________
//__________________________________DC,DR_________________________________



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

if(omar.content.split(' ')[0] == prefix + 'dc') {  // delete all channels
if (!omar.channel.guild) return;
if(!omar.guild.member(omar.author).hasPermission("MANAGE_CHANNELS")) return omar.reply("**You Don't Have ` MANAGE_CHANNELS ` Permission**");
if(!omar.guild.member(client.user).hasPermission("MANAGE_CHANNELS")) return omar.reply("**I Don't Have ` MANAGE_CHANNELS ` Permission**");
omar.guild.channels.forEach(m => {
m.delete();
});// omar jedol / Codes
}// omar jedol / Codes
if(omar.content.split(' ')[0] == prefix + 'dr') { // delete all roles
if (!omar.channel.guild) return;
if(!omar.guild.member(omar.author).hasPermission("MANAGE_ROLES_OR_PERMISSIONS")) return omar.reply("**You Don't Have ` MANAGE_ROLES_OR_PERMISSIONS ` Permission**");
if(!omar.guild.member(client.user).hasPermission("MANAGE_ROLES_OR_PERMISSIONS")) return omar.reply("**I Don't Have ` MANAGE_ROLES_OR_PERMISSIONS ` Permission**");
omar.guild.roles.forEach(m => {
m.delete();
});// omar jedol / Codes
omar.reply("? `Success Deleted All Roles - Ranks`")
}// omar jedol / Codes
});






//_____________________________________TICKET_____________________________________//
//_____________________________________TICKET_____________________________________//
//_____________________________________TICKET_____________________________________//


let mtickets   = true;
let tchannels  = [];
let current    = 0;
const hero     = new Discord.Client();


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

  let CH = client.guilds.get(`${server}`).emojis.find(r => r.name === "check");
  let CR = client.guilds.get(`${server}`).emojis.find(r => r.name === "cross");
    if(message.author.bot || message.channel.type === 'dm') return;
    let args = message.content.split(" ");
    let author = message.author.id;


    if(args[0].toLowerCase() === prefix + `-help`) {
if (!message.channel.guild) return;
            let embed = new Discord.RichEmbed()
            .setAuthor(message.author.username, message.author.avatarURL)
            .setThumbnail(message.author.avatarURL)
            .setColor("#36393e")
            .addField(`? \`${prefix}new\``, `» Usage : \`${prefix}new [Reason]\`\n» Description: **Creates a new ticket.**`)
            .addField(`? لإيقاف الأعضاء من عمل تكتات, \`${prefix}tickets\``, `» Syntax: \`${prefix}tickets [Disable/Enable]\`\n» Description: **لجعل جميع اعضاء السيرفر غير قادرون على عمل تكت.**`)
      .addField(`? لأقفال جميع التكتات المفتوحة, \`${prefix}closeall\``, `» Syntax: \`${prefix}closeall\`\n» Description: **لمسح جميع رومات التكتات المفتوحة في السيرفر**`)
            .addField(`? لقفل التكت المفتوح, \`${prefix}close\``, `» Syntax: \`${prefix}close\`\n» Description: **لأقفال تكت.**\n`)
            await message.channel.send(`${CH}, **هذه قائمة بجميع اوامر البووت.**`);
            await message.channel.send(embed);
    } else if(args[0].toLowerCase() === `${prefix}new`) {
        if(mtickets === false) return message.channel.send(`**${CR} | Sorry , but tickets are disabled right now.**`);
        if(!message.guild.me.hasPermission("MANAGE_CHANNELS")) return message.channel.send(`**${CR} | The Bot don't have a permissions to create a ticket. **`);
      if (!message.guild.roles.exists("name", "ticket")) return message.channel.send(`**${CR} | You have to create a role with the name \`ticket\` .**`);
    console.log(current);
    let openReason = " ";
    current++;
      message.guild.createChannel(`ticket-${current}`, 'text').then(c => {
    tchannels.push(c.id);
        const reason = message.content.split(" ").slice(1).join(" ");

            let role = message.guild.roles.find("name", "ticket");
            let role2 = message.guild.roles.find("name", "@everyone");
//            let role3 = message.guild.roles.find("name", "Blacklist");
            c.overwritePermissions(role, {
                SEND_MESSAGES: true,
                READ_MESSAGES: true
            });
            c.overwritePermissions(role2, {
                SEND_MESSAGES: false,
                READ_MESSAGES: false
            });
            c.overwritePermissions(message.author, {
                SEND_MESSAGES: true,
                READ_MESSAGES: true
            });

            const embed1 = new Discord.RichEmbed()

            //.setFooter('Requested by '+message.author.username, message.author.avatarURL)
            .setDescription(`**${CH} | Created Your ticket , <#${c.id}> .**`)

            .setColor(0x36393e)
            message.channel.sendEmbed(embed1);
            if (!args)return;
      //if(args[1]) openReason = `\nسبب فتح التكت ,  **${args.slice(1).join(" ")}** "`;
            //message.channel.send(`**${CH} | Created Your ticket , <#${c.id}> .**`);
            const embed = new Discord.RichEmbed()
          //.setFooter('Requested by '+message.author.username, message.author.avatarURL)
                .setColor(0x36393e)
               /* .addField(`Hey ${message.author.username}!`, `**
Please wait until our \`Support Team\` answer you.
Try to explain why you opened this ticket with as much detail as possible.
Open Reason : __ ${args.slice(1).join(" ")} __
NOTE : If now anyone answered you , contact them on DM !
**`)  */
                .addField(`Hey ${message.author.username}!`, `**
Please wait until our \`support team\` answer you.
Try to explain why you opened this ticket with as much detail as possible.
Open Reason : __ ${args.slice(1).join(" ")} __
NOTE : If now anyone answered you , contact them on DM !
**`)
                .setTimestamp();
            c.send({
                embed: embed
            });
        }).catch(console.error);
    //}
/*
    if(args[1]) openReason = `\nسبب فتح التكت , " **${args.slice(1).join(" ")}** "`;
    let embed = new Discord.RichEmbed()
    .setAuthor(message.author.username, message.author.avatarURL)
    .setColor("#36393e")
    .setDescription(`**انتظر قليلا الى حين رد الادارة عليك**${openReason}`);
    c.send(`${message.author}`);
    c.send(embed); */
  //});
    } else if(args[0].toLowerCase() === `${prefix}tickets`) {
        if(!message.member.hasPermission("MANAGE_GUILD")) return message.channel.send(`**${CR} | You aren't from the server staff to use this command.**`);
    if(args[1] && args[1].toLowerCase() === "enable") {
      mtickets = true;
      message.channel.send(`**${CH} | Tickets now are enabled to create.**`);
    } else if(args[1] && args[1].toLowerCase() === "disable") {
      mtickets = false;
      message.channel.send(`**${CH} | Tickets now are disabled to create.**`);
    } else if(!args[1]) {
      if(mtickets === true) {
      mtickets = false;
      message.channel.send(`**${CH} | Tickets now are disabled to create.**`);
      } else if(mtickets === false) {
      mtickets = true;
      message.channel.send(`**${CH} | Tickets now are enabled to create.**`);
      }
    }
    } else if(args[0].toLowerCase() === `${prefix}close`) {
    if(!message.member.hasPermission("MANAGE_GUILD")) return message.channel.send(`**${CR} | You aren't from the server staff to use this command.**`);
    if(!message.channel.name.startsWith('ticket-') && !tchannels.includes(message.channel.id)) return message.channel.send(`${CR} | This command can be done only on tickts.`);

    message.channel.send(`** | The ticket will be closed in \`5\` Secounds.**`);
    tchannels.splice( tchannels.indexOf(message.channel.id), 1 );
    setTimeout(() => message.channel.delete(), 5000);
  } else if(args[0].toLowerCase() === `${prefix}restart`) {
    if(!developers.includes(message.author.id)) return message.channel.send(`**${CR} | You aren't from the server staff to use this command.**`);
    message.channel.send(`**${CH} | Restarting ... **`);
    hero.destroy();
  } else if(args[0].toLowerCase() === `${prefix}closeall`) {
    let iq = 0;
    for(let q = 0; q < tchannels.length; q++) {
      let c = message.guild.channels.get(tchannels[q]);
      if(c) {
        c.delete();
        tchannels.splice( tchannels[q], 1 );
        iq++;
      }
      if(q === tchannels.length - 1 || q === tchannels.lengh + 1) {
        message.channel.send(`**${CH} | Closed \`${iq}\` Tickets.**`);  //${CH}, **تم مسح \`${iq}\` من التكتات.**
      }
    }
  }
});



//_____________________________________BC_____________________________________//
//_____________________________________BC_____________________________________//
//_____________________________________BC_____________________________________//

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

if (message.author.id === client.user.id) return;
if (message.guild) {
let embed = new Discord.RichEmbed()
let args = message.content.split(' ').slice(1).join(' ');
if(message.content.split(' ')[0] == prefix + 'obc') {
if(!message.channel.guild) return message.reply('**:x: اسف لكن هذا الامر للسيرفرات فقط **');
if (!args[1]) {
return;
}
  message.guild.members.forEach(m => {
if(!message.member.hasPermission('sendMessage')) return;
      var bc = new Discord.RichEmbed()
      .addField('# | الرسالة ', args)
      .setThumbnail(message.guild.iconURL)
      .setColor('RANDOM')
      m.sendMessage(args)
  });
         if(!message.member.hasPermission('sendMessage')) return message.reply(":x: **ليس لديك صلاحية للنشر هنا**");
  const AziRo = new Discord.RichEmbed()
  .setColor('RANDOM')
  message.channel.sendEmbed(AziRo);
}
} else {
  return;
}
});
client.on("message", message => {

            if (message.content.startsWith(prefix + "bc")) {
                         if (!message.member.hasPermission("sendMessage"))  return;
  let args = message.content.split(" ").slice(1);
  var argresult = args.join(' ');
  message.guild.members.filter(m => m.presence.status !== 'offline').forEach(m => {
 m.send(`${argresult}\n ${m}`);
})
 message.channel.send(`\`${message.guild.members.filter(m => m.presence.status !== 'online').size}\` : عدد الاعضاء المستلمين`);
 message.delete();
};
});


//___________________________________________PROTECT___________________________________________
//___________________________________________PROTECT___________________________________________
//___________________________________________PROTECT___________________________________________


let anti = JSON.parse(fs.readFileSync("./antigreff.json", "UTF8"));
let con = JSON.parse(fs.readFileSync("./config.json", "UTF8"));

client.on("message", message => {
      if (!developers.includes(message.author.id)) return;
    if(!message.channel.guild) return;
    let user = anti[message.guild.id+message.author.id]
    let num = message.content.split(" ").slice(1).join(" ");
    if(!anti[message.guild.id+message.author.id]) anti[message.guild.id+message.author.id] = {
        actions: 0
    }
    if(!con[message.guild.id]) con[message.guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3,
        time: 30
    }
if(message.content.startsWith(prefix + "limit")) {


    if(!message.member.hasPermission('MANAGE_GUILD')) return;
    if(message.content.startsWith(prefix + "limitbans")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].banLimit = num;
        message.channel.send(`**? | Changed bans limit to : ${con[message.guild.id].banLimit}.**`)
    }
    if(message.content.startsWith(prefix + "limitkicks")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].kickLimits = num;
        message.channel.send(`**? | Changed kicks limit to : ${con[message.guild.id].kickLimits}.**`)
    }
    if(message.content.startsWith(prefix + "limitroleD")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].roleDelLimit = num;
        message.channel.send(`**? | Changed Role Deleting limit to : ${con[message.guild.id].roleDelLimit}.**`)
    }
    if(message.content.startsWith(prefix + "limitroleC")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].roleCrLimits = num;
        message.channel.send(`**? | Changed Role Creation limit to : ${con[message.guild.id].roleCrLimits}.**`)
    }
    if(message.content.startsWith(prefix + "limitchannelD")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].chaDelLimit = num;
        message.channel.send(`**? | Changed Channel Deleting limit to : ${con[message.guild.id].chaDelLimit}.**`)
    }
    if(message.content.startsWith(prefix + "limittimes")) {
        if(!num) return message.channel.send("**? | Supply a number !**");
        if(isNaN(num)) return message.channel.send("**? | Supply a number !**");
        con[message.guild.id].time = num;
        message.channel.send(`**? | Changed Times limit to : ${con[message.guild.id].time}.**`)
    }
    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
}
});
client.on("channelDelete", async channel => {
    const entry1 = await channel.guild.fetchAuditLogs({type: 'CHANNEL_DELETE'}).then(audit => audit.entries.first())
    console.log(entry1.executor.username)
    const entry = entry1.executor
    if(!con[channel.guild.id]) con[channel.guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3
    }
    if(!anti[channel.guild.id+entry.id]) {
    anti[channel.guild.id+entry.id] = {
        actions: 1
        }
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
    } else {
        anti[channel.guild.id+entry.id].actions = Math.floor(anti[channel.guild.id+entry.id].actions+1)
        console.log("TETS");
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
        if(anti[channel.guild.id+entry.id].actions >= con[channel.guild.id].chaDelLimit) {
            channel.guild.members.get(entry.id).ban().catch(e => channel.guild.owner.send(`**? | ${entry.username} | Deleted Many Channels on your server! **`))
            anti[channel.guild.id+entry.id].actions = "0"
            fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
    if(e) throw e;
});
fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
    if(e) throw e;
});
        }
    }

    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
});

client.on("roleDelete", async channel => {
    const entry1 = await channel.guild.fetchAuditLogs({type: 'ROLE_DELETE'}).then(audit => audit.entries.first())
    console.log(entry1.executor.username)
    const entry = entry1.executor
    if(!con[channel.guild.id]) con[channel.guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3
    }
    if(!anti[channel.guild.id+entry.id]) {
    anti[channel.guild.id+entry.id] = {
        actions: 1
        }
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
    } else {
        anti[channel.guild.id+entry.id].actions = Math.floor(anti[channel.guild.id+entry.id].actions+1)
        console.log("TETS");
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
        if(anti[channel.guild.id+entry.id].actions >= con[channel.guild.id].roleDelLimit) {
            channel.guild.members.get(entry.id).ban().catch(e => channel.guild.owner.send(`**? | ${entry.username} | Deleted Many Roles on your server! **`))
            anti[channel.guild.id+entry.id].actions = "0"
            fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
    if(e) throw e;
});
fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
    if(e) throw e;
});
        }
    }

    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
});

client.on("roleCreate", async channel => {
    const entry1 = await channel.guild.fetchAuditLogs({type: 'ROLE_CREATE'}).then(audit => audit.entries.first())
    console.log(entry1.executor.username)
    const entry = entry1.executor
    if(!con[channel.guild.id]) con[channel.guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3
    }
    if(!anti[channel.guild.id+entry.id]) {
    anti[channel.guild.id+entry.id] = {
        actions: 1
        }
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
    } else {
        anti[channel.guild.id+entry.id].actions = Math.floor(anti[channel.guild.id+entry.id].actions+1)
        console.log("TETS");
        setTimeout(() => {
            anti[channel.guild.id+entry.id].actions="0"
        }, con[channel.guild.id].time*1000)
        if(anti[channel.guild.id+entry.id].actions >= con[channel.guild.id].roleCrLimits) {
            channel.guild.members.get(entry.id).ban().catch(e => channel.guild.owner.send(`**? | ${entry.username} | Created Many Roles on your server! **`))
            anti[channel.guild.id+entry.id].actions = "0"
            fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
    if(e) throw e;
});
fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
    if(e) throw e;
});
        }
    }

    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
});

client.on("guildBanAdd", async (guild, user) => {
    const entry1 = await channel.guild.fetchAuditLogs({type: 'MEMBER_BAN_ADD'}).then(audit => audit.entries.first())
    console.log(entry1.executor.username)
    const entry = entry1.executor
    if(!con[guild.id]) con[guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3
    }
    if(!anti[guild.id+entry.id]) {
    anti[guild.id+entry.id] = {
        actions: 1
        }
        setTimeout(() => {
            anti[guild.id+entry.id].actions="0"
        }, con[guild.id].time*1000)
    } else {
        anti[guild.id+entry.id].actions = Math.floor(anti[guild.id+entry.id].actions+1)
        console.log("TETS");
        setTimeout(() => {
            anti[guild.id+entry.id].actions="0"
        }, con[guild.id].time*1000)
        if(anti[guild.id+entry.id].actions >= con[guild.id].banLimit) {
            channel.members.get(entry.id).ban().catch(e => channel.owner.send(`**? | ${entry.username} | Banned Many Members on your server! **`))
            anti[guild.id+entry.id].actions = "0"
            fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
    if(e) throw e;
});
fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
    if(e) throw e;
});
        }
    }

    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
});

client.on("guildKickAdd", async (guild, user) => {
    const entry1 = await channel.fetchAuditLogs({type: 'MEMBER_KICK'}).then(audit => audit.entries.first())
    console.log(entry1.executor.username)
    const entry = entry1.executor
    if(!con[guild.id]) con[guild.id] = {
        banLimit: 3,
        chaDelLimit: 3,
        roleDelLimit: 3,
        kickLimits: 3,
        roleCrLimits: 3
    }
    if(!anti[guild.id+entry.id]) {
    anti[guild.id+entry.id] = {
        actions: 1
        }
        setTimeout(() => {
            anti[guild.id+entry.id].actions="0"
        }, con[guild.id].time*1000)
    } else {
        anti[guild.id+entry.id].actions = Math.floor(anti[guild.id+entry.id].actions+1)
        console.log("TETS");
        setTimeout(() => {
            anti[guild.id+entry.id].actions="0"
        }, con[guild.id].time*1000)
        if(anti[guild.id+entry.id].actions >= con[guild.id].banLimit) {
            channel.members.get(entry.id).ban().catch(e => channel.owner.send(`**? | ${entry.username} | Kicked Many Members on your server! **`))
            anti[guild.id+entry.id].actions = "0"
            fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
    if(e) throw e;
});
fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
    if(e) throw e;
});
        }
    }

    fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
});

client.on("guildMemberRemove", async member => {
    const entry1 = await member.guild.fetchAuditLogs().then(audit => audit.entries.first())
    if(entry1.action === "MEMBER_KICK") {
        const entry2 = await member.guild.fetchAuditLogs({type: "MEMBER_KICK"}).then(audit => audit.entries.first())
        const entry = entry2.executor;
        if(!con[member.guild.id]) con[guild.id] = {
            banLimit: 3,
            chaDelLimit: 3,
            roleDelLimit: 3,
            kickLimits: 3,
            roleCrLimits: 3
        }
        if(!anti[member.guild.id+entry.id]) {
        anti[member.guild.id+entry.id] = {
            actions: 1
            }
            setTimeout(() => {
                anti[member.guild.id+entry.id].actions="0"
            }, con[member.guild.id].time*1000)
        } else {
            anti[member.guild.id+entry.id].actions = Math.floor(anti[member.guild.id+entry.id].actions+1)
            console.log("TETS");
            setTimeout(() => {
                anti[member.guild.id+entry.id].actions="0"
            }, con[member.guild.id].time*1000)
            if(anti[member.guild.id+entry.id].actions >= con[member.guild.id].kickLimits) {
                member.members.get(entry.id).ban().catch(e => member.owner.send(`**? | ${entry.username} | Kicked Many Members on your server! **`))
                anti[member.guild.id+entry.id].actions = "0"
                fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
        if(e) throw e;
    });
    fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
        if(e) throw e;
    });
            }
        }

        fs.writeFile("./config.json", JSON.stringify(con, null, 2), function(e) {
            if(e) throw e;
        });
        fs.writeFile("./antigreff.json", JSON.stringify(anti, null, 2), function(e) {
            if(e) throw e;
        });
    }

})
       client.on('message',async message => {
        var room;
        var title;
        var duration;
        var gMembers;
        var filter = m => m.author.id === message.author.id;
        if(message.content.startsWith(prefix + "giveaway")) {
           //return message.channel.send(':heavy_multiplication_x:| **هذا الامر معطل حاليا.. ``حاول في وقت لاحق``**');
          if(!message.guild.member(message.author).hasPermission('MANAGE_GUILD')) return message.channel.send(':heavy_multiplication_x:| **يجب أن يكون لديك خاصية التعديل على السيرفر**');
          message.channel.send(`:eight_pointed_black_star:| **منشن الروم الذي تريد به القيف اواي**`).then(msgg => {
            message.channel.awaitMessages(filter, {
              max: 1,
              time: 20000,
              errors: ['time']
            }).then(collected => {
              let room = message.guild.channels.find('name', collected.first().content);
              if(!room) return message.channel.send(':heavy_multiplication_x:| **لم اقدر على ايجاد الروم المطلوب**');
              room = collected.first().content;
              collected.first().delete();
              msgg.edit(':eight_pointed_black_star:| **اكتب مدة القيف اواي**').then(msg => {
                message.channel.awaitMessages(filter, {
                  max: 1,
                  time: 20000,
                  errors: ['time']
                }).then(collected => {
                  if(isNaN(collected.first().content)) return message.channel.send(':heavy_multiplication_x:| **يجب عليك ان تحدد وقت زمني صحيح.. ``يجب عليك اعادة كتابة الامر``**');
                  duration = collected.first().content * 60000;
                  collected.first().delete();
                  msgg.edit(':eight_pointed_black_star:| **واخيرا اكتب على ماذا تريد القيف اواي**').then(msg => {
                    message.channel.awaitMessages(filter, {
                      max: 1,
                      time: 20000,
                      errors: ['time']
                    }).then(collected => {
                      title = collected.first().content;
                      collected.first().delete();
                      try {
                        let giveEmbed = new Discord.RichEmbed()
                        .setAuthor(message.guild.name, message.guild.iconURL)
                        .setTitle(title)
                        .setDescription(`المدة : ${duration / 60000} دقائق`)
                        .setFooter(message.author.username, message.author.avatarURL);
                        message.guild.channels.find('name', room).send(giveEmbed).then(m => {
                           let re = m.react('??');
                           setTimeout(() => {
                             let users = m.reactions.get("??").users;
                             let list = users.array().filter(u => u.id !== m.author.id);
                             let gFilter = list[Math.floor(Math.random() * list.length) + 0];
                               if(users.size === 1) gFilter = '**لم يتم التحديد**';
                             let endEmbed = new Discord.RichEmbed()
                             .setAuthor(message.author.username, message.author.avatarURL)
                             .setTitle(title)
                             .addField('انتهى القيف اواي !',`الفائز هو : ${gFilter}`)
                             .setFooter(message.guild.name, message.guild.iconURL);
                             m.edit(endEmbed);
                           },duration);
                         });
                        msgg.edit(`:heavy_check_mark:| **تم اعداد القيف اواي**`);
                      } catch(e) {
                        msgg.edit(`:heavy_multiplication_x:| **لم اقدر على اعداد القيف اواي بسبب نقص الخصائص**`);
                        console.log(e);
                      }
                    });
                  });
                });
              });
            });
          });
        }
      });




//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************


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

if(message.content.startsWith(prefix +"server")){
if (!message.channel.guild) return;
var millis = new Date().getTime() - message.guild.createdAt.getTime();
var now = new Date();
dateFormat(now, 'dddd, mmmm dS, yyyy, h:MM:ss TT');
var verificationLevels = ['None', 'Low', 'Medium', 'Insane', 'Extreme'];
var days = millis / 1000 / 60 / 60 / 24;
let roles = client.guilds.get(message.guild.id).roles.map(r => r.name);
var embed  = new Discord.RichEmbed()
.setAuthor(message.guild.name, message.guild.iconURL)
.addField("**?? Server ID:**", message.guild.id,true)
.addField("**?? Created On**", message.guild.createdAt.toLocaleString(),true)
.addField("**?? Owned by**",`${message.guild.owner.user.username}#${message.guild.owner.user.discriminator}`)
.addField("?? Members ",`[${message.guild.memberCount}]`,true)
.addField('**?? Channels **',`**${message.guild.channels.filter(m => m.type === 'text').size}**` + ' text | Voice  '+ `**${message.guild.channels.filter(m => m.type === 'voice').size}** `,true)
.addField("**?? Others **" , message.guild.region,true)
.addField("** ?? Roles **",`**[${message.guild.roles.size}]** Role `,true)
.setColor('#000000')
message.channel.sendEmbed(embed)

}
});



//***********ID***********
//***********ID***********
//***********ID***********


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

    if(message.content === prefix + "id"){
      var embed = new Discord.RichEmbed()
      .setTitle(message.author.tag, message.author.avatarURL)
      .addField(`User`, message.author.username)
      .addField(`Discrim`,`#`+ message.author.discriminator)
      .addField(`Game`,message.author.presence.game ||"Idel.")
      .addField(`Status`,message.author.presence.status)
      message.channel.send(embed);
    }
  });


//***********USER***********
//***********USER***********
//***********USER***********

client.on('message', message => {
           if (message.content.startsWith(prefix + "user")) {
     var args = message.content.split(" ").slice(1);
     let user = message.mentions.users.first();
     var men = message.mentions.users.first();
        var heg;
        if(men) {
            heg = men
        } else {
            heg = message.author
        }
      var mentionned = message.mentions.members.first();
         var h;
        if(mentionned) {
            h = mentionned
        } else {
            h = message.member
        }
               moment.locale('en-TN');
      var id = new  Discord.RichEmbed()
      .setAuthor(message.author.username, message.author.avatarURL)
    .setColor("#707070")
    .addField('Registered :', `${moment(heg.createdTimestamp).format('YYYY/M/D HH:mm:ss')} **\n** \`${moment(heg.createdTimestamp).fromNow()}\`` ,true)
    .addField('Joined :', `${moment(h.joinedAt).format('YYYY/M/D HH:mm:ss')} \n \`${moment(h.joinedAt).fromNow()}\``, true)
    .setThumbnail(heg.avatarURL);
    message.channel.send(id)
}
  });





//***********IMAGE***********
//***********IMAGE***********
//***********IMAGE***********


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


          if(!message.channel.guild) return;
   if(message.author.bot) return;
      if(message.content === prefix + "image"){
          var embed = new Discord.RichEmbed()

      .setTitle(`This is  ** ${message.guild.name} **  Photo !`)
  .setAuthor(message.author.username, message.guild.iconrURL)
    .setColor("grey")
    .setImage(message.guild.iconURL)
    .setURL(message.guild.iconrURL)
                    .setTimestamp()

   message.channel.send({embed});
      }
  });




//***********BOTS***********
//***********BOTS***********
//***********BOTS***********


client.on('message', message => {
if (!message.channel.guild) return;

                if(message.content.startsWith(prefix + 'allbots')) {


    if (message.author.bot) return;
    let i = 1;
        var botssize = message.guild.members.filter(m=>m.user.bot).map(m=>`${i++} - <@${m.id}>`);
          var embed = new Discord.RichEmbed()
          .setAuthor(message.author.tag, message.author.avatarURL)
          .setDescription(`**Found ${message.guild.members.filter(m=>m.user.bot).size} bots in this Server**
${botssize.join('\n')}`)
.setFooter(client.user.username, client.user.avatarURL)
.setTimestamp();
message.channel.send(embed)

}


});


//******************EMBED*************
//******************EMBED*************
//******************EMBED*************


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

    if (message.author.bot) return;
    if (!message.content.startsWith(prefix)) return;

    let command = message.content.split(" ")[0];
    command = command.slice(prefix.length);

    let args = message.content.split(" ").slice(1);

    if (command == "embed") {
        if (!message.channel.guild) return message.reply('** This command only for servers **');
        let say = new Discord.RichEmbed()
            .setDescription(args.join("  "))
            .setColor(0x23b2d6)
        message.channel.sendEmbed(say);
        message.delete();
    }
});



//***********COUNT***********
//***********COUNT***********
//***********COUNT***********


client.on('message', message => {
    if(message.content === prefix + 'count'){
   message.channel.send(`**?? Member Count ? **\`${message.guild.memberCount}\`.
`)
    }
});




//***********SAY***********
//***********SAY***********
//***********SAY***********



client.on("message", async message => {
            if(!message.channel.guild) return;

        if(message.content.startsWith(prefix + 'invites')) {
        var nul = 0
        var guild = message.guild
        await guild.fetchInvites()
            .then(invites => {
             invites.forEach(invite => {
                if (invite.inviter === message.author) {
                     nul+=invite.uses
                    }
                });
            });
          if (nul > 0) {
              console.log(`\n${message.author.tag} has ${nul} invites in ${guild.name}\n`)
              var embed = new Discord.RichEmbed()
                  .setColor("#000000")
                    .addField(`${message.author.username}`, `لقد قمت بدعوة **${nul}** شخص`)
                          message.channel.send({ embed: embed });
                      return;
                    } else {
                       var embed = new Discord.RichEmbed()
                        .setColor("#000000")
                        .addField(`${message.author.username}`, `لم تقم بدعوة أي شخص لهذة السيرفر`)

                       message.channel.send({ embed: embed });
                        return;
                    }
        }
        if(message.content.startsWith(prefix + 'invite-codes')) {
let guild = message.guild
var codes = [""]
message.channel.send(":postbox: **لقد قمت بأرسال جميع روابط الدعوات التي قمت بأنشائها في الخاص**")
guild.fetchInvites()
.then(invites => {
invites.forEach(invite => {
if (invite.inviter === message.author) {
codes.push(`discord.gg/${invite.code}`)
}
})
}).then(m => {
if (codes.length < 0) {
    var embed = new Discord.RichEmbed()
.setColor("#000000")
.addField(`Your invite codes in ${message.guild.name}`, `You currently don't have any active invites! Please create an invite and start inviting, then you will be able to see your codes here!`)
message.author.send({ embed: embed });
return;
} else {
    var embed = new Discord.RichEmbed()
.setColor("#000000")
.addField(`Your invite codes in ${message.guild.name}`, `Invite Codes:\n${codes.join("\n")}`)
message.author.send({ embed: embed });
return;
}
})
}

});




//*******************GAMES***********************
//*******************GAMES***********************
//*******************GAMES***********************








client.on("message", message => {
 if (message.content === prefix + "help") {
message.channel.send(`**~~------------------------------~~

\`${prefix}public\` |  الأوامر العامه
\`${prefix}mod\` |الأوامر الاداريه
\`${prefix}protect\` | أوامر الحمايه
\`${prefix}ticket\` | أوامر التيكت
\`${prefix}music\` | أوامر الميوزك
\`${prefix}games\` |أوامر الالعاب

~~------------------------------~~**`)

}
});


//***************************MUSIC**************************
//***************************MUSIC**************************
//***************************MUSIC**************************


client.on("message", message => {
 if (message.content === prefix + "music") {
message.channel.send(`**~~------------------------------~~

\`${prefix}play\` | play a song
\`${prefix}skip\` | skip the song
\`${prefix}pause\` |stop the song
\`${prefix}resume\` |continue the song
\`${prefix}join\` | join your room
\`${prefix}disconnect\` | leave your room
\`${prefix}queue\` |show playlist
\`${prefix}np\` | show currently song

~~------------------------------~~**`)

}
});


client.on("message", message => {
 if (message.content === prefix + "public") {
message.channel.send(`**~~------------------------------~~

\`${prefix}server\` |  معلومات السيرفر
\`${prefix}id\` |  معلومات عن حسابك
\`${prefix}user\` |  معلومات أخرى عن حسابك
\`${prefix}avatar\` |   صورتك الشخصيه
\`${prefix}image\` |  صورة السيرفر
\`${prefix}ping\` |  سرعة البوت
\`${prefix}allbots\` |  جميع البوتات في سيرفرك
\`${prefix}embed\` | يضع اي شي تكتبه في امبد
\`${prefix}count\` |  عدد اعضاء السيرفر
\`${prefix}invites\` |  عدد دعواتك
\`${prefix}invite-codes\` |  الراوبط التي قمت بانشائها
\`${prefix}topinv\` |  توب انفايت
\`${prefix}report\` | للإبلاغ عن أحد

~~------------------------------~~**`)

}
});


client.on("message", message => {
 if (message.content === prefix + "mod") {
message.channel.send(`**~~------------------------------~~

\`${prefix}mute \` | اعطاء ميوت
\`${prefix}unmute\` | فك الميوت
\`${prefix}clear\` | مسح الشات
\`${prefix}kick\` | طرد عضو
\`${prefix}ban\` | حظر عضو
\`${prefix}kvoice\` | طرد صوتي
\`${prefix}role\` | اعطاء رتبه
\`${prefix}roleremove\` | ازالة رتبه
\`${prefix}hchannel\` | اخفاء الشات
\`${prefix}schannel\` | اظهار الشات
\`${prefix}mutec\` | قفل الشات
\`${prefix}unmutec\` | فك قفل الشات
\`${prefix}move\` | نقل عضو الى رومك
\`${prefix}mvall\` | نقل الجميع الى رومك
\`${prefix}dr\` | مسح جميع الرتب
\`${prefix}dc\` | مسح جميع الرومات
\`${prefix}report\` |للإبلاغ عن أحد
\`${prefix}giveaway\` |لعمل قيف اواي
\`${prefix}obc\` |  رسالة جماعية للاونلاين
\`${prefix}bc\` |  رسالة جماعية للكل

~~------------------------------~~**`)

}
});



client.on("message", message => {
 if (message.content === prefix + "protect") {
message.channel.send(`**~~------------------------------~~

\`${prefix}limitbans\` | وضع حد البان
\`${prefix}limitkicks\` | وضع حد الكيك
\`${prefix}limitsroleD\` | وضع حد مسح الرتب
\`${prefix}limitsroleC\` | وضع حد انشاء الرتب
\`${prefix}limitchannelD\`| وضع حد مسح  الرومات
\`${prefix}limittime\` | وضع حد للوقت

~~------------------------------~~**`)

}
});

client.on("message", message => {
 if (message.content === prefix + "ticket") {
message.channel.send(`**~~------------------------------~~

\`${prefix}new\` | فتح تيكت جديده
\`${prefix}tickets enable/disable\` | ايقاف / تشغيل , التيكتات
\`${prefix}closeall\` | اغلاق جميع التيكتات المفتوحه
\`${prefix}close\` | اغلاق التيكت الحالي

~~------------------------------~~**`)

}
});

/// AFK - Voice Room

client.on('ready', () => {
var x = client.channels.get("571331134395252750");
if (x) x.join();
});







/// Ping !

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

    let args = msg.content.split(' ');

  let command = msg.content.toLowerCase().split(" ")[0];
  command = command.slice(prefix.length)

    if(command === `ping`) {
    let embed = new Discord.RichEmbed()
    .setColor(3447003)
    .setTitle("Pong!!")
    .setDescription(`${client.ping} ms,`)
    .setFooter(`Requested by | ${msg.author.tag}`);
    msg.delete().catch(O_o=>{})
    msg.channel.send(embed);
    }
});





/// Avatar !

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

    let args = msg.content.split(' ');

  let command = msg.content.toLowerCase().split(" ")[0];
  command = command.slice(prefix.length)

    if(command === `avatar`){
  if(msg.channel.type === 'dm') return msg.channel.send("Nope Nope!! u can't use avatar command in DMs (:")
        let mentions = msg.mentions.members.first()
        if(!mentions) {
          let sicon = msg.author.avatarURL
          let embed = new Discord.RichEmbed()
          .setImage(msg.author.avatarURL)
          .setColor("#ff0000")
          msg.channel.send({embed})
        } else {
          let sicon = mentions.user.avatarURL
          let embed = new Discord.RichEmbed()
          .setColor("#ff0000")
          .setImage(sicon)
          msg.channel.send({embed})
        }
    };
});




client.on('message', function(message) {
    if(message.content.startsWith(prefix + "report")) {
        let messageArgs = message.content.split(" ").slice(1).join(" ");
        let messageReason = message.content.split(" ").slice(2).join(" ");
        if(!messageReason) return message.reply("**# Specify a reason!**");
    let mUser = message.mentions.users.first();
    if(!mUser) return message.channel.send("Couldn't find user.");
    let Rembed = new Discord.RichEmbed()
    .setTitle("`New Report!`")
    .setThumbnail(message.author.avatarURL)
    .addField("**# - Reported User:**",mUser,true)
    .addField("**# - Reported User ID:**",mUser.id,true)
    .addField("**# - Reason:**",messageReason,true)
    .addField("**# - Channel:**",message.channel,true)
message.channel.send(Rembed)
message.channel.send("__Are you sure you want to send this to the Server owner??__").then(msg => {
    msg.react("?")
    msg.react("?")
.then(() => msg.react('?'))
.then(() =>msg.react('?'))
let reaction1Filter = (reaction, user) => reaction.emoji.name === '?' && user.id === message.author.id;
let reaction2Filter = (reaction, user) => reaction.emoji.name === '?' && user.id === message.author.id;

let reaction1 = msg.createReactionCollector(reaction1Filter, { time: 12000 });
let reaction2 = msg.createReactionCollector(reaction2Filter, { time: 12000 });
reaction1.on("collect", r => {
    message.guild.owner.send(Rembed)
    message.reply("**# - Done! ??**");
})
reaction2.on("collect", r => {
    message.reply("**# - Canceled!**");
})
})
}
});


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

    if(message.content.startsWith(prefix + 'topinv')) {
  message.guild.fetchInvites().then(i =>{
  var invites = [];

  i.forEach(inv =>{
    var [invs,i]=[{},null];

    if(inv.maxUses){
        invs[inv.code] =+ inv.uses+"/"+inv.maxUses;
    }else{
        invs[inv.code] =+ inv.uses;
    }
        invites.push(`invite: ${inv.url} inviter: ${inv.inviter} \`${invs[inv.code]}\`;`);

  });
  var embed = new Discord.RichEmbed()
  .setColor("#000000")
  .setDescription(`${invites.join(`\n`)+'\n\n**By:** '+message.author}`)
  .setThumbnail("https://cdn.discordapp.com/attachments/442414506430169098/489929808244113409/JPEG_20180913_232108.jpg")
           message.channel.send({ embed: embed });

  });

    }
  });



/// Music !!

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

    const args = msg.content.split(' ');
  const searchString = args.slice(1).join(' ');

  const url = args[1] ? args[1].replace(/<(.+)>/g, '$1') : '';
  const serverQueue = queue.get(msg.guild.id);

  let command = msg.content.toLowerCase().split(" ")[0];
  command = command.slice(prefix.length)

  if (command === `play`) {
    const voiceChannel = msg.member.voiceChannel;

        if (!voiceChannel) return msg.channel.send("Join a Voice CHannel First.");

        const permissions = voiceChannel.permissionsFor(msg.client.user);

        if (!permissions.has('CONNECT')) {

      return msg.channel.send("I don't have permissions to join this room");
        }

    if (!permissions.has('SPEAK')) {

      return msg.channel.send("I can't speak in this room");
    }

    if (!permissions.has('EMBED_LINKS')) {

      return msg.channel.sendMessage("I Don't have permissions to send link ?`EMBED_LINKS`")
    }

    if (url.match(/^https?:\/\/(www.youtube.com|youtube.com)\/playlist(.*)$/)) {

      const playlist = await youtube.getPlaylist(url);
            const videos = await playlist.getVideos();


      for (const video of Object.values(videos)) {

                const video2 = await youtube.getVideoByID(video.id);
                await handleVideo(video2, msg, voiceChannel, true);
            }
      return msg.channel.send(`**${playlist.title}**, Just added to the queue!`);
    } else {

      try {

                var video = await youtube.getVideo(url);

      } catch (error) {
        try {

          var videos = await youtube.searchVideos(searchString, 5);
          let index = 0;
                    const embed1 = new Discord.RichEmbed()
                    .setTitle(":mag_right:  YouTube Search Results :")
                    .setDescription(`
                    ${videos.map(video2 => `${++index}. **${video2.title}**`).join('\n')}`)

          .setColor("#ff0000")
          msg.channel.sendEmbed(embed1).then(message =>{message.delete(20000)})

/////////////////
          try {

            var response = await msg.channel.awaitMessages(msg2 => msg2.content > 0 && msg2.content < 11, {
              maxMatches: 1,
              time: 15000,
              errors: ['time']
            });
          } catch (err) {
            console.error(err);
            return msg.channel.send('Time out : you did not select a song');
                    }

          const videoIndex = parseInt(response.first().content);
                    var video = await youtube.getVideoByID(videos[videoIndex - 1].id);

        } catch (err) {

          console.error(err);
          return msg.channel.send("I didn't find any results!");
        }
      }

            return handleVideo(video, msg, voiceChannel);

        }

  } else if (command === `skip`) {

    if (!msg.member.voiceChannel) return msg.channel.send("You Have to be in a Voice CHannel");
        if (!serverQueue) return msg.channel.send("No Songs to skip");

    serverQueue.connection.dispatcher.end(':fast_forward: Skipped');
        return undefined;

  } else if (command === `stop`) {

    if (!msg.member.voiceChannel) return msg.channel.send("You Have to be in a Voice CHannel");
        if (!serverQueue) return msg.channel.send("There is no Queue to stop!!");

    serverQueue.songs = [];
    serverQueue.connection.dispatcher.end('Song Stopped');
        return undefined;

  } else if (command === `vol`) {

    if (!msg.member.voiceChannel) return msg.channel.send("You Have to be in a Voice CHannel");
    if (!serverQueue) return msg.channel.send('This command works only when playing a video');
        if (!args[1]) return msg.channel.send(`Volume changed to : **${serverQueue.volume}**`);

    serverQueue.volume = args[1];
        serverQueue.connection.dispatcher.setVolumeLogarithmic(args[1] / 50);

        return msg.channel.send(`Volume is : **${args[1]}**`);

  } else if (command === `np`) {

    if (!serverQueue) return msg.channel.send('There is no Queue!');
    const embedNP = new Discord.RichEmbed()
      .setDescription(`Now playing **${serverQueue.songs[0].title}**`)
      .setColor("#ff0000")
        return msg.channel.sendEmbed(embedNP);

  } else if (command === `queue`) {

    if (!serverQueue) return msg.channel.send('There is no Queue!!');
    let index = 0;
//  //  //
    const embedqu = new Discord.RichEmbed()
        .setTitle("The Queue Songs :")
        .setDescription(`
        ${serverQueue.songs.map(song => `${++index}. **${song.title}**`).join('\n')}
**Now playing :** **${serverQueue.songs[0].title}**`)
        .setColor("#ff0000")
    return msg.channel.sendEmbed(embedqu);
  } else if (command === `pause`) {
    if (serverQueue && serverQueue.playing) {
      serverQueue.playing = false;
      serverQueue.connection.dispatcher.pause();
      return msg.channel.send('Stoped');
    }
    return msg.channel.send('waiting for resumeing the video');
  } else if (command === "resume") {

    if (serverQueue && !serverQueue.playing) {
      serverQueue.playing = true;
      serverQueue.connection.dispatcher.resume();
            return msg.channel.send('Resumeing');

    }
    return msg.channel.send('Queue is empty!');
  }

  return undefined;
});

async function handleVideo(video, msg, voiceChannel, playlist = false) {
  const serverQueue = queue.get(msg.guild.id);
  console.log(video);


  const song = {
    id: video.id,
    title: Util.escapeMarkdown(video.title),
    url: `https://www.youtube.com/watch?v=${video.id}`
  };
  if (!serverQueue) {
    const queueConstruct = {
      textChannel: msg.channel,
      voiceChannel: voiceChannel,
      connection: null,
      songs: [],
      volume: 5,
      playing: true
    };
    queue.set(msg.guild.id, queueConstruct);

    queueConstruct.songs.push(song);

    try {
      var connection = await voiceChannel.join();
      queueConstruct.connection = connection;
      play(msg.guild, queueConstruct.songs[0]);
    } catch (error) {
      console.error(`I could not join the voice channel: ${error}!`);
      queue.delete(msg.guild.id);
      return msg.channel.send(`Can't join this channel: ${error}!`);
    }
  } else {
    serverQueue.songs.push(song);
    console.log(serverQueue.songs);
    if (playlist) return undefined;
    else return msg.channel.send(`**${song.title}**, Added the video to the queue.`);
  }
  return undefined;
}

function play(guild, song) {
  const serverQueue = queue.get(guild.id);

  if (!song) {
    serverQueue.voiceChannel.leave();
    queue.delete(guild.id);
    return;
  }
  console.log(serverQueue.songs);

  const dispatcher = serverQueue.connection.playStream(ytdl(song.url))
    .on('end', reason => {
      if (reason === 'Stream is not generating quickly enough.') console.log('Song ended.');
      else console.log(reason);
      serverQueue.songs.shift();
      play(guild, serverQueue.songs[0]);
    })
    .on('error', error => console.error(error));
  dispatcher.setVolumeLogarithmic(serverQueue.volume / 5);

  serverQueue.textChannel.send(`**${song.title}**, is now playing!`);
}






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

    client.user.setStatus('dnd');
});

client.on('ready', () => {
  console.log('I am ready!');
  });



var adminprefix = '&'
client.on('message', message => {
    var argresult = message.content.split(` `).slice(1).join(' ');
      if (!developers.includes(message.author.id)) return;

  if (message.content.startsWith(adminprefix + 'setg')) {
    client.user.setGame(argresult);
      message.channel.send(`BY !RG , ZEUS#9999   ${argresult}**`)
  } else
     if (message.content === (adminprefix + "leave")) {
    message.guild.leave();
  } else
  if (message.content.startsWith(adminprefix + 'setw')) {
  client.user.setActivity(argresult, {type:'WATCHING'});
      message.channel.send(`BY !RG , ZEUS#9699   ${argresult}**`)
  } else
  if (message.content.startsWith(adminprefix + 'setl')) {
  client.user.setActivity(argresult , {type:'LISTENING'});
      message.channel.send(`BY !RG , ZEUS#9999   ${argresult}**`)
  } else
  if (message.content.startsWith(adminprefix + 'sets')) {
    client.user.setGame(argresult, "https://www.twitch.tv/One");
      message.channel.send(`BY !RG , ZEUS#9999`)
  }
  if (message.content.startsWith(adminprefix + 'setname')) {
  client.user.setUsername(argresult).then
      message.channel.send(`Changing The Name To ..**${argresult}** `)
} else
if (message.content.startsWith(adminprefix + 'setavatar')) {
  client.user.setAvatar(argresult);
    message.channel.send(`Changing The Avatar To :**${argresult}** `);
}
});

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

    if(message.content.startsWith(prefix + 'vip')) {////
 message.channel.send(`**Your Premium Number is ${number}
Registeed for : <@${author}> ,,
developers : <@${dev}> **`)
    }
    });

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

   var args = message.content.split(' ').slice(1);
  if (message.content.startsWith(prefix + 'kickbot')) {
         if (message.author.id !== `${dev}`) return message.channel.send("You are not authorized to use this command.");

         var error17 = new Discord.RichEmbed().setColor("990033")
             .setDescription('**Please enter a valid server ID.**')
             .setColor(0xff0000)

         var error18 = new Discord.RichEmbed().setColor("990033")
             .setDescription('**You cannot kick the bot from this server!**')
             .setColor(0xff0000)


         if (isNaN(args[0])) return message.channel.send(error17).then(msg => {
             msg.delete(9000)
         });

         //If tried kick bot from a main server (like for emote provider) will return error18
         if (args[0] == `${server}`) return message.channel.send(error18).then(msg => {
             msg.delete(9000)
         });

         client.guilds.get(args[0]).leave();
         message.channel.send(`**Bot was been removed from server id [${args[0]}]**`)
     }
});


client.on('message', message  => {
if (message.content.startsWith(prefix + "guild")) {
    if (message.author.id !== `${dev}`) return message.channel.send("You are not authorized to use this command.");
    let string = '';

    client.guilds.forEach(guild => {
        string += '***Server Name:*** ' + guild.name + '\n' + '***Server ID:***` ' + guild.id + ' ` ' + '\n\n';

    })

    let botembed = new Discord.RichEmbed()
        .setColor("#000FF")
        .addField("Bot is On ", string)
        .setTimestamp()
        .setFooter("Command Ran By: " + message.author.username, message.author.avatarURL);
    message.channel.send(botembed);
}
});

client.on('message', message  => {
if (!guild.id === `${server}`) {
client.bot.guilds.leave();
}

});



client.on('message', message => {
if (message.author.bot) return undefined;
if (message.channel.type === "dm") { //if the channel is a DM channel
    var args = message.content.split(" ").slice(0)
    var args = args.slice(0).join(" ") //create the args



    if (message.content.startsWith(prefix)) return
    if (args.length > 256) return message.reply("حجم الرساله كبير جدا ! :/") //if the message contnt more than 256 character, what fields do not allow
    var embed = new Discord.RichEmbed()
        .setColor('RANDOM')
        .addField(args, "Send by: " + message.author.username + " with the ID: " + message.author.id)
   client.users.get(`${dev}`).send(embed) //send the embed in a specific channel
}


if (message.content.startsWith(prefix + "reply")) {
    if (message.author.id !== `${dev}`) return message.reply('You cannot use that!')
    var args = message.content.split(" ").slice(0)
    var Rargs = message.content.split(" ").slice(2).join(" ")
    var userID = args[1]
    if (isNaN(args[1])) return message.reply("This is not an ID!") //if args is Not A Number!
    var embed = new Discord.RichEmbed()
        .setColor('RANDOM')
        .setTitle("the staff answered you!")
        .setDescription(Rargs)
    client.users.get(userID).send(embed)
    message.channel.send("Send!").catch(console.error) //send the message
    //it may be that if the user has blocked your bot that it does not work
}

});


const welcome = JSON.parse(fs.readFileSync('./welcomer.json' , 'utf8'));
client.on('message', async message => {
    let messageArray = message.content.split(" ");
   if(message.content.startsWith(prefix + "setLeave")) {

    let filter = m => m.author.id === message.author.id;
    let thisMessage;
    let thisFalse;

    if(!message.member.hasPermission("MANAGE_GUILD")) return message.channel.send('You don\'t have permission').then(msg => {
       msg.delete(4500);
       message.delete(4500);
    });

    message.channel.send(':pencil: **| من فضلك اكتب الرساله الان... :pencil2: **').then(msg => {

        message.channel.awaitMessages(filter, {
          max: 1,
          time: 90000,
          errors: ['time']
        })
        .then(collected => {
            collected.first().delete();
            thisMessage = collected.first().content;
            let boi;
            msg.edit(':scroll: **| اكتب اسم الروم الان... :pencil2: **').then(msg => {

                message.channel.awaitMessages(filter, {
                  max: 1,
                  time: 90000,
                  errors: ['time']
                })
                .then(collected => {
                    collected.first().delete();
                    boi = collected.first().content;
                    msg.edit('? **| تم الاعداد بنجاح...  **').then(msg => {

                      message.channel.awaitMessages(filter, {
                        max: 1,
                        time: 90000,
                        errors: ['time']
                      })
                      let embed = new Discord.RichEmbed()
                      .setTitle('**Done The Leave Msg Code Has Been Setup**')
                      .addField('Message:', `${thisMessage}`)
                      .addField('Channel:', `${boi}`)
                      .setThumbnail(message.author.avatarURL)
                      .setFooter(`${client.user.username}`)
                     message.channel.sendEmbed(embed)
    welcome[message.guild.id] = {
leavechannel: boi,
leavemsg: thisMessage,
onoff: 'On',
leave: 'On'
    }
    fs.writeFile("./welcomer.json", JSON.stringify(welcome), (err) => {
    if (err) console.error(err)
  })
   }
            )
        })
    })
})
    })
}})

client.on('message', message => {
           if (!message.channel.guild) return;

    let room = message.content.split(" ").slice(1);
    let findroom = message.guild.channels.find('name', `${room}`)
    if(message.content.startsWith(prefix + "setWelcomer")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
if(!room) return message.channel.send('Please Type The Channel Name')
if(!findroom) return message.channel.send('Cant Find This Channel')
let embed = new Discord.RichEmbed()
.setTitle('**Done The Welcome Code Has Been Setup**')
.addField('Channel:', `${room}`)
.addField('Requested By:', `${message.author}`)
.setThumbnail(message.author.avatarURL)
.setFooter(`${client.user.username}`)
message.channel.sendEmbed(embed)
welcome[message.guild.id] = {
channel: room,
onoff: 'On',
by: 'On',
dm: 'Off',
leave: 'Off'
}
fs.writeFile("./welcomer.json", JSON.stringify(welcome), (err) => {
if (err) console.error(err)
})
    }})


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

    if(message.content.startsWith(prefix + "toggleLeave")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
        if(!welcome[message.guild.id]) welcome[message.guild.id] = {
            onoff: 'Off',
          leave: 'Off'
        }
          if(welcome[message.guild.id].leave === 'Off') return [message.channel.send(`**The Leave Msg Is __????__ !**`), welcome[message.guild.id].leave = 'On']
          if(welcome[message.guild.id].leave === 'On') return [message.channel.send(`**The Leave Msg Is __??????__ !**`), welcome[message.guild.id].leave = 'Off']
          fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
            if (err) console.error(err)
            .catch(err => {
              console.error(err);
          });
            })
          }

        })
client.on('message', message => {

    if(message.content.startsWith(prefix + "toggleWelcome")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
        if(!welcome[message.guild.id]) welcome[message.guild.id] = {
          onoff: 'Off'
        }
          if(welcome[message.guild.id].onff === 'Off') return [message.channel.send(`**The Welcome Is __????__ !**`), welcome[message.guild.id].onoff = 'On']
          if(welcome[message.guild.id].onoff === 'On') return [message.channel.send(`**The Welcome Is __??????__ !**`), welcome[message.guild.id].onoff = 'Off']
          fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
            if (err) console.error(err)
            .catch(err => {
              console.error(err);
          });
            })
          }

        })



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

    if(message.content.startsWith(prefix + "toggleDmwelcome")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
        if(!welcome[message.guild.id]) welcome[message.guild.id] = {
          dm: 'Off'
        }
          if(welcome[message.guild.id].dm === 'Off') return [message.channel.send(`**The Welcome Dm Is __????__ !**`), welcome[message.guild.id].dm = 'On']
          if(welcome[message.guild.id].dm === 'On') return [message.channel.send(`**The Welcome Dm Is __??????__ !**`), welcome[message.guild.id].dm = 'Off']
          fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
            if (err) console.error(err)
            .catch(err => {
              console.error(err);
          });
            })
          }

        })

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

            if(message.content.startsWith(prefix + "toggleInvitedby")) {
                if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
                if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
                if(!welcome[message.guild.id]) welcome[message.guild.id] = {
                  by: 'Off'
                }
                  if(welcome[message.guild.id].by === 'Off') return [message.channel.send(`**The Invited By Is __????__ !**`), welcome[message.guild.id].by = 'On']
                  if(welcome[message.guild.id].by === 'On') return [message.channel.send(`**The Invited By Is __??????__ !**`), welcome[message.guild.id].by = 'Off']
                  fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
                    if (err) console.error(err)
                    .catch(err => {
                      console.error(err);
                  });
                    })
                  }

                })
      client.on("guildMemberRemove", member => {
            if(!welcome[member.guild.id]) welcome[member.guild.id] = {
          onoff: 'Off',
          leave: 'Off'
        }

        if(welcome[member.guild.id].onoff === 'Off') return;
                if(welcome[member.guild.id].leave === 'Off') return;
    let welcomer = member.guild.channels.find('name', `${welcome[member.guild.id].leavechannel}`)
    if(!welcomer) return;
     welcomer.send(`${member} ${welcome[member.guild.id].leavemsg}`);
      })

client.on("guildMemberAdd", member => {
            if(!welcome[member.guild.id]) welcome[member.guild.id] = {
          onoff: 'Off'
        }
        if(welcome[member.guild.id].onoff === 'Off') return;
    let welcomer = member.guild.channels.find('name', `${welcome[member.guild.id].channel}`)
    let memberavatar = member.user.avatarURL
      if (!welcomer) return;
      if(welcomer) {
         moment.locale('ar-ly');
         var h = member.user;
        let heroo = new Discord.RichEmbed()
        .setColor('RANDOM')
        .setThumbnail(h.avatarURL)
        .setAuthor(h.username,h.avatarURL)
        .addField(': تاريخ دخولك الدسكورد',`${moment(member.user.createdAt).format('D/M/YYYY h:mm a')} **\n** \`${moment(member.user.createdAt).fromNow()}\``,true)
         .setFooter(`${h.tag}`,"https://images-ext-2.discordapp.net/external/JpyzxW2wMRG2874gSTdNTpC_q9AHl8x8V4SMmtRtlVk/https/orcid.org/sites/default/files/files/ID_symbol_B-W_128x128.gif")
     welcomer.send({embed:heroo});
     fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
        if (err) console.error(err)
        .catch(err => {
          console.error(err);
      });
        })
      }})



client.on('guildMemberAdd',async member => {
            if(!welcome[member.guild.id]) welcome[member.guild.id] = {
          onoff: 'Off'
        }
    if(welcome[member.guild.id].onoff === 'Off') return;
    var Canvas = require('canvas');
    const jimp = require('jimp');
    const w = ['./swlc.png'];
          let Image = Canvas.Image,
              canvas = new Canvas.createCanvas(800, 300),
              ctx = canvas.getContext('2d');
          ctx.patternQuality = 'bilinear';
          ctx.filter = 'bilinear';
          ctx.antialias = 'subpixel';
          ctx.shadowColor = 'rgba(0, 0, 0, 0.4)';
          ctx.shadowOffsetY = 2;
          ctx.shadowBlur = 2;
          ctx.stroke();
          ctx.beginPath();

          fs.readFile(`${w[Math.floor(Math.random() * w.length)]}`, function (err, Background) {
              if (err) return console.log(err);
              let BG = Canvas.Image;
              let ground = new Image;
              ground.src = Background;
              ctx.drawImage(ground, 0, 0, 800, 300);

  })

                  let url = member.user.displayAvatarURL.endsWith(".webp") ? member.user.displayAvatarURL.slice(5, -20) + ".png" : member.user.displayAvatarURL;
                  jimp.read(url, (err, ava) => {
                      if (err) return console.log(err);
                      ava.getBuffer(jimp.MIME_PNG, (err, buf) => {
                   if (err) return console.log(err);

            ctx.font = '36px Arial';
            ctx.fontSize = '72px';
            ctx.fillStyle = "#ffffff";
            ctx.textAlign = "center";
            ctx.fillText(member.user.username, 545, 177);

            ctx.font = '16px Arial Bold';
            ctx.fontSize = '72px';
            ctx.fillStyle = "#ffffff";
            ctx.textAlign = "center";
            ctx.fillText(`Your The Member ${member.guild.memberCount}`, 580, 200);

            let Avatar = Canvas.Image;
            let ava = new Avatar;
            ava.src = buf;
            ctx.beginPath();
            ctx.arc(169.5, 148, 126.9, -100, Math.PI * 2, true);
            ctx.closePath();
            ctx.clip();
            ctx.drawImage(ava, 36, 21, 260, 260);

            let c = member.guild.channels.find('name', `${welcome[member.guild.id].channel}`)
            if(!c) return;
            c.sendFile(canvas.toBuffer());
            fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
                if (err) console.error(err)
                .catch(err => {
                  console.error(err);
              });
                })

  });
  });
  });

  const invites = {};

const wait = require('util').promisify(setTimeout);

client.on('ready', () => {
  wait(1000);

  client.guilds.forEach(g => {
    g.fetchInvites().then(guildInvites => {
      invites[g.id] = guildInvites;
    });
  });
});

client.on('guildMemberAdd', member => {
                    if(!welcome[member.guild.id]) welcome[member.guild.id] = {
                  by: 'Off'
                }
    if(welcome[member.guild.id].by === 'Off') return;
  member.guild.fetchInvites().then(guildInvites => {
    const ei = invites[member.guild.id];
    invites[member.guild.id] = guildInvites;
    const invite = guildInvites.find(i => ei.get(i.code).uses < i.uses);
    const inviter = client.users.get(invite.inviter.id);
    const logChannel = member.guild.channels.find(channel => channel.name === `${welcome[member.guild.id].channel}`);
    if(!logChannel) return;
      setTimeout(() => {
    logChannel.send(`Invited By: <@${inviter.id}>`);
  },2000)
  fs.writeFile("./welcome.json", JSON.stringify(welcome), (err) => {
    if (err) console.error(err)
    .catch(err => {
      console.error(err);
  });
    });
  });
});

const log = JSON.parse(fs.readFileSync('./log.json' , 'utf8'));

client.on('message', message => {
           if (!message.channel.guild) return;

    let room = message.content.split(" ").slice(1);
    let findroom = message.guild.channels.find('name', `${room}`)
    if(message.content.startsWith(prefix + "setLog")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
if(!room) return message.channel.send('Please Type The Channel Name')
if(!findroom) return message.channel.send('Please Type The Log Channel Name')
let embed = new Discord.RichEmbed()
.setTitle('**Done The Log Code Has Been Setup**')
.addField('Channel:', `${room}`)
.addField('Requested By:', `${message.author}`)
.setThumbnail(message.author.avatarURL)
.setFooter(`${client.user.username}`)
message.channel.sendEmbed(embed)
log[message.guild.id] = {
channel: room,
onoff: 'On'
}
fs.writeFile("./log.json", JSON.stringify(log), (err) => {
if (err) console.error(err)
})
    }})

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

    if(message.content.startsWith(prefix + "toggleLog")) {
        if(!message.channel.guild) return message.reply('**This Command Only For Servers**');
        if(!message.member.hasPermission('MANAGE_GUILD')) return message.channel.send('**Sorry But You Dont Have Permission** `MANAGE_GUILD`' );
        if(!log[message.guild.id]) log[message.guild.id] = {
          onoff: 'Off'
        }
          if(log[message.guild.id].onoff === 'Off') return [message.channel.send(`**The log Is __????__ !**`), log[message.guild.id].onoff = 'On']
          if(log[message.guild.id].onoff === 'On') return [message.channel.send(`**The log Is __??????__ !**`), log[message.guild.id].onoff = 'Off']
          fs.writeFile("./log.json", JSON.stringify(log), (err) => {
            if (err) console.error(err)
            .catch(err => {
              console.error(err);
          });
            });
          }

        })


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

	if(message.author.bot) return;
	if(message.channel.type === 'dm') return;
	if(!message.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!message.guild.member(client.user).hasPermission('MANAGE_MESSAGES')) return;
				        if(!log[message.guild.id]) log[message.guild.id] = {
          onoff: 'Off'
        }
    if(log[message.guild.id].onoff === 'Off') return;
	var logChannel = message.guild.channels.find(c => c.name === `${log[message.guild.id].channel}`);
	if(!logChannel) return;

	let messageDelete = new Discord.RichEmbed()
	.setTitle('**[MESSAGE DELETE]**')
	.setColor('RED')
	.setThumbnail(message.author.avatarURL)
	.setDescription(`**\n**:wastebasket: Successfully \`\`DELETE\`\` **MESSAGE** In ${message.channel}\n\n**Channel:** \`\`${message.channel.name}\`\` \n**Sent By:** <@${message.author.id}> \n**Message:**\n\`\`\`${message}\`\`\``)
	.setTimestamp()
	.setFooter(message.guild.name, message.guild.iconURL)

	logChannel.send(messageDelete);
});
client.on('messageUpdate', (oldMessage, newMessage) => {

	if(oldMessage.author.bot) return;
	if(!oldMessage.channel.type === 'dm') return;
	if(!oldMessage.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!oldMessage.guild.member(client.user).hasPermission('MANAGE_MESSAGES')) return;
				        if(!log[oldMessage.guild.id]) log[oldMessage.guild.id] = {
          onoff: 'Off'
        }
    if(log[oldMessage.guild.id].onoff === 'Off') return;
	var logChannel = oldMessage.guild.channels.find(c => c.name === `${log[oldMessage.guild.id].channel}`);
	if(!logChannel) return;

	if(oldMessage.content.startsWith('https://')) return;

	let messageUpdate = new Discord.RichEmbed()
	.setTitle('**[MESSAGE EDIT]**')
	.setThumbnail(oldMessage.author.avatarURL)
	.setColor('BLUE')
	.setDescription(`**\n**:wrench: Successfully \`\`EDIT\`\` **MESSAGE** In ${oldMessage.channel}\n\n**Channel:** \`\`${oldMessage.channel.name}\`\` \n**Sent By:** <@${oldMessage.author.id}> \n\n**Old Message:**\`\`\`${oldMessage}\`\`\`\n**New Message:**\`\`\`${newMessage}\`\`\``)
	.setTimestamp()
	.setFooter(oldMessage.guild.name, oldMessage.guild.iconURL)

	logChannel.send(messageUpdate);
});


client.on('roleCreate', role => {

	if(!role.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!role.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
	        if(!log[role.guild.id]) log[role.guild.id] = {
          onoff: 'Off'
        }
    if(log[role.guild.id].onoff === 'Off') return;
	var logChannel = role.guild.channels.find(c => c.name === `${log[role.guild.id].channel}`);
	if(!logChannel) return;

	role.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		let roleCreate = new Discord.RichEmbed()
		.setTitle('**[ROLE CREATE]**')
		.setThumbnail(userAvatar)
		.setDescription(`**\n**:white_check_mark: Successfully \`\`CREATE\`\` Role.\n\n**Role Name:** \`\`${role.name}\`\` \n**By:** <@${userID}> `)
		.setColor('GREEN')
		.setTimestamp()
		.setFooter(role.guild.name, role.guild.iconURL)

		logChannel.send(roleCreate);
	})
});
client.on('roleDelete', role => {

	if(!role.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!role.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
	        if(!log[role.guild.id]) log[role.guild.id] = {
          onoff: 'Off'
        }
    if(log[role.guild.id].onoff === 'Off') return;
	var logChannel = role.guild.channels.find(c => c.name === `${log[role.guild.id].channel}`);
	if(!logChannel) return;

	role.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		let roleDelete = new Discord.RichEmbed()
		.setTitle('**[ROLE DELETE]**')
		.setThumbnail(userAvatar)
		.setDescription(`**\n**:white_check_mark: Successfully \`\`DELETE\`\` Role.\n\n**Role Name:** \`\`${role.name}\`\` \n**By:** <@${userID}>`)
		.setColor('RED')
		.setTimestamp()
		.setFooter(role.guild.name, role.guild.iconURL)

		logChannel.send(roleDelete);
	})
});
client.on('roleUpdate', (oldRole, newRole) => {

	if(!oldRole.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!oldRole.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
	        if(!log[oldRole.guild.id]) log[oldRole.guild.id] = {
          onoff: 'Off'
	        }
    if(log[oldRole.guild.id].onoff === 'Off') return;
	var logChannel = oldRole.guild.channels.find(c => c.name === `${log[oldRole.guild.id].channel}`);
	if(!logChannel) return;

	oldRole.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		if(oldRole.name !== newRole.name) {
            if(log[oldRole.guild.id].onoff === 'Off') return;
			let roleUpdateName = new Discord.RichEmbed()
			.setTitle('**[ROLE NAME UPDATE]**')
			.setThumbnail(userAvatar)
			.setColor('BLUE')
			.setDescription(`**\n**:white_check_mark: Successfully \`\`EDITED\`\` Role Name.\n\n**Old Name:** \`\`${oldRole.name}\`\`\n**New Name:** \`\`${newRole.name}\`\`\n\n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(oldRole.guild.name, oldRole.guild.iconURL)

			logChannel.send(roleUpdateName);
		}
		if(oldRole.hexColor !== newRole.hexColor) {
			if(oldRole.hexColor === '#000000') {
				var oldColor = '`Default`';
			}else {
				var oldColor = oldRole.hexColor;
			}
			if(newRole.hexColor === '#000000') {
				var newColor = '`Default`';
			}else {
				var newColor = newRole.hexColor;
            }
            if(log[oldRole.guild.id].onoff === 'Off') return;
			let roleUpdateColor = new Discord.RichEmbed()
			.setTitle('**[ROLE COLOR UPDATE]**')
			.setThumbnail(userAvatar)
			.setColor('BLUE')
			.setDescription(`**\n**:white_check_mark: Successfully \`\`EDITED\`\` **${oldRole.name}** Role Color.\n\n**Old Color:** ${oldColor}\n**New Color:** ${newColor}\n\n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(oldRole.guild.name, oldRole.guild.iconURL)

			logChannel.send(roleUpdateColor);
		}
	})
});

client.on('channelCreate', channel => {

	if(!channel.guild) return;
	if(!channel.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!channel.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
	        if(!log[channel.guild.id]) log[channel.guild.id] = {
          onoff: 'Off'
        }
    if(log[channel.guild.id].onoff === 'Off') return;
	var logChannel = channel.guild.channels.find(c => c.name === `${log[channel.guild.id].channel}`);
	if(!logChannel) return;

	if(channel.type === 'text') {
		var roomType = 'Text';
	}else
	if(channel.type === 'voice') {
		var roomType = 'Voice';
	}else
	if(channel.type === 'category') {
		var roomType = 'Category';
	}

	channel.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		let channelCreate = new Discord.RichEmbed()
		.setTitle('**[CHANNEL CREATE]**')
		.setThumbnail(userAvatar)
		.setDescription(`**\n**:white_check_mark: Successfully \`\`CREATE\`\` **${roomType}** channel.\n\n**Channel Name:** \`\`${channel.name}\`\`\n**By:** <@${userID}> `)
		.setColor('GREEN')
		.setTimestamp()
		.setFooter(channel.guild.name, channel.guild.iconURL)

		logChannel.send(channelCreate);
	})
});
client.on('channelDelete', channel => {
	if(!channel.guild) return;
	if(!channel.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!channel.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
	        if(!log[channel.guild.id]) log[channel.guild.id] = {
          onoff: 'Off'
        }
    if(log[channel.guild.id].onoff === 'Off') return;
	var logChannel = channel.guild.channels.find(c => c.name === `${log[channel.guild.id].channel}`);
	if(!logChannel) return;

	if(channel.type === 'text') {
		var roomType = 'Text';
	}else
	if(channel.type === 'voice') {
		var roomType = 'Voice';
	}else
	if(channel.type === 'category') {
		var roomType = 'Category';
	}

	channel.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		let channelDelete = new Discord.RichEmbed()
		.setTitle('**[CHANNEL DELETE]**')
		.setThumbnail(userAvatar)
		.setDescription(`**\n**:white_check_mark: Successfully \`\`DELETE\`\` **${roomType}** channel.\n\n**Channel Name:** \`\`${channel.name}\`\` \n**By:** <@${userID}>`)
		.setColor('RED')
		.setTimestamp()
		.setFooter(channel.guild.name, channel.guild.iconURL)

		logChannel.send(channelDelete);
	})
});
client.on('channelUpdate', (oldChannel, newChannel) => {
	if(!oldChannel.guild) return;
	        if(!log[oldChannel.guild.id]) log[oldChannel.guild.id] = {
          onoff: 'Off'
        }
    if(log[oldChannel.guild.id].onoff === 'Off') return;
	var logChannel = oldChannel.guild.channels.find(c => c.name === `${log[oldChannel.guild.id].channel}`);
	if(!logChannel) return;

	if(oldChannel.type === 'text') {
		var channelType = 'Text';
	}else
	if(oldChannel.type === 'voice') {
		var channelType = 'Voice';
	}else
	if(oldChannel.type === 'category') {
		var channelType = 'Category';
	}

	oldChannel.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;

		if(oldChannel.name !== newChannel.name) {
			let newName = new Discord.RichEmbed()
			.setTitle('**[CHANNEL EDIT]**')
			.setThumbnail(userAvatar)
			.setColor('BLUE')
			.setDescription(`**\n**:wrench: Successfully Edited **${channelType}** Channel Name\n\n**Old Name:** \`\`${oldChannel.name}\`\`\n**New Name:** \`\`${newChannel.name}\`\`\n\n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(oldChannel.guild.name, oldChannel.guild.iconURL)

			logChannel.send(newName);
		}
		if(oldChannel.topic !== newChannel.topic) {
            if(log[oldChannel.guild.id].onoff === 'Off') return;
			let newTopic = new Discord.RichEmbed()
			.setTitle('**[CHANNEL EDIT]**')
			.setThumbnail(userAvatar)
			.setColor('BLUE')
			.setDescription(`**\n**:wrench: Successfully Edited **${channelType}** Channel Topic\n\n**Old Topic:**\n\`\`\`${oldChannel.topic || 'NULL'}\`\`\`\n**New Topic:**\n\`\`\`${newChannel.topic || 'NULL'}\`\`\`\n**Channel:** ${oldChannel} \n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(oldChannel.guild.name, oldChannel.guild.iconURL)

			logChannel.send(newTopic);
		}
	})
});



client.on('guildBanAdd', (guild, user) => {

    if(!guild.member(client.user).hasPermission('EMBED_LINKS')) return;
    if(!guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;

    var logChannel = guild.channels.find(c => c.name === 'log');
    if(!logChannel) return;

    guild.fetchAuditLogs().then(logs => {
        var userID = logs.entries.first().executor.id;
        var userAvatar = logs.entries.first().executor.avatarURL;

        if(userID === client.user.id) return;

        let banInfo = new Discord.RichEmbed()
        .setTitle('**[BANNED]**')
        .setThumbnail(userAvatar)
        .setColor('DARK_RED')
        .setDescription(`**\n**:airplane: Successfully \`\`BANNED\`\` **${user.username}** From the server!\n\n**User:** <@${user.id}> (ID: ${user.id})\n**By:** <@${userID}> (ID: ${userID})`)
        .setTimestamp()
        .setFooter(guild.name, guild.iconURL)

        logChannel.send(banInfo);
    })
});
client.on('guildBanRemove', (guild, user) => {
    if(!guild.member(client.user).hasPermission('EMBED_LINKS')) return;
    if(!guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;

    var logChannel = guild.channels.find(c => c.name === 'log');
    if(!logChannel) return;

    guild.fetchAuditLogs().then(logs => {
        var userID = logs.entries.first().executor.id;
        var userAvatar = logs.entries.first().executor.avatarURL;

        if(userID === client.user.id) return;

        let unBanInfo = new Discord.RichEmbed()
        .setTitle('**[UNBANNED]**')
        .setThumbnail(userAvatar)
        .setColor('GREEN')
        .setDescription(`**\n**:unlock: Successfully \`\`UNBANNED\`\` **${user.username}** From the server\n\n**User:** <@${user.id}> (ID: ${user.id})\n**By:** <@${userID}> (ID: ${userID})`)
        .setTimestamp()
        .setFooter(guild.name, guild.iconURL)

        logChannel.send(unBanInfo);
    })
});

client.on('guildUpdate', (oldGuild, newGuild) => {

    if(!oldGuild.member(client.user).hasPermission('EMBED_LINKS')) return;
    if(!oldGuild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;

    var logChannel = oldGuild.channels.find(c => c.name === 'log');
    if(!logChannel) return;

    oldGuild.fetchAuditLogs().then(logs => {
        var userID = logs.entries.first().executor.id;
        var userAvatar = logs.entries.first().executor.avatarURL;

        if(oldGuild.name !== newGuild.name) {
            let guildName = new Discord.RichEmbed()
            .setTitle('**[CHANGE GUILD NAME]**')
            .setThumbnail(userAvatar)
            .setColor('BLUE')
            .setDescription(`**\n**:white_check_mark: Successfully \`\`EDITED\`\` The guild name.\n\n**Old Name:** \`\`${oldGuild.name}\`\`\n**New Name:** \`\`${newGuild.name}\`\`\n**By:** <@${userID}> (ID: ${userID})`)
            .setTimestamp()
            .setFooter(newGuild.name, oldGuild.iconURL)

            logChannel.send(guildName)
        }
        if(oldGuild.region !== newGuild.region) {
            let guildRegion = new Discord.RichEmbed()
            .setTitle('**[CHANGE GUILD REGION]**')
            .setThumbnail(userAvatar)
            .setColor('BLUE')
            .setDescription(`**\n**:white_check_mark: Successfully \`\`EDITED\`\` The guild region.\n\n**Old Region:** ${oldGuild.region}\n**New Region:** ${newGuild.region}\n**By:** <@${userID}> (ID: ${userID})`)
            .setTimestamp()
            .setFooter(oldGuild.name, oldGuild.iconURL)

            logChannel.send(guildRegion);
        }
        if(oldGuild.verificationLevel !== newGuild.verificationLevel) {
            if(oldGuild.verificationLevel === 0) {
                var oldVerLvl = 'Very Easy';
            }else
            if(oldGuild.verificationLevel === 1) {
                var oldVerLvl = 'Easy';
            }else
            if(oldGuild.verificationLevel === 2) {
                var oldVerLvl = 'Medium';
            }else
            if(oldGuild.verificationLevel === 3) {
                var oldVerLvl = 'Hard';
            }else
            if(oldGuild.verificationLevel === 4) {
                var oldVerLvl = 'Very Hard';
            }

            if(newGuild.verificationLevel === 0) {
                var newVerLvl = 'Very Easy';
            }else
            if(newGuild.verificationLevel === 1) {
                var newVerLvl = 'Easy';
            }else
            if(newGuild.verificationLevel === 2) {
                var newVerLvl = 'Medium';
            }else
            if(newGuild.verificationLevel === 3) {
                var newVerLvl = 'Hard';
            }else
            if(newGuild.verificationLevel === 4) {
                var newVerLvl = 'Very Hard';
            }

            let verLog = new Discord.RichEmbed()
            .setTitle('**[GUILD VERIFICATION LEVEL CHANGE]**')
            .setThumbnail(userAvatar)
            .setColor('BLUE')
            .setDescription(`**\n**:white_check_mark: Successfully \`\`EDITED\`\` Guild Verification level.\n\n**Old Verification Level:** ${oldVerLvl}\n**New Verification Level:** ${newVerLvl}\n**By:** <@${userID}> (ID: ${userID})`)
            .setTimestamp()
            .setFooter(oldGuild.name, oldGuild.iconURL)

            logChannel.send(verLog);
        }
    })
});

client.on('guildMemberUpdate', (oldMember, newMember) => {
	if(!oldMember.guild) return;
		        if(!log[oldMember.guild.id]) log[oldMember.guild.id] = {
          onoff: 'Off'
        }
    if(log[oldMember.guild.id].onoff === 'Off') return;
	var logChannel = oldMember.guild.channels.find(c => c.name === `${log[oldMember, newMember.guild.id].channel}`);
	if(!logChannel) return;

	oldMember.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userAvatar = logs.entries.first().executor.avatarURL;
		var userTag = logs.entries.first().executor.tag;

		if(oldMember.nickname !== newMember.nickname) {
			if(oldMember.nickname === null) {
				var oldNM = '`اسمه الاصلي`';
			}else {
				var oldNM = oldMember.nickname;
			}
			if(newMember.nickname === null) {
				var newNM = '`اسمه الاصلي`';
			}else {
				var newNM = newMember.nickname;
			}

			let updateNickname = new Discord.RichEmbed()
			.setTitle('**[UPDATE MEMBER NICKNAME]**')
			.setThumbnail(userAvatar)
			.setColor('BLUE')
			.setDescription(`**\n**:spy: Successfully \`\`CHANGE\`\` Member Nickname.\n\n**User:** ${oldMember} \n**Old Nickname:** ${oldNM}\n**New Nickname:** ${newNM}\n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(oldMember.guild.name, oldMember.guild.iconURL)

			logChannel.send(updateNickname);
		}
		if(oldMember.roles.size < newMember.roles.size) {
			let role = newMember.roles.filter(r => !oldMember.roles.has(r.id)).first();
					        if(!log[oldMember.guild.id]) log[oldMember.guild.id] = {
          onoff: 'Off'
        }
            if(log[oldMember.guild.id].onoff === 'Off') return;
			let roleAdded = new Discord.RichEmbed()
			.setTitle('**[ADDED ROLE TO MEMBER]**')
			.setThumbnail(oldMember.guild.iconURL)
			.setColor('GREEN')
			.setDescription(`**\n**:white_check_mark: Successfully \`\`ADDED\`\` Role to **${oldMember.user.username}**\n\n**User:** <@${oldMember.id}> \n**Role:** \`\`${role.name}\`\` \n**By:** <@${userID}>`)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(roleAdded);
		}
		if(oldMember.roles.size > newMember.roles.size) {
			let role = oldMember.roles.filter(r => !newMember.roles.has(r.id)).first();
					        if(!log[oldMember.guild.id]) log[oldMember.guild.id] = {
          onoff: 'Off'
        }
            if(log[oldMember, newMember.guild.id].onoff === 'Off') return;
			let roleRemoved = new Discord.RichEmbed()
			.setTitle('**[REMOVED ROLE FROM MEMBER]**')
			.setThumbnail(oldMember.guild.iconURL)
			.setColor('RED')
			.setDescription(`**\n**:negative_squared_cross_mark: Successfully \`\`REMOVED\`\` Role from **${oldMember.user.username}**\n\n**User:** <@${oldMember.user.id}> (ID: ${oldMember.id})\n**Role:** \`\`${role.name}\`\` (ID: ${role.id})\n**By:** <@${userID}> (ID: ${userID})`)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(roleRemoved);
		}
	})
	if(oldMember.guild.owner.id !== newMember.guild.owner.id) {
	  		        if(!log[oldMember.guild.id]) log[oldMember.guild.id] = {
          onoff: 'Off'
        }
        if(log[oldMember, newMember.guild.id].onoff === 'Off') return;
        let newOwner = new Discord.RichEmbed()
		.setTitle('**[UPDATE GUILD OWNER]**')
		.setThumbnail(oldMember.guild.iconURL)
		.setColor('GREEN')
		.setDescription(`**\n**:white_check_mark: Successfully \`\`TRANSFER\`\` The Owner Ship.\n\n**Old Owner:** <@${oldMember.user.id}> \n**New Owner:** <@${newMember.user.id}>`)
		.setTimestamp()
		.setFooter(oldMember.guild.name, oldMember.guild.iconURL)

		logChannel.send(newOwner);
	}
});


client.on('voiceStateUpdate', (voiceOld, voiceNew) => {

	if(!voiceOld.guild.member(client.user).hasPermission('EMBED_LINKS')) return;
	if(!voiceOld.guild.member(client.user).hasPermission('VIEW_AUDIT_LOG')) return;
			        if(!log[voiceOld.guild.id]) log[voiceOld.guild.id] = {
          onoff: 'Off'
        }
    if(log[voiceOld, voiceOld.guild.id].onoff === 'Off') return;
	var logChannel = voiceOld.guild.channels.find(c => c.name === `${log[voiceOld, voiceNew.guild.id].channel}`);
	if(!logChannel) return;

	voiceOld.guild.fetchAuditLogs().then(logs => {
		var userID = logs.entries.first().executor.id;
		var userTag = logs.entries.first().executor.tag;
		var userAvatar = logs.entries.first().executor.avatarURL;

		if(voiceOld.serverMute === false && voiceNew.serverMute === true) {
			let serverMutev = new Discord.RichEmbed()
			.setTitle('**[VOICE MUTE]**')
			.setThumbnail('https://images-ext-1.discordapp.net/external/pWQaw076OHwVIFZyeFoLXvweo0T_fDz6U5C9RBlw_fQ/https/cdn.pg.sa/UosmjqDNgS.png')
			.setColor('RED')
			.setDescription(`**User:** ${voiceOld} \n**By:** <@${userID}> \n**Channel:** \`\`${voiceOld.voiceChannel.name}\`\``)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(serverMutev);
		}
		if(voiceOld.serverMute === true && voiceNew.serverMute === false) {
		  			        if(!log[voiceOld.guild.id]) log[voiceOld.guild.id] = {
          onoff: 'Off'
        }
            if(log[voiceOld, voiceOld.guild.id].onoff === 'Off') return;
			let serverUnmutev = new Discord.RichEmbed()
			.setTitle('**[VOICE UNMUTE]**')
			.setThumbnail('https://images-ext-1.discordapp.net/external/u2JNOTOc1IVJGEb1uCKRdQHXIj5-r8aHa3tSap6SjqM/https/cdn.pg.sa/Iy4t8H4T7n.png')
			.setColor('GREEN')
			.setDescription(`**User:** ${voiceOld} \n**By:** <@${userID}> \n**Channel:** \`\`${voiceOld.voiceChannel.name}\`\` `)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(serverUnmutev);
		}
		if(voiceOld.serverDeaf === false && voiceNew.serverDeaf === true) {
		  			        if(!log[voiceOld.guild.id]) log[voiceOld.guild.id] = {
          onoff: 'Off'
        }
            if(log[voiceOld, voiceOld.guild.id].onoff === 'Off') return;
			let serverDeafv = new Discord.RichEmbed()
			.setTitle('**[VOICE DEAF]**')
			.setThumbnail('https://images-ext-1.discordapp.net/external/7ENt2ldbD-3L3wRoDBhKHb9FfImkjFxYR6DbLYRjhjA/https/cdn.pg.sa/auWd5b95AV.png')
			.setColor('RED')
			.setDescription(`**User:** ${voiceOld} \n**By:** <@${userID}> (ID: ${userID})\n**Channel:** \`\`${voiceOld.voiceChannel.name}\`\` `)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(serverDeafv);
		}
		if(voiceOld.serverDeaf === true && voiceNew.serverDeaf === false) {
		  			        if(!log[voiceOld.guild.id]) log[voiceOld.guild.id] = {
          onoff: 'Off'
        }
            if(log[voiceOld, voiceOld.guild.id].onoff === 'Off') return;
			let serverUndeafv = new Discord.RichEmbed()
			.setTitle('**[VOICE UNDEAF]**')
			.setThumbnail('https://images-ext-2.discordapp.net/external/s_abcfAlNdxl3uYVXnA2evSKBTpU6Ou3oimkejx3fiQ/https/cdn.pg.sa/i7fC8qnbRF.png')
			.setColor('GREEN')
			.setDescription(`**User:** ${voiceOld} \n**By:** <@${userID}> (ID: ${userID})\n**Channel:** \`\`${voiceOld.voiceChannel.name}\`\` `)
			.setTimestamp()
			.setFooter(userTag, userAvatar)

			logChannel.send(serverUndeafv);
		}
	})

	if(voiceOld.voiceChannelID !== voiceNew.voiceChannelID && voiceNew.voiceChannel && voiceOld.voiceChannel != null) {
	  			        if(!log[voiceOld.guild.id]) log[voiceOld.guild.id] = {
          onoff: 'Off'
        }
        if(log[voiceOld, voiceOld.guild.id].onoff === 'Off') return;
		let voiceLeave = new Discord.RichEmbed()
		.setTitle('**[CHANGED VOICE ROOM]**')
		.setColor('GREEN')
		.setThumbnail(voiceOld.user.avatarURL)
		.setDescription(`**\n**:repeat: Successfully \`\`CHANGED\`\` The Voice Channel.\n\n**From:** \`\`${voiceOld.voiceChannel.name}\`\` \n**To:** \`\`${voiceNew.voiceChannel.name}\`\` (ID: ${voiceNew.voiceChannelID})\n**User:** ${voiceOld} `)
		.setTimestamp()
		.setFooter(voiceOld.user.tag, voiceOld.user.avatarURL)

		logChannel.send(voiceLeave);
	}
});







var dat = JSON.parse("{}");
function forEachObject(obj, func) {
    Object.keys(obj).forEach(function (key) { func(key, obj[key]) })
}
client.on("ready", () => {
    var guild;
    while (!guild)
        guild = client.guilds.find("name", "ProjectTeam")
    guild.fetchInvites().then((data) => {
        data.forEach((Invite, key, map) => {
            var Inv = Invite.code;
            dat[Inv] = Invite.uses;
        })
    })
})
client.on("guildMemberAdd", (member) => {
    let channel = member.guild.channels.find('name', 'chat');
    if (!channel) {
        console.log("!channel fails");
        return;
    }
    if (member.id == client.user.id) {
        return;
    }
    console.log('made it till here!');
    var guild;
    while (!guild)
        guild = client.guilds.find("name", "ProjectTeam")
    guild.fetchInvites().then((data) => {
        data.forEach((Invite, key, map) => {
            var Inv = Invite.code;
            if (dat[Inv])
                if (dat[Inv] < Invite.uses) {
                    console.log(3);
                    console.log(`${member} joined over ${Invite.inviter}'s invite ${Invite.code}`)
 channel.send(`  **Invited By ${Invite.inviter} ** `)
 }
            dat[Inv] = Invite.uses;
        })
    })
});































client.login("توكن حق بوت انتا يا خالد");