const {
  Client,
  GatewayIntentBits,
  REST,
  Routes,
  Collection,
  EmbedBuilder,
  ChannelType,
  PermissionFlagsBits,
} = require("discord.js");
const { createClient } = require("@supabase/supabase-js");
const http = require("http");
const fs = require("fs");
const path = require("path");

// Dashboard HTML path
const dashboardPath = path.join(__dirname, "public", "dashboard.html");
require("dotenv").config();

// =============================================================================
// ENVIRONMENT VALIDATION (Modified: Supabase now optional)
// =============================================================================

const token = process.env.DISCORD_BOT_TOKEN;
const clientId = process.env.DISCORD_CLIENT_ID;

if (!token) {
  console.error("Missing DISCORD_BOT_TOKEN environment variable");
  process.exit(1);
}

if (!clientId) {
  console.error("Missing DISCORD_CLIENT_ID environment variable");
  process.exit(1);
}

console.log("[Token] Bot token loaded (length: " + token.length + " chars)");

// =============================================================================
// DISCORD CLIENT SETUP (Modified: Added intents for Sentinel)
// =============================================================================

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.GuildModeration,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.DirectMessages,
  ],
});

// =============================================================================
// SUPABASE SETUP (Modified: Now optional)
// =============================================================================

let supabase = null;
if (process.env.SUPABASE_URL && process.env.SUPABASE_SERVICE_ROLE) {
  supabase = createClient(
    process.env.SUPABASE_URL,
    process.env.SUPABASE_SERVICE_ROLE
  );
  console.log("Supabase connected");
} else {
  console.log("Supabase not configured - community features will be limited");
}

// =============================================================================
// SENTINEL: HEAT TRACKING SYSTEM (New)
// =============================================================================

const heatMap = new Map();
const HEAT_THRESHOLD = 3;
const HEAT_WINDOW_MS = 10000;
const whitelistedUsers = (process.env.WHITELISTED_USERS || '').split(',').filter(Boolean);

function addHeat(userId, action) {
  if (whitelistedUsers.includes(userId)) return 0;
  
  const now = Date.now();
  if (!heatMap.has(userId)) {
    heatMap.set(userId, []);
  }
  
  const userEvents = heatMap.get(userId);
  userEvents.push({ action, timestamp: now });
  
  const recentEvents = userEvents.filter(e => now - e.timestamp < HEAT_WINDOW_MS);
  heatMap.set(userId, recentEvents);
  
  return recentEvents.length;
}

function getHeat(userId) {
  const now = Date.now();
  const userEvents = heatMap.get(userId) || [];
  return userEvents.filter(e => now - e.timestamp < HEAT_WINDOW_MS).length;
}

client.heatMap = heatMap;
client.addHeat = addHeat;
client.getHeat = getHeat;
client.HEAT_THRESHOLD = HEAT_THRESHOLD;

// =============================================================================
// SENTINEL: FEDERATION MAPPINGS (New)
// =============================================================================

const federationMappings = new Map();
client.federationMappings = federationMappings;

async function loadFederationMappings() {
  if (!supabase) return;
  try {
    const { data, error } = await supabase
      .from('federation_mappings')
      .select('*');
    if (error) throw error;
    for (const mapping of data || []) {
      federationMappings.set(mapping.role_id, {
        name: mapping.role_name,
        guildId: mapping.guild_id,
        guildName: mapping.guild_name,
        linkedAt: new Date(mapping.linked_at).getTime(),
      });
    }
    console.log(`[Federation] Loaded ${federationMappings.size} mappings from database`);
  } catch (e) {
    console.warn('[Federation] Could not load mappings:', e.message);
  }
}

async function saveFederationMapping(roleId, data) {
  if (!supabase) return;
  try {
    await supabase.from('federation_mappings').upsert({
      role_id: roleId,
      role_name: data.name,
      guild_id: data.guildId,
      guild_name: data.guildName,
      linked_at: new Date(data.linkedAt).toISOString(),
    });
  } catch (e) {
    console.warn('[Federation] Could not save mapping:', e.message);
  }
}

async function deleteFederationMapping(roleId) {
  if (!supabase) return;
  try {
    await supabase.from('federation_mappings').delete().eq('role_id', roleId);
  } catch (e) {
    console.warn('[Federation] Could not delete mapping:', e.message);
  }
}

client.saveFederationMapping = saveFederationMapping;
client.deleteFederationMapping = deleteFederationMapping;

const REALM_GUILDS = {
  hub: process.env.HUB_GUILD_ID,
  labs: process.env.LABS_GUILD_ID,
  gameforge: process.env.GAMEFORGE_GUILD_ID,
  corp: process.env.CORP_GUILD_ID,
  foundation: process.env.FOUNDATION_GUILD_ID,
};
client.REALM_GUILDS = REALM_GUILDS;

// =============================================================================
// GUILD WHITELIST SYSTEM
// =============================================================================

const WHITELISTED_GUILDS = [
  '373713073594302464',  // AeThex | Corporation
  '515711457946632232',  // AeThex (Main)
  '525971009313046529',  // AeThex | Nexus
  '1245619208805416970', // AeThex | GameForge
  '1275962459596783686', // AeThex | LABS
  '1284290638564687925', // AeThex | DevOps
  '1338564560277344287', // AeThex | Foundation
  ...(process.env.EXTRA_WHITELISTED_GUILDS || '').split(',').filter(Boolean),
];
client.WHITELISTED_GUILDS = WHITELISTED_GUILDS;

client.on('guildCreate', async (guild) => {
  if (!WHITELISTED_GUILDS.includes(guild.id)) {
    console.log(`[Whitelist] Unauthorized server detected: ${guild.name} (${guild.id}) - Leaving...`);
    try {
      const owner = await guild.fetchOwner();
      await owner.send(`Your server "${guild.name}" is not authorized to use AeThex Bot. The bot has automatically left. Contact the AeThex team if you believe this is an error.`).catch(() => {});
    } catch (e) {}
    await guild.leave();
    console.log(`[Whitelist] Left unauthorized server: ${guild.name}`);
    return;
  }
  console.log(`[Whitelist] Joined authorized server: ${guild.name} (${guild.id})`);
});

// =============================================================================
// SENTINEL: TICKET TRACKING (New)
// =============================================================================

const activeTickets = new Map();
client.activeTickets = activeTickets;

async function loadActiveTickets() {
  if (!supabase) return;
  try {
    const { data, error } = await supabase
      .from('tickets')
      .select('*')
      .eq('status', 'open');
    if (error) throw error;
    for (const ticket of data || []) {
      activeTickets.set(ticket.channel_id, {
        odId: ticket.id,
        userId: ticket.user_id,
        guildId: ticket.guild_id,
        reason: ticket.reason,
        createdAt: new Date(ticket.created_at).getTime(),
      });
    }
    console.log(`[Tickets] Loaded ${activeTickets.size} active tickets from database`);
  } catch (e) {
    console.warn('[Tickets] Could not load tickets:', e.message);
  }
}

async function saveTicket(channelId, data) {
  if (!supabase) return;
  try {
    await supabase.from('tickets').insert({
      channel_id: channelId,
      user_id: data.userId,
      guild_id: data.guildId,
      reason: data.reason,
      status: 'open',
    });
  } catch (e) {
    console.warn('[Tickets] Could not save ticket:', e.message);
  }
}

async function closeTicket(channelId) {
  if (!supabase) return;
  try {
    await supabase
      .from('tickets')
      .update({ status: 'closed', closed_at: new Date().toISOString() })
      .eq('channel_id', channelId);
  } catch (e) {
    console.warn('[Tickets] Could not close ticket:', e.message);
  }
}

client.saveTicket = saveTicket;
client.closeTicket = closeTicket;

// =============================================================================
// SENTINEL: ALERT SYSTEM (New)
// =============================================================================

let alertChannelId = process.env.ALERT_CHANNEL_ID;
client.alertChannelId = alertChannelId;

async function sendAlert(message, embed = null) {
  if (!alertChannelId) return;
  try {
    const channel = await client.channels.fetch(alertChannelId);
    if (channel) {
      if (embed) {
        await channel.send({ content: message, embeds: [embed] });
      } else {
        await channel.send(message);
      }
    }
  } catch (err) {
    console.error("Failed to send alert:", err.message);
  }
}
client.sendAlert = sendAlert;

// =============================================================================
// ACTIVITY FEED SYSTEM (New - Dashboard Real-time)
// =============================================================================

const activityFeed = [];
const MAX_ACTIVITY_EVENTS = 100;
const threatAlerts = [];
const MAX_THREAT_ALERTS = 50;

// Analytics tracking
const analyticsData = {
  commandUsage: {},
  xpDistributed: 0,
  newMembers: 0,
  modActions: { warnings: 0, kicks: 0, bans: 0, timeouts: 0 },
  hourlyActivity: Array(24).fill(0),
  dailyActivity: Array(7).fill(0),
  lastReset: Date.now(),
};

function trackCommand(commandName) {
  analyticsData.commandUsage[commandName] = (analyticsData.commandUsage[commandName] || 0) + 1;
  const hour = new Date().getHours();
  const day = new Date().getDay();
  analyticsData.hourlyActivity[hour]++;
  analyticsData.dailyActivity[day]++;
}

function trackXP(amount) {
  analyticsData.xpDistributed += amount;
}

function trackNewMember() {
  analyticsData.newMembers++;
}

function trackModAction(type) {
  if (analyticsData.modActions[type] !== undefined) {
    analyticsData.modActions[type]++;
  }
}

function resetDailyAnalytics() {
  const now = Date.now();
  const lastReset = analyticsData.lastReset;
  const dayMs = 24 * 60 * 60 * 1000;
  
  if (now - lastReset > dayMs) {
    analyticsData.commandUsage = {};
    analyticsData.xpDistributed = 0;
    analyticsData.newMembers = 0;
    analyticsData.modActions = { warnings: 0, kicks: 0, bans: 0, timeouts: 0 };
    analyticsData.lastReset = now;
  }
}

client.trackCommand = trackCommand;
client.trackXP = trackXP;
client.trackNewMember = trackNewMember;
client.trackModAction = trackModAction;
client.analyticsData = analyticsData;

function addActivity(type, data) {
  const event = {
    id: Date.now() + Math.random().toString(36).substr(2, 9),
    type,
    data,
    timestamp: new Date().toISOString(),
  };
  activityFeed.unshift(event);
  if (activityFeed.length > MAX_ACTIVITY_EVENTS) {
    activityFeed.pop();
  }
  return event;
}

function addThreatAlert(level, message, details = {}) {
  const alert = {
    id: Date.now() + Math.random().toString(36).substr(2, 9),
    level,
    message,
    details,
    timestamp: new Date().toISOString(),
    resolved: false,
  };
  threatAlerts.unshift(alert);
  if (threatAlerts.length > MAX_THREAT_ALERTS) {
    threatAlerts.pop();
  }
  return alert;
}

client.addActivity = addActivity;
client.activityFeed = activityFeed;
client.addThreatAlert = addThreatAlert;
client.threatAlerts = threatAlerts;

// =============================================================================
// COMMAND LOADING
// =============================================================================

client.commands = new Collection();

const commandsPath = path.join(__dirname, "commands");
if (fs.existsSync(commandsPath)) {
  const commandFiles = fs.readdirSync(commandsPath).filter((file) => file.endsWith(".js"));
  for (const file of commandFiles) {
    const filePath = path.join(commandsPath, file);
    const command = require(filePath);
    if ("data" in command && "execute" in command) {
      client.commands.set(command.data.name, command);
      console.log(`Loaded command: ${command.data.name}`);
    }
  }
}

// =============================================================================
// EVENT LOADING
// =============================================================================

const eventsPath = path.join(__dirname, "events");
if (fs.existsSync(eventsPath)) {
  const eventFiles = fs.readdirSync(eventsPath).filter((file) => file.endsWith(".js"));
  for (const file of eventFiles) {
    const filePath = path.join(eventsPath, file);
    const event = require(filePath);
    if ("name" in event && "execute" in event) {
      client.on(event.name, (...args) => event.execute(...args, client, supabase));
      console.log(`Loaded event: ${event.name}`);
    }
  }
}

// =============================================================================
// SENTINEL LISTENER LOADING (New)
// =============================================================================

const sentinelPath = path.join(__dirname, "listeners", "sentinel");
if (fs.existsSync(sentinelPath)) {
  const sentinelFiles = fs.readdirSync(sentinelPath).filter((file) => file.endsWith(".js"));
  for (const file of sentinelFiles) {
    const filePath = path.join(sentinelPath, file);
    const listener = require(filePath);
    if ("name" in listener && "execute" in listener) {
      client.on(listener.name, (...args) => listener.execute(...args, client));
      console.log(`Loaded sentinel listener: ${listener.name}`);
    }
  }
}

// =============================================================================
// GENERAL LISTENER LOADING (Welcome, Goodbye, XP Tracker)
// =============================================================================

const listenersPath = path.join(__dirname, "listeners");
const generalListenerFiles = ['welcome.js', 'goodbye.js', 'xpTracker.js'];
for (const file of generalListenerFiles) {
  const filePath = path.join(listenersPath, file);
  if (fs.existsSync(filePath)) {
    const listener = require(filePath);
    if ("name" in listener && "execute" in listener) {
      client.on(listener.name, (...args) => listener.execute(...args, client, supabase));
      console.log(`Loaded listener: ${file}`);
    }
  }
}

// =============================================================================
// SERVER CONFIGS MAP
// =============================================================================

const serverConfigs = new Map();
client.serverConfigs = serverConfigs;

async function loadServerConfigs() {
  if (!supabase) return;
  try {
    const { data, error } = await supabase
      .from('server_config')
      .select('*');
    if (error) throw error;
    for (const config of data || []) {
      serverConfigs.set(config.guild_id, config);
    }
    console.log(`[Config] Loaded ${serverConfigs.size} server configurations`);
  } catch (e) {
    console.warn('[Config] Could not load server configs:', e.message);
  }
}

// =============================================================================
// FEED SYNC SETUP (Modified: Guard for missing Supabase)
// =============================================================================

let feedSyncModule = null;
let setupFeedListener = null;
let sendPostToDiscord = null;
let getFeedChannelId = () => null;

try {
  feedSyncModule = require("./listeners/feedSync");
  setupFeedListener = feedSyncModule.setupFeedListener;
  sendPostToDiscord = feedSyncModule.sendPostToDiscord;
  getFeedChannelId = feedSyncModule.getFeedChannelId;
} catch (e) {
  console.log("Feed sync module not available");
}

// =============================================================================
// INTERACTION HANDLER (Modified: Added button handling for tickets)
// =============================================================================

client.on("interactionCreate", async (interaction) => {
  console.log(`[Interaction] Received: type=${interaction.type}, commandName=${interaction.commandName || 'N/A'}, user=${interaction.user?.tag}, guild=${interaction.guildId}`);
  
  if (interaction.isChatInputCommand()) {
    console.log(`[Command] Processing: ${interaction.commandName}`);
    const command = client.commands.get(interaction.commandName);
    if (!command) {
      console.warn(`No command matching ${interaction.commandName} was found.`);
      return;
    }
    
    try {
      console.log(`[Command] Executing: ${interaction.commandName}`);
      await command.execute(interaction, supabase, client);
      console.log(`[Command] Completed: ${interaction.commandName}`);
      
      trackCommand(interaction.commandName);
      resetDailyAnalytics();
      
      addActivity('command', {
        command: interaction.commandName,
        user: interaction.user.tag,
        userId: interaction.user.id,
        guild: interaction.guild?.name || 'DM',
        guildId: interaction.guildId,
      });
    } catch (error) {
      console.error(`Error executing ${interaction.commandName}:`, error);
      
      try {
        const errorEmbed = new EmbedBuilder()
          .setColor(0xff0000)
          .setTitle("Command Error")
          .setDescription("There was an error while executing this command.")
          .setFooter({ text: "Contact support if this persists" });
        
        if (interaction.replied || interaction.deferred) {
          await interaction.followUp({ embeds: [errorEmbed], ephemeral: true }).catch(() => {});
        } else {
          await interaction.reply({ embeds: [errorEmbed], ephemeral: true }).catch(() => {});
        }
      } catch (replyError) {
        console.error("Failed to send error response:", replyError.message);
      }
    }
  }
  
  if (interaction.isButton()) {
    const [action, ...params] = interaction.customId.split('_');
    
    if (action === 'ticket') {
      const ticketAction = params[0];
      if (ticketAction === 'close') {
        try {
          const channel = interaction.channel;
          if (channel && channel.type === ChannelType.GuildText) {
            await interaction.reply({ content: 'Closing ticket...', ephemeral: true });
            activeTickets.delete(channel.id);
            await closeTicket(channel.id);
            setTimeout(() => channel.delete().catch(console.error), 3000);
          }
        } catch (err) {
          console.error('Ticket close error:', err);
        }
      }
    }
  }
});

// =============================================================================
// COMMANDS FOR REGISTRATION (Uses actual command file definitions)
// =============================================================================

function getCommandsToRegister() {
  return Array.from(client.commands.values()).map(cmd => cmd.data.toJSON());
}

// =============================================================================
// COMMAND REGISTRATION FUNCTION
// =============================================================================

async function registerDiscordCommands() {
  try {
    const rest = new REST({ version: "10" }).setToken(
      process.env.DISCORD_BOT_TOKEN,
    );

    const commandsToRegister = getCommandsToRegister();
    console.log(
      `Registering ${commandsToRegister.length} slash commands...`,
    );

    try {
      const data = await rest.put(
        Routes.applicationCommands(process.env.DISCORD_CLIENT_ID),
        { body: commandsToRegister },
      );

      console.log(`Successfully registered ${data.length} slash commands`);
      return { success: true, count: data.length, results: null };
    } catch (bulkError) {
      if (bulkError.code === 50240) {
        console.warn(
          "Error 50240: Entry Point detected. Registering individually...",
        );

        const results = [];
        let successCount = 0;
        let skipCount = 0;

        for (const command of commandsToRegister) {
          try {
            const posted = await rest.post(
              Routes.applicationCommands(process.env.DISCORD_CLIENT_ID),
              { body: command },
            );
            results.push({
              name: command.name,
              status: "registered",
              id: posted.id,
            });
            successCount++;
          } catch (postError) {
            if (postError.code === 50045) {
              results.push({
                name: command.name,
                status: "already_exists",
              });
              skipCount++;
            } else {
              results.push({
                name: command.name,
                status: "error",
                error: postError.message,
              });
            }
          }
        }

        console.log(
          `Registration complete: ${successCount} new, ${skipCount} already existed`,
        );
        return {
          success: true,
          count: successCount,
          skipped: skipCount,
          results,
        };
      }

      throw bulkError;
    }
  } catch (error) {
    console.error("Failed to register commands:", error);
    return { success: false, error: error.message };
  }
}

// =============================================================================
// HTTP SERVER (Modified: Added Sentinel stats to health endpoint)
// =============================================================================

const healthPort = process.env.HEALTH_PORT || 8080;
const ADMIN_TOKEN = process.env.DISCORD_ADMIN_TOKEN || "aethex-bot-admin";

const checkAdminAuth = (req) => {
  const authHeader = req.headers.authorization;
  return authHeader === `Bearer ${ADMIN_TOKEN}`;
};

http
  .createServer((req, res) => {
    res.setHeader("Access-Control-Allow-Origin", "*");
    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
    res.setHeader("Content-Type", "application/json");

    if (req.method === "OPTIONS") {
      res.writeHead(200);
      res.end();
      return;
    }

    if (req.url === "/" || req.url === "/dashboard") {
      res.setHeader("Content-Type", "text/html");
      try {
        const html = fs.readFileSync(dashboardPath, "utf8");
        res.writeHead(200);
        res.end(html);
      } catch (e) {
        res.writeHead(404);
        res.end("<h1>Dashboard not found</h1>");
      }
      return;
    }

    if (req.url === "/health") {
      res.writeHead(200);
      res.end(
        JSON.stringify({
          status: "online",
          guilds: client.guilds.cache.size,
          commands: client.commands.size,
          uptime: Math.floor(process.uptime()),
          heatMapSize: heatMap.size,
          supabaseConnected: !!supabase,
          timestamp: new Date().toISOString(),
        }),
      );
      return;
    }

    if (req.url === "/stats") {
      const guildStats = client.guilds.cache.map(g => ({
        id: g.id,
        name: g.name,
        memberCount: g.memberCount,
      }));
      res.writeHead(200);
      res.end(JSON.stringify({
        guilds: guildStats,
        totalMembers: guildStats.reduce((sum, g) => sum + g.memberCount, 0),
        uptime: Math.floor(process.uptime()),
        activeTickets: activeTickets.size,
        heatEvents: heatMap.size,
        federationLinks: federationMappings.size,
      }));
      return;
    }

    if (req.url === "/activity" || req.url.startsWith("/activity?")) {
      const url = new URL(req.url, `http://localhost:${healthPort}`);
      const limit = parseInt(url.searchParams.get('limit') || '50');
      const since = url.searchParams.get('since');
      
      let events = activityFeed.slice(0, Math.min(limit, 100));
      if (since) {
        events = events.filter(e => new Date(e.timestamp) > new Date(since));
      }
      
      res.writeHead(200);
      res.end(JSON.stringify({
        events,
        total: activityFeed.length,
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/tickets") {
      const ticketList = Array.from(activeTickets.entries()).map(([channelId, data]) => ({
        channelId,
        userId: data.userId,
        guildId: data.guildId,
        reason: data.reason,
        createdAt: new Date(data.createdAt).toISOString(),
        age: Math.floor((Date.now() - data.createdAt) / 60000),
      }));
      
      res.writeHead(200);
      res.end(JSON.stringify({
        tickets: ticketList,
        count: ticketList.length,
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/threats") {
      const unresolvedThreats = threatAlerts.filter(t => !t.resolved);
      const threatLevel = unresolvedThreats.length > 5 ? 'Critical' : 
                          unresolvedThreats.length > 2 ? 'High' :
                          unresolvedThreats.length > 0 ? 'Medium' : 'Low';
      
      res.writeHead(200);
      res.end(JSON.stringify({
        alerts: threatAlerts.slice(0, 50),
        unresolvedCount: unresolvedThreats.length,
        threatLevel,
        heatMapSize: heatMap.size,
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/server-health") {
      const guilds = client.guilds.cache.map(g => {
        const botMember = g.members.cache.get(client.user.id);
        return {
          id: g.id,
          name: g.name,
          memberCount: g.memberCount,
          online: true,
          permissions: botMember?.permissions.has('Administrator') ? 'Admin' : 'Limited',
          joinedAt: g.joinedAt?.toISOString(),
        };
      });
      
      res.writeHead(200);
      res.end(JSON.stringify({
        guilds,
        botStatus: client.isReady() ? 'online' : 'offline',
        ping: client.ws.ping,
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/system-info") {
      const memUsage = process.memoryUsage();
      res.writeHead(200);
      res.end(JSON.stringify({
        uptime: Math.floor(process.uptime()),
        memory: {
          heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
          heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
          rss: Math.round(memUsage.rss / 1024 / 1024),
        },
        nodeVersion: process.version,
        platform: process.platform,
        ping: client.ws.ping,
        guilds: client.guilds.cache.size,
        commands: client.commands.size,
        activityEvents: activityFeed.length,
        whitelistedUsers: whitelistedUsers.length,
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/analytics") {
      resetDailyAnalytics();
      
      const commandsArray = Object.entries(analyticsData.commandUsage)
        .map(([name, count]) => ({ name, count }))
        .sort((a, b) => b.count - a.count);
      
      const totalCommands = commandsArray.reduce((sum, c) => sum + c.count, 0);
      const totalModActions = Object.values(analyticsData.modActions).reduce((sum, c) => sum + c, 0);
      
      res.writeHead(200);
      res.end(JSON.stringify({
        commandsToday: totalCommands,
        xpDistributed: analyticsData.xpDistributed,
        newMembers: analyticsData.newMembers,
        modActionsTotal: totalModActions,
        modActions: analyticsData.modActions,
        commandUsage: commandsArray.slice(0, 15),
        hourlyActivity: analyticsData.hourlyActivity,
        dailyActivity: analyticsData.dailyActivity,
        lastReset: new Date(analyticsData.lastReset).toISOString(),
        timestamp: new Date().toISOString(),
      }));
      return;
    }

    if (req.url === "/leaderboard") {
      if (!supabase) {
        res.writeHead(200);
        res.end(JSON.stringify({ 
          success: false, 
          message: "Supabase not configured",
          xpLeaders: [],
          topChatters: [],
          topMods: [],
        }));
        return;
      }
      
      (async () => {
        try {
          const { data: xpLeaders } = await supabase
            .from('user_profiles')
            .select('id, username, avatar_url, xp')
            .order('xp', { ascending: false })
            .limit(10);
          
          const { data: modActors } = await supabase
            .from('mod_actions')
            .select('moderator_id, moderator_tag')
            .limit(100);
          
          const modCounts = {};
          (modActors || []).forEach(m => {
            modCounts[m.moderator_id] = modCounts[m.moderator_id] || { count: 0, tag: m.moderator_tag };
            modCounts[m.moderator_id].count++;
          });
          
          const topMods = Object.entries(modCounts)
            .map(([id, data]) => ({ id, tag: data.tag, count: data.count }))
            .sort((a, b) => b.count - a.count)
            .slice(0, 10);
          
          res.writeHead(200);
          res.end(JSON.stringify({
            success: true,
            xpLeaders: (xpLeaders || []).map((u, i) => ({
              rank: i + 1,
              username: u.username || 'Unknown',
              avatarUrl: u.avatar_url,
              xp: u.xp || 0,
              level: Math.floor(Math.sqrt((u.xp || 0) / 100)),
            })),
            topMods,
          }));
        } catch (error) {
          res.writeHead(500);
          res.end(JSON.stringify({ success: false, error: error.message }));
        }
      })();
      return;
    }

    if (req.url === "/bot-status") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      const channelId = getFeedChannelId();
      const guilds = client.guilds.cache.map((guild) => ({
        id: guild.id,
        name: guild.name,
        memberCount: guild.memberCount,
        icon: guild.iconURL(),
      }));

      res.writeHead(200);
      res.end(
        JSON.stringify({
          status: client.isReady() ? "online" : "offline",
          bot: {
            tag: client.user?.tag || "Not logged in",
            id: client.user?.id,
            avatar: client.user?.displayAvatarURL(),
          },
          guilds: guilds,
          guildCount: client.guilds.cache.size,
          commands: Array.from(client.commands.keys()),
          commandCount: client.commands.size,
          uptime: Math.floor(process.uptime()),
          feedBridge: {
            enabled: !!channelId,
            channelId: channelId,
          },
          sentinel: {
            heatMapSize: heatMap.size,
            activeTickets: activeTickets.size,
            federationMappings: federationMappings.size,
          },
          supabaseConnected: !!supabase,
          timestamp: new Date().toISOString(),
        }),
      );
      return;
    }

    if (req.url === "/linked-users") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      if (!supabase) {
        res.writeHead(200);
        res.end(JSON.stringify({ success: true, links: [], count: 0, message: "Supabase not configured" }));
        return;
      }

      (async () => {
        try {
          const { data: links, error } = await supabase
            .from("discord_links")
            .select("discord_id, user_id, primary_arm, created_at")
            .order("created_at", { ascending: false })
            .limit(50);

          if (error) throw error;

          const enrichedLinks = await Promise.all(
            (links || []).map(async (link) => {
              const { data: profile } = await supabase
                .from("user_profiles")
                .select("username, avatar_url")
                .eq("id", link.user_id)
                .single();

              return {
                discord_id: link.discord_id.slice(0, 6) + "***",
                user_id: link.user_id.slice(0, 8) + "...",
                primary_arm: link.primary_arm,
                created_at: link.created_at,
                profile: profile ? {
                  username: profile.username,
                  avatar_url: profile.avatar_url,
                } : null,
              };
            })
          );

          res.writeHead(200);
          res.end(JSON.stringify({ success: true, links: enrichedLinks, count: enrichedLinks.length }));
        } catch (error) {
          res.writeHead(500);
          res.end(JSON.stringify({ success: false, error: error.message }));
        }
      })();
      return;
    }

    if (req.url === "/command-stats") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      const cmds = getCommandsToRegister();
      const stats = {
        commands: cmds.map((cmd) => ({
          name: cmd.name,
          description: cmd.description,
          options: cmd.options?.length || 0,
        })),
        totalCommands: cmds.length,
      };

      res.writeHead(200);
      res.end(JSON.stringify({ success: true, stats }));
      return;
    }

    if (req.url === "/feed-stats") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      if (!supabase) {
        res.writeHead(200);
        res.end(JSON.stringify({ success: true, stats: { totalPosts: 0, discordPosts: 0, websitePosts: 0, recentPosts: [] }, message: "Supabase not configured" }));
        return;
      }

      (async () => {
        try {
          const { count: totalPosts } = await supabase
            .from("community_posts")
            .select("*", { count: "exact", head: true });

          const { count: discordPosts } = await supabase
            .from("community_posts")
            .select("*", { count: "exact", head: true })
            .eq("source", "discord");

          const { count: websitePosts } = await supabase
            .from("community_posts")
            .select("*", { count: "exact", head: true })
            .or("source.is.null,source.neq.discord");

          const { data: recentPosts } = await supabase
            .from("community_posts")
            .select("id, content, source, created_at")
            .order("created_at", { ascending: false })
            .limit(10);

          res.writeHead(200);
          res.end(
            JSON.stringify({
              success: true,
              stats: {
                totalPosts: totalPosts || 0,
                discordPosts: discordPosts || 0,
                websitePosts: websitePosts || 0,
                recentPosts: (recentPosts || []).map(p => ({
                  id: p.id,
                  content: p.content?.slice(0, 100) + (p.content?.length > 100 ? "..." : ""),
                  source: p.source,
                  created_at: p.created_at,
                })),
              },
            })
          );
        } catch (error) {
          res.writeHead(500);
          res.end(JSON.stringify({ success: false, error: error.message }));
        }
      })();
      return;
    }

    if (req.url === "/send-to-discord" && req.method === "POST") {
      let body = "";
      req.on("data", (chunk) => {
        body += chunk.toString();
      });
      req.on("end", async () => {
        try {
          const authHeader = req.headers.authorization;
          const expectedToken = process.env.DISCORD_BRIDGE_TOKEN || "aethex-bridge";
          if (authHeader !== `Bearer ${expectedToken}`) {
            res.writeHead(401);
            res.end(JSON.stringify({ error: "Unauthorized" }));
            return;
          }

          const post = JSON.parse(body);
          console.log("[API] Received post to send to Discord:", post.id);

          if (sendPostToDiscord) {
            const result = await sendPostToDiscord(post, post.author);
            res.writeHead(result.success ? 200 : 500);
            res.end(JSON.stringify(result));
          } else {
            res.writeHead(500);
            res.end(JSON.stringify({ error: "Feed sync not available" }));
          }
        } catch (error) {
          console.error("[API] Error processing send-to-discord:", error);
          res.writeHead(500);
          res.end(JSON.stringify({ error: error.message }));
        }
      });
      return;
    }

    if (req.url === "/bridge-status") {
      const channelId = getFeedChannelId();
      res.writeHead(200);
      res.end(
        JSON.stringify({
          enabled: !!channelId,
          channelId: channelId,
          botReady: client.isReady(),
        }),
      );
      return;
    }

    if (req.url.startsWith("/leave-guild/") && req.method === "POST") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      const guildId = req.url.split("/leave-guild/")[1];
      (async () => {
        try {
          const guild = client.guilds.cache.get(guildId);
          if (!guild) {
            res.writeHead(404);
            res.end(JSON.stringify({ error: "Guild not found" }));
            return;
          }

          const guildName = guild.name;
          await guild.leave();
          console.log(`[Admin] Left guild: ${guildName} (${guildId})`);
          res.writeHead(200);
          res.end(JSON.stringify({ success: true, message: `Left guild: ${guildName}` }));
        } catch (error) {
          res.writeHead(500);
          res.end(JSON.stringify({ error: error.message }));
        }
      })();
      return;
    }

    if (req.url.startsWith("/create-invite/") && req.method === "GET") {
      if (!checkAdminAuth(req)) {
        res.writeHead(401);
        res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
        return;
      }

      const guildId = req.url.split("/create-invite/")[1];
      (async () => {
        try {
          const guild = client.guilds.cache.get(guildId);
          if (!guild) {
            res.writeHead(404);
            res.end(JSON.stringify({ error: "Guild not found" }));
            return;
          }

          const channel = guild.channels.cache.find(ch => ch.type === ChannelType.GuildText && ch.permissionsFor(guild.members.me).has('CreateInstantInvite'));
          if (!channel) {
            res.writeHead(403);
            res.end(JSON.stringify({ error: "No channel available to create invite" }));
            return;
          }

          const invite = await channel.createInvite({ maxAge: 86400, maxUses: 1 });
          res.writeHead(200);
          res.end(JSON.stringify({ success: true, invite: invite.url, guild: guild.name, expiresIn: "24 hours" }));
        } catch (error) {
          res.writeHead(500);
          res.end(JSON.stringify({ error: error.message }));
        }
      })();
      return;
    }

    if (req.url === "/register-commands") {
      if (req.method === "GET") {
        if (!checkAdminAuth(req)) {
          res.writeHead(401);
          res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
          return;
        }
        res.writeHead(200, { "Content-Type": "text/html" });
        res.end(`
          <!DOCTYPE html>
          <html>
          <head>
            <title>Register Discord Commands</title>
            <style>
              body {
                font-family: Arial, sans-serif;
                display: flex;
                justify-content: center;
                align-items: center;
                min-height: 100vh;
                margin: 0;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
              }
              .container {
                background: white;
                padding: 40px;
                border-radius: 10px;
                box-shadow: 0 10px 30px rgba(0,0,0,0.3);
                text-align: center;
                max-width: 500px;
              }
              h1 { color: #333; margin-bottom: 20px; }
              p { color: #666; margin-bottom: 30px; }
              button {
                background: #667eea;
                color: white;
                border: none;
                padding: 12px 30px;
                border-radius: 5px;
                cursor: pointer;
                font-size: 16px;
                font-weight: bold;
                transition: background 0.3s;
              }
              button:hover { background: #764ba2; }
              button:disabled { background: #ccc; cursor: not-allowed; }
              #result { margin-top: 30px; padding: 20px; border-radius: 5px; display: none; }
              #result.success { background: #d4edda; color: #155724; display: block; }
              #result.error { background: #f8d7da; color: #721c24; display: block; }
              #loading { display: none; color: #667eea; font-weight: bold; }
            </style>
          </head>
          <body>
            <div class="container">
              <h1>Discord Commands Registration</h1>
              <p>Click to register all ${client.commands.size} slash commands</p>
              <button id="registerBtn" onclick="registerCommands()">Register Commands</button>
              <div id="loading">Registering... please wait...</div>
              <div id="result"></div>
            </div>
            <script>
              async function registerCommands() {
                const btn = document.getElementById('registerBtn');
                const loading = document.getElementById('loading');
                const result = document.getElementById('result');
                btn.disabled = true;
                loading.style.display = 'block';
                result.style.display = 'none';
                try {
                  const response = await fetch('/register-commands', {
                    method: 'POST',
                    headers: { 'Authorization': 'Bearer ${ADMIN_TOKEN}', 'Content-Type': 'application/json' }
                  });
                  const data = await response.json();
                  loading.style.display = 'none';
                  if (response.ok && data.success) {
                    result.className = 'success';
                    result.innerHTML = '<h3>Success!</h3><p>Registered ' + data.count + ' commands</p>';
                  } else {
                    result.className = 'error';
                    result.innerHTML = '<h3>Error</h3><p>' + (data.error || 'Failed') + '</p>';
                  }
                } catch (error) {
                  loading.style.display = 'none';
                  result.className = 'error';
                  result.innerHTML = '<h3>Error</h3><p>' + error.message + '</p>';
                } finally {
                  btn.disabled = false;
                }
              }
            </script>
          </body>
          </html>
        `);
        return;
      }

      if (req.method === "POST") {
        if (!checkAdminAuth(req)) {
          res.writeHead(401);
          res.end(JSON.stringify({ error: "Unauthorized - Admin token required" }));
          return;
        }

        registerDiscordCommands().then((result) => {
          if (result.success) {
            res.writeHead(200);
            res.end(JSON.stringify(result));
          } else {
            res.writeHead(500);
            res.end(JSON.stringify(result));
          }
        });
        return;
      }
    }

    res.writeHead(404);
    res.end(JSON.stringify({ error: "Not found" }));
  })
  .listen(healthPort, () => {
    console.log(`Health check server running on port ${healthPort}`);
    console.log(`Register commands at: POST http://localhost:${healthPort}/register-commands`);
  });

// =============================================================================
// BOT LOGIN AND READY
// =============================================================================

client.login(token).catch((error) => {
  console.error("Failed to login to Discord");
  console.error(`Error Code: ${error.code}`);
  console.error(`Error Message: ${error.message}`);

  if (error.code === "TokenInvalid") {
    console.error("\nDISCORD_BOT_TOKEN is invalid!");
    console.error("Get a new token from: https://discord.com/developers/applications");
  }

  process.exit(1);
});

client.once("clientReady", async () => {
  console.log(`Bot logged in as ${client.user.tag}`);
  console.log(`Bot ID: ${client.user.id}`);
  console.log(`CLIENT_ID from env: ${process.env.DISCORD_CLIENT_ID}`);
  console.log(`IDs match: ${client.user.id === process.env.DISCORD_CLIENT_ID}`);
  console.log(`Watching ${client.guilds.cache.size} server(s)`);
  
  // Load persisted data from Supabase
  await loadFederationMappings();
  await loadActiveTickets();
  await loadServerConfigs();
  
  // Auto-register commands on startup
  console.log("Registering slash commands with Discord...");
  const regResult = await registerDiscordCommands();
  if (regResult.success) {
    console.log(`Successfully registered ${regResult.count} commands`);
  } else {
    console.error("Failed to register commands:", regResult.error);
  }
  
  client.user.setActivity("Protecting the Federation", { type: 3 });
  
  if (setupFeedListener && supabase) {
    setupFeedListener(client);
  }
  
  sendAlert(`AeThex Bot is now online! Watching ${client.guilds.cache.size} servers.`);
});

// =============================================================================
// ERROR HANDLING
// =============================================================================

process.on("unhandledRejection", (error) => {
  console.error("Unhandled Promise Rejection:", error);
});

process.on("uncaughtException", (error) => {
  console.error("Uncaught Exception:", error);
  process.exit(1);
});

module.exports = client;