import discord
from discord.ext import commands
import requests
from pymongo.mongo_client import MongoClient
from pymongo.server_api import ServerApi
import random
import os
import glob
import json
import sys
import re
from dhooks_lite import Webhook
import time

config = json.load(open('config.json'))

intents = discord.Intents.default()
intents.members = True
intents.presences =  True
intents.message_content =  True
bot = discord.Bot(intents=intents)


folder_path = 'combo'

# Utilisez glob pour récupérer tous les fichiers du dossier
file_paths = glob.glob(os.path.join(folder_path, '*'))


# Créez l'objet MongoClient
client = MongoClient(config["MongoClient"])

# Accédez à la base de données
db = client['gen']


service2 = db['services']
# Accédez à la collection
collection = db['credentials']

services_list = service2.distinct("name")
print(f"All service imported : \n{services_list}")



services = list(collection.distinct("service"))




admins = config["admin-id"]
serveraid = config["server-id"]
idrestock = config["id-restock"]

cooldown = config["cooldown"]
stockchannel = config["stockchannel"]
restockchannel = config["restockchannel"]
genchannel = config["genchannel"]

roleidtel = config["roleidtel"]
roleidpc = config["roleidpc"]
rolevip = config["rolevip"]
Webook = config["webook"]
def restart():
    print("argv was",sys.argv)
    print("sys.executable was", sys.executable)
    print("restart now")
    os.execv(sys.executable, ['python'] + sys.argv)


def logwebook(personne, var):
    current_time = time.localtime()
    formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", current_time)
    hook = Webhook(Webook)
    hook.execute(f"[{formatted_time}] — UserId: {personne} — Reponse: {var}")


@bot.event
async def on_ready():

    print(f'Logged in as {bot.user.name} ({bot.user.id})')



@bot.slash_command(name="setstatus", description="Met à jour le statut du bot")
async def setstatus(ctx, status: str = None):
    if str(ctx.author.id) not in admins:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas le droit d'utiliser cette commande !",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return
    
    if status:
        await bot.change_presence(activity=discord.Game(name=status))
        await ctx.respond(f"Statut mis à jour : Joue à {status}", ephemeral=True)
    else:
        await bot.change_presence(activity=None)
        await ctx.respond("Statut supprimé", ephemeral=True)


categories = [
    'Anal', 'Ass', 'Boobs', 'Gonewild', 'Hanal', 'Hass', 'Hboobs',
    'Hentai', 'Hkitsune', 'Hmidriff', 'Hneko', 'Hthigh', 'Neko',
    'Paizuri', 'Pgif', 'Pussy', 'Tentacle', 'Thigh', 'Yaoi'
]

@bot.slash_command(name="nsfw")
async def nsfw(ctx, category: discord.Option(str, choices=categories)): # type: ignore

    if str(ctx.author.id) not in admins:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas le droit d'utiliser cette commande !",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")
        return
    
    url = f"https://api.night-api.com/images/nsfw?category={category}"
    headers = {
        "authorization": "UW9QPOyFHx-52GvPoGwLBqGpxIZ7Y4s-hoAVcEZBYF"
    }
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        data = response.json()
        desc = f"Here is your {category} image"
        image = data['content']['url']
        color = discord.Colour.blurple()
    else:
        desc = f"Error contact Dovik"
        color = discord.Colour.red()
    embed = discord.Embed(
        title=f"{category} Image!",
        description=desc,
        color=color,
    )
    embed.set_image(url=image)
    await ctx.respond(embed=embed)


#gen bot commence ici






async def cooldown(ctx: commands.Context):
    if ctx.author.id in admins:  # Si l'utilisateur est administrateur, pas de cooldown.
        return None
    
    return commands.Cooldown(1, 50).total_seconds()



service_types = ["free", "premium"]

@bot.slash_command(name="create")
async def create(ctx, type: discord.Option(str, choices=service_types), name: str):
    if str(ctx.author.id) not in admins:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas le droit d'utiliser cette commande !",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")
        return
    

    # Vérifier si le service existe déjà
    existing_service = service2.find_one({"name": name})
    if existing_service:
        embed = discord.Embed(title="Erreur", description=f"Le service '{name}' existe déjà dans la base de données.", color=discord.Color.red())
        await ctx.respond(embed=embed, ephemeral=True)
        return
    
    # Insérer le nouveau service dans la collection MongoDB
    service_data = {
        "name": name,
        "type": type
    }
    result = service2.insert_one(service_data)
    print(f"Inserted Document ID: {result.inserted_id}")
    
    embed = discord.Embed(title="Service ajouté", description=f"Service `{name}` de type `{type}` ajouté avec succès!", color=discord.Color.blue())
    await ctx.respond(embed=embed)
    
    services_list.append(type)
    restart()

@bot.slash_command(name="remove")
async def remove(ctx, service: discord.Option(str, choices=services_list)): # type: ignore
    
    author_id_str = str(ctx.author.id)

    if author_id_str in admins:
        # Supprimer le service de la base de données service2
        delete_result_service2 = service2.delete_one({"name": service})

        if delete_result_service2.deleted_count == 1:
            # Supprimer toutes les données associées dans db2_collection
            delete_result_db2 = collection.delete_many({"service": service})
            deleted_count_db2 = delete_result_db2.deleted_count
            
            embed = discord.Embed(
                title="Service Supprimé",
                description=f"Le service `{service}` a été supprimé avec succès de la base de données.",
                color=discord.Color.blue()
            )
            embed.add_field(
                name="Entrées Supprimées",
                value=f"{deleted_count_db2} entrées associées ont également été supprimées de `db2`."
            )
            await ctx.respond(embed=embed)
            restart()
        else:
            embed = discord.Embed(
                title="Erreur",
                description=f"Impossible de supprimer le service `{service}` de la base de données. Assurez-vous que le nom est correct.",
                color=discord.Color.red()
            )
            await ctx.respond(embed=embed, ephemeral=True)
    else:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas le droit d'utiliser cette commande !",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")


@bot.slash_command(name="reboot", description="Reboots the bot")
async def reboot(ctx):

    author_id_str = str(ctx.author.id)
    if author_id_str in admins:
        embed = discord.Embed(
            title="Redémarrage en Cours",
            description="Le bot va redémarrer. Tous les changements apportés au bot seront appliqués.",
            color=discord.Color.blue()  # Choisissez une couleur appropriée pour le redémarrage
        )
        await ctx.respond(embed=embed)
        restart()  # Appel à la fonction ou méthode de redémarrage du bot
    else:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas le droit d'utiliser cette commande !",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")



@bot.slash_command(name="stock")
async def stock(ctx):
    if ctx.guild.id != serveraid:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande sur ce serveur. ID serveur invalide: [{serveraid}]",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error Mauvais serveur \n Id: {ctx.guild.id} — Le lien : {await ctx.channel.create_invite(max_age=0, max_uses=0)}")
        return

    if ctx.channel.id != stockchannel:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande dans ce canal. Utilisez le canal <#{stockchannel}>.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error mauvais Channel {ctx.channel.id}")
        return

    # Récupérer les services de DB1
    services_cursor = service2.find()

    # Préparer une liste de services
    services = []
    for service in services_cursor:
        if 'name' in service and 'type' in service:
            services.append(service)

    # Créer un dictionnaire pour stocker les résultats
    result_dict = {}

    # Parcourir chaque service et compter les occurrences dans DB2
    for service in services:
        service_name = service['name']
        service_type = service['type']

        # Chercher le nombre d'occurrences du service dans DB2
        count = collection.count_documents({'service': service_name})

        if service_type not in result_dict:
            result_dict[service_type] = []

        # Déterminer la couleur en fonction du nombre de services
        if count <= 10:
            color = "🔴"
        elif count <= 40:
            color = "🟡"
        elif count <= 2000:
            color = "🟢"
        else:
            color = "🔵"

        # Ajouter l'information au dictionnaire
        result_dict[service_type].append(f"{color} {service_name}: {count}")

    # Vérifier si le dictionnaire est vide
    if not result_dict:
        await ctx.respond("Il n'y a aucun service disponible en stock.")
        return

    # Créer un embed pour afficher les résultats
    embed = discord.Embed(title="Stock Complet des Services", color=discord.Color.blue())

    # Ajouter les services au embed
    for service_type, service_list in result_dict.items():
        services_str = "\n".join(service_list)  # Combinez tous les services en une seule chaîne
        embed.add_field(name=f"{service_type}", value=f"```{services_str}```", inline=False)

    # Ajouter la légende
    embed.set_footer(text="🔴: Stock très bas\n🟡: Stock faible\n🟢: Stock abondant\n🔵: Stock complet")

    # Envoyer l'embed en réponse
    await ctx.respond(embed=embed)



@bot.slash_command(name="restock")
async def restock(ctx, service: discord.Option(str, choices=services_list), file: discord.Attachment):

    if ctx.guild.id != serveraid:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande sur ce serveur.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error Mauvais serveur \n Id: {ctx.guild.id} — Le lien : {await ctx.channel.create_invite(max_age=0, max_uses=0)}")
        return


    if str(ctx.author.id) not in admins:
        if str(ctx.author.id) not in idrestock:
            embed = discord.Embed(
                title="Accès Refusé",
                description="Vous n'avez pas le droit d'utiliser cette commande !",
                color=discord.Color.red()
            )
            await ctx.respond(embed=embed, ephemeral=True)
            logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")
            return
    

    if ctx.channel.id != restockchannel:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande dans ce canal. Utilisez le canal <#{restockchannel}>.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error mauvais Channel {ctx.channel.id}")
        return

    # Vérifier si le service existe dans la collection service2
    service_exists = service2.find_one({"name": service})
    if not service_exists:
        embed = discord.Embed(
            title="Service Non Trouvé",
            description=f"Le service `{service}` n'existe pas dans la base de données.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return

    # Vérifier le type de fichier
    if not file.filename.endswith('.txt'):
        embed = discord.Embed(
            title="Format de Fichier Incorrect",
            description="Veuillez fournir un fichier texte (.txt).",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return

    # Télécharger et lire le fichier
    file_data = await file.read()
    file_content = file_data.decode('utf-8')
    lines = file_content.splitlines()

    # Regex pour vérifier le format variable:truc
    pattern = re.compile(r'^[^:]+:[^:]+$')

    # Préparer les services à ajouter
    services_to_add = []
    invalid_lines = []
    for line in lines:
        if pattern.match(line):
            # Séparer la ligne en variable et truc
            variable, truc = line.split(':', 1)
            entry = {
                "service": service,
                "email": variable.strip(),
                "pass": truc.strip()
            }
            services_to_add.append(entry)
        else:
            invalid_lines.append(line)

    if invalid_lines:
        embed = discord.Embed(
            title="Lignes Invalides",
            description=f"Les lignes suivantes ont un format invalide : \n```\n{invalid_lines}\n```",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return

    # Insérer les services dans db2_collection
    if services_to_add:
        await ctx.respond(f"{len(services_to_add)} entrées ajoutées pour le service `{service}`.")
        collection.insert_many(services_to_add)
    else:
        embed = discord.Embed(
            title="Aucune Entrée à Ajouter",
            description="Le fichier est vide ou n'a pas de contenu valide pour le restockage.",
            color=discord.Color.orange()
        )
        await ctx.respond(embed=embed)



services = service2.find({'type': "free".lower()})
freeservicelist = [service['name'] for service in services]

@bot.slash_command(name="gen", description="Génère un compte pour le service spécifié.")
@commands.cooldown(1, 600, commands.BucketType.user)
async def gen(ctx, service: discord.Option(str, choices=freeservicelist)):


    if ctx.guild.id != serveraid:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande sur ce serveur.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error Mauvais serveur \n Id: {ctx.guild.id} — Le lien : {await ctx.channel.create_invite(max_age=0, max_uses=0)}")
        return


    if ctx.channel.id != genchannel:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande dans ce canal. Utilisez le canal <#{genchannel}>.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error mauvais Channel {ctx.channel.id}")
        return
    

    # Vérifiez si le service existe et son type (gratuit ou premium)
    service_info = service2.find_one({"name": service}, {"type": 1})
    if not service_info:
        embed = discord.Embed(
            title="Service Non Trouvé",
            description=f"Le service `{service}` n'existe pas dans la base de données.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return
    
    # Vérifiez le type de service
    type_service = service_info.get("type", None)

    if type_service == 'premium':
        # Vérifiez si l'utilisateur a le rôle premium
        premium_role = discord.utils.get(ctx.guild.roles, id=rolevip)
        if not premium_role or premium_role not in ctx.author.roles:
            embed = discord.Embed(
                title="Accès Refusé",
                description="Vous n'avez pas le rôle requis pour générer un compte pour ce service premium.",
                color=discord.Color.red()
            )
            await ctx.respond(embed=embed)
            return

    # Chercher un compte disponible dans la base de données
    account = collection.find_one({"service": service})

    if not account:
        embed = discord.Embed(
            title="Compte Indisponible",
            description=f"Aucun compte disponible pour le service `{service}` de type `{type_service}`.",
            color=discord.Color.orange()
        )
        await ctx.respond(embed=embed)
        return

    collection.delete_one({"_id": account["_id"]})

    try:
        
        rolepc = discord.utils.get(ctx.guild.roles, id=roleidpc)
        author_id_str = str(ctx.author.id)


        roletel = discord.utils.get(ctx.guild.roles, id=roleidtel)
        if not roletel or roletel not in ctx.author.roles:
            if not rolepc or rolepc not in ctx.author.roles:
                if author_id_str in admins:
                    embed = ""
                    embed = discord.Embed(
                        title="Compte Généré",
                        description="Les informations du compte ont été envoyées en privé.",
                        color=discord.Color.green()
                    )
                    await ctx.respond(embed=embed)
                    embed = ""

                    embed = discord.Embed(
                    title=f"Compte {service} généré",
                    description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                    color=discord.Color.green()  # Couleur verte
                    )

                    # Ajoute les champs à l'embed
                    embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                    embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                    embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                    # Ajoute un pied de page
                    embed.set_footer(
                        text="Ce bot a été créé par Dovik",
                    )
                    await ctx.author.send(embed=embed)
                else:
                    embed = discord.Embed(
                        title="Erreur",
                        description="Il semble que vous n'avez pas pris votre rôle ! Veuillez choisir un rôle dans <#1257695481190940713> pour continuer.",
                        color=discord.Color.red()
                    )
                    embed.set_footer(text="Assurez-vous de sélectionner le rôle approprié.")

                    await ctx.send(embed=embed)
            else:
                embed = ""
                embed = discord.Embed(
                    title="Compte Généré",
                    description="Les informations du compte ont été envoyées en privé.",
                    color=discord.Color.green()
                )
                await ctx.respond(embed=embed)
                embed = ""

                embed = discord.Embed(
                title=f"Compte {service} généré",
                description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                color=discord.Color.green()  # Couleur verte
                )

                # Ajoute les champs à l'embed
                embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                # Ajoute un pied de page
                embed.set_footer(
                    text="Ce bot a été créé par Dovik",
                )
                await ctx.author.send(embed=embed)
        else:
            embed = ""
            embed = discord.Embed(
                title="Compte Généré",
                description="Les informations du compte ont été envoyées en privé.",
                color=discord.Color.green()
            )
            await ctx.respond(embed=embed)
            embed = ""

            await ctx.author.send(f"Compte {service} généré :")
            await ctx.author.send(f"{account["email"]}:{account["pass"]}")

    except discord.Forbidden:
        embed = discord.Embed(
            title="Erreur",
            description="Impossible d'envoyer un message privé. Veuillez vérifier vos paramètres de confidentialité.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed)



@gen.error
async def erreur_error(ctx, error):
    if isinstance(error, commands.CommandOnCooldown):
        embed = discord.Embed(
            title="Cooldown",
            description=f"Cette commande est en cooldown. Réessayez dans {error.retry_after:.2f} secondes.",
            color=discord.Color.orange()
        )
        embed.set_footer(text="Merci de votre patience.")
        await ctx.respond(embed=embed, ephemeral=True)


pservices = service2.find({'type': "premium".lower()})
premiumservicelist = [service['name'] for service in pservices]




@bot.slash_command(name="pgen", description="Génère un compte pour le service spécifié.")
@commands.cooldown(1, 60, commands.BucketType.user)
async def pgen(ctx, service: discord.Option(str, choices=services_list)):


    if ctx.guild.id != serveraid:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande sur ce serveur.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error Mauvais serveur \n Id: {ctx.guild.id} — Le lien : {await ctx.channel.create_invite(max_age=0, max_uses=0)}")
        return

    if ctx.channel.id != genchannel:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande dans ce canal. Utilisez le canal <#{genchannel}>.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error mauvais Channel {ctx.channel.id}")
        return

    # Vérifiez si le service existe et son type (gratuit ou premium)
    service_info = service2.find_one({"name": service}, {"type": 1})
    if not service_info:
        embed = discord.Embed(
            title="Service Non Trouvé",
            description=f"Le service `{service}` n'existe pas dans la base de données.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return
    
    # Vérifiez le type de service
    type_service = service_info.get("type", None)

    if type_service == 'premium':
        # Vérifiez si l'utilisateur a le rôle premium
        premium_role = discord.utils.get(ctx.guild.roles, id=rolevip)
        if not premium_role or premium_role not in ctx.author.roles:
            embed = discord.Embed(
                title="Accès Refusé",
                description="Vous n'avez pas le rôle requis pour générer un compte pour ce service premium.",
                color=discord.Color.red()
            )
            await ctx.respond(embed=embed, ephemeral=True)
            return

    # Chercher un compte disponible dans la base de données
    account = collection.find_one({"service": service})

    if not account:
        embed = discord.Embed(
            title="Compte Indisponible",
            description=f"Aucun compte disponible pour le service `{service}` de type `{type_service}`.",
            color=discord.Color.orange()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return

    collection.delete_one({"_id": account["_id"]})


    # Envoi des informations de compte en message privé
    
    try:
        
        rolepc = discord.utils.get(ctx.guild.roles, id=roleidpc)
        author_id_str = str(ctx.author.id)


        roletel = discord.utils.get(ctx.guild.roles, id=roleidtel)
        if not roletel or roletel not in ctx.author.roles:
            if not rolepc or rolepc not in ctx.author.roles:
                if author_id_str in admins:
                    embed = ""
                    embed = discord.Embed(
                        title="Compte Généré",
                        description="Les informations du compte ont été envoyées en privé.",
                        color=discord.Color.green()
                    )
                    await ctx.respond(embed=embed)
                    embed = ""

                    embed = discord.Embed(
                    title=f"Compte {service} généré",
                    description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                    color=discord.Color.green()  # Couleur verte
                    )

                    # Ajoute les champs à l'embed
                    embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                    embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                    embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                    # Ajoute un pied de page
                    embed.set_footer(
                        text="Ce bot a été créé par Dovik",
                    )
                    await ctx.author.send(embed=embed)
                else:
                    embed = discord.Embed(
                        title="Erreur",
                        description="Il semble que vous n'avez pas pris votre rôle ! Veuillez choisir un rôle dans <#1257695481190940713> pour continuer.",
                        color=discord.Color.red()
                    )
                    embed.set_footer(text="Assurez-vous de sélectionner le rôle approprié.")

                    await ctx.send(embed=embed)
            else:
                embed = ""
                embed = discord.Embed(
                    title="Compte Généré",
                    description="Les informations du compte ont été envoyées en privé.",
                    color=discord.Color.green()
                )
                await ctx.respond(embed=embed)
                embed = ""

                embed = discord.Embed(
                title=f"Compte {service} généré",
                description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                color=discord.Color.green()  # Couleur verte
                )

                # Ajoute les champs à l'embed
                embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                # Ajoute un pied de page
                embed.set_footer(
                    text="Ce bot a été créé par Dovik",
                )
                await ctx.author.send(embed=embed)
        else:
            embed = ""
            embed = discord.Embed(
                title="Compte Généré",
                description="Les informations du compte ont été envoyées en privé.",
                color=discord.Color.green()
            )
            await ctx.respond(embed=embed)
            embed = ""

            await ctx.author.send(f"Compte {service} généré :")
            await ctx.author.send(f"{account["email"]}:{account["pass"]}")

    except discord.Forbidden:
        embed = discord.Embed(
            title="Erreur",
            description="Impossible d'envoyer un message privé. Veuillez vérifier vos paramètres de confidentialité.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed)

@pgen.error
async def erreur_error(ctx, error):
    if isinstance(error, commands.CommandOnCooldown):
        embed = discord.Embed(
            title="Cooldown",
            description=f"Cette commande est en cooldown. Réessayez dans {error.retry_after:.2f} secondes.",
            color=discord.Color.orange()
        )
        embed.set_footer(text="Merci de votre patience.")
        await ctx.respond(embed=embed, ephemeral=True)



@bot.slash_command(name="staffgen", description="Génère un compte pour le service spécifié.")
async def staffgen(ctx, service: discord.Option(str, choices=services_list)):

    if ctx.guild.id != serveraid:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande sur ce serveur.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error Mauvais serveur \n Id: {ctx.guild.id} — Le lien : {await ctx.channel.create_invite(max_age=0, max_uses=0)}")
        return

    if ctx.channel.id != genchannel:
        embed = discord.Embed(
            title="Accès Refusé",
            description=f"Vous ne pouvez pas utiliser cette commande dans ce canal. Utilisez le canal <#{genchannel}>.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Error mauvais Channel {ctx.channel.id}")
        return

    author_id_str = str(ctx.author.id)
    if author_id_str not in admins:
        embed = discord.Embed(
            title="Accès Refusé",
            description="Vous n'avez pas les droits requis pour générer un compte pour ce services !.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        logwebook(ctx.author.id, f"Commande : {ctx.command.name} — Vous avez pas le droit !")
        return

    # Vérifiez si le service existe et son type (gratuit ou premium)
    service_info = service2.find_one({"name": service}, {"type": 1})
    if not service_info:
        embed = discord.Embed(
            title="Service Non Trouvé",
            description=f"Le service `{service}` n'existe pas dans la base de données.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return
    
    # Vérifiez le type de service
    type_service = service_info.get("type", None)

    if type_service == 'premium':
        # Vérifiez si l'utilisateur a le rôle premium
        premium_role = discord.utils.get(ctx.guild.roles, id=rolevip)
        if not premium_role or premium_role not in ctx.author.roles:
            embed = discord.Embed(
                title="Accès Refusé",
                description="Vous n'avez pas le rôle requis pour générer un compte pour ce service premium.",
                color=discord.Color.red()
            )
            await ctx.respond(embed=embed, ephemeral=True)
            return

    # Chercher un compte disponible dans la base de données
    account = collection.find_one({"service": service})

    if not account:
        embed = discord.Embed(
            title="Compte Indisponible",
            description=f"Aucun compte disponible pour le service `{service}` de type `{type_service}`.",
            color=discord.Color.orange()
        )
        await ctx.respond(embed=embed, ephemeral=True)
        return

    collection.delete_one({"_id": account["_id"]})


    # Envoi des informations de compte en message privé
    
    try:
        
        rolepc = discord.utils.get(ctx.guild.roles, id=roleidpc)
        author_id_str = str(ctx.author.id)


        roletel = discord.utils.get(ctx.guild.roles, id=roleidtel)
        if not roletel or roletel not in ctx.author.roles:
            if not rolepc or rolepc not in ctx.author.roles:
                if author_id_str in admins:
                    embed = ""
                    embed = discord.Embed(
                        title="Compte Généré",
                        description="Les informations du compte ont été envoyées en privé.",
                        color=discord.Color.green()
                    )
                    await ctx.respond(embed=embed)
                    embed = ""

                    embed = discord.Embed(
                    title=f"Compte {service} généré",
                    description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                    color=discord.Color.green()  # Couleur verte
                    )

                    # Ajoute les champs à l'embed
                    embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                    embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                    embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                    # Ajoute un pied de page
                    embed.set_footer(
                        text="Ce bot a été créé par Dovik",
                    )
                    await ctx.author.send(embed=embed)
                else:
                    embed = discord.Embed(
                        title="Erreur",
                        description="Il semble que vous n'avez pas pris votre rôle ! Veuillez choisir un rôle dans <#1257695481190940713> pour continuer.",
                        color=discord.Color.red()
                    )
                    embed.set_footer(text="Assurez-vous de sélectionner le rôle approprié.")

                    await ctx.send(embed=embed)
            else:
                embed = ""
                embed = discord.Embed(
                    title="Compte Généré",
                    description="Les informations du compte ont été envoyées en privé.",
                    color=discord.Color.green()
                )
                await ctx.respond(embed=embed)
                embed = ""

                embed = discord.Embed(
                title=f"Compte {service} généré",
                description="Merci d'utiliser Gen Factory. Veuillez laisser un avis sur le serveur.",
                color=discord.Color.green()  # Couleur verte
                )

                # Ajoute les champs à l'embed
                embed.add_field(name="ID:", value=f"```{account["email"]}```", inline=True)
                embed.add_field(name="Mot de passe:", value=f"```{account["pass"]}```", inline=True)
                embed.add_field(name="Combo:", value=f"```{account["email"]}:{account["pass"]}```", inline=False)
                # Ajoute un pied de page
                embed.set_footer(
                    text="Ce bot a été créé par Dovik",
                )
                await ctx.author.send(embed=embed)
        else:
            embed = ""
            embed = discord.Embed(
                title="Compte Généré",
                description="Les informations du compte ont été envoyées en privé.",
                color=discord.Color.green()
            )
            await ctx.respond(embed=embed)
            embed = ""

            await ctx.author.send(f"Compte {service} généré :")
            await ctx.author.send(f"{account["email"]}:{account["pass"]}")

    except discord.Forbidden:
        embed = discord.Embed(
            title="Erreur",
            description="Impossible d'envoyer un message privé. Veuillez vérifier vos paramètres de confidentialité.",
            color=discord.Color.red()
        )
        await ctx.respond(embed=embed)




bot.run(config["token"])