Guild and Server Management

from nextcord import Guild, Client
import nextcord

# Basic guild information
@client.event
async def on_guild_join(guild: Guild):
    print(f"Joined guild: {guild.name}")
    print(f"Guild ID: {guild.id}")
    print(f"Member count: {guild.member_count}")
    print(f"Owner: {guild.owner}")
    print(f"Region: {guild.region}")
    print(f"Premium tier: {guild.premium_tier}")

# Edit guild settings
async def configure_guild(guild: Guild):
    await guild.edit(
        name="New Server Name",
        description="Updated server description",
        verification_level=nextcord.VerificationLevel.medium,
        explicit_content_filter=nextcord.ContentFilter.members_without_roles,
        default_notifications=nextcord.NotificationLevel.only_mentions,
        afk_timeout=300,  # 5 minutes
        system_channel=guild.text_channels[0],  # Set system channel
        rules_channel=guild.get_channel(12345),  # Community servers
        public_updates_channel=guild.get_channel(67890),
        preferred_locale="en-US"
    )

# Upload guild assets
with open("icon.png", "rb") as f:
    icon_data = f.read()
    
with open("banner.png", "rb") as f:
    banner_data = f.read()

await guild.edit(
    icon=icon_data,
    banner=banner_data,
    splash=None  # Remove splash image
)

# System channel management
guild.system_channel  # Channel for system messages
guild.system_channel_flags  # System channel settings
guild.rules_channel  # Rules channel (Community guilds)  
guild.public_updates_channel  # Public updates channel
guild.safety_alerts_channel  # Safety alerts channel

# AFK channel configuration
guild.afk_channel  # AFK voice channel
guild.afk_timeout  # AFK timeout in seconds

# Check guild limits
print(f"Emoji limit: {guild.emoji_limit}")
print(f"Sticker limit: {guild.sticker_limit}") 
print(f"Bitrate limit: {guild.bitrate_limit}")
print(f"File upload limit: {guild.filesize_limit}")

# Premium features
print(f"Premium tier: {guild.premium_tier}")
print(f"Boost count: {guild.premium_subscription_count}")
print(f"Premium subscribers: {len(guild.premium_subscribers)}")

# Access members
all_members = guild.members  # List of cached members
member = guild.get_member(user_id)  # Get by ID
member = guild.get_member_named("username#1234")  # Get by name

# Fetch members from API
member = await guild.fetch_member(user_id)

# Bulk member operations
async for member in guild.fetch_members(limit=1000):
    print(f"Member: {member.name}")

# Query members by username
members = await guild.query_members(
    query="user",  # Username prefix
    limit=50,
    presences=True  # Include presence info
)

# Chunk all members (requires members intent)
members = await guild.chunk(cache=True)

# Member collections
guild.members  # All cached members
guild.bots  # Bot members only  
guild.humans  # Human members only
guild.premium_subscribers  # Members who boosted the server

# Member counts and status
guild.member_count  # Total member count
guild.approximate_member_count  # Approximate count
guild.approximate_presence_count  # Active members
guild.chunked  # Whether all members are cached

# Kick member
await guild.kick(member, reason="Violation of rules")

# Ban member  
await guild.ban(
    member,
    reason="Serious rule violation",
    delete_message_seconds=86400  # Delete 1 day of messages
)

# Unban member
user = await client.fetch_user(user_id)
await guild.unban(user, reason="Appeal accepted")

# Timeout member (done via Member object)
import datetime
await member.timeout_for(
    datetime.timedelta(minutes=10),
    reason="Temporary timeout"
)

# Remove timeout
await member.remove_timeout(reason="Timeout lifted")

# Estimate prunable members
count = await guild.estimate_pruned_members(
    days=30,  # Inactive for 30 days
    roles=[guild.get_role(role_id)]  # Only members with specific roles
)

# Prune inactive members
pruned = await guild.prune_members(
    days=30,
    compute_prune_count=True,
    roles=[guild.get_role(role_id)],
    reason="Cleaning inactive members"
)

# Channel collections by type
guild.channels  # All channels
guild.text_channels  # Text channels only
guild.voice_channels  # Voice channels only  
guild.stage_channels  # Stage channels only
guild.categories  # Category channels only
guild.forum_channels  # Forum channels only
guild.threads  # Threads you can view

# Get channels
channel = guild.get_channel(channel_id)
thread = guild.get_thread(thread_id) 
channel_or_thread = guild.get_channel_or_thread(id)

# Fetch from API
channel = await guild.fetch_channel(channel_id)
channels = await guild.fetch_channels()
threads = await guild.active_threads()

# Channels organized by category
categorized = guild.by_category()
for category, channels in categorized:
    if category:
        print(f"Category: {category.name}")
    else:
        print("Uncategorized channels:")
    
    for channel in channels:
        print(f"  - {channel.name}")

from nextcord import PermissionOverwrite

# Create text channel
overwrites = {
    guild.default_role: PermissionOverwrite(read_messages=False),
    guild.me: PermissionOverwrite(read_messages=True)
}

text_channel = await guild.create_text_channel(
    "general-chat",
    category=guild.categories[0],  # Place in category
    topic="General discussion",
    slowmode_delay=5,  # 5 second slowmode
    nsfw=False,
    overwrites=overwrites,
    position=0,
    default_thread_slowmode_delay=60,
    reason="Creating new text channel"
)

# Create voice channel
voice_channel = await guild.create_voice_channel(
    "General Voice",
    category=guild.categories[0],
    bitrate=96000,  # 96kbps
    user_limit=10,  # Max 10 users
    rtc_region=nextcord.VoiceRegion.us_east,
    video_quality_mode=nextcord.VideoQualityMode.auto,
    overwrites=overwrites,
    reason="Creating voice channel"
)

# Create stage channel
stage_channel = await guild.create_stage_channel(
    "Weekly Events", 
    topic="Weekly community events",
    category=guild.categories[0],
    bitrate=128000,
    user_limit=50,
    overwrites=overwrites,
    reason="Creating stage channel"
)

# Create category
category = await guild.create_category(
    "Community Channels",
    overwrites=overwrites,
    position=0,
    reason="Organizing channels"
)

# Create forum channel  
from nextcord.channel import ForumTag

forum_tags = [
    ForumTag(name="Question", emoji="❓", moderated=False),
    ForumTag(name="Solved", emoji="✅", moderated=True)
]

forum_channel = await guild.create_forum_channel(
    "Help Forum",
    topic="Community help and support",
    category=guild.categories[0], 
    available_tags=forum_tags,
    default_thread_slowmode_delay=0,
    default_sort_order=nextcord.SortOrderType.creation_date,
    overwrites=overwrites,
    reason="Creating help forum"
)

# Access roles
guild.roles  # All roles in hierarchy order
role = guild.get_role(role_id)  # Get by ID
guild.default_role  # @everyone role
guild.premium_subscriber_role  # Boost role
guild.self_role  # Bot's role

# Fetch from API
roles = await guild.fetch_roles(cache=True)

from nextcord import Permissions, Colour

# Create role
permissions = Permissions(
    send_messages=True,
    read_messages=True,
    manage_messages=True,
    kick_members=True
)

role = await guild.create_role(
    name="Moderator",
    permissions=permissions,
    colour=Colour.blue(),
    hoist=True,  # Display separately
    mentionable=True,
    icon="🛡️",  # Unicode emoji or image bytes
    reason="Creating moderator role"
)

# Edit role positions
positions = {
    role1: 1,
    role2: 2, 
    admin_role: 10
}
await guild.edit_role_positions(positions, reason="Reorganizing roles")

# Add/remove roles from members
await member.add_roles(role1, role2, reason="Promoting member")
await member.remove_roles(role1, reason="Role cleanup")

# Bulk role operations
moderator_role = guild.get_role(moderator_role_id)
for member in guild.members:
    if member.premium_since:  # If they boost the server
        await member.add_roles(moderator_role)

# Ban management
async def ban_user(guild: Guild, user_id: int, reason: str):
    # Ban user
    user = await client.fetch_user(user_id)
    await guild.ban(
        user,
        reason=reason,
        delete_message_seconds=604800  # Delete 7 days of messages
    )

# Check bans
ban_entry = await guild.fetch_ban(user)
print(f"Ban reason: {ban_entry.reason}")

# Iterate through all bans
async for ban in guild.bans(limit=100):
    print(f"{ban.user.name} - {ban.reason}")

# Unban
await guild.unban(user, reason="Appeal approved")

from nextcord.auto_moderation import (
    AutoModerationTriggerMetadata,
    AutoModerationAction,
    AutoModerationActionType,
    AutoModerationEventType, 
    AutoModerationTriggerType
)

# Create auto moderation rule
trigger_metadata = AutoModerationTriggerMetadata(
    keyword_filter=["badword1", "badword2"],
    regex_patterns=[r"\b\d{16,18}\b"],  # Credit card numbers
    mention_total_limit=5
)

actions = [
    AutoModerationAction(
        type=AutoModerationActionType.block_message
    ),
    AutoModerationAction(
        type=AutoModerationActionType.send_alert_message,
        metadata={"channel_id": alert_channel.id}
    ),
    AutoModerationAction(
        type=AutoModerationActionType.timeout,
        metadata={"duration_seconds": 300}
    )
]

rule = await guild.create_auto_moderation_rule(
    name="Content Filter",
    event_type=AutoModerationEventType.message_send,
    trigger_type=AutoModerationTriggerType.keyword,
    actions=actions,
    trigger_metadata=trigger_metadata,
    enabled=True,
    exempt_roles=[moderator_role],
    exempt_channels=[staff_channel],
    reason="Setting up content filtering"
)

# Get existing rules
rules = await guild.auto_moderation_rules()
rule = await guild.fetch_auto_moderation_rule(rule_id)

# Access audit logs
async for entry in guild.audit_logs(
    limit=100,
    action=nextcord.AuditLogAction.ban,
    user=moderator_user,  # Filter by moderator
    after=datetime.datetime.now() - datetime.timedelta(days=7)
):
    print(f"{entry.user} {entry.action} {entry.target}")
    print(f"Reason: {entry.reason}")

from nextcord.scheduled_events import EntityMetadata
import datetime

# Create scheduled event
start_time = datetime.datetime.now() + datetime.timedelta(hours=24)
end_time = start_time + datetime.timedelta(hours=2)

# Stage channel event
event = await guild.create_scheduled_event(
    name="Weekly Community Meeting",
    entity_type=nextcord.ScheduledEventEntityType.stage_instance,
    start_time=start_time,
    end_time=end_time,
    channel=guild.stage_channels[0],
    description="Weekly community discussion and updates",
    privacy_level=nextcord.ScheduledEventPrivacyLevel.guild_only,
    reason="Creating weekly meeting"
)

# External event
external_event = await guild.create_scheduled_event(
    name="Game Tournament", 
    entity_type=nextcord.ScheduledEventEntityType.external,
    start_time=start_time,
    end_time=end_time,
    metadata=EntityMetadata(location="Community Center, Main St"),
    description="Monthly gaming tournament",
    reason="Creating tournament event"
)

# Get events
guild.scheduled_events  # Cached events
event = guild.get_scheduled_event(event_id)
event = await guild.fetch_scheduled_event(event_id, with_users=True)

# Iterate events
async for event in guild.fetch_scheduled_events(with_users=True):
    print(f"Event: {event.name} - Users interested: {event.user_count}")

# Event user management
async for user in event.fetch_users(limit=100, with_members=True):
    print(f"Interested user: {user.user.name}")
    if user.member:
        print(f"  Member since: {user.member.joined_at}")

# Application commands (slash commands)
commands = guild.get_application_commands()
await guild.sync_application_commands(
    associate_known=True,
    delete_unknown=True, 
    update_known=True,
    register_new=True
)

# Register specific commands
await guild.register_application_commands(*command_objects)

# Delete commands
await guild.delete_application_commands(*command_objects)

# Get guild webhooks
webhooks = await guild.webhooks()
for webhook in webhooks:
    print(f"Webhook: {webhook.name} in {webhook.channel}")

# Webhook management is typically done per-channel
channel_webhooks = await text_channel.webhooks()

# Get integrations (YouTube, Twitch, etc.)
integrations = await guild.integrations()
for integration in integrations:
    print(f"Integration: {integration.name} ({integration.type})")

# Create integration
await guild.create_integration(
    type="twitch",  # Integration type
    id=integration_id
)

# Guild templates
templates = await guild.templates()
for template in templates:
    print(f"Template: {template.name} - {template.code}")

# Create template
template = await guild.create_template(
    name="Community Server Template",
    description="Basic community server setup"
)

# Change bot's voice state
await guild.change_voice_state(
    channel=voice_channel,  # None to disconnect
    self_mute=False,
    self_deaf=False
)

# Access voice states
voice_client = guild.voice_client  # Bot's voice connection
for member in voice_channel.members:
    voice_state = member.voice
    if voice_state:
        print(f"{member.name} - Muted: {voice_state.mute}")

# Stage instances
guild.stage_instances  # Active stage instances
stage_instance = guild.get_stage_instance(instance_id)

# Create stage instance (done via StageChannel)
stage_instance = await stage_channel.create_instance(
    topic="Community Discussion",
    privacy_level=nextcord.StagePrivacyLevel.guild_only,
    reason="Starting community discussion"
)

# Guild widget
widget = await guild.widget()
print(f"Widget enabled: {widget.enabled}")
print(f"Instant invite: {widget.invite_url}")

# Edit widget
await guild.edit_widget(
    enabled=True,
    channel=guild.text_channels[0]
)

# Vanity invite
vanity_invite = await guild.vanity_invite()
if vanity_invite:
    print(f"Vanity URL: {vanity_invite.url}")

# Guild assets
if guild.icon:
    print(f"Icon URL: {guild.icon.url}")
    
if guild.banner:
    print(f"Banner URL: {guild.banner.url}")
    
if guild.splash:
    print(f"Splash URL: {guild.splash.url}")
    
if guild.discovery_splash:
    print(f"Discovery splash URL: {guild.discovery_splash.url}")

# Emoji management
guild.emojis  # All guild emojis
emoji = await guild.fetch_emoji(emoji_id)
emojis = await guild.fetch_emojis()

# Create custom emoji
with open("emoji.png", "rb") as f:
    emoji_data = f.read()
    
emoji = await guild.create_custom_emoji(
    name="custom_emoji",
    image=emoji_data,
    roles=[moderator_role],  # Restrict to specific roles
    reason="Adding custom emoji"
)

# Delete emoji
await guild.delete_emoji(emoji, reason="Cleaning up emojis")

# Sticker management  
guild.stickers  # All guild stickers
sticker = await guild.fetch_sticker(sticker_id)
stickers = await guild.fetch_stickers()

# Create sticker
from nextcord import File

sticker_file = File("sticker.png", filename="sticker.png")
sticker = await guild.create_sticker(
    name="custom_sticker",
    description="Custom guild sticker", 
    emoji="😄",  # Related emoji
    file=sticker_file,
    reason="Adding custom sticker"
)

# Delete sticker
await guild.delete_sticker(sticker, reason="Removing sticker")

# Parse mentions in text
text = "Hello <@123456789> and <@&987654321> in <#555666777>!"

mentioned_users = guild.parse_mentions(text)  # List of Member/User objects
mentioned_roles = guild.parse_role_mentions(text)  # List of Role objects  
mentioned_channels = guild.parse_channel_mentions(text)  # List of Channel objects

# Get raw IDs
from nextcord import utils
user_ids = utils.parse_raw_mentions(text)
role_ids = utils.parse_raw_role_mentions(text) 
channel_ids = utils.parse_raw_channel_mentions(text)

# Leave guild (cannot leave if owner)
await guild.leave()

# Delete guild (owner only)
await guild.delete()

# Guild information
print(f"Created at: {guild.created_at}")
print(f"Shard ID: {guild.shard_id}")
print(f"Is large: {guild.large}")
print(f"Invites disabled: {guild.invites_disabled}")

async def setup_new_guild(guild: Guild):
    """Complete setup for a new guild"""
    
    # 1. Configure basic settings
    await guild.edit(
        name="My Community Server",
        description="A friendly community server",
        verification_level=nextcord.VerificationLevel.medium,
        explicit_content_filter=nextcord.ContentFilter.members_without_roles,
        default_notifications=nextcord.NotificationLevel.only_mentions
    )
    
    # 2. Create role hierarchy
    admin_role = await guild.create_role(
        name="Admin",
        permissions=nextcord.Permissions.all(),
        colour=nextcord.Colour.red(),
        hoist=True,
        mentionable=True
    )
    
    mod_role = await guild.create_role(
        name="Moderator", 
        permissions=nextcord.Permissions(
            kick_members=True,
            ban_members=True,
            manage_messages=True
        ),
        colour=nextcord.Colour.blue(),
        hoist=True
    )
    
    # 3. Create channel structure
    general_category = await guild.create_category("General")
    
    await guild.create_text_channel(
        "rules",
        category=general_category,
        topic="Server rules and guidelines",
        position=0
    )
    
    await guild.create_text_channel(
        "general",
        category=general_category,
        topic="General discussion"
    )
    
    voice_category = await guild.create_category("Voice")
    await guild.create_voice_channel(
        "General Voice",
        category=voice_category
    )
    
    # 4. Set up auto moderation
    await guild.create_auto_moderation_rule(
        name="Spam Protection",
        event_type=nextcord.AutoModerationEventType.message_send,
        trigger_type=nextcord.AutoModerationTriggerType.mention_spam,
        actions=[
            nextcord.AutoModerationAction(
                type=nextcord.AutoModerationActionType.block_message
            )
        ],
        trigger_metadata=nextcord.AutoModerationTriggerMetadata(
            mention_total_limit=5
        ),
        enabled=True,
        exempt_roles=[admin_role, mod_role]
    )

@client.event
async def on_member_join(member: Member):
    """Handle new member joining"""
    guild = member.guild
    
    # Send welcome message
    welcome_channel = guild.get_channel(WELCOME_CHANNEL_ID)
    if welcome_channel:
        embed = nextcord.Embed(
            title=f"Welcome {member.display_name}!",
            description=f"Welcome to {guild.name}! Please read the rules.",
            colour=nextcord.Colour.green()
        )
        embed.set_thumbnail(url=member.avatar.url)
        await welcome_channel.send(embed=embed)
    
    # Assign default role
    default_role = guild.get_role(DEFAULT_ROLE_ID)
    if default_role:
        await member.add_roles(default_role, reason="New member default role")
    
    # Log join in audit channel
    audit_channel = guild.get_channel(AUDIT_CHANNEL_ID)
    if audit_channel:
        await audit_channel.send(
            f"📥 {member.mention} joined the server. "
            f"Account created: {member.created_at.strftime('%Y-%m-%d')}"
        )

class ModerationSystem:
    def __init__(self, guild: Guild):
        self.guild = guild
        
    async def warn_member(self, member: Member, reason: str, moderator: Member):
        """Warn a member with logging"""
        # Log to database (implement your own storage)
        await self.log_warning(member.id, reason, moderator.id)
        
        # Notify member
        try:
            await member.send(f"You received a warning in {self.guild.name}: {reason}")
        except:
            pass  # DMs disabled
            
        # Log in moderation channel
        mod_channel = self.guild.get_channel(MOD_LOG_CHANNEL)
        if mod_channel:
            embed = nextcord.Embed(
                title="Member Warned",
                colour=nextcord.Colour.yellow()
            )
            embed.add_field(name="Member", value=member.mention)
            embed.add_field(name="Moderator", value=moderator.mention)
            embed.add_field(name="Reason", value=reason, inline=False)
            await mod_channel.send(embed=embed)
    
    async def timeout_member(self, member: Member, duration: int, reason: str):
        """Timeout a member"""
        import datetime
        
        await member.timeout_for(
            datetime.timedelta(seconds=duration),
            reason=reason
        )
        
        # Log timeout
        mod_channel = self.guild.get_channel(MOD_LOG_CHANNEL)
        if mod_channel:
            embed = nextcord.Embed(
                title="Member Timed Out",
                colour=nextcord.Colour.orange()
            )
            embed.add_field(name="Member", value=member.mention)
            embed.add_field(name="Duration", value=f"{duration} seconds")
            embed.add_field(name="Reason", value=reason, inline=False)
            await mod_channel.send(embed=embed)
    
    async def ban_member(self, member: Member, reason: str, delete_days: int = 1):
        """Ban a member with full logging"""
        await self.guild.ban(
            member,
            reason=reason,
            delete_message_seconds=delete_days * 24 * 60 * 60
        )
        
        # Log ban
        mod_channel = self.guild.get_channel(MOD_LOG_CHANNEL) 
        if mod_channel:
            embed = nextcord.Embed(
                title="Member Banned",
                colour=nextcord.Colour.red()
            )
            embed.add_field(name="Member", value=f"{member} ({member.id})")
            embed.add_field(name="Reason", value=reason, inline=False)
            embed.add_field(name="Messages Deleted", value=f"{delete_days} days")
            await mod_channel.send(embed=embed)