import discord
from discord.ext import commands

class Voice(commands.Cog):
    def __init__(self, bot):
        self.bot: commands.Bot = bot
        print('Module {} is loaded'.format(self.__class__.__name__))

    @commands.Cog.listener()
    async def on_voice_state_update(self, member, before, after):
        if after.channel != None:
            if after.channel.id == айди нашего канала:
                category = after.channel.category
              
                channel2 = await member.guild.create_voice_channel(
                    name = f'{ member.display_name }',
                    category = category,
                )
                await channel2.set_permissions(member, connect = True)
                await member.move_to(channel2)
                role = discord.utils.get(member.guild.roles, name='voice') # название своей роли при заходе в наш войс
                await member.add_roles(role)

                def check(x, y, z): return len(channel2.members) == 0
              
                await self.bot.wait_for('voice_state_update', check = check) # проверка канала когда мы ливаем
                await channel2.delete() # удаление канала
                await member.remove_roles(role) # снятие роли

def setup(client):
    client.add_cog(Voice(client))

blacklist = ["сука", "шлюха", "пидр", "нахуй", "блять", "Блять", "Сука", "Шлюха", "Пидр", "Нахуй", "хуй", "Хуй", "долбаеб", "Долбаеб", "Нахуя", "нахуя", "уебан", "Уебан", "долбаёб", "Долбаёб"]

    @commands.Cog.listener()
    async def on_message(self, message):
        content = message.content.replace(' ', '')
        if any(word in content.lower() for word in blacklist):
            role = discord.utils.get(message.guild.roles, name = 'модер')
            if role in message.author.roles:
                return
            await message.channel.send(f'{message.author.mention}, ууу... кого по губам отшлепать??')
            await message.delete()

            name = message.guild.name

            base.execute('CREATE TABLE IF NOT EXISTS {}(userid INT, count INT)'.format(name))
            base.commit()

            warning = cur.execute('SELECT * FROM {} WHERE userid == ?'.format(name),(message.author.id,)).fetchone()

            if warning == None:
                cur.execute('INSERT INTO {} VALUES(?, ?)'.format(name),(message.author.id,1))
                base.commit()
                await message.channel.send(f'{message.author.mention}, 1-ое предупреждение, на 3-е - БАН')

            elif warning[1] == 1:
                cur.execute('UPDATE {} SET count == ? WHERE userid == ?'.format(name),(2,message.author.id))
                base.commit()
                await message.channel.send(f'{message.author.mention}, 2-ое предупреждение, на 3-е - БАН')
            
            elif warning[1] == 2:
                cur.execute('UPDATE {} SET count == ? WHERE userid == ?'.format(name),(3,message.author.id))
                base.commit()
                await message.channel.send(f'{message.author.mention}, забанен за мат в чате.')
                cur.execute('DELETE FROM {} WHERE userid == ?'.format(message.guild.name),(message.author.id,)).fetchone()
                base.commit()
                cur.execute(f'DELETE FROM users WHERE guildid = {message.guild.id} and userid={message.author.id}')
                base.commit()
                await message.author.ban(reason='Мат в чате')

def load_json(filename):
    with open(filename, encoding="utf-8") as infile:
        return json.load(infile)


def write_json(filename, content):
    with open(filename, "w") as outfile:
        json.dump(content, outfile, ensure_ascii=True, indent=4)

    @commands.command()
    @commands.has_permissions(administrator=True)
    async def unmute(self, ctx, member: discord.Member):
        await member.remove_roles(self.mutedrole)
        emb = discord.Embed( title = 'Unmute', description = f'{ctx.author.name} размутил {member.display_name}', colour = discord.Color.blue() )
        emb.set_footer( text = ctx.author.name, icon_url = ctx.author.avatar)
        await ctx.send(embed=emb)
        mutes = load_json("jsons/mutes.json")
        mutes.pop(str(member.id))
        write_json("jsons/mutes.json", mutes)

    @commands.command()
    @commands.has_permissions(administrator=True)
    async def mute(self, ctx, member: discord.Member = None, time: str = None, *, reason="не указана"):
        if member is None:
            return await ctx.send("Пользователь не указан")
        if member.bot is True:
            return await ctx.send("Вы не можете замутить бота")
        if member == ctx.author:
            return await ctx.send("Вы не можете замутить себя")
        if len(reason) > 150:
            return await ctx.send("Причина слишком длинная")
        if member and member.top_role.position >= ctx.author.top_role.position:
            return await ctx.send("Вы не можете замутить человека с ролью выше вашей")
        if time is None:
            return await ctx.send("Вы не указали время")
        else:
            try:
                seconds = int(time[:-1])
                duration = time[-1]
                if duration == "s":
                    pass
                if duration == "m":
                    seconds *= 60
                if duration == "h":
                    seconds *= 3600
                if duration == "d":
                    seconds *= 86400
            except:
                return await ctx.send("Не правильная длительность")
            mute_expiration = (datetime.datetime.now() + datetime.timedelta(hours = +2, seconds=int(seconds))).strftime("%H:%M:%S %d.%m.%Y")
            if not self.mutedrole:
                return await ctx.send("Я не могу найти роль")
            mutes = load_json("jsons/mutes.json")
            try:
                member_mute = mutes[str(member.id)]
                return await ctx.send("Пользователь уже замучен")
            except:
                mute_expiration = (datetime.datetime.now() + datetime.timedelta(hours = +2, seconds=int(seconds))).strftime("%H:%M:%S %d.%m.%Y")
                mutes[str(member.id)] = str(mute_expiration)
                write_json("jsons/mutes.json", mutes)
                await member.add_roles(self.mutedrole)
                await member.move_to(channel=None)
                emb = discord.Embed( title = 'Mute', description = f'{ctx.author.name} замутил {member.display_name} до {mute_expiration} по причине: {reason}', colour = discord.Color.blue() )
                emb.set_footer( text = ctx.author.name, icon_url = ctx.author.avatar)
                await ctx.send(embed=emb)

    @tasks.loop()
    async def check_mutes(self):
        current = (datetime.datetime.now() + datetime.timedelta(hours = +2))
        mutes = load_json("jsons/mutes.json")
        users, times = list(mutes.keys()), list(mutes.values())
        for i in range(len(times)):
            time = times[i]
            unmute = datetime.datetime.strptime(str(time), "%H:%M:%S %d.%m.%Y")
            if unmute < current:
                user_id = users[times.index(time)]
                try:
                    member = await self.guild.fetch_member(int(user_id))
                    await member.remove_roles(self.mutedrole)
                    mutes.pop(str(member.id))
                except discord.NotFound:
                    pass
                write_json("jsons/mutes.json", mutes)

def load_json(filename):
    with open(filename, encoding="utf-8") as infile:
        return json.load(infile)


def write_json(filename, content):
    with open(filename, "w") as outfile:
        json.dump(content, outfile, ensure_ascii=True, indent=4)

@client.event
async def on_member_join(member):
    mutes = load_json("jsons/mutes.json")
    if str(member.id) in mutes:
        role = discord.utils.get(member.guild.roles, name='mute')
        await member.add_roles(role)

import discord
from discord.ext import commands, tasks
import json
import sqlite3
from discord.ui import Button, View, Modal, InputText

class Verif(Modal): # делаем класс для отправки модального меню, также вам прийдется создать папку jsons и вставить туда файлы users.json и passw.json
    def __init__(self, bot) -> None:
        self.bot = bot
        super().__init__(title="Подтвердить действие")

        self.add_item(
            InputText(
            label="Ваш id:",
            placeholder="123456789101112131",
            min_length = 18,
            max_length = 18,
            style=discord.InputTextStyle.singleline
            )
        )
        self.add_item(
            InputText(
            label="Ваш капча-код из Л/С:",
            placeholder="123456789",
            min_length = 6,
            max_length = 6,
            style=discord.InputTextStyle.singleline
            )
        )

    async def callback(self, interaction: discord.Interaction):
        short = self.children[1].value
        short1 = self.children[0].value
        cc = load_json("jsons/passw.json")
        captcha_code = cc[str(interaction.user.id)]
        if short == captcha_code and interaction.user.id == int(short1):
            await interaction.response.send_message(f'Спасибо, Вы успешно прошли капчу! Добро пожаловать, {interaction.user.name}!', ephemeral=True)
            cc = load_json("jsons/passw.json")
            status = 'verified'
            cc[str(interaction.user.id)] = str(status)
            write_json("jsons/passw.json", cc)
            verify = discord.utils.get(interaction.user.guild.roles, name='verify') # сюда название своей роли
            await interaction.user.add_roles( verify )
            channel = self.bot.get_channel(986647044116611132)
            await channel.send(f'{interaction.user} прошел верефикацию')
        else:
            await interaction.response.send_message(f"Упс... Вы не прошли капчу, Вы кикнуты!", ephemeral=True)
            await interaction.user.send(f'Уважаемый пользователь! Вы были кикнуты с сервера, т.к. Вы не прошли капчу.')
            await interaction.user.kick(reason='Данный пользователь не прошёл капчу (проверку).')
            channel = self.bot.get_channel(986647044116611132)
            await channel.send(f'{interaction.user} не прошел верефикацию')
           
class Myview(discord.ui.View): # далее делаем класс с бесконечной кнопкой
    def __init__(self, bot):
        self.bot = bot
        super().__init__(timeout=None)
    @discord.ui.button(label="ПОДТВЕРДИТЬ", style=discord.ButtonStyle.primary, emoji = '<:735015302794051665:853212498671960074> ', custom_id='button') # эмодзи замените на свое т.к. кнопка может не работать

    async def button_callback(self, button, interaction):
        base.execute('CREATE TABLE IF NOT EXISTS verify(userid INT, status TEXT)')
        base.commit()
        verify = cur.execute(f'SELECT userid FROM verify WHERE userid == {interaction.user.id}').fetchone()
        if verify == None:
            cur.execute(f"INSERT INTO verify VALUES (?, ?)", [interaction.user.id, 'click'])
            base.commit()
            cc = load_json("jsons/passw.json")
            captcha_code = cc[str(interaction.user.id)]
            await interaction.response.send_message(f'Здравствуйте, ваш код: ||{captcha_code}||\nВы его должны ввести прямо сейчас, нажав на кнопку еще раз.', ephemeral=True)
        else:
            modal = Verif(self.bot)
            await interaction.response.send_modal(modal)
           
class Moderation(commands.Cog): # запускаем сам ког
    def __init__(self, bot):
        self.bot: commands.Bot = bot
        print('Module {} is loaded'.format(self.__class__.__name__))
       
    @commands.command()
    @commands.has_permissions(administrator=True)
    async def verif(self, ctx):
        emb = discord.Embed( title = 'Верефицироваться', description = f'Нажимая на данныю кнопку вы подтвержаете что ознакомлены со всеми правилами', colour = discord.Color.blue() )
        await ctx.send(embed=emb, view=Myview(self.bot))

    @commands.Cog.listener()
    async def on_ready(self):
        global base, cur
        base = sqlite3.connect('cogs/Warn.db')
        cur = base.cursor()
        if base:
            print('Database подключен')
        for guild in self.bot.guilds:
            #try:
                self.bot.add_view(Myview(self.bot)) # комменты не убираем выше и нижу они нужны
           #except TypeError:
                #continue

def setup(client):
    client.add_cog(Moderation(client))

from discord.ext import commands
import discord
import sqlite3 # импорт нашей дб

class Messages(commands.Cog):
    def __init__(self, bot):
        self.bot: commands.Bot = bot
        print('Module {} is loaded'.format(self.__class__.__name__))

    @commands.Cog.listener()
    async def on_message(self, message):
        if not message.author.bot:
            if not message.content.startswith('*'):
                base = sqlite3.connect('cogs/Warn.db') # коннект к дб, название пишите какое хотите
                cur = base.cursor()
                base.execute('CREATE TABLE IF NOT EXISTS users(guildid INT, userid INT, messages INT)') # после коннекта создается таблица с данными о пользователе, а тоесть айди гильдии, айди юзера, и кол-во сообщений
                base.commit()

                messages = cur.execute(f'SELECT userid FROM users WHERE guildid == ? and userid == ?', [message.guild.id, message.author.id]).fetchone() # он селектит наш айди и проверяет его в дб

                if messages == None: # как видите если такого нет, то он заносит его в дб, показано ниже
                    cur.execute(f"INSERT INTO users VALUES ({message.guild.id}, {message.author.id}, 1)")
                    base.commit()
                else: # если есть то он прибовляет +1 к сообщениям
                    cur.execute(f"SELECT * FROM users WHERE guildid = {message.guild.id} and userid={message.author.id}")
                    if len(message.content) >=  1:
                        cur.execute(f"UPDATE users SET messages = messages + 1 WHERE guildid = {message.guild.id} and userid={message.author.id}")
                        base.commit()

def setup(client):
    client.add_cog(Messages(client))

from discord.ext import commands
import os
from config import settings #туда токен
import discord
from discord.ext import tasks


intents = discord.Intents.all()
client = commands.Bot(command_prefix='*', intents=intents)
client.remove_command('help')

@client.command()
async def load(ctx, extension):
    if ctx.author.id == ваш айди:
        await client.load_extension(f'cogs.{extension}')
        await ctx.send(f'{extension} loaded')
    else:
        await ctx.send('Вы не создатель бота')


@client.command()
async def unload(ctx, extension):
    if ctx.author.id == ваш айди:
        await client.unload_extension(f'cogs.{extension}')
        await ctx.send(f'{extension} unloaded')
    else:
        await ctx.send('Вы не создатель бота')


@client.command()
async def reload(ctx, extension):
    if ctx.author.id == ваш айди:
        await client.unload_extension(f'cogs.{extension}')
        await client.load_extension(f'cogs.{extension}')
        await ctx.send(f'{extension} reloaded')
    else:
        await ctx.send('Вы не создатель бота')


for filename in os.listdir(r"cogs"):
    if filename.endswith('.py'):
        client.load_extension(f'cogs.{filename[:-3]}')

client.run(settings['token'])

settings = {
    'token': 'токен вашего бота',
}

from discord.ext import commands
import discord

class Messages(commands.Cog): #Messages - название кога оно может быть любым
    def __init__(self, bot):
        self.bot: commands.Bot = bot
        print('Module {} is loaded'.format(self.__class__.__name__))

    @commands.command()
    async def ping(self, ctx): # self обязательно должно присутствовать в любой команде кога
        await ctx.send('Pong!')

def setup(client):
    client.add_cog(Messages(client)) # Messages тоже заменяем тут если вам надо