import asyncio
import logging
import time
import discord
from datetime import datetime, timezone
from database import db
from database.helpers import ConfigurationHelper
from database.models import ModerationEvent
from discord import Message

def get_staff_role_ids():
	staff_roles = ConfigurationHelper().getValue('moderation_staff_role_ids')
	if staff_roles:
		return [int(role_id.strip()) for role_id in staff_roles.split(',') if role_id.strip()]
	staff_role_old = ConfigurationHelper().getValue('moderation_staff_role_id')
	if staff_role_old:
		return [int(staff_role_old)]
	return []

def has_staff_role(user_roles):
	staff_role_ids = get_staff_role_ids()
	if not staff_role_ids:
		return False
	return any(role.id in staff_role_ids for role in user_roles)

def get_embed_delete_delay():
	delay = ConfigurationHelper().getValue('moderation_embed_delete_delay')
	return int(delay) if delay else 0

async def delete_after_delay(message):
	delay = get_embed_delete_delay()
	if delay > 0:
		await asyncio.sleep(delay)
		try:
			await message.delete()
		except:
			pass

async def safe_delete_message(message: Message):
	try:
		await message.delete()
	except:
		pass

async def send_access_denied(channel):
	embed = discord.Embed(
		title="❌ Accès refusé",
		description="Vous n'avez pas les permissions nécessaires pour utiliser cette commande.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

async def send_user_not_found(channel):
	embed = discord.Embed(
		title="❌ Erreur",
		description="Utilisateur introuvable. Vérifiez la mention ou l'ID Discord.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

async def parse_target_user_and_reason(message, bot, parts: list):
	if message.mentions:
		target_user = message.mentions[0]
		reason = parts[2] if len(parts) > 2 else "Sans raison"
		return target_user, reason
	
	try:
		user_id = int(parts[1])
		target_user = await bot.fetch_user(user_id)
		reason = parts[2] if len(parts) > 2 else "Sans raison"
		return target_user, reason
	except (ValueError, discord.NotFound):
		return None, None

async def send_warning_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!averto @utilisateur [raison]` ou `!averto <id> [raison]`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!averto @User Spam dans le chat`\n• `!warn 123456789012345678 Comportement inapproprié`\n• `!av @User`", inline=False)
	embed.add_field(name="Aliases", value="`!averto`, `!av`, `!avertissement`, `!warn`", inline=False)
	await channel.send(embed=embed)

def create_warning_event(target_user, reason: str, staff_member):
	event = ModerationEvent(
		type='warning',
		username=target_user.name,
		discord_id=str(target_user.id),
		created_at=datetime.utcnow(),
		reason=reason,
		staff_id=str(staff_member.id),
		staff_name=staff_member.name
	)
	db.session.add(event)
	_commit_with_retry()

def _commit_with_retry(max_retries: int = 5, base_delay: float = 0.1):
	attempt = 0
	while True:
		try:
			db.session.commit()
			return
		except Exception as e:
			msg = str(e)
			if 'database is locked' in msg.lower() and attempt < max_retries:
				db.session.rollback()
				delay = base_delay * (2 ** attempt)
				time.sleep(delay)
				attempt += 1
				continue
			db.session.rollback()
			raise

async def send_warning_confirmation(channel, target_user, reason: str, original_message: Message):
	embed = discord.Embed(
		title="⚠️ Sanction",
		description=f"L'utilisateur **{target_user.name}** (`@{target_user.name}`) a été **averti**.",
		color=discord.Color.orange()
	)
	if reason != "Sans raison":
		embed.add_field(name="Raison", value=reason, inline=False)
	
	sent_message = await channel.send(embed=embed)
	await safe_delete_message(original_message)
	asyncio.create_task(delete_after_delay(sent_message))

async def handle_warning_command(message: Message, bot):
	parts = message.content.split(maxsplit=2)
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
	elif len(parts) < 2:
		await send_warning_usage(message.channel)
	else:
		target_user, reason = await parse_target_user_and_reason(message, bot, parts)
		if not target_user:
			await send_user_not_found(message.channel)
		else:
			await _process_warning_success(message, target_user, reason)

async def _process_warning_success(message: Message, target_user, reason: str):
	create_warning_event(target_user, reason, message.author)
	await send_warning_confirmation(message.channel, target_user, reason, message)

async def send_remove_warning_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!delaverto <id>`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!delaverto 5`\n• `!removewarn 12`", inline=False)
	embed.add_field(name="Aliases", value="`!delaverto`, `!removewarn`, `!delwarn`", inline=False)
	await channel.send(embed=embed)

async def send_invalid_event_id(channel):
	embed = discord.Embed(
		title="❌ Erreur",
		description="L'ID doit être un nombre entier.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

async def send_event_not_found(channel, event_id: int):
	embed = discord.Embed(
		title="❌ Erreur",
		description=f"Aucun événement de modération trouvé avec l'ID `{event_id}`.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

def delete_moderation_event(event: ModerationEvent):
	db.session.delete(event)
	db.session.commit()

async def send_event_deleted_confirmation(channel, event: ModerationEvent, moderator, original_message: Message):
	embed = discord.Embed(
		title="✅ Événement supprimé",
		description=f"L'événement de type **{event.type}** pour **{event.username}** (ID: {event.id}) a été supprimé.",
		color=discord.Color.green(),
		timestamp=datetime.utcnow()
	)
	embed.add_field(name="🛡️ Modérateur", value=f"{moderator.name}\n`{moderator.id}`", inline=True)
	embed.set_footer(text="Mamie Henriette")
	
	await channel.send(embed=embed)
	await safe_delete_message(original_message)

async def handle_remove_warning_command(message: Message, bot):
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
		return
	
	parts = message.content.split(maxsplit=1)
	
	if len(parts) < 2:
		await send_remove_warning_usage(message.channel)
		return
	
	try:
		event_id = int(parts[1])
	except ValueError:
		await send_invalid_event_id(message.channel)
		return
	
	event = ModerationEvent.query.filter_by(id=event_id).first()
	
	if not event:
		await send_event_not_found(message.channel, event_id)
		return
	
	delete_moderation_event(event)
	await send_event_deleted_confirmation(message.channel, event, message.author, message)

def get_moderation_events(user_filter: str = None):
	if user_filter:
		return ModerationEvent.query.filter_by(discord_id=user_filter).order_by(ModerationEvent.created_at.desc()).all()
	return ModerationEvent.query.order_by(ModerationEvent.created_at.desc()).all()

async def send_no_events_found(channel):
	embed = discord.Embed(
		title="📋 Liste des événements",
		description="Aucun événement de modération trouvé.",
		color=discord.Color.blue()
	)
	await channel.send(embed=embed)

def create_events_list_embed(events: list, page_num: int, per_page: int):
	start = page_num * per_page
	end = start + per_page
	page_events = events[start:end]
	max_page = (len(events) - 1) // per_page
	
	embed = discord.Embed(
		title="📋 Liste des événements de modération",
		description=f"Total : {len(events)} événement(s)",
		color=discord.Color.blue(),
		timestamp=datetime.utcnow()
	)
	
	for event in page_events:
		date_str = event.created_at.strftime('%d/%m/%Y %H:%M') if event.created_at else 'N/A'
		embed.add_field(
			name=f"ID {event.id} - {event.type.upper()} - {event.username}",
			value=f"**Discord ID:** `{event.discord_id}`\n**Date:** {date_str}\n**Raison:** {event.reason}\n**Staff:** {event.staff_name}",
			inline=False
		)
	
	embed.set_footer(text=f"Page {page_num + 1}/{max_page + 1}")
	return embed

async def add_pagination_reactions(msg, max_page: int):
	if max_page > 0:
		await msg.add_reaction('⬅️')
		await msg.add_reaction('➡️')
	await msg.add_reaction('❌')

async def handle_pagination_loop(msg, bot, message_author, events: list, per_page: int):
	page = 0
	max_page = (len(events) - 1) // per_page
	
	def check(reaction, user):
		return user == message_author and str(reaction.emoji) in ['⬅️', '➡️', '❌'] and reaction.message.id == msg.id
	
	while True:
		try:
			reaction, user = await bot.wait_for('reaction_add', timeout=60.0, check=check)
			
			if str(reaction.emoji) == '❌':
				await msg.delete()
				break
			elif str(reaction.emoji) == '➡️' and page < max_page:
				page += 1
				await msg.edit(embed=create_events_list_embed(events, page, per_page))
			elif str(reaction.emoji) == '⬅️' and page > 0:
				page -= 1
				await msg.edit(embed=create_events_list_embed(events, page, per_page))
			
			await msg.remove_reaction(reaction, user)
		except:
			break
	
	try:
		await msg.clear_reactions()
	except:
		pass

async def handle_list_warnings_command(message: Message, bot):
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
		return
	
	parts = message.content.split(maxsplit=1)
	user_filter = str(message.mentions[0].id) if len(parts) > 1 and message.mentions else None
	
	events = get_moderation_events(user_filter)
	
	if not events:
		await send_no_events_found(message.channel)
		return
	
	per_page = 5
	max_page = (len(events) - 1) // per_page
	
	msg = await message.channel.send(embed=create_events_list_embed(events, 0, per_page))
	await add_pagination_reactions(msg, max_page)
	await handle_pagination_loop(msg, bot, message.author, events, per_page)
	await safe_delete_message(message)

async def handle_ban_command(message: Message, bot):
	parts = message.content.split(maxsplit=2)
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
	elif len(parts) < 2:
		await _send_ban_usage(message.channel)
	else:
		target_user, reason = await _parse_ban_target_and_reason(message, bot, parts)
		if not target_user:
			await _send_user_not_found_for_ban(message.channel)
		else:
			await _process_ban_success(message, target_user, reason)

async def _send_ban_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!ban @utilisateur [raison]` ou `!ban <id> [raison]`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!ban @User Spam répété`\n• `!ban 123456789012345678 Comportement toxique`", inline=False)
	await channel.send(embed=embed)

async def _parse_ban_target_and_reason(message: Message, bot, parts: list):
	if message.mentions:
		return message.mentions[0], (parts[2] if len(parts) > 2 else "Sans raison")
	try:
		user_id = int(parts[1])
		user = await bot.fetch_user(user_id)
		return user, (parts[2] if len(parts) > 2 else "Sans raison")
	except (ValueError, discord.NotFound):
		return None, None

async def _send_user_not_found_for_ban(channel):
	embed = discord.Embed(
		title="❌ Erreur",
		description="Utilisateur introuvable. Vérifiez la mention ou l'ID Discord.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

def _create_ban_event(target_user, reason: str, staff_member):
	event = ModerationEvent(
		type='ban',
		username=target_user.name,
		discord_id=str(target_user.id),
		created_at=datetime.utcnow(),
		reason=reason,
		staff_id=str(staff_member.id),
		staff_name=staff_member.name
	)
	db.session.add(event)
	_commit_with_retry()
	return event

async def _process_ban_success(message: Message, target_user, reason: str):
	member = message.guild.get_member(target_user.id)
	joined_days = None
	if member and member.joined_at:
		delta = datetime.utcnow() - member.joined_at.replace(tzinfo=None)
		joined_days = delta.days
	try:
		await message.guild.ban(target_user, reason=reason)
	except discord.Forbidden:
		embed = discord.Embed(
			title="❌ Erreur",
			description="Je n'ai pas les permissions nécessaires pour bannir cet utilisateur.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return

	event = _create_ban_event(target_user, reason, message.author)

	embed = discord.Embed(
		title="⚠️ Sanction",
		description=f"L'utilisateur **{target_user.name}** (`@{target_user.name}`) a été **banni**.",
		color=discord.Color.red()
	)
	embed.add_field(name="ID Discord", value=f"`{target_user.id}`", inline=False)
	if joined_days is not None:
		embed.add_field(name="Membre depuis", value=format_days_to_age(joined_days), inline=False)
	if reason != "Sans raison":
		embed.add_field(name="Raison", value=reason, inline=False)

	sent_message = await message.channel.send(embed=embed)
	await safe_delete_message(message)
	asyncio.create_task(delete_after_delay(sent_message))
async def handle_unban_command(message: Message, bot):
	parts = message.content.split(maxsplit=2)
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
	elif len(parts) < 2:
		await _send_unban_usage(message.channel)
	else:
		target_user, discord_id, reason = await _parse_unban_target_and_reason(message, bot, parts)
		if not discord_id:
			await _send_unban_invalid_id(message.channel)
		else:
			await _process_unban_success(message, bot, target_user, discord_id, reason)

async def _send_unban_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!unban <discord_id>` ou `!unban #<sanction_id> [raison]`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!unban 123456789012345678`\n• `!unban #5 Appel accepté`", inline=False)
	await channel.send(embed=embed)

async def _parse_unban_target_and_reason(message: Message, bot, parts: list):
	reason = parts[2] if len(parts) > 2 else "Sans raison"
	target_user = None
	discord_id = None
	if parts[1].startswith('#'):
		try:
			sanction_id = int(parts[1][1:])
			evt = ModerationEvent.query.filter_by(id=sanction_id, type='ban').first()
			if not evt:
				return None, None, reason
			discord_id = evt.discord_id
			try:
				target_user = await bot.fetch_user(int(discord_id))
			except discord.NotFound:
				pass
		except ValueError:
			return None, None, reason
	else:
		try:
			discord_id = parts[1]
			target_user = await bot.fetch_user(int(discord_id))
		except (ValueError, discord.NotFound):
			return None, None, reason
	return target_user, discord_id, reason

async def _send_unban_invalid_id(channel):
	embed = discord.Embed(
		title="❌ Erreur",
		description="ID Discord invalide ou utilisateur introuvable.",
		color=discord.Color.red()
	)
	await channel.send(embed=embed)

async def _process_unban_success(message: Message, bot, target_user, discord_id: str, reason: str):
	try:
		await message.guild.unban(discord.Object(id=int(discord_id)), reason=reason)
	except discord.NotFound:
		embed = discord.Embed(
			title="❌ Erreur",
			description="Cet utilisateur n'est pas banni.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return
	except discord.Forbidden:
		embed = discord.Embed(
			title="❌ Erreur",
			description="Je n'ai pas les permissions nécessaires pour débannir cet utilisateur.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return

	username = target_user.name if target_user else f"ID: {discord_id}"
	create = ModerationEvent(
		type='unban',
		username=username,
		discord_id=discord_id,
		created_at=datetime.utcnow(),
		reason=reason,
		staff_id=str(message.author.id),
		staff_name=message.author.name
	)
	db.session.add(create)
	_commit_with_retry()

	try:
		asyncio.create_task(_send_unban_invite(message, bot, target_user, discord_id))
	except:
		pass

	embed = discord.Embed(
		title="⚠️ Sanction",
		description=f"L'utilisateur **{username}** (`@{username}`) a été **débanni**.",
		color=discord.Color.green()
	)
	if reason != "Sans raison":
		embed.add_field(name="Raison", value=reason, inline=False)
	
	sent_message = await message.channel.send(embed=embed)
	await safe_delete_message(message)
	asyncio.create_task(delete_after_delay(sent_message))

async def _send_unban_invite(message: Message, bot, target_user, discord_id: str):
	try:
		user_obj = target_user or await bot.fetch_user(int(discord_id))
		channel = None
		try:
			channel_id = ConfigurationHelper().getIntValue('welcome_channel_id')
			if channel_id:
				channel = bot.get_channel(channel_id) or message.guild.get_channel(channel_id)
		except:
			pass
		if not channel:
			me = message.guild.me or message.guild.get_member(bot.user.id)
			for ch in message.guild.text_channels:
				try:
					perms = ch.permissions_for(me) if me else None
					if not perms or not perms.create_instant_invite:
						continue
					channel = ch
					break
				except:
					continue
		if not channel:
			channel = message.guild.system_channel or message.channel
		invite = None
		try:
			invite = await channel.create_invite(max_age=86400, max_uses=1, unique=True, reason='Invitation automatique après débannissement')
		except Exception as e:
			logging.warning(f"[UNBAN] Échec création d'invitation sur #{channel and channel.name}: {e}")
			return
		if user_obj and invite:
			try:
				msg = f"Tu as été débanni de {message.guild.name}. Voici une invitation pour revenir : {invite.url}"
				await user_obj.send(msg)
			except Exception as e:
				logging.warning(f"[UNBAN] Impossible d'envoyer un MP à {user_obj} ({user_obj.id}): {e}")
				try:
					await message.author.send(f"Impossible d'envoyer un MP à {user_obj} pour l'unban. Voici l'invitation à lui transmettre : {invite.url}")
				except:
					pass
	except:
		pass

async def handle_ban_list_command(message: Message, bot):
	if not has_staff_role(message.author.roles):
		embed = discord.Embed(
			title="❌ Accès refusé",
			description="Vous n'avez pas les permissions nécessaires pour utiliser cette commande.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return

	# Récupérer la liste des bannis
	bans = []
	try:
		async for entry in message.guild.bans(limit=None):
			bans.append(entry)
	except TypeError:
		try:
			bans = await message.guild.bans()
		except Exception:
			bans = []
	except Exception:
		bans = []

	if not bans:
		embed = discord.Embed(
			title="🔨 Utilisateurs bannis",
			description="Aucun utilisateur banni sur ce serveur.",
			color=discord.Color.blue()
		)
		msg = await message.channel.send(embed=embed)
		asyncio.create_task(delete_after_delay(msg))
		await safe_delete_message(message)
		return

	page = 0
	per_page = 10
	max_page = (len(bans) - 1) // per_page

	def create_banlist_embed(page_num: int):
		start = page_num * per_page
		end = start + per_page
		page_bans = bans[start:end]
		embed = discord.Embed(
			title="🔨 Utilisateurs bannis",
			description=f"Total : {len(bans)} utilisateur(s) banni(s)",
			color=discord.Color.red(),
			timestamp=datetime.utcnow()
		)
		for entry in page_bans:
			user = entry.user
			reason = entry.reason or 'Sans raison'
			embed.add_field(
				name=f"{user.name} ({user.id})",
				value=f"Raison: {reason}",
				inline=False
			)
		embed.set_footer(text=f"Page {page_num + 1}/{max_page + 1}")
		return embed

	msg = await message.channel.send(embed=create_banlist_embed(page))
	if max_page > 0:
		await msg.add_reaction('⬅️')
		await msg.add_reaction('➡️')
	await msg.add_reaction('❌')

	def check(reaction, user):
		return user == message.author and str(reaction.emoji) in ['⬅️', '➡️', '❌'] and reaction.message.id == msg.id

	while True:
		try:
			reaction, user = await bot.wait_for('reaction_add', timeout=60.0, check=check)
			if str(reaction.emoji) == '❌':
				await msg.delete()
				break
			elif str(reaction.emoji) == '➡️' and page < max_page:
				page += 1
				await msg.edit(embed=create_banlist_embed(page))
			elif str(reaction.emoji) == '⬅️' and page > 0:
				page -= 1
				await msg.edit(embed=create_banlist_embed(page))
			await msg.remove_reaction(reaction, user)
		except Exception:
			break

	try:
		await msg.clear_reactions()
	except Exception:
		pass

	await safe_delete_message(message)

async def handle_staff_help_command(message: Message, bot):
	if not has_staff_role(message.author.roles):
		embed = discord.Embed(
			title="❌ Accès refusé",
			description="Cette commande est réservée au staff.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return

	embed = discord.Embed(
		title="🛠️ Aide staff",
		description="Commandes de modération disponibles",
		color=discord.Color.blurple(),
		timestamp=datetime.utcnow()
	)
	embed.set_footer(text=f"Demandé par {message.author.name}")

	# Avertissements
	if ConfigurationHelper().getValue('moderation_enable'):
		value = (
			"• `!averto @utilisateur [raison]`\n"
			"• `!delaverto <id>`\n"
			"• `!warnings` ou `!warnings @utilisateur`\n"
			"Exemples:\n"
			"`!averto @User Spam`\n"
			"`!delaverto 12`\n"
			"`!warnings @User`"
		)
		embed.add_field(name="⚠️ Avertissements", value=value, inline=False)
		# Inspect
		embed.add_field(
			name="🔎 Inspection",
			value=("• `!inspect @utilisateur` ou `!inspect <id>`\n"
					"Ex: `!inspect @User`"),
			inline=False
		)

	# Bans / Unban
	if ConfigurationHelper().getValue('moderation_ban_enable'):
		value = (
			"• `!ban @utilisateur [raison]`\n"
			"• `!unban <discord_id>` ou `!unban #<sanction_id> [raison]`\n"
			"• `!banlist`\n"
			"Exemples:\n"
			"`!ban @User Toxicité`\n"
			"`!unban 123456789012345678 Erreur`\n"
			"`!unban #5 Appel accepté`"
		)
		embed.add_field(name="🔨 Ban / Unban", value=value, inline=False)

	# Kick
	if ConfigurationHelper().getValue('moderation_kick_enable'):
		value = (
			"• `!kick @utilisateur [raison]`\n"
			"Exemple: `!kick @User Spam`"
		)
		embed.add_field(name="👢 Kick", value=value, inline=False)

	try:
		sent = await message.channel.send(embed=embed)
		asyncio.create_task(delete_after_delay(sent))
	except Exception:
		pass
	await safe_delete_message(message)

async def handle_kick_command(message: Message, bot):
	parts = message.content.split(maxsplit=2)
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
	elif len(parts) < 2 or not message.mentions:
		await _send_kick_usage(message.channel)
	else:
		target_member = message.mentions[0]
		reason = parts[2] if len(parts) > 2 else "Sans raison"
		await _process_kick_success(message, target_member, reason)

async def _send_kick_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!kick @utilisateur [raison]`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!kick @User Spam dans le chat`\n• `!kick @User Comportement inapproprié`", inline=False)
	await channel.send(embed=embed)

async def _process_kick_success(message: Message, target_member, reason: str):
	member_obj = message.guild.get_member(target_member.id)
	if not member_obj:
		embed = discord.Embed(
			title="❌ Erreur",
			description="L'utilisateur n'est pas membre du serveur.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return
	joined_days = None
	if member_obj.joined_at:
		delta = datetime.utcnow() - member_obj.joined_at.replace(tzinfo=None)
		joined_days = delta.days
	try:
		await message.guild.kick(member_obj, reason=reason)
	except discord.Forbidden:
		embed = discord.Embed(
			title="❌ Erreur",
			description="Je n'ai pas les permissions nécessaires pour expulser cet utilisateur.",
			color=discord.Color.red()
		)
		await message.channel.send(embed=embed)
		return
	create = ModerationEvent(
		type='kick',
		username=target_member.name,
		discord_id=str(target_member.id),
		created_at=datetime.utcnow(),
		reason=reason,
		staff_id=str(message.author.id),
		staff_name=message.author.name
	)
	db.session.add(create)
	_commit_with_retry()
	embed = discord.Embed(
		title="⚠️ Sanction",
		description=f"L'utilisateur **{target_member.name}** (`@{target_member.name}`) a été **expulsé**.",
		color=discord.Color.orange()
	)
	if joined_days is not None:
		embed.add_field(name="Membre depuis", value=format_days_to_age(joined_days), inline=False)
	if reason != "Sans raison":
		embed.add_field(name="Raison", value=reason, inline=False)
	sent_message = await message.channel.send(embed=embed)
	await safe_delete_message(message)
	asyncio.create_task(delete_after_delay(sent_message))

def format_days_to_age(days: int) -> str:
	if days >= 365:
		years = days // 365
		remaining_days = days % 365
		if remaining_days > 0:
			return f"{years} an{'s' if years > 1 else ''} et {remaining_days} jour{'s' if remaining_days > 1 else ''}"
		return f"{years} an{'s' if years > 1 else ''}"
	return f"{days} jour{'s' if days > 1 else ''}"

async def get_member_join_info(guild, member_id: int):
	member = guild.get_member(member_id)
	if not member or not member.joined_at:
		return None, None
	
	join_date = member.joined_at
	days_on_server = (datetime.now(timezone.utc) - join_date).days
	return join_date, days_on_server

def get_account_age(user):
	if not user.created_at:
		return None
	account_age = (datetime.now(timezone.utc) - user.created_at).days
	return account_age

def get_user_moderation_history(discord_id: str):
	events = ModerationEvent.query.filter_by(discord_id=discord_id).order_by(ModerationEvent.created_at.desc()).all()
	
	warnings = [e for e in events if e.type == 'warning']
	kicks = [e for e in events if e.type == 'kick']
	bans = [e for e in events if e.type == 'ban']
	
	return warnings, kicks, bans

async def send_inspect_usage(channel):
	embed = discord.Embed(
		title="📋 Utilisation de la commande",
		description="**Syntaxe :** `!inspect @utilisateur` ou `!inspect <id>`",
		color=discord.Color.blue()
	)
	embed.add_field(name="Exemples", value="• `!inspect @User`\n• `!inspect 123456789012345678`", inline=False)
	await channel.send(embed=embed)

async def parse_target_user(message: Message, bot, parts: list):
	if message.mentions:
		return message.mentions[0]
	
	try:
		user_id = int(parts[1])
		return await bot.fetch_user(user_id)
	except (ValueError, discord.NotFound):
		return None

def create_inspect_embed(user, member, join_date, days_on_server, account_age, warnings, kicks, bans, invite_info):
	embed = discord.Embed(
		title=f"🔍 Inspection de {user.name}",
		color=discord.Color.blue(),
		timestamp=datetime.utcnow()
	)
	
	embed.set_thumbnail(url=user.display_avatar.url)
	embed.add_field(name="👤 Utilisateur", value=f"{user.mention}\n`{user.id}`", inline=True)
	
	if account_age is not None:
		embed.add_field(
			name="📅 Compte créé",
			value=f"{user.created_at.strftime('%d/%m/%Y')}\n({format_days_to_age(account_age)})",
			inline=True
		)
	
	if member and join_date:
		embed.add_field(
			name="📥 Rejoint le serveur",
			value=f"{join_date.strftime('%d/%m/%Y à %H:%M')}\n({format_days_to_age(days_on_server)})",
			inline=True
		)
	
	if invite_info:
		embed.add_field(name="🎫 Invitation", value=invite_info, inline=True)
	else:
		embed.add_field(name="🎫 Invitation", value="Inconnue", inline=True)
	
	warning_text = f"⚠️ **{len(warnings)}** avertissement{'s' if len(warnings) > 1 else ''}"
	kick_text = f"👢 **{len(kicks)}** expulsion{'s' if len(kicks) > 1 else ''}"
	ban_text = f"🔨 **{len(bans)}** ban{'s' if len(bans) > 1 else ''}"
	
	mod_history = f"{warning_text}\n{kick_text}\n{ban_text}"
	
	if warnings or kicks or bans:
		embed.add_field(name="📋 Historique de modération", value=mod_history, inline=False)
		
		if warnings:
			recent_warnings = warnings[:3]
			warnings_detail = "\n".join([
				f"• ID {w.id} - {w.created_at.strftime('%d/%m/%Y')} - {w.reason[:50]}{'...' if len(w.reason) > 50 else ''}"
				for w in recent_warnings
			])
			if len(warnings) > 3:
				warnings_detail += f"\n*... et {len(warnings) - 3} autre(s)*"
			embed.add_field(name="⚠️ Derniers avertissements", value=warnings_detail, inline=False)
	else:
		embed.add_field(name="✅ Historique de modération", value="Aucun incident", inline=False)
	
	embed.set_footer(text="Mamie Henriette")
	return embed

async def get_invite_info_for_user(bot, guild, user_id: int):
	try:
		from discordbot.welcome import invite_cache
		
		audit_logs = [entry async for entry in guild.audit_logs(limit=100, action=discord.AuditLogAction.member_join)]
		
		for entry in audit_logs:
			if entry.target and entry.target.id == user_id:
				if hasattr(entry, 'extra') and entry.extra:
					return f"Code: `{entry.extra}`"
		
		return None
	except:
		return None

async def handle_inspect_command(message: Message, bot):
	if not has_staff_role(message.author.roles):
		await send_access_denied(message.channel)
		return
	
	parts = message.content.split(maxsplit=1)
	
	if len(parts) < 2:
		await send_inspect_usage(message.channel)
		return
	
	target_user = await parse_target_user(message, bot, parts)
	
	if not target_user:
		await send_user_not_found(message.channel)
		return
	
	member = message.guild.get_member(target_user.id)
	join_date, days_on_server = await get_member_join_info(message.guild, target_user.id)
	account_age = get_account_age(target_user)
	warnings, kicks, bans = get_user_moderation_history(str(target_user.id))
	invite_info = await get_invite_info_for_user(bot, message.guild, target_user.id)
	
	embed = create_inspect_embed(
		target_user,
		member,
		join_date,
		days_on_server,
		account_age,
		warnings,
		kicks,
		bans,
		invite_info
	)
	
	await message.channel.send(embed=embed)
	await safe_delete_message(message)