import discord

from [Link] import commands, tasks

from discord import app_commands
import asyncio
import json
import time
from datetime import datetime, timedelta
from collections import defaultdict, deque
import re
import logging
import sqlite3
from typing import Dict, List, Optional
import hashlib

# Setup logging

[Link](level=[Link])
logger = [Link](*name*)

class AntiRaidBot([Link]):
def *init*(self):
intents = [Link]()
super().*init*(command_prefix=’!’, intents=intents)

# Configurazioni anti-raid
[Link] = {
'max_joins_per_minute': 5,
'max_messages_per_minute': 10,
'quarantine_duration': 600, # 10 minuti
'raid_mode': False,
'auto_quarantine': True,
'log_channel_id': None,
'admin_role_id': None,
'timeout_duration': 600 # 10 minuti timeout
}

# Tracciamento attività
self.join_tracker = defaultdict(deque)
self.message_tracker = defaultdict(deque)
self.nickname_changes = defaultdict(list)
self.user_flags = defaultdict(int)

# Database setup
self.init_database()

# Whitelist/Blacklist
[Link] = set()
[Link] = set()

# Pattern sospetti
self.suspicious_patterns = [
r'discord\.gg\/\w+', # Inviti Discord
r'@everyone',
r'@here',
r'(.)\1{10,}', # Caratteri ripetuti
r'[^\w\s]{5,}', # Troppi simboli
]
def init_database(self):
"""Inizializza il database SQLite"""
[Link] = [Link]('[Link]')
cursor = [Link]()

[Link]('''
CREATE TABLE IF NOT EXISTS logs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT,
user_id TEXT,
action TEXT,
reason TEXT,
guild_id TEXT
)
''')

[Link]('''
CREATE TABLE IF NOT EXISTS warnings (
user_id TEXT,
guild_id TEXT,
warnings INTEGER DEFAULT 0,
PRIMARY KEY (user_id, guild_id)
)
''')

[Link]()

async def setup_hook(self):

"""Setup iniziale del bot"""
await [Link]()
print(f"✅ Bot sincronizzato! Comandi slash disponibili.")
self.cleanup_tracker.start()

async def on_ready(self):

"""Bot pronto"""
print(f'🚀 {[Link]} è online!')
print(f'📊 Connesso a {len([Link])} server')

async def log_action(self, guild_id: int, user_id: int, action: str, reason: str):
"""Log delle azioni nel database"""
cursor = [Link]()
[Link](
'INSERT INTO logs (timestamp, user_id, action, reason, guild_id) VALUES (?,
?, ?, ?, ?)',
([Link]().isoformat(), str(user_id), action, reason, str(guild_id))
)
[Link]()

# Log nel canale se configurato

if [Link]['log_channel_id']:
channel = self.get_channel([Link]['log_channel_id'])
if channel:
embed = [Link](
title="🛡 Azione Anti-Raid",
color=[Link](),
timestamp=[Link]()
)
embed.add_field(name="Utente", value=f"<@{user_id}>", inline=True)
embed.add_field(name="Azione", value=action, inline=True)
 embed.add_field(name="Motivo", value=reason, inline=False)
await [Link](embed=embed)

async def on_member_join(self, member):

"""Controllo nuovi membri"""
guild_id = [Link]
user_id = [Link]
now = [Link]()

# Traccia i join
self.join_tracker[guild_id].append(now)

# Rimuovi join vecchi (più di 1 minuto)

while (self.join_tracker[guild_id] and
now - self.join_tracker[guild_id][0] > 60):
self.join_tracker[guild_id].popleft()

# Controllo blacklist
if user_id in [Link]:
await [Link](reason="Utente in blacklist")
await self.log_action(guild_id, user_id, "BAN", "Utente in blacklist")
return

# Controllo raid (troppi join)

if len(self.join_tracker[guild_id]) > [Link]['max_joins_per_minute']:
await self.enable_raid_mode([Link])
await self.log_action(guild_id, user_id, "RAID_DETECTED",
f"{len(self.join_tracker[guild_id])} join in 1 minuto")

# Auto-quarantena se abilitata
if [Link]['auto_quarantine'] and user_id not in [Link]:
await self.quarantine_user(member)

async def on_message(self, message):

"""Controllo messaggi per spam/raid"""
if [Link]:
return

guild_id = [Link] if [Link] else None

user_id = [Link]
now = [Link]()

if not guild_id:
return

# Traccia messaggi
self.message_tracker[user_id].append(now)

# Rimuovi messaggi vecchi

while (self.message_tracker[user_id] and
now - self.message_tracker[user_id][0] > 60):
self.message_tracker[user_id].popleft()

# Controllo spam
if len(self.message_tracker[user_id]) > [Link]['max_messages_per_minute']:
await self.timeout_user([Link], "Spam rilevato")
await [Link]()
return
 # Controllo pattern sospetti
for pattern in self.suspicious_patterns:
if [Link](pattern, [Link], [Link]):
self.user_flags[user_id] += 1
if self.user_flags[user_id] >= 3:
await self.timeout_user([Link], "Pattern sospetti
rilevati")
await [Link]()
return

await self.process_commands(message)

async def on_member_update(self, before, after):

"""Controllo cambi nickname sospetti"""
if before.display_name == after.display_name:
return

user_id = [Link]
guild_id = [Link]

# Traccia cambi nickname

self.nickname_changes[user_id].append({
'timestamp': [Link](),
'old_name': before.display_name,
'new_name': after.display_name
})

# Rimuovi cambi vecchi (più di 1 ora)

cutoff = [Link]() - 3600
self.nickname_changes[user_id] = [
change for change in self.nickname_changes[user_id]
if change['timestamp'] > cutoff
]

# Troppi cambi nickname = sospetto

if len(self.nickname_changes[user_id]) > 5:
await self.timeout_user(after, "Troppi cambi nickname")
await self.log_action(guild_id, user_id, "TIMEOUT", "Cambi nickname
sospetti")

async def quarantine_user(self, member):

"""Mette un utente in quarantena"""
try:
# Timeout per il periodo di quarantena
timeout_until = [Link]() +
timedelta(seconds=[Link]['quarantine_duration'])
await [Link](timeout_until, reason="Quarantena automatica")

await self.log_action([Link], [Link], "QUARANTINE",

"Auto-quarantena nuovo utente")
except [Link]:
[Link](f"Non posso mettere {member} in quarantena - permessi
insufficienti")

async def timeout_user(self, member, reason):

"""Timeout utente"""
try:
timeout_until = [Link]() +
timedelta(seconds=[Link]['timeout_duration'])
 await [Link](timeout_until, reason=reason)

await self.log_action([Link], [Link], "TIMEOUT", reason)

except [Link]:
[Link](f"Non posso dare timeout a {member} - permessi
insufficienti")

async def enable_raid_mode(self, guild):

"""Attiva modalità raid"""
[Link]['raid_mode'] = True

# Cerca di modificare le impostazioni del server

try:
await [Link](verification_level=[Link])
except [Link]:
pass

# Notifica
if [Link]['log_channel_id']:
channel = self.get_channel([Link]['log_channel_id'])
if channel:
embed = [Link](
title="🚨 MODALITÀ RAID ATTIVATA",
description="Rilevata attività sospetta! Modalità protezione
massima attiva.",
color=[Link]()
)
await [Link](embed=embed)

@[Link](minutes=5)
async def cleanup_tracker(self):
"""Pulizia periodica dei tracker"""
now = [Link]()
cutoff = now - 3600 # 1 ora

# Pulisci tracker join

for guild_id in list(self.join_tracker.keys()):
while (self.join_tracker[guild_id] and
self.join_tracker[guild_id][0] < cutoff):
self.join_tracker[guild_id].popleft()

# Pulisci tracker messaggi

for user_id in list(self.message_tracker.keys()):
while (self.message_tracker[user_id] and
self.message_tracker[user_id][0] < cutoff):
self.message_tracker[user_id].popleft()

# ==================== COMANDI SLASH ====================

@app_commands.command(name="antispam", description="Configura il sistema anti-

spam")
@app_commands.describe(
action="Abilita o disabilita l'anti-spam",
limit="Limite messaggi per minuto (default: 10)"
)
@app_commands.choices(action=[
app_commands.Choice(name="enable", value="enable"),
app_commands.Choice(name="disable", value="disable")
])
async def antispam(self, interaction: [Link], action: str, limit: int
= 10):
"""Sistema anti-spam"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

if action == "enable":
[Link]['max_messages_per_minute'] = limit
await [Link].send_message(f"✅ Anti-spam attivato! Limite:
{limit} messaggi/minuto")
else:
[Link]['max_messages_per_minute'] = 999999
await [Link].send_message("✅ Anti-spam disattivato!")

@app_commands.command(name="quarantine", description="Configura la quarantena

automatica")
@app_commands.describe(
action="Abilita o disabilita la quarantena",
duration="Durata in minuti (default: 10)"
)
@app_commands.choices(action=[
app_commands.Choice(name="enable", value="enable"),
app_commands.Choice(name="disable", value="disable")
])
async def quarantine(self, interaction: [Link], action: str, duration:
int = 10):
"""Quarantena automatica"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

if action == "enable":
[Link]['auto_quarantine'] = True
[Link]['quarantine_duration'] = duration * 60
await [Link].send_message(f"✅ Quarantena attivata! Durata:
{duration} minuti")
else:
[Link]['auto_quarantine'] = False
await [Link].send_message("✅ Quarantena disattivata!")

@app_commands.command(name="whitelist", description="Gestisci la whitelist")

@app_commands.describe(
action="Aggiungi o rimuovi dalla whitelist",
user="Utente da gestire"
)
@app_commands.choices(action=[
app_commands.Choice(name="add", value="add"),
app_commands.Choice(name="remove", value="remove"),
app_commands.Choice(name="list", value="list")
])
async def whitelist(self, interaction: [Link], action: str, user:
[Link] = None):
"""Gestione whitelist"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
 return

if action == "add" and user:

[Link]([Link])
await [Link].send_message(f"✅ {[Link]} aggiunto alla
whitelist!")
elif action == "remove" and user:
[Link]([Link])
await [Link].send_message(f"✅ {[Link]} rimosso dalla
whitelist!")
elif action == "list":
if [Link]:
users = [f"<@{uid}>" for uid in list([Link])[:10]]
await [Link].send_message(f"📝 Whitelist: {',
'.join(users)}")
else:
await [Link].send_message("📝 Whitelist vuota!")

@app_commands.command(name="blacklist", description="Gestisci la blacklist")

@app_commands.describe(
action="Aggiungi o rimuovi dalla blacklist",
user="Utente da gestire"
)
@app_commands.choices(action=[
app_commands.Choice(name="add", value="add"),
app_commands.Choice(name="remove", value="remove"),
app_commands.Choice(name="list", value="list")
])
async def blacklist(self, interaction: [Link], action: str, user:
[Link] = None):
"""Gestione blacklist"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

if action == "add" and user:

[Link]([Link])
await [Link].send_message(f"✅ {[Link]} aggiunto alla
blacklist!")
# Banna se presente nel server
try:
member = [Link].get_member([Link])
if member:
await [Link](reason="Aggiunto alla blacklist")
except:
pass
elif action == "remove" and user:
[Link]([Link])
await [Link].send_message(f"✅ {[Link]} rimosso dalla
blacklist!")
elif action == "list":
if [Link]:
users = [f"<@{uid}>" for uid in list([Link])[:10]]
await [Link].send_message(f"📝 Blacklist: {',
'.join(users)}")
else:
await [Link].send_message("📝 Blacklist vuota!")
@app_commands.command(name="raidmode", description="Modalità emergenza raid")
@app_commands.describe(action="Abilita o disabilita la modalità raid")
@app_commands.choices(action=[
app_commands.Choice(name="enable", value="enable"),
app_commands.Choice(name="disable", value="disable")
])
async def raidmode(self, interaction: [Link], action: str):
"""Modalità raid"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

if action == "enable":
await self.enable_raid_mode([Link])
await [Link].send_message("🚨 **MODALITÀ RAID ATTIVATA**\
nProtezione massima abilitata!")
else:
[Link]['raid_mode'] = False
try:
await
[Link](verification_level=[Link])
except:
pass
await [Link].send_message("✅ Modalità raid disattivata!")

@app_commands.command(name="logs", description="Visualizza i log di sicurezza")

@app_commands.describe(limit="Numero di log da mostrare (max 20)")
async def logs(self, interaction: [Link], limit: int = 10):
"""Visualizza log"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

cursor = [Link]()
[Link](
'SELECT timestamp, user_id, action, reason FROM logs WHERE guild_id = ?
ORDER BY id DESC LIMIT ?',
(str([Link]), min(limit, 20))
)

logs = [Link]()
if not logs:
await [Link].send_message("📝 Nessun log disponibile!")
return

embed = [Link](title="📋 Log di Sicurezza", color=[Link]())

for timestamp, user_id, action, reason in logs:

dt = [Link](timestamp)
embed.add_field(
name=f"{action} - <@{user_id}>",
value=f"**Motivo:** {reason}\n**Data:** {[Link]('%d/%m/%Y %H:
%M')}",
inline=False
)

await [Link].send_message(embed=embed, ephemeral=True)

@app_commands.command(name="settings", description="Visualizza le impostazioni
correnti")
async def settings(self, interaction: [Link]):
"""Impostazioni attuali"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

embed = [Link](title="⚙ Impostazioni Anti-Raid",

color=[Link]())

embed.add_field(name="🔄 Max Join/minuto",

value=[Link]['max_joins_per_minute'], inline=True)
embed.add_field(name="💬 Max Messaggi/minuto",
value=[Link]['max_messages_per_minute'], inline=True)
embed.add_field(name="⏱ Durata Quarantena",
value=f"{[Link]['quarantine_duration']//60}min", inline=True)
embed.add_field(name="🛡 Auto-Quarantena", value="✅" if
[Link]['auto_quarantine'] else "❌", inline=True)
embed.add_field(name="🚨 Modalità Raid", value="✅" if [Link]['raid_mode']
else "❌", inline=True)
embed.add_field(name="⏰ Durata Timeout",
value=f"{[Link]['timeout_duration']//60}min", inline=True)

embed.add_field(name="📊 Statistiche", value=f"Whitelist: {len([Link])}\

nBlacklist: {len([Link])}", inline=False)

await [Link].send_message(embed=embed, ephemeral=True)

@app_commands.command(name="logchannel", description="Imposta il canale per i log")

@app_commands.describe(channel="Canale dove inviare i log")
async def logchannel(self, interaction: [Link], channel:
[Link]):
"""Imposta canale log"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

[Link]['log_channel_id'] = [Link]
await [Link].send_message(f"✅ Canale log impostato su
{[Link]}!")

@app_commands.command(name="mass_timeout", description="Timeout di massa per utenti

recenti")
@app_commands.describe(minutes="Minuti di timeout", recent_joins="Timeout solo per
utenti entrati negli ultimi X minuti")
async def mass_timeout(self, interaction: [Link], minutes: int = 10,
recent_joins: int = 60):
"""Timeout di massa"""
if not [Link].guild_permissions.administrator:
await [Link].send_message("❌ Non hai i permessi necessari!",
ephemeral=True)
return

await [Link]()
 cutoff = [Link]() - timedelta(minutes=recent_joins)
timeout_until = [Link]() + timedelta(minutes=minutes)
count = 0

for member in [Link]:

if (member.joined_at and member.joined_at > cutoff and
not [Link] and [Link] not in [Link]):
try:
await [Link](timeout_until, reason="Timeout di massa -
protezione raid")
count += 1
if count % 5 == 0: # Pausa ogni 5 per evitare rate limit
await [Link](1)
except:
continue

await [Link](f"✅ Timeout applicato a {count} utenti

recenti!")

@app_commands.command(name="status", description="Stato del sistema anti-raid")

async def status(self, interaction: [Link]):
"""Stato sistema"""
embed = [Link](title="📊 Stato Sistema Anti-Raid",
color=[Link]())

# Calcola statistiche recenti

now = [Link]()
recent_joins = sum(1 for deq in self.join_tracker.values() for t in deq if now
- t < 3600)
active_users = sum(1 for deq in self.message_tracker.values() if deq and now -
deq[-1] < 300)

embed.add_field(name="🔄 Join ultima ora", value=recent_joins, inline=True)

embed.add_field(name="👤 Utenti attivi (5min)", value=active_users, inline=True)
embed.add_field(name="🚩 Utenti flaggati", value=len(self.user_flags),
inline=True)

embed.add_field(name="📈 Cambi nickname", value=sum(len(changes) for changes in

self.nickname_changes.values()), inline=True)
embed.add_field(name="✅ Whitelist", value=len([Link]), inline=True)
embed.add_field(name="❌ Blacklist", value=len([Link]), inline=True)

# Stato modalità
status_text = "🚨 **RAID MODE**" if [Link]['raid_mode'] else "✅
**NORMALE**"
embed.add_field(name="🛡 Stato", value=status_text, inline=False)

await [Link].send_message(embed=embed)

# Avvia il bot

if *name* == “*main*”:
bot = AntiRaidBot()

# IMPORTANTE: Sostituisci con il tuo token

TOKEN = "IL_TUO_TOKEN_QUI"
print("🤖 Avvio bot anti-raid...")
print("📋 Comandi disponibili:")
print(" /antispam - Configura anti-spam")
print(" /quarantine - Quarantena automatica")
print(" /whitelist - Gestisci whitelist")
print(" /blacklist - Gestisci blacklist")
print(" /raidmode - Modalità emergenza")
print(" /logs - Visualizza log sicurezza")
print(" /settings - Mostra impostazioni")
print(" /logchannel - Imposta canale log")
print(" /mass_timeout - Timeout di massa")
print(" /status - Stato del sistema")
print("\n🚀 Avvio in corso...")

try:
[Link](TOKEN)
except Exception as e:
print(f"❌ Errore: {e}")
print("🔑 Assicurati di aver inserito il token corretto!")