bot.py

"""
Veil Security Bot - STFC Rank-Based Verification & Updates

Features:
  - Verify STFC players via stfc.pro/stfc.wtf data
  - Extract alliance rank (Agent, Operative, Premier, Commodore, Admiral)
  - Assign roles based on alliance rank
  - Request admin confirmation for Commodore/Admiral promotions
  - Detect rank changes on periodic updates
  - Screenshot logging for verification records
"""

import os
import re
import sqlite3
import asyncio
import logging
from datetime import datetime, timezone, timedelta
from typing import Optional

import discord
from discord import app_commands, ui
from discord.ext import tasks, commands
from dotenv import load_dotenv

from stfc_scraper import STFCProScraper, PlayerData, format_player_info

# ---------------------------------------------------------------------------
# Environment & Logging
# ---------------------------------------------------------------------------
load_dotenv()

DEBUG = os.getenv("DEBUG", "0") not in ("0", "", "false", "False", "no", "No")
logging.basicConfig(
    level=logging.DEBUG if DEBUG else logging.INFO,
    format="%(asctime)s %(levelname)-7s %(name)s :: %(message)s",
)
log = logging.getLogger("veil_bot")


# ---------------------------------------------------------------------------
# Config Helpers
# ---------------------------------------------------------------------------
def _env_int(name: str, required: bool = True, default: Optional[int] = None) -> Optional[int]:
    """Load integer from environment variable."""
    v = os.getenv(name)
    if v is None or v == "":
        if required:
            raise SystemExit(f"Missing required env var: {name}")
        return default
    try:
        return int(v)
    except ValueError:
        raise SystemExit(f"Env var {name} must be an integer.")


# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
GUILD_ID = _env_int("GUILD_ID")
STFC_SERVER_ID = _env_int("STFC_SERVER_ID")

MEMBER_ROLE_ID = _env_int("MEMBER_ROLE_ID")
COMMODORE_ROLE_ID = _env_int("COMMODORE_ROLE_ID")
ADMIRAL_ROLE_ID = _env_int("ADMIRAL_ROLE_ID")
VERIFY_ROLE_ID = _env_int("VERIFY_ROLE_ID", required=False, default=0)
ADMIN_ROLE_ID = _env_int("ADMIN_ROLE_ID", required=False, default=0)

VERIFY_CHANNEL_ID = _env_int("VERIFY_CHANNEL_ID")
LOG_CHANNEL_ID = _env_int("LOG_CHANNEL_ID")

UPDATE_CHECK_HOURS = int(os.getenv("UPDATE_CHECK_HOURS", "24"))
DB_PATH = os.getenv("DB_PATH", "stfc_players.db")

log.info(
    "Config: GUILD=%s STFC_SERVER=%s MEMBER_ROLE=%s COMMODORE_ROLE=%s ADMIRAL_ROLE=%s VERIFY_ROLE=%s ADMIN_ROLE=%s "
    "VERIFY_CH=%s LOG_CH=%s UPDATE_CHECK=%sh",
    GUILD_ID, STFC_SERVER_ID, MEMBER_ROLE_ID, COMMODORE_ROLE_ID, ADMIRAL_ROLE_ID, VERIFY_ROLE_ID, ADMIN_ROLE_ID,
    VERIFY_CHANNEL_ID, LOG_CHANNEL_ID, UPDATE_CHECK_HOURS,
)


# ---------------------------------------------------------------------------
# Rank Classification
# ---------------------------------------------------------------------------
RANK_TIERS = {
    "agent": "base",
    "operative": "base",
    "premier": "base",
    "commodore": "commodore",
    "admiral": "admiral",
}

def get_rank_tier(rank: Optional[str]) -> Optional[str]:
    """Get the tier category for a rank."""
    if not rank:
        return None
    return RANK_TIERS.get(rank.lower())


# ---------------------------------------------------------------------------
# Discord Views (Buttons & Forms)
# ---------------------------------------------------------------------------
class StartWizardView(discord.ui.View):
    """Initial welcome message with Start button."""
    def __init__(self):
        super().__init__(timeout=None)

    @discord.ui.button(label="Start Verification", style=discord.ButtonStyle.green)
    async def start_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        user_id = interaction.user.id
        
        # Check if user is already verified
        if store.get_player_data(user_id):
            await interaction.response.send_message(
                "⚠️ You have already verified your STFC account!\n\n"
                "If you need to:\n"
                "- **Update your information or report an issue** → Open a support ticket in <#1506711181740605631>.\n\n"
                "Only Admins can modify or recall your verification.",
                ephemeral=True,
            )
            log.info(f"[WIZARD] User {user_id} attempted re-verification (already verified)")
            return
        
        # Initialize wizard session in database
        store.create_wizard_session(user_id)
        log.info(f"[WIZARD] Created session for user {user_id}")
        
        await interaction.response.defer()
        
        embed = discord.Embed(
            title="📋 Step 1: STFC Player Link",
            description="Please send your https://stfc.pro  player profile link.\n\n"
                        "**Valid formats:**\n"
                        "- `https://stfc.pro/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.wtf/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.live/players/XXXXXXXXXXXXX`\n"
                        "- Or just the player ID: `XXXXXXXXXXXXX`",
            colour=discord.Colour.blue(),
        )
        embed.set_footer(text="Reply with your link in the next message")
        
        await interaction.followup.send(embed=embed)
        log.info(f"[WIZARD] User {user_id} started verification wizard")


class SkipStepsView(discord.ui.View):
    """View with Restart button during verification."""
    def __init__(self, user_id: int):
        super().__init__(timeout=None)
        self.user_id = user_id

    @discord.ui.button(label="🔄 Restart", style=discord.ButtonStyle.danger)
    async def restart_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user.id != self.user_id:
            await interaction.response.send_message("❌ This is not your verification wizard.", ephemeral=True)
            return
        
        await interaction.response.defer()
        
        # Reset session
        store.update_wizard_session(self.user_id, step=1, stfc_link=None, screenshot_data=None)
        
        embed = discord.Embed(
            title="📋 Step 1: STFC Player Link",
            description="Please send your https://stfc.pro player profile link.\n\n"
                        "**Valid formats:**\n"
                        "- `https://stfc.pro/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.wtf/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.live/players/XXXXXXXXXXXXX`\n"
                        "- Or just the player ID: `XXXXXXXXXXXXX`",
            colour=discord.Colour.blue(),
        )
        embed.set_footer(text="Reply with your link in the next message")
        
        await interaction.followup.send(embed=embed, view=SkipStepsView(self.user_id))
        log.info(f"[WIZARD] User {self.user_id} restarted verification wizard")


class SessionExpiredView(discord.ui.View):
    """View for expired session with Restart button."""
    def __init__(self, user_id: int):
        super().__init__(timeout=None)
        self.user_id = user_id

    @discord.ui.button(label="🔄 Restart Verification", style=discord.ButtonStyle.green)
    async def restart_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user.id != self.user_id:
            await interaction.response.send_message("❌ This is not your verification wizard.", ephemeral=True)
            return
        
        # Initialize new wizard session
        store.create_wizard_session(self.user_id)
        log.info(f"[WIZARD] Created new session for user {self.user_id} after timeout")
        
        await interaction.response.defer()
        
        embed = discord.Embed(
            title="📋 Step 1: STFC Player Link",
            description="Please send your https://stfc.pro player profile link.\n\n"
                        "**Valid formats:**\n"
                        "- `https://stfc.pro/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.wtf/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.live/players/XXXXXXXXXXXXX`\n"
                        "- Or just the player ID: `XXXXXXXXXXXXX`",
            colour=discord.Colour.blue(),
        )
        embed.set_footer(text="Reply with your link in the next message (session expires in 10 minutes)")
        
        await interaction.followup.send(embed=embed, view=SkipStepsView(self.user_id))
        log.info(f"[WIZARD] Restarted wizard for user {self.user_id}")


class ConfirmVerificationView(discord.ui.View):
    """Final confirmation with Complete and Restart buttons."""
    def __init__(self, user_id: int):
        super().__init__(timeout=None)
        self.user_id = user_id

    @discord.ui.button(label="✅ Complete", style=discord.ButtonStyle.green)
    async def complete_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user.id != self.user_id:
            await interaction.response.send_message("❌ This is not your verification wizard.", ephemeral=True)
            return
        
        session = store.get_wizard_session(self.user_id)
        if not session:
            await interaction.response.send_message("❌ Verification session expired.", ephemeral=True)
            return
        
        await interaction.response.defer(thinking=True)
        
        session = store.get_wizard_session(self.user_id)
        await _finalize_verification(interaction, session)
        
        # Clean up session
        store.delete_wizard_session(self.user_id)

    @discord.ui.button(label="🔄 Restart", style=discord.ButtonStyle.danger)
    async def restart_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user.id != self.user_id:
            await interaction.response.send_message("❌ This is not your verification wizard.", ephemeral=True)
            return
        
        await interaction.response.defer()
        
        # Reset session
        store.update_wizard_session(self.user_id, step=1, stfc_link=None, screenshot_data=None)
        
        embed = discord.Embed(
            title="📋 Step 1: STFC Player Link",
            description="Please send your https://stfc.pro player profile link.\n\n"
                        "**Valid formats:**\n"
                        "- `https://stfc.pro/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.wtf/players/XXXXXXXXXXXXX`\n"
                        "- `https://stfc.live/players/XXXXXXXXXXXXX`\n"
                        "- Or just the player ID: `XXXXXXXXXXXXX`",
            colour=discord.Colour.blue(),
        )
        embed.set_footer(text="Reply with your link in the next message")
        
        await interaction.followup.send(embed=embed, view=SkipStepsView(self.user_id))
        log.info(f"[WIZARD] User {self.user_id} restarted verification wizard")


class RankConfirmationView(discord.ui.View):
    """View for admin to confirm/reject rank changes."""

    def __init__(self, user_id: int, member_name: str, rank: str, player_name: str, alliance_tag: str):
        super().__init__(timeout=None)
        self.user_id = user_id
        self.member_name = member_name
        self.rank = rank
        self.player_name = player_name
        self.alliance_tag = alliance_tag
        self.confirmed = None
        self.user_message = None
        self.log_message = None

    @discord.ui.button(label="✅ Accept", style=discord.ButtonStyle.green, custom_id="rank_accept")
    async def accept_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        """Accept the rank promotion."""
        self.confirmed = True
        await interaction.response.defer()
        await self.on_confirmation(interaction.guild)
        if self.log_message:
            try:
                embed = self.log_message.embeds[0] if self.log_message.embeds else None
                if embed:
                    embed.color = discord.Color.green()
                    embed.title = "✅ Rank Confirmation - ACCEPTED"
                    await self.log_message.edit(embed=embed, view=None)
            except Exception as e:
                log.warning(f"[CONFIRM] Could not edit log message: {e}")
        self.stop()

    @discord.ui.button(label="❌ Reject", style=discord.ButtonStyle.red, custom_id="rank_reject")
    async def reject_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        """Reject the rank promotion."""
        self.confirmed = False
        await interaction.response.defer()
        await self.on_confirmation(interaction.guild)
        if self.log_message:
            try:
                embed = self.log_message.embeds[0] if self.log_message.embeds else None
                if embed:
                    embed.color = discord.Color.red()
                    embed.title = "❌ Rank Confirmation - REJECTED"
                    await self.log_message.edit(embed=embed, view=None)
            except Exception as e:
                log.warning(f"[CONFIRM] Could not edit log message: {e}")
        self.stop()

    async def on_confirmation(self, guild: discord.Guild):
        """Handle the confirmation result."""
        member = guild.get_member(self.user_id)
        if not member:
            log.warning(f"[CONFIRM] Member {self.user_id} not found for confirmation")
            return

        if self.confirmed:
            log.info(f"[CONFIRM] Admin ACCEPTED rank change for {member.name}: {self.rank}")
            commodore_role = guild.get_role(COMMODORE_ROLE_ID)
            admiral_role = guild.get_role(ADMIRAL_ROLE_ID)
            
            rank_tier = get_rank_tier(self.rank)
            
            try:
                if rank_tier == "commodore":
                    if commodore_role:
                        await member.add_roles(commodore_role, reason=f"Confirmed rank: {self.rank}")
                    if admiral_role and admiral_role in member.roles:
                        await member.remove_roles(admiral_role, reason="Rank downgrade")
                    log.info(f"[CONFIRM] Assigned commodore role to {member.name}")
                    
                elif rank_tier == "admiral":
                    if admiral_role:
                        await member.add_roles(admiral_role, reason=f"Confirmed rank: {self.rank}")
                    if commodore_role and commodore_role in member.roles:
                        await member.remove_roles(commodore_role, reason="Rank promotion")
                    log.info(f"[CONFIRM] Assigned admiral role to {member.name}")
            except Exception as e:
                log.error(f"[CONFIRM] Error assigning leadership role: {e}")
            
            if self.user_message:
                try:
                    embed = discord.Embed(
                        title="✅ Verification Successful",
                        description=f"Welcome, **{self.player_name}**! Your rank has been confirmed by admins.",
                        color=discord.Color.green(),
                    )
                    embed.add_field(name="Rank", value=self.rank, inline=True)
                    embed.add_field(name="Alliance", value=f"[{self.alliance_tag}]" if self.alliance_tag != "N/A" else "N/A", inline=True)
                    await self.user_message.edit(embed=embed)
                except Exception as e:
                    log.warning(f"[CONFIRM] Could not edit user message: {e}")
            
            # Send DM confirmation to user
            try:
                dm_embed = discord.Embed(
                    title="✅ Verification Complete!",
                    description=f"Your rank promotion to **{self.rank}** has been confirmed by admins.",
                    color=discord.Color.green(),
                )
                dm_embed.add_field(name="Rank", value=self.rank, inline=True)
                dm_embed.add_field(name="Alliance", value=f"[{self.alliance_tag}]" if self.alliance_tag != "N/A" else "N/A", inline=True)
                dm_embed.add_field(name="Status", value="You now have full access to server features!", inline=False)
                dm_embed.set_footer(text="Thank you for verifying your STFC account!")
                await member.send(embed=dm_embed)
                log.info(f"[CONFIRM] Sent DM confirmation to {member.id}")
            except discord.Forbidden:
                log.warning(f"[CONFIRM] Could not send DM to {member.id} (DMs disabled)")
            except Exception as e:
                log.warning(f"[CONFIRM] Error sending DM to {member.id}: {e}")
        else:
            log.info(f"[CONFIRM] Admin REJECTED rank change for {member.name}: {self.rank}")
            
            if self.user_message:
                try:
                    embed = discord.Embed(
                        title="❌ Verification Rejected",
                        description=f"Your rank promotion to {self.rank} was rejected by admins.",
                        color=discord.Color.red(),
                    )
                    await self.user_message.edit(embed=embed)
                except Exception as e:
                    log.warning(f"[CONFIRM] Could not edit user message: {e}")
            
            # Send DM rejection notice to user
            try:
                dm_embed = discord.Embed(
                    title="❌ Verification Rejected",
                    description=f"Your rank promotion to **{self.rank}** was rejected by admins.",
                    color=discord.Color.red(),
                )
                dm_embed.add_field(name="Rank", value=self.rank, inline=True)
                dm_embed.add_field(name="Next Steps", value="Please contact an admin if you believe this was a mistake.", inline=False)
                await member.send(embed=dm_embed)
                log.info(f"[CONFIRM] Sent DM rejection notice to {member.id}")
            except discord.Forbidden:
                log.warning(f"[CONFIRM] Could not send DM to {member.id} (DMs disabled)")
            except Exception as e:
                log.warning(f"[CONFIRM] Error sending DM to {member.id}: {e}")


# ---------------------------------------------------------------------------
# SQLite Store for STFC Player Links
# ---------------------------------------------------------------------------
class Store:
    """SQLite wrapper to store STFC player links for periodic updates."""

    def __init__(self, path: str):
        self.path = path
        self._init_db()

    def _init_db(self):
        """Initialize database tables."""
        with sqlite3.connect(self.path) as conn:
            conn.execute("""
                CREATE TABLE IF NOT EXISTS stfc_players (
                    user_id INTEGER PRIMARY KEY,
                    stfc_link TEXT NOT NULL,
                    player_id TEXT NOT NULL,
                    username TEXT,
                    level INTEGER,
                    server INTEGER,
                    alliance_tag TEXT,
                    verification_status TEXT DEFAULT 'verified',
                    verified_at TIMESTAMP,
                    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            """)
            conn.execute("""
                CREATE TABLE IF NOT EXISTS verification_logs (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER NOT NULL,
                    action TEXT NOT NULL,
                    admin_id INTEGER,
                    reason TEXT,
                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY(user_id) REFERENCES stfc_players(user_id)
                )
            """)
            conn.execute("""
                CREATE TABLE IF NOT EXISTS wizard_sessions (
                    user_id INTEGER PRIMARY KEY,
                    step INTEGER DEFAULT 1,
                    stfc_link TEXT,
                    screenshot_data TEXT,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    expires_at TIMESTAMP
                )
            """)
            
            # Migration: Add missing columns to existing tables
            cursor = conn.execute("PRAGMA table_info(stfc_players)")
            columns = {row[1] for row in cursor.fetchall()}
            
            if "verification_status" not in columns:
                conn.execute(
                    "ALTER TABLE stfc_players ADD COLUMN verification_status TEXT DEFAULT 'verified'"
                )
                log.info("[DB] Migrated: Added verification_status column")
            
            if "verified_at" not in columns:
                conn.execute(
                    "ALTER TABLE stfc_players ADD COLUMN verified_at TIMESTAMP"
                )
                log.info("[DB] Migrated: Added verified_at column")
            
            if "rank" not in columns:
                conn.execute(
                    "ALTER TABLE stfc_players ADD COLUMN rank TEXT"
                )
                log.info("[DB] Migrated: Added rank column")
            
            if "alliance_role_id" not in columns:
                conn.execute(
                    "ALTER TABLE stfc_players ADD COLUMN alliance_role_id INTEGER"
                )
                log.info("[DB] Migrated: Added alliance_role_id column")
            
            # Add player_data_json column to wizard_sessions if missing
            cursor = conn.execute("PRAGMA table_info(wizard_sessions)")
            wizard_columns = {row[1] for row in cursor.fetchall()}
            
            if "player_data_json" not in wizard_columns:
                conn.execute(
                    "ALTER TABLE wizard_sessions ADD COLUMN player_data_json TEXT"
                )
                log.info("[DB] Migrated: Added player_data_json column to wizard_sessions")
            
            conn.commit()

    def store_stfc_player(
        self,
        user_id: int,
        stfc_link: str,
        player_data: PlayerData,
    ):
        """Store or update a player's STFC link and data. Does not overwrite alliance_role_id."""
        with sqlite3.connect(self.path) as conn:
            # Check if user exists
            cursor = conn.execute("SELECT 1 FROM stfc_players WHERE user_id = ?", (user_id,))
            user_exists = cursor.fetchone() is not None
            
            if user_exists:
                # Update existing user, preserving alliance_role_id
                conn.execute("""
                    UPDATE stfc_players
                    SET stfc_link = ?, player_id = ?, username = ?, level = ?, server = ?, 
                        alliance_tag = ?, rank = ?, last_updated = CURRENT_TIMESTAMP
                    WHERE user_id = ?
                """, (
                    stfc_link,
                    player_data.player_id,
                    player_data.username,
                    player_data.level,
                    player_data.server,
                    player_data.alliance_tag,
                    player_data.rank,
                    user_id,
                ))
            else:
                # Insert new user
                conn.execute("""
                    INSERT INTO stfc_players
                    (user_id, stfc_link, player_id, username, level, server, alliance_tag, rank, last_updated)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
                """, (
                    user_id,
                    stfc_link,
                    player_data.player_id,
                    player_data.username,
                    player_data.level,
                    player_data.server,
                    player_data.alliance_tag,
                    player_data.rank,
                ))
            conn.commit()

    def get_all_players(self) -> list[tuple]:
        """Get all stored player links for update checks."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT user_id, stfc_link, player_id FROM stfc_players"
            )
            return cursor.fetchall()

    def get_player_data(self, user_id: int) -> Optional[tuple]:
        """Get stored player data for a user. Returns: (username, level, server, alliance_tag, rank)"""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT username, level, server, alliance_tag, rank FROM stfc_players WHERE user_id = ?",
                (user_id,),
            )
            return cursor.fetchone()

    def get_verification_status(self, user_id: int) -> Optional[str]:
        """Get verification status for a user."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT verification_status FROM stfc_players WHERE user_id = ?",
                (user_id,),
            )
            row = cursor.fetchone()
            return row[0] if row else None

    def is_user_verified(self, user_id: int) -> bool:
        """Check if user has already verified."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT user_id FROM stfc_players WHERE user_id = ? AND verification_status = 'verified'",
                (user_id,),
            )
            return cursor.fetchone() is not None

    def mark_verified(self, user_id: int):
        """Mark user as verified."""
        with sqlite3.connect(self.path) as conn:
            conn.execute(
                "UPDATE stfc_players SET verification_status = 'verified', verified_at = CURRENT_TIMESTAMP WHERE user_id = ?",
                (user_id,),
            )
            conn.commit()

    def delete_verification(self, user_id: int):
        """Delete a user's verification entry."""
        with sqlite3.connect(self.path) as conn:
            conn.execute("DELETE FROM stfc_players WHERE user_id = ?", (user_id,))
            conn.commit()

    def log_verification_action(self, user_id: int, action: str, admin_id: int = None, reason: str = None):
        """Log a verification action."""
        with sqlite3.connect(self.path) as conn:
            conn.execute(
                """INSERT INTO verification_logs (user_id, action, admin_id, reason)
                   VALUES (?, ?, ?, ?)""",
                (user_id, action, admin_id, reason),
            )
            conn.commit()

    def create_wizard_session(self, user_id: int) -> None:
        """Create a new wizard session for a user."""
        from datetime import datetime, timedelta
        expires_at = (datetime.now() + timedelta(minutes=10)).isoformat()
        with sqlite3.connect(self.path) as conn:
            conn.execute(
                """INSERT OR REPLACE INTO wizard_sessions (user_id, step, created_at, expires_at)
                   VALUES (?, 1, CURRENT_TIMESTAMP, ?)""",
                (user_id, expires_at),
            )
            conn.commit()

    def get_wizard_session(self, user_id: int) -> Optional[dict]:
        """Get wizard session for a user, or None if expired/not found."""
        from datetime import datetime
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                """SELECT user_id, step, stfc_link, screenshot_data, created_at, expires_at, player_data_json
                   FROM wizard_sessions WHERE user_id = ?""",
                (user_id,),
            )
            row = cursor.fetchone()
            
            if not row:
                return None
            
            # Check if expired
            expires_at = datetime.fromisoformat(row[5])
            if datetime.now() > expires_at:
                conn.execute("DELETE FROM wizard_sessions WHERE user_id = ?", (user_id,))
                conn.commit()
                return None
            
            return {
                "user_id": row[0],
                "step": row[1],
                "stfc_link": row[2],
                "screenshot_data": row[3],
                "created_at": row[4],
                "expires_at": row[5],
                "player_data_json": row[6],
            }

    def update_wizard_session(self, user_id: int, step: int = None, stfc_link: str = None, screenshot_data: str = None, player_data_json: str = None) -> None:
        """Update wizard session."""
        updates = []
        params = []
        if step is not None:
            updates.append("step = ?")
            params.append(step)
        if stfc_link is not None:
            updates.append("stfc_link = ?")
            params.append(stfc_link)
        if screenshot_data is not None:
            updates.append("screenshot_data = ?")
            params.append(screenshot_data)
        if player_data_json is not None:
            updates.append("player_data_json = ?")
            params.append(player_data_json)
        
        if not updates:
            return
        
        params.append(user_id)
        with sqlite3.connect(self.path) as conn:
            conn.execute(
                f"UPDATE wizard_sessions SET {', '.join(updates)} WHERE user_id = ?",
                params,
            )
            conn.commit()

    def get_wizard_player_data(self, user_id: int):
        """Get stored player data from wizard session."""
        import json
        from dataclasses import dataclass
        
        session = self.get_wizard_session(user_id)
        if not session or not session.get('player_data_json'):
            return None
        
        try:
            data = json.loads(session['player_data_json'])
            # Reconstruct PlayerData object
            @dataclass
            class PlayerData:
                player_id: str
                username: str
                level: int
                server: int
                alliance_tag: str = None
                rank: str = None
            
            return PlayerData(**data)
        except (json.JSONDecodeError, TypeError):
            return None

    def delete_wizard_session(self, user_id: int) -> None:
        """Delete wizard session for a user."""
        with sqlite3.connect(self.path) as conn:
            conn.execute("DELETE FROM wizard_sessions WHERE user_id = ?", (user_id,))
            conn.commit()

    def get_user_alliance_role_id(self, user_id: int) -> Optional[int]:
        """Get the alliance role ID currently assigned to a user."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT alliance_role_id FROM stfc_players WHERE user_id = ?",
                (user_id,),
            )
            row = cursor.fetchone()
            return row[0] if row else None

    def update_user_alliance_role_id(self, user_id: int, alliance_role_id: Optional[int]):
        """Update the alliance role ID for a user."""
        with sqlite3.connect(self.path) as conn:
            conn.execute(
                "UPDATE stfc_players SET alliance_role_id = ? WHERE user_id = ?",
                (alliance_role_id, user_id),
            )
            conn.commit()

    def get_user_full_data(self, user_id: int) -> Optional[tuple]:
        """Get all stored player data for a user including alliance tag and role ID."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT username, level, server, alliance_tag, rank, alliance_role_id FROM stfc_players WHERE user_id = ?",
                (user_id,),
            )
            return cursor.fetchone()

    def get_user_stfc_link(self, user_id: int) -> Optional[str]:
        """Get stored STFC link for a user."""
        with sqlite3.connect(self.path) as conn:
            cursor = conn.execute(
                "SELECT stfc_link FROM stfc_players WHERE user_id = ?",
                (user_id,),
            )
            row = cursor.fetchone()
            return row[0] if row else None


store = Store(DB_PATH)


# ---------------------------------------------------------------------------
# Discord Bot
# ---------------------------------------------------------------------------
class VeilBot(commands.Bot):
    """Veil Security Bot for STFC verification and updates."""

    def __init__(self):
        intents = discord.Intents.default()
        intents.message_content = True
        intents.members = True
        super().__init__(command_prefix="!", intents=intents)

    async def setup_hook(self):
        """Load cogs and start background tasks."""
        # Load all cogs from the cogs folder
        import pathlib
        cogs_dir = pathlib.Path(__file__).parent / "cogs"
        for cog_file in cogs_dir.glob("*.py"):
            if cog_file.name.startswith("_"):
                continue
            cog_name = f"cogs.{cog_file.stem}"
            try:
                await self.load_extension(cog_name)
                log.info(f"[SETUP] Loaded cog: {cog_name}")
            except Exception as e:
                log.error(f"[SETUP] Failed to load cog {cog_name}: {e}")

        # Sync commands globally
        await self.tree.sync()
        log.info("[SETUP] Commands synced globally")

        # Sync admin commands to guild only (removes them from other servers)
        try:
            guild = discord.Object(id=GUILD_ID)
            await self.tree.sync(guild=guild)
            log.info(f"[SETUP] Commands synced to guild {GUILD_ID}")
        except Exception as e:
            log.warning(f"[SETUP] Could not sync to guild: {e}")

        self.update_stfc_players.start()
        log.info("[SETUP] Background tasks started")

    async def on_ready(self):
        """Bot ready."""
        log.info(f"[READY] Logged in as {self.user}")

    async def post_to_log_channel(self, embed: discord.Embed = None, file: discord.File = None, view: discord.ui.View = None, content: str = None):
        """Post a message to the log channel. Returns the sent message or None."""
        if not LOG_CHANNEL_ID:
            return None

        guild = self.get_guild(GUILD_ID)
        if not guild:
            return None

        log_ch = guild.get_channel(LOG_CHANNEL_ID)
        if not log_ch:
            log.warning(f"[LOG] Log channel {LOG_CHANNEL_ID} not found")
            return None

        try:
            message = await log_ch.send(content=content, embed=embed, file=file, view=view)
            return message
        except Exception as e:
            log.warning(f"[LOG] Could not send to log channel: {e}")
            return None

    async def post_admin_notification(self, message: str):
        """Post a message to admins (via admin role if available)."""
        if not ADMIN_ROLE_ID:
            return

        guild = self.get_guild(GUILD_ID)
        if not guild:
            return

        admin_role = guild.get_role(ADMIN_ROLE_ID)
        if not admin_role:
            log.warning(f"[ADMIN] Admin role {ADMIN_ROLE_ID} not found")
            return

        for channel in guild.text_channels:
            try:
                await channel.send(f"{admin_role.mention} {message}")
                return
            except discord.Forbidden:
                continue

        log.warning("[ADMIN] Could not find a channel to send notification")



    async def get_or_create_alliance_role(self, guild: discord.Guild, alliance_tag: str) -> Optional[discord.Role]:
        """Get or create a role for an alliance tag. Returns the role or None if fails."""
        if not guild:
            return None
        
        # Check if role already exists
        for role in guild.roles:
            if role.name == alliance_tag:
                return role
        
        # Create new role
        try:
            new_role = await guild.create_role(
                name=alliance_tag,
                color=discord.Color.blue(),
                reason=f"Auto-created for alliance tag: {alliance_tag}"
            )
            log.info(f"[ALLIANCE] Created new role: {alliance_tag} (ID: {new_role.id})")
            return new_role
        except discord.Forbidden:
            log.error(f"[ALLIANCE] No permission to create role {alliance_tag}")
            return None
        except Exception as e:
            log.error(f"[ALLIANCE] Error creating role {alliance_tag}: {e}")
            return None

    async def get_or_create_na_role(self, guild: discord.Guild) -> Optional[discord.Role]:
        """Get or create the N/A role for users without an alliance."""
        if not guild:
            return None
        
        # Check if role already exists
        for role in guild.roles:
            if role.name == "N/A":
                return role
        
        # Create new role
        try:
            new_role = await guild.create_role(
                name="N/A",
                color=discord.Color.light_gray(),
                reason="Auto-created for users without an alliance"
            )
            log.info(f"[ALLIANCE] Created new N/A role (ID: {new_role.id})")
            return new_role
        except discord.Forbidden:
            log.error("[ALLIANCE] No permission to create N/A role")
            return None
        except Exception as e:
            log.error(f"[ALLIANCE] Error creating N/A role: {e}")
            return None

    @tasks.loop(hours=1)
    async def update_stfc_players(self):
        """Periodically update player data from stfc.pro and check for rank/alliance changes."""
        guild = self.get_guild(GUILD_ID)
        if not guild:
            log.warning("[UPDATE] Guild not found")
            return

        log.info("[UPDATE] Starting periodic player update check")

        players = store.get_all_players()
        log.info(f"[UPDATE] Found {len(players)} players to check")

        for user_id, stfc_link, player_id in players:
            member = guild.get_member(user_id)
            if not member:
                log.debug(f"[UPDATE] Member {user_id} no longer in guild")
                continue

            try:
                player_data = STFCProScraper.fetch_player_data(player_id)
                if not player_data:
                    log.warning(f"[UPDATE] Could not fetch data for player {player_id}")
                    continue

                old_data = store.get_user_full_data(user_id)
                if not old_data:
                    continue
                
                old_rank = old_data[4] if len(old_data) > 4 else None
                old_alliance_tag = old_data[3] if len(old_data) > 3 else None
                old_alliance_role_id = old_data[5] if len(old_data) > 5 else None

                # Update nickname if changed
                new_nick = self._build_nickname(player_data)
                if member.nick != new_nick:
                    try:
                        await member.edit(nick=new_nick)
                        log.info(
                            f"[UPDATE] Updated nickname for {member.id} ({member.name}): {new_nick}"
                        )
                    except discord.Forbidden:
                        log.debug(f"[UPDATE] Could not update nickname for {member.id} (Forbidden)")
                    except Exception as e:
                        log.warning(f"[UPDATE] Error updating nickname for {member.id}: {e}")

                # Handle alliance tag changes or initial assignment
                new_alliance_tag = player_data.alliance_tag or "N/A"
                alliance_changed = old_alliance_tag != new_alliance_tag
                needs_initial_assignment = (new_alliance_tag != "N/A" and not old_alliance_role_id) or \
                                          (new_alliance_tag == "N/A" and old_alliance_tag and not old_alliance_role_id)
                
                if alliance_changed or needs_initial_assignment:
                    if alliance_changed:
                        log.info(
                            f"[UPDATE] Alliance change detected for {member.id} ({member.name}): "
                            f"{old_alliance_tag} → {new_alliance_tag}"
                        )
                    else:
                        log.info(
                            f"[UPDATE] Initial alliance role assignment for {member.id} ({member.name}): {new_alliance_tag}"
                        )

                    # Remove old alliance role if it exists
                    if old_alliance_role_id:
                        old_role = guild.get_role(old_alliance_role_id)
                        if old_role and old_role in member.roles:
                            try:
                                await member.remove_roles(old_role, reason=f"Alliance changed from {old_alliance_tag} to {new_alliance_tag}")
                                log.info(f"[UPDATE] Removed old alliance role {old_role.name} from {member.id}")
                            except Exception as e:
                                log.warning(f"[UPDATE] Error removing old alliance role from {member.id}: {e}")

                    # Get or create new alliance role and assign it
                    if new_alliance_tag == "N/A":
                        new_role = await self.get_or_create_na_role(guild)
                    else:
                        new_role = await self.get_or_create_alliance_role(guild, new_alliance_tag)
                    
                    if new_role:
                        try:
                            if new_role not in member.roles:
                                await member.add_roles(new_role, reason=f"Alliance tag: {new_alliance_tag}")
                            log.info(f"[UPDATE] Assigned alliance role {new_role.name} to {member.id}")
                            store.update_user_alliance_role_id(user_id, new_role.id)
                        except Exception as e:
                            log.warning(f"[UPDATE] Error assigning new alliance role to {member.id}: {e}")

                # Check for rank changes
                if old_rank != player_data.rank:
                    log.info(
                        f"[UPDATE] Rank change detected for {member.id} ({member.name}): "
                        f"{old_rank} → {player_data.rank}"
                    )

                    # Request confirmation for rank changes
                    confirmation_view = RankConfirmationView(
                        member.id,
                        member.name,
                        player_data.rank,
                        player_data.username,
                        player_data.alliance_tag or "N/A",
                    )

                    admin_ping = f"<@&{ADMIN_ROLE_ID}>" if ADMIN_ROLE_ID else "Admins"
                    alliance_display = f"[{player_data.alliance_tag}]" if player_data.alliance_tag else "N/A"
                    confirm_embed = discord.Embed(
                        title="🔔 Rank Change Detected - Confirmation Required",
                        description=f"{admin_ping}, please confirm this rank change.",
                        color=discord.Color.orange(),
                    )
                    confirm_embed.add_field(name="Player", value=f"{member.mention} ({player_data.username})", inline=False)
                    confirm_embed.add_field(name="Previous Rank", value=old_rank or "N/A", inline=True)
                    confirm_embed.add_field(name="New Rank", value=player_data.rank or "N/A", inline=True)
                    confirm_embed.add_field(name="Alliance", value=alliance_display, inline=True)
                    
                    log_msg = await self.post_to_log_channel(embed=confirm_embed, view=confirmation_view)
                    if log_msg:
                        confirmation_view.log_message = log_msg

                # Store updated player data
                store.store_stfc_player(user_id, stfc_link, player_data)

            except Exception as e:
                log.error(f"[UPDATE] Error updating player {player_id}: {e}")

        log.info("[UPDATE] Periodic player update check completed")

    @update_stfc_players.before_loop
    async def before_update_stfc(self):
        """Wait for bot to be ready before starting update loop."""
        await self.wait_until_ready()

    def _build_nickname(self, player_data: PlayerData) -> str:
        """Build nickname in format [TAG] username."""
        if player_data.alliance_tag:
            nick = f"[{player_data.alliance_tag}] {player_data.username}"
        else:
            nick = player_data.username

        if len(nick) > 32:
            nick = nick[:32]

        return nick

    async def on_message(self, message: discord.Message):
        """Handle wizard flow messages in DMs."""
        log.debug(f"[WIZARD] on_message called for {message.author.id}")
        
        # Ignore bot messages
        if message.author.bot:
            return
        
        # Only handle DMs
        if message.guild is not None:
            return
        
        user_id = message.author.id
        
        # Check if user has an active wizard session
        session = store.get_wizard_session(user_id)
        if not session:
            log.debug(f"[WIZARD] No active session for {user_id}, ignoring message")
            # Check if there's an expired session to notify user
            with sqlite3.connect(DB_PATH) as conn:
                cursor = conn.execute(
                    "SELECT expires_at FROM wizard_sessions WHERE user_id = ?",
                    (user_id,),
                )
                row = cursor.fetchone()
                if row:
                    # Session exists but expired - notify user with restart button
                    from datetime import datetime
                    expires_at = datetime.fromisoformat(row[0])
                    if datetime.now() > expires_at:
                        conn.execute("DELETE FROM wizard_sessions WHERE user_id = ?", (user_id,))
                        conn.commit()
                        
                        embed = discord.Embed(
                            title="⏰ Verification Session Expired",
                            description="Your verification session has expired (10 minute timeout).\n\nClick the button below to start a new verification session.",
                            colour=discord.Colour.orange(),
                        )
                        await message.author.send(embed=embed, view=SessionExpiredView(user_id))
                        log.info(f"[WIZARD] Notified user {user_id} of session expiration")
            return
        
        log.info(f"[WIZARD] Received DM from {user_id}: '{message.content[:50]}'... (step: {session['step']})")
        
        try:
            if session['step'] == 1:
                # Expecting STFC link
                player_link = message.content.strip()
                
                # Extract and validate player ID
                player_id = STFCProScraper.extract_player_id_from_url(player_link)
                if not player_id:
                    await message.reply(
                        "❌ Invalid player link. Please use format:\n"
                        "`https://stfc.pro/players/XXXXXXXXXXXXX` or `https://stfc.wtf/players/XXXXXXXXXXXXX` or just `XXXXXXXXXXXXX`",
                    )
                    return
                
                # Fetch player data
                player_data = STFCProScraper.fetch_player_data(player_id)
                if not player_data:
                    await message.reply(
                        f"❌ Could not fetch player data from stfc.pro. Check the ID: `{player_id}`"
                    )
                    return
                
                # Store link and player data as JSON
                import json
                player_data_json = json.dumps({
                    "player_id": player_data.player_id,
                    "username": player_data.username,
                    "level": player_data.level,
                    "server": player_data.server,
                    "alliance_tag": player_data.alliance_tag,
                    "rank": player_data.rank,
                })
                store.update_wizard_session(user_id, stfc_link=player_link, player_data_json=player_data_json)
                store.update_wizard_session(user_id, step=2)
                
                # Ask for screenshot
                embed = discord.Embed(
                    title="📷 Step 2: Player Profile Screenshot",
                    description="Please upload a screenshot of your STFC player profile.\n\n"
                                "This is used for logging and verification purposes.",
                    colour=discord.Colour.blue(),
                )
                embed.set_footer(text="Reply with a screenshot attachment in the next message")
                
                await message.reply(embed=embed, view=SkipStepsView(user_id))
                log.info(f"[WIZARD] User {user_id} provided STFC link, moving to step 2")
            
            elif session['step'] == 2:
                # Expecting screenshot
                if not message.attachments:
                    await message.reply("❌ Please attach a screenshot image.")
                    return
                
                screenshot = message.attachments[0]
                
                # Validate screenshot
                if not screenshot.content_type or not screenshot.content_type.startswith("image/"):
                    await message.reply("❌ Please upload an image file (PNG, JPG, etc.)")
                    return
                
                # Read and store screenshot
                try:
                    img_bytes = await screenshot.read()
                    import base64
                    screenshot_b64 = base64.b64encode(img_bytes).decode('utf-8')
                    store.update_wizard_session(user_id, screenshot_data=screenshot_b64, step=3)
                except Exception as e:
                    log.error(f"[WIZARD] Failed to read screenshot: {e}")
                    await message.reply("❌ Could not read screenshot. Please try again.")
                    return
                
                # Get player data from session
                player_data = store.get_wizard_player_data(user_id)
                if not player_data:
                    await message.reply("❌ Session error: Could not retrieve player data. Please restart.")
                    store.delete_wizard_session(user_id)
                    return
                
                # Show summary
                embed = discord.Embed(
                    title="✅ Step 3: Verify Information",
                    description="Please review your information below. If everything looks correct, click **Complete**.",
                    colour=discord.Colour.gold(),
                )
                embed.add_field(name="Player Name", value=f"{player_data.username}", inline=True)
                embed.add_field(name="Level", value=f"{player_data.level}", inline=True)
                embed.add_field(name="Server", value=f"{player_data.server}", inline=True)
                embed.add_field(name="Alliance", value=player_data.alliance_tag or "None", inline=True)
                embed.add_field(name="Rank", value=player_data.rank or "Unknown", inline=True)
                
                embed.set_footer(text="Review the data above and click Complete or Restart")
                
                await message.reply(embed=embed, view=ConfirmVerificationView(user_id))
                log.info(f"[WIZARD] User {user_id} provided stfc.pro link, showing summary")
        
        except Exception as e:
            log.error(f"[WIZARD] Error in wizard flow for user {user_id}: {e}", exc_info=True)
            await message.reply(f"❌ An error occurred: {e}")
            store.delete_wizard_session(user_id)


bot = VeilBot()


# ---------------------------------------------------------------------------
# Slash Commands
# ---------------------------------------------------------------------------
# Verification Helpers
async def _finalize_verification(interaction: discord.Interaction, session: dict):
    """Finalize the verification after user clicks Complete."""
    user_id = session['user_id']
    guild = bot.get_guild(GUILD_ID)
    if not guild:
        await interaction.followup.send("❌ Could not access the server.", ephemeral=True)
        return

    member = guild.get_member(user_id)
    if not member:
        await interaction.followup.send("❌ Could not find your account.", ephemeral=True)
        return

    player_link = session['stfc_link']
    
    # Fetch player data from stfc link
    from stfc_scraper import STFCProScraper
    player_id = STFCProScraper.extract_player_id_from_url(player_link)
    if not player_id:
        await interaction.followup.send("❌ Invalid player link stored.", ephemeral=True)
        return
    
    player_data = STFCProScraper.fetch_player_data(player_id)
    if not player_data:
        await interaction.followup.send("❌ Could not fetch player data.", ephemeral=True)
        return
    
    # Verify player is on the correct STFC server
    if player_data.server != STFC_SERVER_ID:
        await interaction.followup.send(
            f"❌ Your character must be on STFC Server {STFC_SERVER_ID}. "
            f"You are currently on Server {player_data.server}.",
            ephemeral=True
        )
        log.warning(f"[WIZARD] User {user_id} attempted verification on wrong server: {player_data.server} (expected {STFC_SERVER_ID})")
        return

    # Build completion message
    feedback = ["📋 **Verification Complete**\n"]
    feedback.append("✅ **stfc.pro Data:**")
    feedback.append(f"  {format_player_info(player_data)}\n")

    # Set nickname
    new_nick = bot._build_nickname(player_data)
    try:
        await member.edit(nick=new_nick)
        feedback.append(f"✅ Nickname set to: `{new_nick}`")
        log.info(f"[WIZARD] Set nickname for {member.id}: {new_nick}")
    except discord.Forbidden:
        feedback.append(f"⚠️ Could not set nickname (missing permissions)")
        log.warning(f"[WIZARD] Could not set nickname for {member.id} (Forbidden)")
    except Exception as e:
        feedback.append(f"⚠️ Error setting nickname: {e}")
        log.error(f"[WIZARD] Error setting nickname for {member.id}: {e}")

    # Assign roles based on rank
    member_role = guild.get_role(MEMBER_ROLE_ID)
    commodore_role = guild.get_role(COMMODORE_ROLE_ID)
    admiral_role = guild.get_role(ADMIRAL_ROLE_ID)
    
    rank_tier = get_rank_tier(player_data.rank)
    confirmation_view = None

    if not member_role:
        feedback.append(f"❌ Member role {MEMBER_ROLE_ID} not found - cannot assign ranks")
        log.error(f"[WIZARD] Member role {MEMBER_ROLE_ID} not found for {member.id}")
    else:
        try:
            # Always assign base member role for base ranks
            if rank_tier == "base":
                await member.add_roles(member_role, reason=f"Verified rank: {player_data.rank}")
                feedback.append(f"✅ Base role assigned (rank: {player_data.rank})")
                
                # Remove leadership roles if they had them
                if commodore_role and commodore_role in member.roles:
                    await member.remove_roles(commodore_role, reason="Rank downgrade")
                if admiral_role and admiral_role in member.roles:
                    await member.remove_roles(admiral_role, reason="Rank downgrade")
                log.info(f"[WIZARD] Assigned base role to {member.id} (rank: {player_data.rank})")

            elif rank_tier == "commodore":
                # Assign base member role, request confirmation for commodore role
                await member.add_roles(member_role, reason=f"Verified rank: {player_data.rank}")
                feedback.append(f"✅ Base role assigned (rank: {player_data.rank})")
                
                # Create confirmation view for leadership rank
                confirmation_view = RankConfirmationView(
                    member.id,
                    member.name,
                    player_data.rank,
                    player_data.username,
                    player_data.alliance_tag or "N/A",
                )
                feedback.append(f"⏳ Commodore role pending admin confirmation...")
                log.info(f"[WIZARD] Created confirmation for {member.id}: Commodore rank")

            elif rank_tier == "admiral":
                # Assign base member role, request confirmation for admiral role
                await member.add_roles(member_role, reason=f"Verified rank: {player_data.rank}")
                feedback.append(f"✅ Base role assigned (rank: {player_data.rank})")
                
                # Create confirmation view for leadership rank
                confirmation_view = RankConfirmationView(
                    member.id,
                    member.name,
                    player_data.rank,
                    player_data.username,
                    player_data.alliance_tag or "N/A",
                )
                feedback.append(f"⏳ Admiral role pending admin confirmation...")
                log.info(f"[WIZARD] Created confirmation for {member.id}: Admiral rank")

        except Exception as e:
            feedback.append(f"❌ Error assigning roles: {e}")
            log.error(f"[WIZARD] Error assigning roles to {member.id}: {e}")

    # Assign verify role if configured
    if VERIFY_ROLE_ID:
        verify_role = guild.get_role(VERIFY_ROLE_ID)
        if verify_role:
            try:
                await member.add_roles(verify_role, reason="Verified via stfc.pro")
                feedback.append(f"✅ Verification role assigned")
                log.info(f"[WIZARD] Assigned verify role to {member.id}")
            except Exception as e:
                feedback.append(f"⚠️ Error assigning verify role: {e}")
                log.warning(f"[WIZARD] Error assigning verify role to {member.id}: {e}")

    # Assign alliance tag role
    if player_data.alliance_tag:
        alliance_role = await bot.get_or_create_alliance_role(guild, player_data.alliance_tag)
        if alliance_role:
            try:
                await member.add_roles(alliance_role, reason=f"Alliance tag: {player_data.alliance_tag}")
                feedback.append(f"✅ Alliance role assigned: `{alliance_role.name}`")
                store.update_user_alliance_role_id(member.id, alliance_role.id)
                log.info(f"[WIZARD] Assigned alliance role {alliance_role.name} to {member.id}")
            except Exception as e:
                feedback.append(f"⚠️ Error assigning alliance role: {e}")
                log.warning(f"[WIZARD] Error assigning alliance role to {member.id}: {e}")
    else:
        # Assign N/A role for users without alliance
        na_role = await bot.get_or_create_na_role(guild)
        if na_role:
            try:
                await member.add_roles(na_role, reason="No alliance")
                feedback.append(f"✅ Alliance role assigned: `{na_role.name}`")
                store.update_user_alliance_role_id(member.id, na_role.id)
                log.info(f"[WIZARD] Assigned N/A role to {member.id}")
            except Exception as e:
                feedback.append(f"⚠️ Error assigning N/A role: {e}")
                log.warning(f"[WIZARD] Error assigning N/A role to {member.id}: {e}")

    # Store player link and data for periodic updates
    store.store_stfc_player(member.id, player_link, player_data)
    store.mark_verified(member.id)
    store.log_verification_action(member.id, "verified")
    feedback.append(f"💾 Player data stored for periodic updates")

    feedback_text = "\n".join(feedback)
    await interaction.followup.send(feedback_text, ephemeral=True)

     # Log to log channel and post confirmation if needed
    if LOG_CHANNEL_ID:
        embed = discord.Embed(
            title="✅ Verification Successful",
            description=f"**{member.mention}** verified as **{player_data.username}**",
            colour=discord.Colour.green(),
            timestamp=interaction.created_at,
        )
        embed.add_field(name="Player", value=f"{player_data.username}", inline=True)
        embed.add_field(name="Rank", value=f"{player_data.rank or 'N/A'}", inline=True)
        embed.add_field(name="Level", value=f"{player_data.level}", inline=True)
        embed.add_field(name="Server", value=f"{player_data.server}", inline=True)
        embed.add_field(
            name="Alliance",
            value=player_data.alliance_tag or "None",
            inline=True,
        )
        
        # Get screenshot from session if available
        screenshot_file = None
        if session.get('screenshot_data'):
            try:
                import base64
                import io
                screenshot_bytes = base64.b64decode(session['screenshot_data'])
                screenshot_file = discord.File(io.BytesIO(screenshot_bytes), filename="verification.png")
                embed.set_image(url="attachment://verification.png")
            except Exception as e:
                log.warning(f"[WIZARD] Could not decode screenshot: {e}")
        
        try:
            if screenshot_file:
                log_msg = await bot.post_to_log_channel(embed, screenshot_file)
            else:
                log_msg = await bot.post_to_log_channel(embed)
            
            # If confirmation is needed for leadership rank, post it
            if confirmation_view and log_msg:
                confirmation_view.log_message = log_msg
                
                admin_ping = f"<@&{ADMIN_ROLE_ID}>" if ADMIN_ROLE_ID else "Admins"
                alliance_display = f"[{player_data.alliance_tag}]" if player_data.alliance_tag else "N/A"
                confirm_embed = discord.Embed(
                    title="🔔 Leadership Rank Confirmation Required",
                    description=f"Please confirm this rank promotion.",
                    color=discord.Color.orange(),
                )
                confirm_embed.add_field(name="Player", value=f"{member.mention} ({player_data.username})", inline=False)
                confirm_embed.add_field(name="Rank", value=player_data.rank, inline=True)
                confirm_embed.add_field(name="Alliance", value=alliance_display, inline=True)
                
                confirm_msg = await bot.post_to_log_channel(embed=confirm_embed, view=confirmation_view, content=admin_ping)
                if confirm_msg:
                    confirmation_view.log_message = confirm_msg
            
            log.info("[WIZARD] Logged verification to log channel")
        except Exception as e:
            log.warning(f"[WIZARD] Could not log to channel: {e}")

    log.info(
        f"[WIZARD] user={member.id} name={player_data.username} "
        f"server={player_data.server} alliance={player_data.alliance_tag} "
        f"level={player_data.level} rank={player_data.rank} "
        f"confirmation_needed={confirmation_view is not None}"
    )


# Slash commands are now in cogs/ folder for better organization


@bot.event
async def on_member_join(member: discord.Member):
    """Send verification wizard welcome when user joins."""
    # Only handle the main guild
    if member.guild.id != GUILD_ID:
        return
    
    # Ignore bots
    if member.bot:
        return
    
    try:
        embed = discord.Embed(
            title="👋 Welcome to the Server!",
            description="To access server features, you need to verify your STFC account.",
            colour=discord.Colour.blurple(),
        )
        embed.add_field(
            name="What is this?",
            value="We use stfc.pro/stfc.wtf player data to verify your account and assign appropriate roles.\n"
                  "This ensures our community stays safe and organized.",
            inline=False,
        )
        embed.add_field(
            name="⚠️ Important Rules",
            value="• **One-time verification**: You can only verify once.\n"
                  "• **Link uniqueness**: Each player link can only be used once.\n"
                  "• **Admin recall**: If admins recall your verification, you can re-verify after authorization.",
            inline=False,
        )
        embed.add_field(
            name="🚀 Ready?",
            value="Click the button below to start the verification wizard.",
            inline=False,
        )
        embed.set_footer(text="This message contains important information about verification.")
        
        await member.send(embed=embed, view=StartWizardView())
        log.info(f"[WIZARD] Sent welcome message to new member {member.id}")
    except discord.Forbidden:
        log.warning(f"[WIZARD] Could not send DM to new member {member.id} (DMs disabled)")
    except Exception as e:
        log.error(f"[WIZARD] Error sending welcome to member {member.id}: {e}")


@bot.event
async def on_member_remove(member: discord.Member):
    """Clean up verification data when user leaves."""
    # Only handle the main guild
    if member.guild.id != GUILD_ID:
        return
    
    # Remove from database if verified
    if store.get_player_data(member.id):
        store.delete_verification(member.id)
        store.log_verification_action(member.id, "removed", None, "User left the server")
        log.info(f"[DB] Deleted verification for user {member.id} (left server)")
    
    # Clean up wizard session if exists
    store.delete_wizard_session(member.id)
    log.info(f"[WIZARD] Cleared wizard session for user {member.id}")


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    token = os.getenv("DISCORD_TOKEN")
    if not token:
        raise SystemExit("Missing DISCORD_TOKEN in .env")

    bot.run(token)