[V0_FILE]typescriptreact:file="bot/commands/balance.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder().setName("balance").setDescription("Check your current balance"), async execute(interaction, supabase) { // Get user from database const { data: user, error } = await supabase .from("users") .select("*") .eq("discord_id", interaction.user.id) .single() if (error) { return interaction.reply({ content: "Failed to retrieve your balance. Please try again later.", ephemeral: true, }) } // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create embed const embed = new EmbedBuilder() .setColor(0x0099ff) .setTitle(`${interaction.user.username}'s Balance`) .setThumbnail(interaction.user.displayAvatarURL()) .addFields({ name: "Balance", value: `${currency.symbol} ${user.balance.toLocaleString()}` }) .setTimestamp() await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="bot/commands/shop.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require("discord.js") module.exports = { data: new SlashCommandBuilder() .setName("shop") .setDescription("Browse the shop") .addStringOption((option) => option.setName("category").setDescription("Filter items by category").setRequired(false), ), async execute(interaction, supabase) { const category = interaction.options.getString("category") // Query to get items let query = supabase.from("items").select("*") // Apply category filter if provided if (category) { query = query.eq("category", category) } // Execute query const { data: items, error } = await query.order("price") if (error || items.length === 0) { return interaction.reply({ content: category ? `No items found in the category "${category}".` : "No items available in the shop right now.", ephemeral: true, }) } // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create embed const embed = new EmbedBuilder() .setColor(0x0099ff) .setTitle("🛒 Shop") .setDescription(category ? `Browsing category: ${category}` : "Browse all available items") .setTimestamp() // Add items to embed items.slice(0, 10).forEach((item) => { embed.addFields({ name: `${item.name} - ${currency.symbol} ${item.price.toLocaleString()}`, value: item.description || "No description available", }) }) // Create buttons for pagination if needed const row = new ActionRowBuilder().addComponents( new ButtonBuilder() .setCustomId("shop_prev") .setLabel("Previous") .setStyle(ButtonStyle.Secondary) .setDisabled(true), new ButtonBuilder() .setCustomId("shop_next") .setLabel("Next") .setStyle(ButtonStyle.Secondary) .setDisabled(items.length <= 10), ) await interaction.reply({ embeds: [embed], components: [row] }) }, } [V0_FILE]typescriptreact:file="bot/commands/buy.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder() .setName("buy") .setDescription("Purchase an item from the shop") .addStringOption((option) => option.setName("item").setDescription("The name of the item to purchase").setRequired(true), ) .addIntegerOption((option) => option .setName("quantity") .setDescription("How many to purchase") .setRequired(false) .setMinValue(1) .setMaxValue(100), ), async execute(interaction, supabase) { const itemName = interaction.options.getString("item") const quantity = interaction.options.getInteger("quantity") || 1 // Start a Supabase transaction const { data: { session }, } = await supabase.auth.getSession() // Get the item const { data: item, error: itemError } = await supabase.from("items").select("*").ilike("name", itemName).single() if (itemError || !item) { return interaction.reply({ content: `Item "${itemName}" not found in the shop.`, ephemeral: true, }) } // Get user const { data: user, error: userError } = await supabase .from("users") .select("*") .eq("discord_id", interaction.user.id) .single() if (userError) { return interaction.reply({ content: "Failed to retrieve your profile. Please try again later.", ephemeral: true, }) } // Check if user has enough balance const totalCost = item.price * quantity if (user.balance < totalCost) { return interaction.reply({ content: `You don't have enough balance to purchase ${quantity}x ${item.name}. You need ${totalCost} coins.`, ephemeral: true, }) } // Check if item is in stock if (item.stock !== -1 && item.stock < quantity) { return interaction.reply({ content: `Not enough stock available. Only ${item.stock} remaining.`, ephemeral: true, }) } // Perform the purchase transaction const { error: purchaseError } = await supabase.rpc("purchase_item", { p_user_id: user.id, p_item_id: item.id, p_quantity: quantity, p_total_cost: totalCost, }) if (purchaseError) { console.error("Purchase error:", purchaseError) return interaction.reply({ content: "There was an error processing your purchase. Please try again later.", ephemeral: true, }) } // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create success embed const embed = new EmbedBuilder() .setColor(0x00ff00) .setTitle("Purchase Successful") .setDescription( `You have purchased ${quantity}x ${item.name} for ${currency.symbol} ${totalCost.toLocaleString()}.`, ) .addFields({ name: "New Balance", value: `${currency.symbol} ${(user.balance - totalCost).toLocaleString()}` }) .setTimestamp() await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="bot/commands/inventory.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require("discord.js") module.exports = { data: new SlashCommandBuilder().setName("inventory").setDescription("View your inventory"), async execute(interaction, supabase) { // Get user's inventory const { data: inventory, error } = await supabase .from("inventory") .select(` quantity, items ( id, name, description, price, image_url, category ) `) .eq("user_id", interaction.user.id) if (error) { return interaction.reply({ content: "Failed to retrieve your inventory. Please try again later.", ephemeral: true, }) } if (!inventory || inventory.length === 0) { return interaction.reply({ content: "Your inventory is empty. Purchase items from the shop with `/shop` and `/buy`.", ephemeral: true, }) } // Create embed const embed = new EmbedBuilder() .setColor(0x0099ff) .setTitle(`${interaction.user.username}'s Inventory`) .setThumbnail(interaction.user.displayAvatarURL()) .setTimestamp() // Add items to embed inventory.slice(0, 10).forEach((entry) => { embed.addFields({ name: `${entry.items.name} (x${entry.quantity})`, value: entry.items.description || "No description available", }) }) // Create buttons for pagination if needed const row = new ActionRowBuilder().addComponents( new ButtonBuilder() .setCustomId("inv_prev") .setLabel("Previous") .setStyle(ButtonStyle.Secondary) .setDisabled(true), new ButtonBuilder() .setCustomId("inv_next") .setLabel("Next") .setStyle(ButtonStyle.Secondary) .setDisabled(inventory.length <= 10), ) await interaction.reply({ embeds: [embed], components: [row] }) }, } [V0_FILE]typescriptreact:file="bot/commands/daily.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder().setName("daily").setDescription("Claim your daily reward"), async execute(interaction, supabase) { // Check if user has already claimed today const today = new Date() today.setHours(0, 0, 0, 0) const { data: transactions, error: transactionError } = await supabase .from("transactions") .select("created_at") .eq("user_id", interaction.user.id) .eq("type", "daily") .gte("created_at", today.toISOString()) .limit(1) if (transactionError) { return interaction.reply({ content: "Failed to check your daily status. Please try again later.", ephemeral: true, }) } if (transactions && transactions.length > 0) { // User already claimed today const nextReset = new Date() nextReset.setDate(nextReset.getDate() + 1) nextReset.setHours(0, 0, 0, 0) const timeRemaining = nextReset - new Date() const hoursRemaining = Math.floor(timeRemaining / (1000 * 60 * 60)) const minutesRemaining = Math.floor((timeRemaining % (1000 * 60 * 60)) / (1000 * 60)) return interaction.reply({ content: `You've already claimed your daily reward today. Next reward available in ${hoursRemaining}h ${minutesRemaining}m.`, ephemeral: true, }) } // Get daily reward amount from settings const { data: dailySetting } = await supabase.from("settings").select("value").eq("key", "daily_reward").single() const dailyAmount = dailySetting?.value?.amount || 200 // Update user balance and add transaction const { data: user, error: userError } = await supabase .from("users") .select("balance") .eq("discord_id", interaction.user.id) .single() if (userError) { return interaction.reply({ content: "Failed to retrieve your profile. Please try again later.", ephemeral: true, }) } // Update balance const { error: updateError } = await supabase .from("users") .update({ balance: user.balance + dailyAmount }) .eq("discord_id", interaction.user.id) if (updateError) { return interaction.reply({ content: "Failed to update your balance. Please try again later.", ephemeral: true, }) } // Add transaction await supabase.from("transactions").insert({ user_id: interaction.user.id, amount: dailyAmount, type: "daily", description: "Daily reward claim", }) // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create success embed const embed = new EmbedBuilder() .setColor(0x00ff00) .setTitle("Daily Reward Claimed") .setDescription(`You have claimed your daily reward of ${currency.symbol} ${dailyAmount.toLocaleString()}.`) .addFields({ name: "New Balance", value: `${currency.symbol} ${(user.balance + dailyAmount).toLocaleString()}` }) .setTimestamp() await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="bot/commands/transfer.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder() .setName("transfer") .setDescription("Transfer coins to another user") .addUserOption((option) => option.setName("user").setDescription("The user to transfer coins to").setRequired(true)) .addIntegerOption((option) => option.setName("amount").setDescription("The amount of coins to transfer").setRequired(true).setMinValue(1), ), async execute(interaction, supabase) { const targetUser = interaction.options.getUser("user") const amount = interaction.options.getInteger("amount") // Check if trying to transfer to self if (targetUser.id === interaction.user.id) { return interaction.reply({ content: "You cannot transfer coins to yourself.", ephemeral: true, }) } // Get sender's data const { data: sender, error: senderError } = await supabase .from("users") .select("*") .eq("discord_id", interaction.user.id) .single() if (senderError) { return interaction.reply({ content: "Failed to retrieve your profile. Please try again later.", ephemeral: true, }) } // Check if sender has enough balance if (sender.balance < amount) { return interaction.reply({ content: `You don't have enough balance to transfer ${amount} coins.`, ephemeral: true, }) } // Check if recipient exists, create if not const { data: recipient, error: recipientError } = await supabase .from("users") .select("*") .eq("discord_id", targetUser.id) .single() if (recipientError && recipientError.code === "PGRST116") { // Recipient doesn't exist, create them await supabase.from("users").insert({ discord_id: targetUser.id, username: targetUser.username, avatar: targetUser.displayAvatarURL(), }) } // Get recipient again if we just created them const { data: updatedRecipient } = await supabase.from("users").select("*").eq("discord_id", targetUser.id).single() // Perform the transfer transaction const { error: transferError } = await supabase.rpc("transfer_coins", { p_sender_id: sender.id, p_recipient_id: updatedRecipient.id, p_amount: amount, }) if (transferError) { console.error("Transfer error:", transferError) return interaction.reply({ content: "There was an error processing your transfer. Please try again later.", ephemeral: true, }) } // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create success embed const embed = new EmbedBuilder() .setColor(0x00ff00) .setTitle("Transfer Successful") .setDescription(`You have transferred ${currency.symbol} ${amount.toLocaleString()} to ${targetUser.username}.`) .addFields({ name: "New Balance", value: `${currency.symbol} ${(sender.balance - amount).toLocaleString()}` }) .setTimestamp() await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="app/layout.tsx" isMerged="true" import type React from "react" import "./globals.css" import { Inter } from "next/font/google" import { ThemeProvider } from "@/components/theme-provider" const inter = Inter({ subsets: ["latin"] }) export const metadata = { title: "Discord Shop Bot Dashboard", description: "Admin dashboard for managing Discord shop bot", } export default function RootLayout({ children, }: { children: React.ReactNode }) { return ( {children} ) } [V0_FILE]typescriptreact:file="app/page.tsx" isMerged="true" import Link from "next/link" import { Button } from "@/components/ui/button" import { createServerClient } from "@/lib/supabase-server" import { redirect } from "next/navigation" export default async function Home() { const supabase = createServerClient() const { data: { session }, } = await supabase.auth.getSession() if (session) { redirect("/dashboard") } return (

Discord Shop Bot

Manage Your Discord Shop Bot

A comprehensive dashboard to manage your Discord shop bot. Add items, view transactions, and configure settings.

Shop Management

Add, edit, and remove items from your shop. Set prices, descriptions, and stock levels.

User Management

View user balances, inventory, and transaction history. Manage user permissions and roles.

Bot Configuration

Configure bot settings, currency, and commands. Customize the bot to fit your server's needs.

) } [V0_FILE]typescriptreact:file="app/login/page.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { useRouter } from "next/navigation" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card" import { Alert, AlertDescription } from "@/components/ui/alert" export default function Login() { const [email, setEmail] = useState("") const [password, setPassword] = useState("") const [error, setError] = useState(null) const [loading, setLoading] = useState(false) const router = useRouter() const supabase = createClientComponentClient() const handleLogin = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) setError(null) const { error } = await supabase.auth.signInWithPassword({ email, password, }) if (error) { setError(error.message) setLoading(false) return } router.push("/dashboard") router.refresh() } return (

Contact your administrator if you need access to the dashboard.

) } [V0_FILE]typescriptreact:file="app/dashboard/layout.tsx" isMerged="true" import type React from "react" import { redirect } from "next/navigation" import { createServerClient } from "@/lib/supabase-server" import Sidebar from "@/components/dashboard/sidebar" import Header from "@/components/dashboard/header" export default async function DashboardLayout({ children, }: { children: React.ReactNode }) { const supabase = createServerClient() const { data: { session }, } = await supabase.auth.getSession() if (!session) { redirect("/login") } return (

{children}

) } [V0_FILE]typescriptreact:file="components/dashboard/header.tsx" isMerged="true" "use client" import type { User } from "@supabase/supabase-js" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import { useRouter } from "next/navigation" import { Button } from "@/components/ui/button" import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, } from "@/components/ui/dropdown-menu" import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar" interface HeaderProps { user: User } export default function Header({ user }: HeaderProps) { const router = useRouter() const supabase = createClientComponentClient() const handleSignOut = async () => { await supabase.auth.signOut() router.push("/") router.refresh() } return (

{user.email}

Administrator

Log out

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { createServerClient } from "@/lib/supabase-server" import { BarChart, DollarSign, ShoppingBag, Users } from "lucide-react" export default async function DashboardPage() { const supabase = createServerClient() // Get stats const { data: userCount } = await supabase.from("users").select("id", { count: "exact", head: true }) const { data: itemCount } = await supabase.from("items").select("id", { count: "exact", head: true }) const { data: transactionSum } = await supabase.rpc("get_total_transactions") const { data: recentTransactions } = await supabase .from("transactions") .select(` id, amount, type, description, created_at, users ( username ) `) .order("created_at", { ascending: false }) .limit(5) return (

Dashboard

Overview of your Discord Shop Bot

Total Users

{userCount?.count || 0}

Discord users registered

Shop Items

{itemCount?.count || 0}

Items available in shop

Total Transactions

{transactionSum?.count || 0}

Transactions processed

Economy Value

{transactionSum?.total_amount || 0}

Total coins in circulation

Recent Transactions The latest activity in your Discord server

{recentTransactions?.map((transaction) => (

{transaction.users.username}

{transaction.description}

{transaction.amount > 0 ? "+" : ""} {transaction.amount} coins

))}

Bot Status Current status of your Discord bot

Status

Online

Uptime

3 days, 5 hours

Commands Used Today

152

Active Servers

) } [V0_FILE]typescriptreact:file="app/dashboard/items/page.tsx" isMerged="true" import Link from "next/link" import { Button } from "@/components/ui/button" import { createServerClient } from "@/lib/supabase-server" import { DataTable } from "@/components/dashboard/data-table" import { Plus } from "lucide-react" import { columns } from "./columns" export default async function ItemsPage() { const supabase = createServerClient() const { data: items } = await supabase.from("items").select("*").order("id") return (

Shop Items

Manage the items available in your shop

) } [V0_FILE]typescriptreact:file="app/dashboard/items/columns.tsx" isMerged="true" "use client" import type { ColumnDef } from "@tanstack/react-table" import { ArrowUpDown, MoreHorizontal } from "lucide-react" import { Button } from "@/components/ui/button" import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, } from "@/components/ui/dropdown-menu" import Link from "next/link" export type Item = { id: number name: string description: string price: number stock: number category: string created_at: string } export const columns: ColumnDef[] = [ { accessorKey: "id", header: "ID", cell: ({ row }) =>

{row.getValue("id")}

, }, { accessorKey: "name", header: ({ column }) => { return ( ) }, }, { accessorKey: "price", header: ({ column }) => { return ( ) }, cell: ({ row }) => { const price = Number.parseFloat(row.getValue("price")) return

{price.toLocaleString()} coins

}, }, { accessorKey: "stock", header: "Stock", cell: ({ row }) => { const stock = Number.parseInt(row.getValue("stock")) return

{stock === -1 ? "Unlimited" : stock}

}, }, { accessorKey: "category", header: "Category", }, { id: "actions", cell: ({ row }) => { const item = row.original return ( Actions Edit Item Delete Item ) }, }, ] [V0_FILE]typescriptreact:file="lib/supabase-server.ts" isMerged="true" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import type { Database } from "@/types/supabase" export const createServerClient = () => { const cookieStore = cookies() return createServerComponentClient({ cookies: () => cookieStore }) } [V0_FILE]typescriptreact:file="lib/supabase-client.ts" isMerged="true" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import type { Database } from "@/types/supabase" export const createClient = () => { return createClientComponentClient() } [V0_FILE]typescriptreact:file="types/supabase.ts" isMerged="true" export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[] export interface Database { public: { Tables: { users: { Row: { id: number discord_id: string username: string avatar: string | null balance: number created_at: string updated_at: string } Insert: { id?: number discord_id: string username: string avatar?: string | null balance?: number created_at?: string updated_at?: string } Update: { id?: number discord_id?: string username?: string avatar?: string | null balance?: number created_at?: string updated_at?: string } } items: { Row: { id: number name: string description: string | null price: number image_url: string | null stock: number category: string | null created_at: string updated_at: string } Insert: { id?: number name: string description?: string | null price: number image_url?: string | null stock?: number category?: string | null created_at?: string updated_at?: string } Update: { id?: number name?: string description?: string | null price?: number image_url?: string | null stock?: number category?: string | null created_at?: string updated_at?: string } } inventory: { Row: { id: number user_id: number item_id: number quantity: number created_at: string } Insert: { id?: number user_id: number item_id: number quantity?: number created_at?: string } Update: { id?: number user_id?: number item_id?: number quantity?: number created_at?: string } } transactions: { Row: { id: number user_id: number amount: number type: string description: string | null reference_id: string | null created_at: string } Insert: { id?: number user_id: number amount: number type: string description?: string | null reference_id?: string | null created_at?: string } Update: { id?: number user_id?: number amount?: number type?: string description?: string | null reference_id?: string | null created_at?: string } } settings: { Row: { id: number key: string value: Json updated_at: string } Insert: { id?: number key: string value: Json updated_at?: string } Update: { id?: number key?: string value?: Json updated_at?: string } } } Functions: { purchase_item: { Args: { p_user_id: number p_item_id: number p_quantity: number p_total_cost: number } Returns: undefined } transfer_coins: { Args: { p_sender_id: number p_recipient_id: number p_amount: number } Returns: undefined } get_total_transactions: { Args: Record Returns: { count: number total_amount: number } } } } } [V0_FILE]typescriptreact:file="package.json" isFixed="true" isQuickEdit="true" isMerged="true" { "name": "discord-shop-bot", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "@supabase/auth-helpers-nextjs": "^0.7.4", "@supabase/supabase-js": "^2.32.0", "@tanstack/react-table": "^8.9.3", "class-variance-authority": "^0.7.0", "clsx": "^2.0.0", "date-fns": "^2.30.0", "discord.js": "^14.13.0", "lucide-react": "^0.263.1", "next": "13.4.19", "react": "18.2.0", "react-dom": "18.2.0", "tailwind-merge": "^1.14.0", "tailwindcss-animate": "^1.0.6", "zod": "^3.22.2" }, "devDependencies": { "@types/node": "20.5.6", "@types/react": "18.2.21", "@types/react-dom": "18.2.7", "autoprefixer": "10.4.15", "eslint": "8.48.0", "eslint-config-next": "13.4.19", "postcss": "8.4.28", "tailwindcss": "3.3.3", "typescript": "5.2.2" } } [V0_FILE]typescriptreact:file="README.md" isMerged="true" # Discord Shop Bot A comprehensive Discord bot with shop and banking features, along with a web dashboard for administration. ## Features - **Shop System**: Browse and purchase items using Discord slash commands - **Banking System**: Check balance, transfer coins, and view transaction history - **User Inventory**: View and manage your purchased items - **Web Dashboard**: Admin interface to manage shop items, view user data, and configure bot settings ## Tech Stack - **Discord Bot**: Discord.js with slash commands - **Database**: Supabase (PostgreSQL) - **Web Dashboard**: Next.js with App Router - **Authentication**: Supabase Auth - **Styling**: Tailwind CSS with shadcn/ui components ## Setup Instructions ### Prerequisites - Node.js 16.x or higher - Discord Developer Account - Supabase Account ### Discord Bot Setup 1. Go to the [Discord Developer Portal](https://discord.com/developers/applications) 2. Create a new application and set up a bot 3. Enable the necessary intents (Guilds, Guild Messages, Message Content) 4. Copy the bot token and client ID ### Supabase Setup 1. Create a new Supabase project 2. Run the SQL scripts in `supabase/schema.sql` and `supabase/functions.sql` to set up the database schema and functions 3. Set up authentication (Email/Password) for the web dashboard ### Environment Variables Create a `.env` file with the following variables: \`\`\` # Discord Bot DISCORD_BOT_TOKEN=your_bot_token DISCORD_CLIENT_ID=your_client_id # Supabase NEXT_PUBLIC_SUPABASE_URL=your_supabase_url NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key \`\`\` ### Installation 1. Clone the repository 2. Install dependencies: \`\`\` npm install \`\`\` 3. Start the development server: \`\`\` npm run dev \`\`\` 4. Run the Discord bot: \`\`\` node bot/index.js \`\`\` ### Adding the Bot to Your Server 1. Generate an OAuth2 URL with the `applications.commands` scope 2. Visit the URL and select your server 3. The bot will be added with slash command permissions ## Usage ### Discord Commands - `/shop` - Browse available items - `/buy [item] [quantity]` - Purchase an item - `/balance` - Check your coin balance - `/inventory` - View your purchased items - `/daily` - Claim your daily reward - `/transfer [user] [amount]` - Transfer coins to another user ### Web Dashboard Access the web dashboard at `http://localhost:3000` (or your deployed URL). 1. Log in with your admin credentials 2. Manage shop items, view user data, and configure bot settings ## Deployment ### Vercel Deployment (Web Dashboard) 1. Push your code to GitHub 2. Connect your repository to Vercel 3. Set up the environment variables 4. Deploy ### Discord Bot Deployment 1. Set up a VPS or use a service like Railway or Heroku 2. Deploy the bot code 3. Set up the environment variables 4. Start the bot process ## License MIT \`\`\` This completes the Discord Shop Bot project with a full shop and banking system, along with a web dashboard for administration. The project includes: 1. A Discord bot with slash commands for shop, bank, and inventory management 2. A Supabase database with tables for users, items, inventory, and transactions 3. A Next.js web dashboard for administration 4. Comprehensive documentation for setup and usage [V0_FILE]typescriptreact:file="scripts/setup.js" isMerged="true" require("dotenv").config() const { createClient } = require("@supabase/supabase-js") const readline = require("readline") const rl = readline.createInterface({ input: process.stdin, output: process.stdout, }) // Initialize Supabase client const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY const supabase = createClient(supabaseUrl, supabaseKey) async function setupAdmin() { console.log("=== Discord Shop Bot Setup ===") console.log("This script will help you set up your first admin user for the dashboard.") // Ask for admin email const email = await new Promise((resolve) => { rl.question("Enter admin email: ", (answer) => { resolve(answer) }) }) // Ask for admin password const password = await new Promise((resolve) => { rl.question("Enter admin password (min 6 characters): ", (answer) => { resolve(answer) }) }) try { // Create admin user const { data, error } = await supabase.auth.admin.createUser({ email, password, email_confirm: true, }) if (error) { console.error("Error creating admin user:", error.message) return } console.log("Admin user created successfully!") console.log("You can now log in to the dashboard with these credentials.") // Add sample items console.log("\nAdding sample shop items...") const sampleItems = [ { name: "VIP Role", description: "Get the VIP role on the server", price: 5000, image_url: null, stock: -1, category: "Roles", }, { name: "Custom Color", description: "Get a custom color for your name", price: 2000, image_url: null, stock: -1, category: "Roles", }, { name: "Loot Box", description: "A mystery box with random rewards", price: 1000, image_url: null, stock: 50, category: "Items", }, { name: "Double XP Boost", description: "Double your XP earnings for 24 hours", price: 3000, image_url: null, stock: -1, category: "Boosts", }, { name: "Server Badge", description: "A special badge to show off in the server", price: 7500, image_url: null, stock: 10, category: "Special", }, ] const { error: itemsError } = await supabase.from("items").insert(sampleItems) if (itemsError) { console.error("Error adding sample items:", itemsError.message) } else { console.log("Sample items added successfully!") } // Set up default settings console.log("\nConfiguring default settings...") const defaultSettings = [ { key: "currency", value: { symbol: "💰", name: "Coins" }, }, { key: "daily_reward", value: { amount: 200 }, }, { key: "shop_categories", value: ["Roles", "Items", "Boosts", "Special"], }, { key: "starting_balance", value: 1000, }, ] const { error: settingsError } = await supabase.from("settings").insert(defaultSettings) if (settingsError) { console.error("Error configuring settings:", settingsError.message) } else { console.log("Default settings configured successfully!") } console.log("\n=== Setup Complete ===") console.log("Your Discord Shop Bot is ready to use!") console.log("1. Invite your bot to your server using the OAuth2 URL") console.log("2. Start the bot with 'node bot/index.js'") console.log("3. Access the dashboard at your deployed URL") } catch (error) { console.error("Unexpected error:", error) } finally { rl.close() } } setupAdmin() [V0_FILE]typescriptreact:file="scripts/generate-invite-url.js" isMerged="true" require("dotenv").config() const clientId = process.env.DISCORD_CLIENT_ID if (!clientId) { console.error("Error: DISCORD_CLIENT_ID environment variable is not set.") process.exit(1) } // Generate the OAuth2 URL with necessary permissions const scopes = ["bot", "applications.commands"] const permissions = [ "SendMessages", "EmbedLinks", "AttachFiles", "UseExternalEmojis", "AddReactions", "ReadMessageHistory", ] const permissionValue = calculatePermissions(permissions) const url = `https://discord.com/api/oauth2/authorize?client_id=${clientId}&permissions=${permissionValue}&scope=${scopes.join("%20")}` console.log("=== Discord Bot Invite URL ===") console.log("Use this URL to invite your bot to your Discord server:") console.log(url) console.log("\nMake sure you have the 'Manage Server' permission in the server you want to add the bot to.") // Function to calculate permission value function calculatePermissions(permissionNames) { const permissionsBits = { CreateInstantInvite: 1 << 0, KickMembers: 1 << 1, BanMembers: 1 << 2, Administrator: 1 << 3, ManageChannels: 1 << 4, ManageGuild: 1 << 5, AddReactions: 1 << 6, ViewAuditLog: 1 << 7, PrioritySpeaker: 1 << 8, Stream: 1 << 9, ViewChannel: 1 << 10, SendMessages: 1 << 11, SendTTSMessages: 1 << 12, ManageMessages: 1 << 13, EmbedLinks: 1 << 14, AttachFiles: 1 << 15, ReadMessageHistory: 1 << 16, MentionEveryone: 1 << 17, UseExternalEmojis: 1 << 18, ViewGuildInsights: 1 << 19, Connect: 1 << 20, Speak: 1 << 21, MuteMembers: 1 << 22, DeafenMembers: 1 << 23, MoveMembers: 1 << 24, UseVAD: 1 << 25, ChangeNickname: 1 << 26, ManageNicknames: 1 << 27, ManageRoles: 1 << 28, ManageWebhooks: 1 << 29, ManageEmojisAndStickers: 1 << 30, UseApplicationCommands: 1 << 31, RequestToSpeak: 1 << 32, ManageEvents: 1 << 33, ManageThreads: 1 << 34, CreatePublicThreads: 1 << 35, CreatePrivateThreads: 1 << 36, UseExternalStickers: 1 << 37, SendMessagesInThreads: 1 << 38, UseEmbeddedActivities: 1 << 39, ModerateMembers: 1 << 40, } let value = 0n for (const name of permissionNames) { if (permissionsBits[name] !== undefined) { value |= BigInt(permissionsBits[name]) } } return value.toString() } [V0_FILE]typescriptreact:file="bot/commands/help.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder().setName("help").setDescription("Shows all available commands"), async execute(interaction, supabase) { // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create embed const embed = new EmbedBuilder() .setColor(0x0099ff) .setTitle("Discord Shop Bot - Help") .setDescription("Here are all the available commands:") .addFields( { name: "/shop [category]", value: "Browse the shop, optionally filtered by category" }, { name: "/buy [item] [quantity]", value: "Purchase an item from the shop" }, { name: "/balance", value: `Check your ${currency.name} balance` }, { name: "/inventory", value: "View your purchased items" }, { name: "/daily", value: "Claim your daily reward" }, { name: "/transfer [user] [amount]", value: `Transfer ${currency.name} to another user` }, { name: "/leaderboard", value: "View the richest users on the server" }, { name: "/help", value: "Show this help message" }, ) .setFooter({ text: "Discord Shop Bot" }) .setTimestamp() await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="bot/commands/leaderboard.js" isMerged="true" const { SlashCommandBuilder, EmbedBuilder } = require("discord.js") module.exports = { data: new SlashCommandBuilder().setName("leaderboard").setDescription("View the richest users on the server"), async execute(interaction, supabase) { // Get top 10 users by balance const { data: users, error } = await supabase .from("users") .select("*") .order("balance", { ascending: false }) .limit(10) if (error) { return interaction.reply({ content: "Failed to retrieve leaderboard. Please try again later.", ephemeral: true, }) } // Get currency settings const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single() const currency = currencySetting?.value || { symbol: "💰", name: "Coins" } // Create embed const embed = new EmbedBuilder() .setColor(0xf1c40f) .setTitle(`${currency.name} Leaderboard`) .setDescription(`The richest users on the server`) .setTimestamp() // Add users to embed users.forEach((user, index) => { const medal = index === 0 ? "🥇" : index === 1 ? "🥈" : index === 2 ? "🥉" : `${index + 1}.` embed.addFields({ name: `${medal} ${user.username}`, value: `${currency.symbol} ${user.balance.toLocaleString()}`, }) }) await interaction.reply({ embeds: [embed] }) }, } [V0_FILE]typescriptreact:file="app/dashboard/settings/page.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { useToast } from "@/hooks/use-toast" export default function SettingsPage() { const [loading, setLoading] = useState(true) const [saving, setSaving] = useState(false) const [settings, setSettings] = useState({ currency: { symbol: "💰", name: "Coins" }, daily_reward: { amount: 200 }, starting_balance: 1000, shop_categories: ["General", "Roles", "Special"], }) const [newCategory, setNewCategory] = useState("") const { toast } = useToast() const supabase = createClientComponentClient() useEffect(() => { async function loadSettings() { const { data, error } = await supabase.from("settings").select("*") if (error) { toast({ title: "Error loading settings", description: error.message, variant: "destructive", }) return } const settingsObj = {} data.forEach((setting) => { settingsObj[setting.key] = setting.value }) setSettings({ currency: settingsObj.currency || { symbol: "💰", name: "Coins" }, daily_reward: settingsObj.daily_reward || { amount: 200 }, starting_balance: settingsObj.starting_balance || 1000, shop_categories: settingsObj.shop_categories || ["General", "Roles", "Special"], }) setLoading(false) } loadSettings() }, [supabase, toast]) const saveSettings = async (key, value) => { setSaving(true) const { error } = await supabase.from("settings").upsert( { key, value, }, { onConflict: "key" }, ) if (error) { toast({ title: "Error saving settings", description: error.message, variant: "destructive", }) } else { toast({ title: "Settings saved", description: "Your changes have been saved successfully.", }) } setSaving(false) } const handleCurrencyChange = (field, value) => { setSettings({ ...settings, currency: { ...settings.currency, [field]: value, }, }) } const saveCurrency = () => { saveSettings("currency", settings.currency) } const handleDailyRewardChange = (value) => { setSettings({ ...settings, daily_reward: { ...settings.daily_reward, amount: Number.parseInt(value), }, }) } const saveDailyReward = () => { saveSettings("daily_reward", settings.daily_reward) } const handleStartingBalanceChange = (value) => { setSettings({ ...settings, starting_balance: Number.parseInt(value), }) } const saveStartingBalance = () => { saveSettings("starting_balance", settings.starting_balance) } const addCategory = () => { if (!newCategory.trim()) return const updatedCategories = [...settings.shop_categories, newCategory.trim()] setSettings({ ...settings, shop_categories: updatedCategories, }) saveSettings("shop_categories", updatedCategories) setNewCategory("") } const removeCategory = (index) => { const updatedCategories = [...settings.shop_categories] updatedCategories.splice(index, 1) setSettings({ ...settings, shop_categories: updatedCategories, }) saveSettings("shop_categories", updatedCategories) } if (loading) { return

Loading settings...

} return (

Bot Settings

Configure your Discord Shop Bot

General Economy Shop Currency Settings Configure the currency used in your bot

Currency Symbol handleCurrencyChange("symbol", e.target.value)} />

Currency Name handleCurrencyChange("name", e.target.value)} />

Daily Reward Configure the daily reward amount

Daily Reward Amount handleDailyRewardChange(e.target.value)} />

Starting Balance Set the starting balance for new users

Starting Balance handleStartingBalanceChange(e.target.value)} />

Shop Categories Manage the categories for shop items

Current Categories

{settings.shop_categories.map((category, index) => (

{category}

))}

setNewCategory(e.target.value)} onKeyDown={(e) => e.key === "Enter" && addCategory()} />

) } [V0_FILE]typescriptreact:file="app/dashboard/items/new/page.tsx" isMerged="true" "use client" import { useState } from "react" import { useRouter } from "next/navigation" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Textarea } from "@/components/ui/textarea" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card" import { useToast } from "@/hooks/use-toast" import { Switch } from "@/components/ui/switch" export default function NewItemPage() { const [loading, setLoading] = useState(false) const [categories, setCategories] = useState([]) const [formData, setFormData] = useState({ name: "", description: "", price: 100, category: "", stock: -1, unlimited: true, }) const router = useRouter() const { toast } = useToast() const supabase = createClientComponentClient() // Load categories on component mount useState(async () => { const { data, error } = await supabase.from("settings").select("value").eq("key", "shop_categories").single() if (!error && data) { setCategories(data.value) if (data.value.length > 0) { setFormData((prev) => ({ ...prev, category: data.value[0] })) } } }, []) const handleChange = (e) => { const { name, value } = e.target setFormData({ ...formData, [name]: name === "price" ? Number.parseInt(value) : value, }) } const handleCategoryChange = (value) => { setFormData({ ...formData, category: value, }) } const handleUnlimitedChange = (checked) => { setFormData({ ...formData, unlimited: checked, stock: checked ? -1 : 1, }) } const handleStockChange = (e) => { const value = Number.parseInt(e.target.value) setFormData({ ...formData, stock: value, }) } const handleSubmit = async (e) => { e.preventDefault() setLoading(true) const itemData = { name: formData.name, description: formData.description, price: formData.price, category: formData.category, stock: formData.unlimited ? -1 : formData.stock, } const { error } = await supabase.from("items").insert(itemData) if (error) { toast({ title: "Error creating item", description: error.message, variant: "destructive", }) setLoading(false) return } toast({ title: "Item created", description: "The item has been added to the shop.", }) router.push("/dashboard/items") router.refresh() } return (

Add New Item

Create a new item for your shop

Item Details Enter the details for the new shop item

Item Name

Description

</div>

<div className="space-y-2">
              <Label htmlFor="price">Price</Label>
              <Input
                id="price"
                name="price"
                type="number"
                min="1"
                value={formData.price}
                onChange={handleChange}
                required
              />
            </div>

<div className="space-y-2">
              <Label htmlFor="category">Category</Label>
              <Select value={formData.category} onValueChange={handleCategoryChange}>
                <SelectTrigger>
                  <SelectValue placeholder="Select a category" />
                </SelectTrigger>
                <SelectContent>
                  {categories.map((category) => (
                    <SelectItem key={category} value={category}>
                      {category}
                    </SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>

<div className="flex items-center space-x-2">
              <Switch id="unlimited" checked={formData.unlimited} onCheckedChange={handleUnlimitedChange} />
              <Label htmlFor="unlimited">Unlimited Stock</Label>
            </div>

{!formData.unlimited && (
              <div className="space-y-2">
                <Label htmlFor="stock">Stock Quantity</Label>
                <Input
                  id="stock"
                  type="number"
                  min="1"
                  value={formData.stock === -1 ? 1 : formData.stock}
                  onChange={handleStockChange}
                  required
                />
              </div>
            )}
          </CardContent>
          <CardFooter>
            <Button type="submit" disabled={loading}>
              {loading ? "Creating..." : "Create Item"}
            </Button>
          </CardFooter>
        </form>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="docs/deployment-guide.md" isMerged="true"
# Discord Shop Bot Deployment Guide

This guide will help you deploy your Discord Shop Bot to production.

## Prerequisites

Before you begin, make sure you have:

1. A Discord bot created in the [Discord Developer Portal](https://discord.com/developers/applications)
2. A Supabase account and project
3. A hosting platform for the bot (e.g., VPS, Heroku, Railway)
4. A hosting platform for the web dashboard (e.g., Vercel)

## Step 1: Set Up the Database

1. Log in to your Supabase dashboard
2. Navigate to the SQL Editor
3. Run the SQL scripts from `supabase/schema.sql` and `supabase/functions.sql`

## Step 2: Configure Environment Variables

You'll need to set up the following environment variables:

### For the Discord Bot

\`\`\`
DISCORD_BOT_TOKEN=your_bot_token
DISCORD_CLIENT_ID=your_client_id
NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key
\`\`\`

### For the Web Dashboard

\`\`\`
NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key
SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key
\`\`\`

## Step 3: Deploy the Web Dashboard

### Deploying to Vercel

1. Push your code to a GitHub repository
2. Connect your repository to Vercel
3. Configure the environment variables in the Vercel dashboard
4. Deploy the project

## Step 4: Deploy the Discord Bot

### Option 1: Deploy to a VPS

1. SSH into your VPS
2. Clone your repository
3. Install dependencies: `npm install`
4. Set up environment variables
5. Start the bot: `node bot/index.js`
6. Use a process manager like PM2 to keep the bot running: `pm2 start bot/index.js --name discord-shop-bot`

### Option 2: Deploy to Railway

1. Create a new project in Railway
2. Connect your GitHub repository
3. Configure the environment variables
4. Set the start command to `node bot/index.js`
5. Deploy the project

## Step 5: Initial Setup

1. Run the setup script to create your admin user and add sample items:
   \`\`\`
   node scripts/setup.js
   \`\`\`

2. Generate an invite URL for your bot:
   \`\`\`
   node scripts/generate-invite-url.js
   \`\`\`

3. Use the generated URL to invite the bot to your Discord server

## Step 6: Verify Everything Works

1. Check that the bot is online in your Discord server
2. Try using some commands like `/help` or `/shop`
3. Log in to the web dashboard and verify you can manage items and settings

## Troubleshooting

### Bot is not responding to commands

1. Check that the bot is online
2. Verify that the bot has the necessary permissions
3. Check the console for any error messages
4. Make sure the slash commands are registered correctly

### Web dashboard is not working

1. Check that the environment variables are set correctly
2. Verify that the Supabase project is set up correctly
3. Check the browser console for any error messages
4. Make sure you're using the correct login credentials

### Database issues

1. Check that the SQL scripts were executed correctly
2. Verify that the Supabase service role key has the necessary permissions
3. Check for any error messages in the console

## Regular Maintenance

To keep your Discord Shop Bot running smoothly:

1. Regularly back up your database
2. Keep your dependencies updated
3. Monitor the bot's performance and resource usage
4. Check for any Discord API changes that might affect your bot

## Conclusion

Your Discord Shop Bot should now be fully deployed and operational. If you encounter any issues, check the troubleshooting section or refer to the documentation for the specific services you're using.

Happy bot managing!
\`\`\`

Let's also add a component for the users page in the dashboard:
[V0_FILE]typescriptreact:file="app/dashboard/users/page.tsx" isMerged="true"
import { createServerClient } from "@/lib/supabase-server"
import { DataTable } from "@/components/dashboard/data-table"
import { columns } from "./columns"

export default async function UsersPage() {
  const supabase = createServerClient()

const { data: users } = await supabase.from("users").select("*").order("balance", { ascending: false })

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Users</h1>
        <p className="text-muted-foreground">Manage users and their balances</p>
      </div>
      <DataTable columns={columns} data={users || []} searchKey="username" />
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/users/columns.tsx" isMerged="true"
"use client"

import type { ColumnDef } from "@tanstack/react-table"
import { ArrowUpDown, MoreHorizontal } from "lucide-react"
import { Button } from "@/components/ui/button"
import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuLabel,
  DropdownMenuSeparator,
  DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar"
import { formatDistanceToNow } from "date-fns"

export type User = {
  id: number
  discord_id: string
  username: string
  avatar: string | null
  balance: number
  created_at: string
}

export const columns: ColumnDef<User>[] = [
  {
    accessorKey: "username",
    header: ({ column }) => {
      return (
        <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
          Username
          <ArrowUpDown className="ml-2 h-4 w-4" />
        </Button>
      )
    },
    cell: ({ row }) => {
      return (
        <div className="flex items-center gap-2">
          <Avatar className="h-8 w-8">
            <AvatarImage src={row.original.avatar || ""} alt={row.getValue("username")} />
            <AvatarFallback>{row.getValue("username").charAt(0).toUpperCase()}</AvatarFallback>
          </Avatar>
          <span>{row.getValue("username")}</span>
        </div>
      )
    },
  },
  {
    accessorKey: "balance",
    header: ({ column }) => {
      return (
        <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
          Balance
          <ArrowUpDown className="ml-2 h-4 w-4" />
        </Button>
      )
    },
    cell: ({ row }) => {
      const balance = Number.parseInt(row.getValue("balance"))
      return <div>{balance.toLocaleString()} coins</div>
    },
  },
  {
    accessorKey: "created_at",
    header: "Joined",
    cell: ({ row }) => {
      return <div>{formatDistanceToNow(new Date(row.getValue("created_at")), { addSuffix: true })}</div>
    },
  },
  {
    id: "actions",
    cell: ({ row }) => {
      const user = row.original

return (
        <DropdownMenu>
          <DropdownMenuTrigger asChild>
            <Button variant="ghost" className="h-8 w-8 p-0">
              <span className="sr-only">Open menu</span>
              <MoreHorizontal className="h-4 w-4" />
            </Button>
          </DropdownMenuTrigger>
          <DropdownMenuContent align="end">
            <DropdownMenuLabel>Actions</DropdownMenuLabel>
            <DropdownMenuItem>View Inventory</DropdownMenuItem>
            <DropdownMenuItem>View Transactions</DropdownMenuItem>
            <DropdownMenuSeparator />
            <DropdownMenuItem>Edit Balance</DropdownMenuItem>
          </DropdownMenuContent>
        </DropdownMenu>
      )
    },
  },
]
[V0_FILE]typescriptreact:file="app/dashboard/shop/items/page.tsx" isMerged="true"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { createServerClient } from "@/lib/supabase-server"
import { DataTable } from "@/components/dashboard/data-table"
import { Plus } from "lucide-react"
import { columns } from "./columns"

export default async function ShopItemsPage() {
  const supabase = createServerClient()

const { data: items } = await supabase.from("items").select("*").order("id")

return (
    <div className="space-y-6">
      <div className="flex items-center justify-between">
        <div>
          <h1 className="text-3xl font-bold tracking-tight">Shop Items</h1>
          <p className="text-muted-foreground">Manage the items available in your shop</p>
        </div>
        <Link href="/dashboard/shop/items/new">
          <Button>
            <Plus className="mr-2 h-4 w-4" />
            Add Item
          </Button>
        </Link>
      </div>
      <DataTable columns={columns} data={items || []} searchKey="name" />
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/shop/items/columns.tsx" isMerged="true"
"use client"

import type { ColumnDef } from "@tanstack/react-table"
import { ArrowUpDown, MoreHorizontal } from "lucide-react"
import { Button } from "@/components/ui/button"
import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuLabel,
  DropdownMenuSeparator,
  DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import Link from "next/link"
import { Badge } from "@/components/ui/badge"

export type Item = {
  id: number
  name: string
  description: string
  price: number
  stock: number
  category: string
  created_at: string
}

export const columns: ColumnDef<Item>[] = [
  {
    accessorKey: "id",
    header: "ID",
    cell: ({ row }) => <div className="w-[50px]">{row.getValue("id")}</div>,
  },
  {
    accessorKey: "name",
    header: ({ column }) => {
      return (
        <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
          Name
          <ArrowUpDown className="ml-2 h-4 w-4" />
        </Button>
      )
    },
  },
  {
    accessorKey: "price",
    header: ({ column }) => {
      return (
        <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
          Price
          <ArrowUpDown className="ml-2 h-4 w-4" />
        </Button>
      )
    },
    cell: ({ row }) => {
      const price = Number.parseFloat(row.getValue("price"))
      return <div>{price.toLocaleString()} coins</div>
    },
  },
  {
    accessorKey: "stock",
    header: "Stock",
    cell: ({ row }) => {
      const stock = Number.parseInt(row.getValue("stock"))
      return <div>{stock === -1 ? "Unlimited" : stock}</div>
    },
  },
  {
    accessorKey: "category",
    header: "Category",
    cell: ({ row }) => {
      const category = row.getValue("category") as string
      return category ? <Badge variant="outline">{category}</Badge> : <span>-</span>
    },
  },
  {
    id: "actions",
    cell: ({ row }) => {
      const item = row.original

return (
        <DropdownMenu>
          <DropdownMenuTrigger asChild>
            <Button variant="ghost" className="h-8 w-8 p-0">
              <span className="sr-only">Open menu</span>
              <MoreHorizontal className="h-4 w-4" />
            </Button>
          </DropdownMenuTrigger>
          <DropdownMenuContent align="end">
            <DropdownMenuLabel>Actions</DropdownMenuLabel>
            <DropdownMenuItem asChild>
              <Link href={`/dashboard/shop/items/${item.id}`}>Edit Item</Link>
            </DropdownMenuItem>
            <DropdownMenuSeparator />
            <DropdownMenuItem className="text-red-600">Delete Item</DropdownMenuItem>
          </DropdownMenuContent>
        </DropdownMenu>
      )
    },
  },
]
[V0_FILE]typescriptreact:file="app/dashboard/shop/items/[id]/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { useRouter } from "next/navigation"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Textarea } from "@/components/ui/textarea"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Switch } from "@/components/ui/switch"
import { Loader2 } from "lucide-react"
import {
  AlertDialog,
  AlertDialogAction,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogTrigger,
} from "@/components/ui/alert-dialog"

export default function EditItemPage({ params }: { params: { id: string } }) {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [deleting, setDeleting] = useState(false)
  const [categories, setCategories] = useState([])
  const [formData, setFormData] = useState({
    name: "",
    description: "",
    price: 100,
    category: "",
    stock: -1,
    unlimited: true,
  })

const router = useRouter()
  const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadData() {
      // Load item data
      const { data: item, error: itemError } = await supabase.from("items").select("*").eq("id", params.id).single()

if (itemError) {
        toast({
          title: "Error loading item",
          description: itemError.message,
          variant: "destructive",
        })
        router.push("/dashboard/shop/items")
        return
      }

// Load categories
      const { data: categoriesData, error: categoriesError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "shop_categories")
        .single()

if (!categoriesError && categoriesData) {
        setCategories(categoriesData.value)
      }

// Set form data
      setFormData({
        name: item.name,
        description: item.description || "",
        price: item.price,
        category: item.category || "",
        stock: item.stock,
        unlimited: item.stock === -1,
      })

setLoading(false)
    }

loadData()
  }, [params.id, supabase, toast, router])

const handleChange = (e) => {
    const { name, value } = e.target
    setFormData({
      ...formData,
      [name]: name === "price" ? Number.parseInt(value) : value,
    })
  }

const handleCategoryChange = (value) => {
    setFormData({
      ...formData,
      category: value,
    })
  }

const handleUnlimitedChange = (checked) => {
    setFormData({
      ...formData,
      unlimited: checked,
      stock: checked ? -1 : 1,
    })
  }

const handleStockChange = (e) => {
    const value = Number.parseInt(e.target.value)
    setFormData({
      ...formData,
      stock: value,
    })
  }

const handleSubmit = async (e) => {
    e.preventDefault()
    setSaving(true)

const itemData = {
      name: formData.name,
      description: formData.description,
      price: formData.price,
      category: formData.category,
      stock: formData.unlimited ? -1 : formData.stock,
    }

const { error } = await supabase.from("items").update(itemData).eq("id", params.id)

if (error) {
      toast({
        title: "Error updating item",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

toast({
      title: "Item updated",
      description: "The item has been updated successfully.",
    })

setSaving(false)
  }

const handleDelete = async () => {
    setDeleting(true)

const { error } = await supabase.from("items").delete().eq("id", params.id)

if (error) {
      toast({
        title: "Error deleting item",
        description: error.message,
        variant: "destructive",
      })
      setDeleting(false)
      return
    }

toast({
      title: "Item deleted",
      description: "The item has been deleted from the shop.",
    })

router.push("/dashboard/shop/items")
    router.refresh()
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div className="flex items-center justify-between">
        <div>
          <h1 className="text-3xl font-bold tracking-tight">Edit Item</h1>
          <p className="text-muted-foreground">Update the details for this shop item</p>
        </div>
        <AlertDialog>
          <AlertDialogTrigger asChild>
            <Button variant="destructive">Delete Item</Button>
          </AlertDialogTrigger>
          <AlertDialogContent>
            <AlertDialogHeader>
              <AlertDialogTitle>Are you absolutely sure?</AlertDialogTitle>
              <AlertDialogDescription>
                This action cannot be undone. This will permanently delete the item from the shop and remove it from all
                user inventories.
              </AlertDialogDescription>
            </AlertDialogHeader>
            <AlertDialogFooter>
              <AlertDialogCancel>Cancel</AlertDialogCancel>
              <AlertDialogAction onClick={handleDelete} disabled={deleting}>
                {deleting ? "Deleting..." : "Delete"}
              </AlertDialogAction>
            </AlertDialogFooter>
          </AlertDialogContent>
        </AlertDialog>
      </div>

<Card>
        <form onSubmit={handleSubmit}>
          <CardHeader>
            <CardTitle>Item Details</CardTitle>
            <CardDescription>Update the details for this shop item</CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="name">Item Name</Label>
              <Input id="name" name="name" value={formData.name} onChange={handleChange} required />
            </div>

<div className="space-y-2">
              <Label htmlFor="description">Description</Label>
              <Textarea
                id="description"
                name="description"
                value={formData.description}
                onChange={handleChange}
                rows={3}
              />
            </div>

{!formData.unlimited && (
              <div className="space-y-2">
                <Label htmlFor="stock">Stock Quantity</Label>
                <Input
                  id="stock"
                  type="number"
                  min="1"
                  value={formData.stock === -1 ? 1 : formData.stock}
                  onChange={handleStockChange}
                  required
                />
              </div>
            )}
          </CardContent>
          <CardFooter className="flex justify-between">
            <Button type="button" variant="outline" onClick={() => router.back()}>
              Cancel
            </Button>
            <Button type="submit" disabled={saving}>
              {saving ? "Saving..." : "Save Changes"}
            </Button>
          </CardFooter>
        </form>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/shop/categories/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, Plus, X } from "lucide-react"
import { Badge } from "@/components/ui/badge"
import {
  AlertDialog,
  AlertDialogAction,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogTrigger,
} from "@/components/ui/alert-dialog"

export default function CategoriesPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [categories, setCategories] = useState([])
  const [newCategory, setNewCategory] = useState("")
  const [categoryToDelete, setCategoryToDelete] = useState(null)
  const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadCategories() {
      const { data, error } = await supabase.from("settings").select("value").eq("key", "shop_categories").single()

if (error) {
        toast({
          title: "Error loading categories",
          description: error.message,
          variant: "destructive",
        })
        return
      }

setCategories(data.value || [])
      setLoading(false)
    }

loadCategories()
  }, [supabase, toast])

const saveCategories = async (updatedCategories) => {
    setSaving(true)

const { error } = await supabase.from("settings").update({ value: updatedCategories }).eq("key", "shop_categories")

if (error) {
      toast({
        title: "Error saving categories",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return false
    }

setCategories(updatedCategories)
    setSaving(false)
    return true
  }

const handleAddCategory = async (e) => {
    e.preventDefault()
    if (!newCategory.trim()) return

// Check if category already exists
    if (categories.includes(newCategory.trim())) {
      toast({
        title: "Category already exists",
        description: "Please enter a unique category name.",
        variant: "destructive",
      })
      return
    }

const updatedCategories = [...categories, newCategory.trim()]
    const success = await saveCategories(updatedCategories)

if (success) {
      toast({
        title: "Category added",
        description: `"${newCategory}" has been added to the shop categories.`,
      })
      setNewCategory("")
    }
  }

const handleDeleteCategory = async () => {
    if (categoryToDelete === null) return

// Check if there are items using this category
    const { data: items, error: itemsError } = await supabase
      .from("items")
      .select("id")
      .eq("category", categories[categoryToDelete])

if (itemsError) {
      toast({
        title: "Error checking items",
        description: itemsError.message,
        variant: "destructive",
      })
      return
    }

if (items && items.length > 0) {
      toast({
        title: "Cannot delete category",
        description: `There are ${items.length} items using this category. Please reassign or delete these items first.`,
        variant: "destructive",
      })
      return
    }

const updatedCategories = [...categories]
    updatedCategories.splice(categoryToDelete, 1)

const success = await saveCategories(updatedCategories)

if (success) {
      toast({
        title: "Category deleted",
        description: "The category has been removed from the shop.",
      })
      setCategoryToDelete(null)
    }
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Shop Categories</h1>
        <p className="text-muted-foreground">Manage the categories for your shop items</p>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Add New Category</CardTitle>
          <CardDescription>Create a new category for organizing shop items</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleAddCategory} className="flex items-end gap-2">
            <div className="flex-1">
              <Input
                placeholder="Enter category name"
                value={newCategory}
                onChange={(e) => setNewCategory(e.target.value)}
              />
            </div>
            <Button type="submit" disabled={saving || !newCategory.trim()}>
              <Plus className="mr-2 h-4 w-4" />
              Add Category
            </Button>
          </form>
        </CardContent>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>Existing Categories</CardTitle>
          <CardDescription>Manage your shop categories</CardDescription>
        </CardHeader>
        <CardContent>
          {categories.length === 0 ? (
            <p className="text-muted-foreground text-center py-4">
              No categories found. Add your first category above.
            </p>
          ) : (
            <div className="flex flex-wrap gap-2">
              {categories.map((category, index) => (
                <div key={index} className="flex items-center">
                  <Badge className="px-3 py-1 text-sm">
                    {category}
                    <AlertDialog>
                      <AlertDialogTrigger asChild>
                        <button
                          onClick={() => setCategoryToDelete(index)}
                          className="ml-2 text-xs hover:text-destructive"
                        >
                          <X className="h-3 w-3" />
                        </button>
                      </AlertDialogTrigger>
                      <AlertDialogContent>
                        <AlertDialogHeader>
                          <AlertDialogTitle>Delete Category</AlertDialogTitle>
                          <AlertDialogDescription>
                            Are you sure you want to delete the "{category}" category? This action cannot be undone.
                          </AlertDialogDescription>
                        </AlertDialogHeader>
                        <AlertDialogFooter>
                          <AlertDialogCancel onClick={() => setCategoryToDelete(null)}>Cancel</AlertDialogCancel>
                          <AlertDialogAction onClick={handleDeleteCategory}>Delete</AlertDialogAction>
                        </AlertDialogFooter>
                      </AlertDialogContent>
                    </AlertDialog>
                  </Badge>
                </div>
              ))}
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/users/balances/page.tsx" isFixed="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, Search } from "lucide-react"
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar"
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
  DialogTrigger,
} from "@/components/ui/dialog"
import { Label } from "@/components/ui/label"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"

export default function UserBalancesPage() {
  const [loading, setLoading] = useState(true)
  const [users, setUsers] = useState([])
  const [filteredUsers, setFilteredUsers] = useState([])
  const [searchQuery, setSearchQuery] = useState("")
  const [selectedUser, setSelectedUser] = useState(null)
  const [transactionType, setTransactionType] = useState("add")
  const [amount, setAmount] = useState(100)
  const [reason, setReason] = useState("")
  const [processing, setProcessing] = useState(false)
  const [currencySymbol, setCurrencySymbol] = useState("💰")

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadData() {
      // Load users
      const { data: usersData, error: usersError } = await supabase.from("users").select("*").order("username")

if (usersError) {
        toast({
          title: "Error loading users",
          description: usersError.message,
          variant: "destructive",
        })
        setLoading(false)
        return
      }

// Load currency settings
      const { data: currencyData, error: currencyError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "currency")
        .single()

if (!currencyError && currencyData) {
        setCurrencySymbol(currencyData.value.symbol || "💰")
      }

setUsers(usersData || [])
      setFilteredUsers(usersData || [])
      setLoading(false)
    }

loadData()
  }, [supabase, toast])

useEffect(() => {
    if (searchQuery.trim() === "") {
      setFilteredUsers(users)
    } else {
      const query = searchQuery.toLowerCase()
      setFilteredUsers(
        users.filter((user) => user.username.toLowerCase().includes(query) || user.discord_id.includes(query)),
      )
    }
  }, [searchQuery, users])

const handleSearch = (e) => {
    setSearchQuery(e.target.value)
  }

const handleUpdateBalance = async () => {
    if (!selectedUser || !amount || amount <= 0) return

setProcessing(true)

const multiplier = transactionType === "add" ? 1 : -1
    const amountToUpdate = amount * multiplier

// Start a transaction to update user balance and add transaction record
    const { data: userData, error: userError } = await supabase
      .from("users")
      .select("balance")
      .eq("id", selectedUser.id)
      .single()

if (userError) {
      toast({
        title: "Error retrieving user balance",
        description: userError.message,
        variant: "destructive",
      })
      setProcessing(false)
      return
    }

// Check if removing balance would result in negative balance
    if (transactionType === "remove" && userData.balance < amount) {
      toast({
        title: "Insufficient balance",
        description: `User only has ${userData.balance} coins. Cannot remove ${amount} coins.`,
        variant: "destructive",
      })
      setProcessing(false)
      return
    }

// Update user balance
    const newBalance = userData.balance + amountToUpdate
    const { error: updateError } = await supabase
      .from("users")
      .update({ balance: newBalance })
      .eq("id", selectedUser.id)

if (updateError) {
      toast({
        title: "Error updating balance",
        description: updateError.message,
        variant: "destructive",
      })
      setProcessing(false)
      return
    }

// Add transaction record
    const { error: transactionError } = await supabase.from("transactions").insert({
      user_id: selectedUser.id,
      amount: amountToUpdate,
      type: "admin",
      description: reason || `Admin ${transactionType === "add" ? "added" : "removed"} balance`,
    })

if (transactionError) {
      toast({
        title: "Error recording transaction",
        description: transactionError.message,
        variant: "destructive",
      })
    }

// Update local state
    setUsers(users.map((user) => (user.id === selectedUser.id ? { ...user, balance: newBalance } : user)))
    setFilteredUsers(
      filteredUsers.map((user) => (user.id === selectedUser.id ? { ...user, balance: newBalance } : user)),
    )

toast({
      title: "Balance updated",
      description: `Successfully ${transactionType === "add" ? "added" : "removed"} ${amount} coins ${transactionType === "add" ? "to" : "from"} ${selectedUser.username}'s balance.`,
    })

setSelectedUser(null)
    setAmount(100)
    setReason("")
    setProcessing(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">User Balances</h1>
        <p className="text-muted-foreground">Manage user balances and add or remove coins</p>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Search Users</CardTitle>
          <CardDescription>Find users by username or Discord ID</CardDescription>
        </CardHeader>
        <CardContent>
          <div className="relative">
            <Search className="absolute left-2 top-2.5 h-4 w-4 text-muted-foreground" />
            <Input placeholder="Search users..." className="pl-8" value={searchQuery} onChange={handleSearch} />
          </div>
        </CardContent>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>User List</CardTitle>
          <CardDescription>Select a user to modify their balance</CardDescription>
        </CardHeader>
        <CardContent>
          {filteredUsers.length === 0 ? (
            <p className="text-muted-foreground text-center py-4">No users found matching your search.</p>
          ) : (
            <div className="space-y-4">
              {filteredUsers.map((user) => (
                <Dialog key={user.id}>
                  <DialogTrigger asChild>
                    <div
                      className="flex items-center justify-between p-3 rounded-lg border hover:bg-accent cursor-pointer"
                      onClick={() => setSelectedUser(user)}
                    >
                      <div className="flex items-center gap-3">
                        <Avatar>
                          <AvatarImage src={user.avatar || ""} alt={user.username} />
                          <AvatarFallback>{user.username.charAt(0).toUpperCase()}</AvatarFallback>
                        </Avatar>
                        <div>
                          <p className="font-medium">{user.username}</p>
                          <p className="text-sm text-muted-foreground">ID: {user.discord_id}</p>
                        </div>
                      </div>
                      <div className="font-medium">
                        {currencySymbol} {user.balance.toLocaleString()}
                      </div>
                    </div>
                  </DialogTrigger>
                  <DialogContent>
                    <DialogHeader>
                      <DialogTitle>Modify Balance for {user.username}</DialogTitle>
                      <DialogDescription>Add or remove coins from this user's balance.</DialogDescription>
                    </DialogHeader>
                    <div className="space-y-4 py-4">
                      <div className="flex items-center gap-4">
                        <div className="flex-1 space-y-2">
                          <Label>Current Balance</Label>
                          <div className="p-2 border rounded-md bg-muted">
                            {currencySymbol} {user.balance.toLocaleString()}
                          </div>
                        </div>
                        <div className="flex-1 space-y-2">
                          <Label htmlFor="transaction-type">Action</Label>
                          <Select value={transactionType} onValueChange={setTransactionType}>
                            <SelectTrigger id="transaction-type">
                              <SelectValue placeholder="Select action" />
                            </SelectTrigger>
                            <SelectContent>
                              <SelectItem value="add">Add Coins</SelectItem>
                              <SelectItem value="remove">Remove Coins</SelectItem>
                            </SelectContent>
                          </Select>
                        </div>
                      </div>
                      <div className="space-y-2">
                        <Label htmlFor="amount">Amount</Label>
                        <Input
                          id="amount"
                          type="number"
                          min="1"
                          value={amount}
                          onChange={(e) => setAmount(Number.parseInt(e.target.value) || 0)}
                        />
                      </div>
                      <div className="space-y-2">
                        <Label htmlFor="reason">Reason (Optional)</Label>
                        <Input
                          id="reason"
                          placeholder="Reason for adjustment"
                          value={reason}
                          onChange={(e) => setReason(e.target.value)}
                        />
                      </div>
                    </div>
                    <DialogFooter>
                      <Button variant="outline" onClick={() => setSelectedUser(null)}>
                        Cancel
                      </Button>
                      <Button onClick={handleUpdateBalance} disabled={processing || amount <= 0}>
                        {processing ? "Processing..." : "Update Balance"}
                      </Button>
                    </DialogFooter>
                  </DialogContent>
                </Dialog>
              ))}
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/users/balances/loading.tsx" isFixed="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/dashboard/bot-settings/general/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2 } from "lucide-react"
import { Textarea } from "@/components/ui/textarea"
import { Switch } from "@/components/ui/switch"

export default function BotGeneralSettingsPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [settings, setSettings] = useState({
    bot_name: "Shop Bot",
    bot_description: "A Discord bot for shop and economy features",
    bot_prefix: "!",
    use_slash_commands: true,
    bot_status: "online",
    bot_activity: "Managing the shop",
    embed_color: "#0099ff",
  })

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadSettings() {
      const { data, error } = await supabase.from("settings").select("value").eq("key", "bot_settings").single()

if (!error && data) {
        setSettings(data.value)
      }

setLoading(false)
    }

loadSettings()
  }, [supabase, toast])

const handleChange = (e) => {
    const { name, value } = e.target
    setSettings({
      ...settings,
      [name]: value,
    })
  }

const handleSwitchChange = (name, checked) => {
    setSettings({
      ...settings,
      [name]: checked,
    })
  }

const handleSubmit = async (e) => {
    e.preventDefault()
    setSaving(true)

const { error } = await supabase.from("settings").upsert(
      {
        key: "bot_settings",
        value: settings,
      },
      { onConflict: "key" },
    )

if (error) {
      toast({
        title: "Error saving settings",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

toast({
      title: "Settings saved",
      description: "Bot settings have been updated successfully.",
    })

setSaving(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Bot Settings</h1>
        <p className="text-muted-foreground">Configure general settings for your Discord bot</p>
      </div>

<form onSubmit={handleSubmit}>
        <div className="space-y-6">
          <Card>
            <CardHeader>
              <CardTitle>Basic Information</CardTitle>
              <CardDescription>Configure the basic information for your bot</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="bot_name">Bot Name</Label>
                <Input id="bot_name" name="bot_name" value={settings.bot_name} onChange={handleChange} />
              </div>
              <div className="space-y-2">
                <Label htmlFor="bot_description">Bot Description</Label>
                <Textarea
                  id="bot_description"
                  name="bot_description"
                  value={settings.bot_description}
                  onChange={handleChange}
                  rows={3}
                />
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Command Settings</CardTitle>
              <CardDescription>Configure how users interact with your bot</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="bot_prefix">Command Prefix</Label>
                <Input
                  id="bot_prefix"
                  name="bot_prefix"
                  value={settings.bot_prefix}
                  onChange={handleChange}
                  maxLength={5}
                />
                <p className="text-sm text-muted-foreground">This prefix is used for text commands (e.g., !balance)</p>
              </div>
              <div className="flex items-center space-x-2">
                <Switch
                  id="use_slash_commands"
                  checked={settings.use_slash_commands}
                  onCheckedChange={(checked) => handleSwitchChange("use_slash_commands", checked)}
                />
                <Label htmlFor="use_slash_commands">Enable Slash Commands</Label>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Appearance</CardTitle>
              <CardDescription>Configure how your bot appears in Discord</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="bot_status">Bot Status</Label>
                <select
                  id="bot_status"
                  name="bot_status"
                  value={settings.bot_status}
                  onChange={handleChange}
                  className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50"
                >
                  <option value="online">Online</option>
                  <option value="idle">Idle</option>
                  <option value="dnd">Do Not Disturb</option>
                  <option value="invisible">Invisible</option>
                </select>
              </div>
              <div className="space-y-2">
                <Label htmlFor="bot_activity">Bot Activity</Label>
                <Input id="bot_activity" name="bot_activity" value={settings.bot_activity} onChange={handleChange} />
                <p className="text-sm text-muted-foreground">
                  This will be displayed as "Playing [activity]" in Discord
                </p>
              </div>
              <div className="space-y-2">
                <Label htmlFor="embed_color">Embed Color</Label>
                <div className="flex gap-2">
                  <Input
                    id="embed_color"
                    name="embed_color"
                    type="color"
                    value={settings.embed_color}
                    onChange={handleChange}
                    className="w-16 h-10 p-1"
                  />
                  <Input
                    name="embed_color"
                    value={settings.embed_color}
                    onChange={handleChange}
                    placeholder="#0099ff"
                  />
                </div>
                <p className="text-sm text-muted-foreground">This color will be used for all bot embeds</p>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Save Changes</CardTitle>
              <CardDescription>Apply these settings to your bot</CardDescription>
            </CardHeader>
            <CardContent>
              <p className="text-sm text-muted-foreground">
                Note: Some settings may require restarting your bot to take effect.
              </p>
            </CardContent>
            <CardFooter>
              <Button type="submit" disabled={saving}>
                {saving ? "Saving..." : "Save Settings"}
              </Button>
            </CardFooter>
          </Card>
        </div>
      </form>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/bot-settings/commands/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Switch } from "@/components/ui/switch"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2 } from "lucide-react"
import { Badge } from "@/components/ui/badge"
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
  DialogTrigger,
} from "@/components/ui/dialog"
import { Label } from "@/components/ui/label"
import { Input } from "@/components/ui/input"
import { Textarea } from "@/components/ui/textarea"

// Default commands list
const defaultCommands = [
  {
    name: "shop",
    description: "Browse the shop",
    enabled: true,
    category: "Shop",
    cooldown: 5,
  },
  {
    name: "buy",
    description: "Purchase an item from the shop",
    enabled: true,
    category: "Shop",
    cooldown: 5,
  },
  {
    name: "balance",
    description: "Check your current balance",
    enabled: true,
    category: "Economy",
    cooldown: 3,
  },
  {
    name: "inventory",
    description: "View your inventory",
    enabled: true,
    category: "Shop",
    cooldown: 5,
  },
  {
    name: "daily",
    description: "Claim your daily reward",
    enabled: true,
    category: "Economy",
    cooldown: 0,
  },
  {
    name: "transfer",
    description: "Transfer coins to another user",
    enabled: true,
    category: "Economy",
    cooldown: 10,
  },
  {
    name: "leaderboard",
    description: "View the richest users on the server",
    enabled: true,
    category: "Economy",
    cooldown: 10,
  },
  {
    name: "help",
    description: "Shows all available commands",
    enabled: true,
    category: "General",
    cooldown: 5,
  },
]

export default function CommandsPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [commands, setCommands] = useState(defaultCommands)
  const [selectedCommand, setSelectedCommand] = useState(null)
  const [editedCommand, setEditedCommand] = useState(null)

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadCommands() {
      const { data, error } = await supabase.from("settings").select("value").eq("key", "commands").single()

if (!error && data) {
        setCommands(data.value)
      } else {
        // If no commands are found, save the default commands
        await supabase.from("settings").upsert(
          {
            key: "commands",
            value: defaultCommands,
          },
          { onConflict: "key" },
        )
      }

setLoading(false)
    }

loadCommands()
  }, [supabase, toast])

const saveCommands = async (updatedCommands) => {
    setSaving(true)

const { error } = await supabase.from("settings").upsert(
      {
        key: "commands",
        value: updatedCommands,
      },
      { onConflict: "key" },
    )

if (error) {
      toast({
        title: "Error saving commands",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return false
    }

setCommands(updatedCommands)
    setSaving(false)
    return true
  }

const handleToggleCommand = async (index) => {
    const updatedCommands = [...commands]
    updatedCommands[index].enabled = !updatedCommands[index].enabled

const success = await saveCommands(updatedCommands)

if (success) {
      toast({
        title: `Command ${updatedCommands[index].enabled ? "enabled" : "disabled"}`,
        description: `The /${updatedCommands[index].name} command has been ${updatedCommands[index].enabled ? "enabled" : "disabled"}.`,
      })
    }
  }

const handleEditCommand = () => {
    if (!editedCommand) return

const updatedCommands = [...commands]
    updatedCommands[selectedCommand] = {
      ...editedCommand,
      cooldown: Number.parseInt(editedCommand.cooldown) || 0,
    }

saveCommands(updatedCommands).then((success) => {
      if (success) {
        toast({
          title: "Command updated",
          description: `The /${editedCommand.name} command has been updated.`,
        })
        setSelectedCommand(null)
        setEditedCommand(null)
      }
    })
  }

const handleInputChange = (e) => {
    const { name, value } = e.target
    setEditedCommand({
      ...editedCommand,
      [name]: value,
    })
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Manage Commands</h1>
        <p className="text-muted-foreground">Enable, disable, and configure bot commands</p>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Bot Commands</CardTitle>
          <CardDescription>Manage the commands available to your users</CardDescription>
        </CardHeader>
        <CardContent>
          <div className="space-y-4">
            {commands.map((command, index) => (
              <div key={index} className="flex items-center justify-between p-3 rounded-lg border">
                <div className="flex items-center gap-3">
                  <div>
                    <div className="flex items-center gap-2">
                      <p className="font-medium">/{command.name}</p>
                      <Badge variant={command.enabled ? "default" : "secondary"}>
                        {command.enabled ? "Enabled" : "Disabled"}
                      </Badge>
                      <Badge variant="outline">{command.category}</Badge>
                    </div>
                    <p className="text-sm text-muted-foreground">{command.description}</p>
                  </div>
                </div>
                <div className="flex items-center gap-2">
                  <Dialog>
                    <DialogTrigger asChild>
                      <Button
                        variant="outline"
                        size="sm"
                        onClick={() => {
                          setSelectedCommand(index)
                          setEditedCommand({ ...command })
                        }}
                      >
                        Edit
                      </Button>
                    </DialogTrigger>
                    <DialogContent>
                      {editedCommand && (
                        <>
                          <DialogHeader>
                            <DialogTitle>Edit Command</DialogTitle>
                            <DialogDescription>
                              Modify the settings for the /{editedCommand.name} command
                            </DialogDescription>
                          </DialogHeader>
                          <div className="space-y-4 py-4">
                            <div className="space-y-2">
                              <Label htmlFor="description">Description</Label>
                              <Textarea
                                id="description"
                                name="description"
                                value={editedCommand.description}
                                onChange={handleInputChange}
                                rows={2}
                              />
                            </div>
                            <div className="space-y-2">
                              <Label htmlFor="category">Category</Label>
                              <Input
                                id="category"
                                name="category"
                                value={editedCommand.category}
                                onChange={handleInputChange}
                              />
                            </div>
                            <div className="space-y-2">
                              <Label htmlFor="cooldown">Cooldown (seconds)</Label>
                              <Input
                                id="cooldown"
                                name="cooldown"
                                type="number"
                                min="0"
                                value={editedCommand.cooldown}
                                onChange={handleInputChange}
                              />
                            </div>
                            <div className="flex items-center space-x-2">
                              <Switch
                                id="enabled"
                                checked={editedCommand.enabled}
                                onCheckedChange={(checked) => setEditedCommand({ ...editedCommand, enabled: checked })}
                              />
                              <Label htmlFor="enabled">Enabled</Label>
                            </div>
                          </div>
                          <DialogFooter>
                            <Button
                              variant="outline"
                              onClick={() => {
                                setSelectedCommand(null)
                                setEditedCommand(null)
                              }}
                            >
                              Cancel
                            </Button>
                            <Button onClick={handleEditCommand} disabled={saving}>
                              {saving ? "Saving..." : "Save Changes"}
                            </Button>
                          </DialogFooter>
                        </>
                      )}
                    </DialogContent>
                  </Dialog>
                  <Switch
                    checked={command.enabled}
                    onCheckedChange={() => handleToggleCommand(index)}
                    disabled={saving}
                  />
                </div>
              </div>
            ))}
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/economy/currency/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2 } from "lucide-react"

export default function CurrencySettingsPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [settings, setSettings] = useState({
    currency: { symbol: "💰", name: "Coins" },
    daily_reward: { amount: 200 },
    starting_balance: 1000,
  })

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadSettings() {
      // Load currency settings
      const { data: currencyData, error: currencyError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "currency")
        .single()

if (!currencyError && currencyData) {
        setSettings((prev) => ({ ...prev, currency: currencyData.value }))
      }

// Load daily reward settings
      const { data: dailyData, error: dailyError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "daily_reward")
        .single()

if (!dailyError && dailyData) {
        setSettings((prev) => ({ ...prev, daily_reward: dailyData.value }))
      }

// Load starting balance settings
      const { data: balanceData, error: balanceError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "starting_balance")
        .single()

if (!balanceError && balanceData) {
        setSettings((prev) => ({ ...prev, starting_balance: balanceData.value }))
      }

setLoading(false)
    }

loadSettings()
  }, [supabase, toast])

const handleCurrencyChange = (field, value) => {
    setSettings({
      ...settings,
      currency: {
        ...settings.currency,
        [field]: value,
      },
    })
  }

const handleDailyRewardChange = (value) => {
    setSettings({
      ...settings,
      daily_reward: {
        ...settings.daily_reward,
        amount: Number.parseInt(value),
      },
    })
  }

const handleStartingBalanceChange = (value) => {
    setSettings({
      ...settings,
      starting_balance: Number.parseInt(value),
    })
  }

const handleSubmit = async (e) => {
    e.preventDefault()
    setSaving(true)

// Update currency settings
    const { error: currencyError } = await supabase.from("settings").upsert(
      {
        key: "currency",
        value: settings.currency,
      },
      { onConflict: "key" },
    )

if (currencyError) {
      toast({
        title: "Error saving currency settings",
        description: currencyError.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

// Update daily reward settings
    const { error: dailyError } = await supabase.from("settings").upsert(
      {
        key: "daily_reward",
        value: settings.daily_reward,
      },
      { onConflict: "key" },
    )

if (dailyError) {
      toast({
        title: "Error saving daily reward settings",
        description: dailyError.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

// Update starting balance settings
    const { error: balanceError } = await supabase.from("settings").upsert(
      {
        key: "starting_balance",
        value: settings.starting_balance,
      },
      { onConflict: "key" },
    )

if (balanceError) {
      toast({
        title: "Error saving starting balance settings",
        description: balanceError.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

toast({
      title: "Settings saved",
      description: "Economy settings have been updated successfully.",
    })

setSaving(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Currency Settings</h1>
        <p className="text-muted-foreground">Configure the economy settings for your bot</p>
      </div>

<form onSubmit={handleSubmit}>
        <div className="space-y-6">
          <Card>
            <CardHeader>
              <CardTitle>Currency Configuration</CardTitle>
              <CardDescription>Set up how currency is displayed and used in your bot</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="grid grid-cols-2 gap-4">
                <div className="space-y-2">
                  <Label htmlFor="currency-symbol">Currency Symbol</Label>
                  <Input
                    id="currency-symbol"
                    value={settings.currency.symbol}
                    onChange={(e) => handleCurrencyChange("symbol", e.target.value)}
                  />
                  <p className="text-sm text-muted-foreground">
                    This symbol will be displayed next to amounts (e.g., 💰 100)
                  </p>
                </div>
                <div className="space-y-2">
                  <Label htmlFor="currency-name">Currency Name</Label>
                  <Input
                    id="currency-name"
                    value={settings.currency.name}
                    onChange={(e) => handleCurrencyChange("name", e.target.value)}
                  />
                  <p className="text-sm text-muted-foreground">
                    The name of your currency (e.g., Coins, Gold, Credits)
                  </p>
                </div>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Daily Rewards</CardTitle>
              <CardDescription>Configure the daily reward system</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="daily-amount">Daily Reward Amount</Label>
                <Input
                  id="daily-amount"
                  type="number"
                  min="1"
                  value={settings.daily_reward.amount}
                  onChange={(e) => handleDailyRewardChange(e.target.value)}
                />
                <p className="text-sm text-muted-foreground">
                  The amount of currency users receive when claiming their daily reward
                </p>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Starting Balance</CardTitle>
              <CardDescription>Set the starting balance for new users</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="starting-balance">Starting Balance</Label>
                <Input
                  id="starting-balance"
                  type="number"
                  min="0"
                  value={settings.starting_balance}
                  onChange={(e) => handleStartingBalanceChange(e.target.value)}
                />
                <p className="text-sm text-muted-foreground">
                  The amount of currency new users start with when they first interact with the bot
                </p>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Save Changes</CardTitle>
              <CardDescription>Apply these settings to your bot</CardDescription>
            </CardHeader>
            <CardContent>
              <p className="text-sm text-muted-foreground">
                Note: These changes will take effect immediately for all users.
              </p>
            </CardContent>
            <CardFooter>
              <Button type="submit" disabled={saving}>
                {saving ? "Saving..." : "Save Settings"}
              </Button>
            </CardFooter>
          </Card>
        </div>
      </form>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/economy/transactions/page.tsx" isMerged="true"
import { createServerClient } from "@/lib/supabase-server"
import { DataTable } from "@/components/dashboard/data-table"
import { columns } from "./columns"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"

export default async function TransactionsPage() {
  const supabase = createServerClient()

// Get transactions with user information
  const { data: transactions } = await supabase
    .from("transactions")
    .select(`
      id,
      user_id,
      amount,
      type,
      description,
      reference_id,
      created_at,
      users (
        username
      )
    `)
    .order("created_at", { ascending: false })
    .limit(100)

// Get currency settings
  const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()

const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

// Get transaction stats
  const { data: stats } = await supabase.rpc("get_total_transactions")

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Transactions</h1>
        <p className="text-muted-foreground">View and manage all economy transactions</p>
      </div>

<div className="grid gap-4 md:grid-cols-3">
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Transactions</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats?.count || 0}</div>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Volume</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">
              {currency.symbol} {Math.abs(stats?.total_amount || 0).toLocaleString()}
            </div>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Currency</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">
              {currency.symbol} {currency.name}
            </div>
          </CardContent>
        </Card>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Recent Transactions</CardTitle>
          <CardDescription>View the most recent economy transactions</CardDescription>
        </CardHeader>
        <CardContent>
          <DataTable columns={columns(currency)} data={transactions || []} searchKey="description" />
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/economy/transactions/columns.tsx" isMerged="true"
"use client"

import type { ColumnDef } from "@tanstack/react-table"
import { ArrowUpDown } from "lucide-react"
import { Button } from "@/components/ui/button"
import { Badge } from "@/components/ui/badge"
import { formatDistanceToNow } from "date-fns"

export type Transaction = {
  id: number
  user_id: number
  amount: number
  type: string
  description: string
  reference_id: string | null
  created_at: string
  users: {
    username: string
  }
}

export const columns = (currency: { symbol: string; name: string }) => {
  const columnsDef: ColumnDef<Transaction>[] = [
    {
      accessorKey: "users.username",
      header: ({ column }) => {
        return (
          <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
            User
            <ArrowUpDown className="ml-2 h-4 w-4" />
          </Button>
        )
      },
      cell: ({ row }) => <div>{row.original.users.username}</div>,
    },
    {
      accessorKey: "amount",
      header: ({ column }) => {
        return (
          <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
            Amount
            <ArrowUpDown className="ml-2 h-4 w-4" />
          </Button>
        )
      },
      cell: ({ row }) => {
        const amount = row.getValue("amount") as number
        const isPositive = amount > 0

return (
          <div className={isPositive ? "text-green-600" : "text-red-600"}>
            {isPositive ? "+" : ""}
            {amount} {currency.symbol}
          </div>
        )
      },
    },
    {
      accessorKey: "type",
      header: "Type",
      cell: ({ row }) => {
        const type = row.getValue("type") as string
        let badgeVariant: "default" | "secondary" | "destructive" | "outline" = "default"

switch (type) {
          case "purchase":
            badgeVariant = "destructive"
            break
          case "daily":
            badgeVariant = "default"
            break
          case "transfer":
            badgeVariant = "secondary"
            break
          case "admin":
            badgeVariant = "outline"
            break
          default:
            badgeVariant = "default"
        }

return <Badge variant={badgeVariant}>{type}</Badge>
      },
    },
    {
      accessorKey: "description",
      header: "Description",
      cell: ({ row }) => <div className="max-w-[300px] truncate">{row.getValue("description")}</div>,
    },
    {
      accessorKey: "created_at",
      header: ({ column }) => {
        return (
          <Button variant="ghost" onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}>
            Date
            <ArrowUpDown className="ml-2 h-4 w-4" />
          </Button>
        )
      },
      cell: ({ row }) => {
        return <div>{formatDistanceToNow(new Date(row.getValue("created_at")), { addSuffix: true })}</div>
      },
    },
  ]

return columnsDef
}
[V0_FILE]typescriptreact:file="app/dashboard/users/inventory/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, Search, Package, X } from "lucide-react"
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar"
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogHeader,
  DialogTitle,
  DialogTrigger,
} from "@/components/ui/dialog"
import { Badge } from "@/components/ui/badge"
import {
  AlertDialog,
  AlertDialogAction,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogTrigger,
} from "@/components/ui/alert-dialog"

export default function UserInventoryPage() {
  const [loading, setLoading] = useState(true)
  const [users, setUsers] = useState([])
  const [filteredUsers, setFilteredUsers] = useState([])
  const [searchQuery, setSearchQuery] = useState("")
  const [selectedUser, setSelectedUser] = useState(null)
  const [userInventory, setUserInventory] = useState([])
  const [loadingInventory, setLoadingInventory] = useState(false)
  const [itemToRemove, setItemToRemove] = useState(null)
  const [removing, setRemoving] = useState(false)

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadUsers() {
      const { data, error } = await supabase.from("users").select("*").order("username")

if (error) {
        toast({
          title: "Error loading users",
          description: error.message,
          variant: "destructive",
        })
        setLoading(false)
        return
      }

setUsers(data || [])
      setFilteredUsers(data || [])
      setLoading(false)
    }

loadUsers()
  }, [supabase, toast])

const handleSearch = (e) => {
    setSearchQuery(e.target.value)
  }

const loadUserInventory = async (user) => {
    setSelectedUser(user)
    setLoadingInventory(true)

const { data, error } = await supabase
      .from("inventory")
      .select(`
        id,
        quantity,
        items (
          id,
          name,
          description,
          price,
          category
        )
      `)
      .eq("user_id", user.id)
      .order("id")

if (error) {
      toast({
        title: "Error loading inventory",
        description: error.message,
        variant: "destructive",
      })
      setLoadingInventory(false)
      return
    }

setUserInventory(data || [])
    setLoadingInventory(false)
  }

const handleRemoveItem = async () => {
    if (!itemToRemove) return

setRemoving(true)

const { error } = await supabase.from("inventory").delete().eq("id", itemToRemove.id)

if (error) {
      toast({
        title: "Error removing item",
        description: error.message,
        variant: "destructive",
      })
      setRemoving(false)
      return
    }

// Update local state
    setUserInventory(userInventory.filter((item) => item.id !== itemToRemove.id))

toast({
      title: "Item removed",
      description: `Successfully removed ${itemToRemove.items.name} from ${selectedUser.username}'s inventory.`,
    })

setItemToRemove(null)
    setRemoving(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">User Inventory</h1>
        <p className="text-muted-foreground">View and manage user inventories</p>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Search Users</CardTitle>
          <CardDescription>Find users to view their inventory</CardDescription>
        </CardHeader>
        <CardContent>
          <div className="relative">
            <Search className="absolute left-2 top-2.5 h-4 w-4 text-muted-foreground" />
            <Input placeholder="Search users..." className="pl-8" value={searchQuery} onChange={handleSearch} />
          </div>
        </CardContent>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>User List</CardTitle>
          <CardDescription>Select a user to view their inventory</CardDescription>
        </CardHeader>
        <CardContent>
          {filteredUsers.length === 0 ? (
            <p className="text-muted-foreground text-center py-4">No users found matching your search.</p>
          ) : (
            <div className="space-y-4">
              {filteredUsers.map((user) => (
                <Dialog key={user.id}>
                  <DialogTrigger asChild>
                    <div
                      className="flex items-center justify-between p-3 rounded-lg border hover:bg-accent cursor-pointer"
                      onClick={() => loadUserInventory(user)}
                    >
                      <div className="flex items-center gap-3">
                        <Avatar>
                          <AvatarImage src={user.avatar || ""} alt={user.username} />
                          <AvatarFallback>{user.username.charAt(0).toUpperCase()}</AvatarFallback>
                        </Avatar>
                        <div>
                          <p className="font-medium">{user.username}</p>
                          <p className="text-sm text-muted-foreground">ID: {user.discord_id}</p>
                        </div>
                      </div>
                      <Button variant="ghost" size="icon">
                        <Package className="h-4 w-4" />
                      </Button>
                    </div>
                  </DialogTrigger>
                  <DialogContent className="max-w-3xl">
                    <DialogHeader>
                      <DialogTitle>{user.username}'s Inventory</DialogTitle>
                      <DialogDescription>View and manage this user's items</DialogDescription>
                    </DialogHeader>

{loadingInventory ? (
                      <div className="flex justify-center items-center py-8">
                        <Loader2 className="h-8 w-8 animate-spin text-primary" />
                      </div>
                    ) : userInventory.length === 0 ? (
                      <div className="text-center py-8">
                        <p className="text-muted-foreground">This user has no items in their inventory.</p>
                      </div>
                    ) : (
                      <div className="space-y-4 py-4">
                        {userInventory.map((item) => (
                          <div key={item.id} className="flex items-center justify-between p-3 rounded-lg border">
                            <div>
                              <div className="flex items-center gap-2">
                                <p className="font-medium">{item.items.name}</p>
                                <Badge variant="outline">x{item.quantity}</Badge>
                                {item.items.category && <Badge variant="secondary">{item.items.category}</Badge>}
                              </div>
                              <p className="text-sm text-muted-foreground">{item.items.description}</p>
                            </div>
                            <AlertDialog>
                              <AlertDialogTrigger asChild>
                                <Button variant="ghost" size="icon" onClick={() => setItemToRemove(item)}>
                                  <X className="h-4 w-4 text-destructive" />
                                </Button>
                              </AlertDialogTrigger>
                              <AlertDialogContent>
                                <AlertDialogHeader>
                                  <AlertDialogTitle>Remove Item</AlertDialogTitle>
                                  <AlertDialogDescription>
                                    Are you sure you want to remove {item.items.name} from {user.username}'s inventory?
                                    This action cannot be undone.
                                  </AlertDialogDescription>
                                </AlertDialogHeader>
                                <AlertDialogFooter>
                                  <AlertDialogCancel onClick={() => setItemToRemove(null)}>Cancel</AlertDialogCancel>
                                  <AlertDialogAction onClick={handleRemoveItem} disabled={removing}>
                                    {removing ? "Removing..." : "Remove"}
                                  </AlertDialogAction>
                                </AlertDialogFooter>
                              </AlertDialogContent>
                            </AlertDialog>
                          </div>
                        ))}
                      </div>
                    )}
                  </DialogContent>
                </Dialog>
              ))}
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/users/inventory/loading.tsx" isFixed="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/dashboard/bot-settings/permissions/page.tsx" isMerged="true"
"use client"

export default function PermissionsPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [permissions, setPermissions] = useState({
    admin_roles: [],
    mod_roles: [],
    blacklisted_users: [],
    blacklisted_channels: [],
    command_permissions: {
      shop: { roles: [], channels: [] },
      buy: { roles: [], channels: [] },
      balance: { roles: [], channels: [] },
      inventory: { roles: [], channels: [] },
      daily: { roles: [], channels: [] },
      transfer: { roles: [], channels: [] },
      leaderboard: { roles: [], channels: [] },
      help: { roles: [], channels: [] },
    },
  })
  const [newAdminRole, setNewAdminRole] = useState("")
  const [newModRole, setNewModRole] = useState("")
  const [newBlacklistedUser, setNewBlacklistedUser] = useState("")
  const [newBlacklistedChannel, setNewBlacklistedChannel] = useState("")

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadPermissions() {
      const { data, error } = await supabase.from("settings").select("value").eq("key", "permissions").single()

if (!error && data) {
        setPermissions(data.value)
      } else {
        // If no permissions are found, save the default permissions
        await supabase.from("settings").upsert(
          {
            key: "permissions",
            value: permissions,
          },
          { onConflict: "key" },
        )
      }

setLoading(false)
    }

loadPermissions()
  }, [supabase, toast])

const savePermissions = async (updatedPermissions) => {
    setSaving(true)

const { error } = await supabase.from("settings").upsert(
      {
        key: "permissions",
        value: updatedPermissions,
      },
      { onConflict: "key" },
    )

if (error) {
      toast({
        title: "Error saving permissions",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return false
    }

setPermissions(updatedPermissions)
    setSaving(false)
    return true
  }

const handleAddAdminRole = async (e) => {
    e.preventDefault()
    if (!newAdminRole.trim()) return

// Check if role already exists
    if (permissions.admin_roles.includes(newAdminRole.trim())) {
      toast({
        title: "Role already exists",
        description: "This role is already in the admin roles list.",
        variant: "destructive",
      })
      return
    }

const updatedPermissions = {
      ...permissions,
      admin_roles: [...permissions.admin_roles, newAdminRole.trim()],
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Admin role added",
        description: `"${newAdminRole}" has been added to the admin roles.`,
      })
      setNewAdminRole("")
    }
  }

const handleRemoveAdminRole = async (index) => {
    const updatedPermissions = {
      ...permissions,
      admin_roles: permissions.admin_roles.filter((_, i) => i !== index),
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Admin role removed",
        description: "The role has been removed from admin roles.",
      })
    }
  }

const handleAddModRole = async (e) => {
    e.preventDefault()
    if (!newModRole.trim()) return

// Check if role already exists
    if (permissions.mod_roles.includes(newModRole.trim())) {
      toast({
        title: "Role already exists",
        description: "This role is already in the moderator roles list.",
        variant: "destructive",
      })
      return
    }

const updatedPermissions = {
      ...permissions,
      mod_roles: [...permissions.mod_roles, newModRole.trim()],
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Moderator role added",
        description: `"${newModRole}" has been added to the moderator roles.`,
      })
      setNewModRole("")
    }
  }

const handleRemoveModRole = async (index) => {
    const updatedPermissions = {
      ...permissions,
      mod_roles: permissions.mod_roles.filter((_, i) => i !== index),
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Moderator role removed",
        description: "The role has been removed from moderator roles.",
      })
    }
  }

const handleAddBlacklistedUser = async (e) => {
    e.preventDefault()
    if (!newBlacklistedUser.trim()) return

// Check if user already exists
    if (permissions.blacklisted_users.includes(newBlacklistedUser.trim())) {
      toast({
        title: "User already blacklisted",
        description: "This user is already in the blacklist.",
        variant: "destructive",
      })
      return
    }

const updatedPermissions = {
      ...permissions,
      blacklisted_users: [...permissions.blacklisted_users, newBlacklistedUser.trim()],
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "User blacklisted",
        description: `User "${newBlacklistedUser}" has been added to the blacklist.`,
      })
      setNewBlacklistedUser("")
    }
  }

const handleRemoveBlacklistedUser = async (index) => {
    const updatedPermissions = {
      ...permissions,
      blacklisted_users: permissions.blacklisted_users.filter((_, i) => i !== index),
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "User removed from blacklist",
        description: "The user has been removed from the blacklist.",
      })
    }
  }

const handleAddBlacklistedChannel = async (e) => {
    e.preventDefault()
    if (!newBlacklistedChannel.trim()) return

// Check if channel already exists
    if (permissions.blacklisted_channels.includes(newBlacklistedChannel.trim())) {
      toast({
        title: "Channel already blacklisted",
        description: "This channel is already in the blacklist.",
        variant: "destructive",
      })
      return
    }

const updatedPermissions = {
      ...permissions,
      blacklisted_channels: [...permissions.blacklisted_channels, newBlacklistedChannel.trim()],
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Channel blacklisted",
        description: `Channel "${newBlacklistedChannel}" has been added to the blacklist.`,
      })
      setNewBlacklistedChannel("")
    }
  }

const handleRemoveBlacklistedChannel = async (index) => {
    const updatedPermissions = {
      ...permissions,
      blacklisted_channels: permissions.blacklisted_channels.filter((_, i) => i !== index),
    }

const success = await savePermissions(updatedPermissions)

if (success) {
      toast({
        title: "Channel removed from blacklist",
        description: "The channel has been removed from the blacklist.",
      })
    }
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Permissions</h1>
        <p className="text-muted-foreground">Configure who can use your bot and its commands</p>
      </div>

<Tabs defaultValue="roles">
        <TabsList>
          <TabsTrigger value="roles">Roles</TabsTrigger>
          <TabsTrigger value="blacklist">Blacklist</TabsTrigger>
          <TabsTrigger value="commands">Command Permissions</TabsTrigger>
        </TabsList>

<TabsContent value="roles" className="space-y-6 mt-6">
          <Card>
            <CardHeader>
              <CardTitle>Admin Roles</CardTitle>
              <CardDescription>Users with these roles will have full access to all bot commands</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <form onSubmit={handleAddAdminRole} className="flex items-end gap-2">
                <div className="flex-1">
                  <Label htmlFor="admin-role">Role ID</Label>
                  <Input
                    id="admin-role"
                    placeholder="Enter Discord role ID"
                    value={newAdminRole}
                    onChange={(e) => setNewAdminRole(e.target.value)}
                  />
                </div>
                <Button type="submit" disabled={saving || !newAdminRole.trim()}>
                  <Plus className="mr-2 h-4 w-4" />
                  Add Role
                </Button>
              </form>

<div className="space-y-2">
                <Label>Current Admin Roles</Label>
                {permissions.admin_roles.length === 0 ? (
                  <p className="text-sm text-muted-foreground">No admin roles configured.</p>
                ) : (
                  <div className="flex flex-wrap gap-2">
                    {permissions.admin_roles.map((role, index) => (
                      <div key={index} className="flex items-center">
                        <Badge className="px-3 py-1 text-sm">
                          {role}
                          <button
                            onClick={() => handleRemoveAdminRole(index)}
                            className="ml-2 text-xs hover:text-destructive"
                            disabled={saving}
                          >
                            <X className="h-3 w-3" />
                          </button>
                        </Badge>
                      </div>
                    ))}
                  </div>
                )}
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Moderator Roles</CardTitle>
              <CardDescription>Users with these roles will have access to moderation commands</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <form onSubmit={handleAddModRole} className="flex items-end gap-2">
                <div className="flex-1">
                  <Label htmlFor="mod-role">Role ID</Label>
                  <Input
                    id="mod-role"
                    placeholder="Enter Discord role ID"
                    value={newModRole}
                    onChange={(e) => setNewModRole(e.target.value)}
                  />
                </div>
                <Button type="submit" disabled={saving || !newModRole.trim()}>
                  <Plus className="mr-2 h-4 w-4" />
                  Add Role
                </Button>
              </form>

<div className="space-y-2">
                <Label>Current Moderator Roles</Label>
                {permissions.mod_roles.length === 0 ? (
                  <p className="text-sm text-muted-foreground">No moderator roles configured.</p>
                ) : (
                  <div className="flex flex-wrap gap-2">
                    {permissions.mod_roles.map((role, index) => (
                      <div key={index} className="flex items-center">
                        <Badge className="px-3 py-1 text-sm">
                          {role}
                          <button
                            onClick={() => handleRemoveModRole(index)}
                            className="ml-2 text-xs hover:text-destructive"
                            disabled={saving}
                          >
                            <X className="h-3 w-3" />
                          </button>
                        </Badge>
                      </div>
                    ))}
                  </div>
                )}
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="blacklist" className="space-y-6 mt-6">
          <Card>
            <CardHeader>
              <CardTitle>Blacklisted Users</CardTitle>
              <CardDescription>These users will not be able to use any bot commands</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <form onSubmit={handleAddBlacklistedUser} className="flex items-end gap-2">
                <div className="flex-1">
                  <Label htmlFor="blacklisted-user">User ID</Label>
                  <Input
                    id="blacklisted-user"
                    placeholder="Enter Discord user ID"
                    value={newBlacklistedUser}
                    onChange={(e) => setNewBlacklistedUser(e.target.value)}
                  />
                </div>
                <Button type="submit" disabled={saving || !newBlacklistedUser.trim()}>
                  <Plus className="mr-2 h-4 w-4" />
                  Add User
                </Button>
              </form>

<div className="space-y-2">
                <Label>Blacklisted Users</Label>
                {permissions.blacklisted_users.length === 0 ? (
                  <p className="text-sm text-muted-foreground">No users are blacklisted.</p>
                ) : (
                  <div className="flex flex-wrap gap-2">
                    {permissions.blacklisted_users.map((user, index) => (
                      <div key={index} className="flex items-center">
                        <Badge variant="destructive" className="px-3 py-1 text-sm">
                          {user}
                          <button
                            onClick={() => handleRemoveBlacklistedUser(index)}
                            className="ml-2 text-xs hover:text-white"
                            disabled={saving}
                          >
                            <X className="h-3 w-3" />
                          </button>
                        </Badge>
                      </div>
                    ))}
                  </div>
                )}
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Blacklisted Channels</CardTitle>
              <CardDescription>The bot will ignore commands in these channels</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <form onSubmit={handleAddBlacklistedChannel} className="flex items-end gap-2">
                <div className="flex-1">
                  <Label htmlFor="blacklisted-channel">Channel ID</Label>
                  <Input
                    id="blacklisted-channel"
                    placeholder="Enter Discord channel ID"
                    value={newBlacklistedChannel}
                    onChange={(e) => setNewBlacklistedChannel(e.target.value)}
                  />
                </div>
                <Button type="submit" disabled={saving || !newBlacklistedChannel.trim()}>
                  <Plus className="mr-2 h-4 w-4" />
                  Add Channel
                </Button>
              </form>

<div className="space-y-2">
                <Label>Blacklisted Channels</Label>
                {permissions.blacklisted_channels.length === 0 ? (
                  <p className="text-sm text-muted-foreground">No channels are blacklisted.</p>
                ) : (
                  <div className="flex flex-wrap gap-2">
                    {permissions.blacklisted_channels.map((channel, index) => (
                      <div key={index} className="flex items-center">
                        <Badge variant="destructive" className="px-3 py-1 text-sm">
                          {channel}
                          <button
                            onClick={() => handleRemoveBlacklistedChannel(index)}
                            className="ml-2 text-xs hover:text-white"
                            disabled={saving}
                          >
                            <X className="h-3 w-3" />
                          </button>
                        </Badge>
                      </div>
                    ))}
                  </div>
                )}
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="commands" className="space-y-6 mt-6">
          <Card>
            <CardHeader>
              <CardTitle>Command Permissions</CardTitle>
              <CardDescription>Configure which roles can use specific commands</CardDescription>
            </CardHeader>
            <CardContent>
              <p className="text-sm text-muted-foreground mb-4">
                Coming soon: Detailed permission settings for each command.
              </p>
            </CardContent>
          </Card>
        </TabsContent>
      </Tabs>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/dashboard/data-table.tsx" isEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import {
  type ColumnDef,
  flexRender,
  getCoreRowModel,
  getPaginationRowModel,
  getSortedRowModel,
  type SortingState,
  useReactTable,
  type ColumnFiltersState,
  getFilteredRowModel,
} from "@tanstack/react-table"

import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"

interface DataTableProps<TData, TValue> {
  columns: ColumnDef<TData, TValue>[]
  data: TData[]
  searchKey?: string
}

export function DataTable<TData, TValue>({ columns, data, searchKey }: DataTableProps<TData, TValue>) {
  const [sorting, setSorting] = useState<SortingState>([])
  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([])

const table = useReactTable({
    data,
    columns,
    getCoreRowModel: getCoreRowModel(),
    getPaginationRowModel: getPaginationRowModel(),
    onSortingChange: setSorting,
    getSortedRowModel: getSortedRowModel(),
    onColumnFiltersChange: setColumnFilters,
    getFilteredRowModel: getFilteredRowModel(),
    state: {
      sorting,
      columnFilters,
    },
  })

return (
    <div>
      {searchKey && (
        <div className="flex items-center py-4">
          <Input
            placeholder="Search"
            value={(table.getColumn(searchKey)?.getFilterValue() as string) ?? ""}
            onChange={(event) => table.getColumn(searchKey)?.setFilterValue(event.target.value)}
            className="max-w-sm"
          />
        </div>
      )}
      <div className="rounded-md border">
        <Table>
          <TableHeader>
            {table.getHeaderGroups().map((headerGroup) => (
              <TableRow key={headerGroup.id}>
                {headerGroup.headers.map((header) => {
                  return (
                    <TableHead key={header.id}>
                      {header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())}
                    </TableHead>
                  )
                })}
              </TableRow>
            ))}
          </TableHeader>
          <TableBody>
            {table.getRowModel().rows?.length ? (
              table.getRowModel().rows.map((row) => (
                <TableRow key={row.id} data-state={row.getIsSelected() && "selected"}>
                  {row.getVisibleCells().map((cell) => (
                    <TableCell key={cell.id}>{flexRender(cell.column.columnDef.cell, cell.getContext())}</TableCell>
                  ))}
                </TableRow>
              ))
            ) : (
              <TableRow>
                <TableCell colSpan={columns.length} className="h-24 text-center">
                  No results.
                </TableCell>
              </TableRow>
            )}
          </TableBody>
        </Table>
      </div>
      <div className="flex items-center justify-end space-x-2 py-4">
        <Button variant="outline" size="sm" onClick={() => table.previousPage()} disabled={!table.getCanPreviousPage()}>
          Previous
        </Button>
        <Button variant="outline" size="sm" onClick={() => table.nextPage()} disabled={!table.getCanNextPage()}>
          Next
        </Button>
      </div>
    </div>
  )
}
[V0_FILE]sql:file="supabase/functions.sql" isFixed="true" isEdit="true" isMerged="true"
-- Function to handle item purchases
CREATE OR REPLACE FUNCTION purchase_item(
  p_user_id INTEGER,
  p_item_id INTEGER,
  p_quantity INTEGER,
  p_total_cost INTEGER
) RETURNS VOID AS $$
BEGIN
  -- Begin transaction
  BEGIN
    -- Update user balance
    UPDATE users
    SET balance = balance - p_total_cost
    WHERE id = p_user_id;
    
    -- Update item stock if it's not unlimited
    UPDATE items
    SET stock = stock - p_quantity
    WHERE id = p_item_id AND stock != -1;
    
    -- Add to inventory or update quantity
    INSERT INTO inventory (user_id, item_id, quantity)
    VALUES (p_user_id, p_item_id, p_quantity)
    ON CONFLICT (user_id, item_id)
    DO UPDATE SET quantity = inventory.quantity + p_quantity;
    
    -- Record transaction
    INSERT INTO transactions (user_id, amount, type, description)
    VALUES (p_user_id, -p_total_cost, 'purchase', 'Purchased item #' || p_item_id);
    
    -- Commit transaction
    COMMIT;
  EXCEPTION
    WHEN OTHERS THEN
      -- Rollback transaction on error
      ROLLBACK;
      RAISE;
  END;
END;
$$ LANGUAGE plpgsql;

-- Function to handle coin transfers
CREATE OR REPLACE FUNCTION transfer_coins(
  p_sender_id INTEGER,
  p_recipient_id INTEGER,
  p_amount INTEGER
) RETURNS VOID AS $$
BEGIN
  -- Begin transaction
  BEGIN
    -- Update sender balance
    UPDATE users
    SET balance = balance - p_amount
    WHERE id = p_sender_id;
    
    -- Update recipient balance
    UPDATE users
    SET balance = balance + p_amount
    WHERE id = p_recipient_id;
    
    -- Record sender transaction
    INSERT INTO transactions (user_id, amount, type, description, reference_id)
    VALUES (
      p_sender_id, 
      -p_amount, 
      'transfer', 
      'Transferred coins to user #' || p_recipient_id,
      (SELECT discord_id FROM users WHERE id = p_recipient_id)
    );
    
    -- Record recipient transaction
    INSERT INTO transactions (user_id, amount, type, description, reference_id)
    VALUES (
      p_recipient_id, 
      p_amount, 
      'transfer', 
      'Received coins from user #' || p_sender_id,
      (SELECT discord_id FROM users WHERE id = p_sender_id)
    );
    
    -- Commit transaction
    COMMIT;
  EXCEPTION
    WHEN OTHERS THEN
      -- Rollback transaction on error
      ROLLBACK;
      RAISE;
  END;
END;
$$ LANGUAGE plpgsql;

-- Function to get transaction statistics
CREATE OR REPLACE FUNCTION get_total_transactions()
RETURNS TABLE (
  count BIGINT,
  total_amount BIGINT
) AS $$
BEGIN
  RETURN QUERY
  SELECT 
    COUNT(*)::BIGINT,
    SUM(ABS(amount))::BIGINT
  FROM transactions;
END;
$$ LANGUAGE plpgsql;
[V0_FILE]javascript:file="bot/commands/profile.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")
const { formatDistanceToNow } = require("date-fns")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("profile")
    .setDescription("View your profile or another user's profile")
    .addUserOption((option) => option.setName("user").setDescription("The user to view").setRequired(false)),

async execute(interaction, supabase) {
    const targetUser = interaction.options.getUser("user") || interaction.user

// Get user from database
    const { data: user, error } = await supabase.from("users").select("*").eq("discord_id", targetUser.id).single()

if (error) {
      if (error.code === "PGRST116") {
        return interaction.reply({
          content: `${targetUser.username} hasn't interacted with the bot yet.`,
          ephemeral: true,
        })
      }
      return interaction.reply({
        content: "Failed to retrieve user profile. Please try again later.",
        ephemeral: true,
      })
    }

// Get inventory count
    const { data: inventory, error: inventoryError } = await supabase
      .from("inventory")
      .select("id", { count: "exact" })
      .eq("user_id", user.id)

const inventoryCount = inventoryError ? 0 : inventory.length

// Get transaction count
    const { data: transactions, error: transactionsError } = await supabase
      .from("transactions")
      .select("id", { count: "exact" })
      .eq("user_id", user.id)

const transactionCount = transactionsError ? 0 : transactions.length

// Get currency settings
    const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()

const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

// Create embed
    const embed = new EmbedBuilder()
      .setColor(0x0099ff)
      .setTitle(`${targetUser.username}'s Profile`)
      .setThumbnail(targetUser.displayAvatarURL())
      .addFields(
        { name: "Balance", value: `${currency.symbol} ${user.balance.toLocaleString()}`, inline: true },
        { name: "Items Owned", value: inventoryCount.toString(), inline: true },
        { name: "Transactions", value: transactionCount.toString(), inline: true },
        {
          name: "Account Created",
          value: formatDistanceToNow(new Date(user.created_at), { addSuffix: true }),
          inline: false,
        },
      )
      .setTimestamp()

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/commands/give.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("give")
    .setDescription("Give coins to a user (Admin only)")
    .addUserOption((option) => option.setName("user").setDescription("The user to give coins to").setRequired(true))
    .addIntegerOption((option) =>
      option.setName("amount").setDescription("The amount of coins to give").setRequired(true).setMinValue(1),
    )
    .addStringOption((option) =>
      option.setName("reason").setDescription("The reason for giving coins").setRequired(false),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async execute(interaction, supabase) {
    const targetUser = interaction.options.getUser("user")
    const amount = interaction.options.getInteger("amount")
    const reason = interaction.options.getString("reason") || "Admin gift"

// Check if user exists, create if not
    const { data: user, error: userError } = await supabase
      .from("users")
      .select("*")
      .eq("discord_id", targetUser.id)
      .single()

if (userError && userError.code === "PGRST116") {
      // User doesn't exist, create them
      await supabase.from("users").insert({
        discord_id: targetUser.id,
        username: targetUser.username,
        avatar: targetUser.displayAvatarURL(),
      })
    }

// Get user again if we just created them
    const { data: updatedUser } = await supabase.from("users").select("*").eq("discord_id", targetUser.id).single()

// Update user balance
    const { error: updateError } = await supabase
      .from("users")
      .update({ balance: updatedUser.balance + amount })
      .eq("discord_id", targetUser.id)

if (updateError) {
      return interaction.reply({
        content: "Failed to update user balance. Please try again later.",
        ephemeral: true,
      })
    }

// Add transaction
    await supabase.from("transactions").insert({
      user_id: updatedUser.id,
      amount: amount,
      type: "admin",
      description: reason,
    })

// Get currency settings
    const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()

const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

// Create success embed
    const embed = new EmbedBuilder()
      .setColor(0x00ff00)
      .setTitle("Coins Given")
      .setDescription(`You have given ${currency.symbol} ${amount.toLocaleString()} to ${targetUser.username}.`)
      .addFields({
        name: "New Balance",
        value: `${currency.symbol} ${(updatedUser.balance + amount).toLocaleString()}`,
      })
      .setTimestamp()

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/commands/take.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("take")
    .setDescription("Take coins from a user (Admin only)")
    .addUserOption((option) => option.setName("user").setDescription("The user to take coins from").setRequired(true))
    .addIntegerOption((option) =>
      option.setName("amount").setDescription("The amount of coins to take").setRequired(true).setMinValue(1),
    )
    .addStringOption((option) =>
      option.setName("reason").setDescription("The reason for taking coins").setRequired(false),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

// Get user
    const { data: user, error: userError } = await supabase
      .from("users")
      .select("*")
      .eq("discord_id", targetUser.id)
      .single()

if (userError) {
      if (userError.code === "PGRST116") {
        return interaction.reply({
          content: `${targetUser.username} hasn't interacted with the bot yet.`,
          ephemeral: true,
        })
      }
      return interaction.reply({
        content: "Failed to retrieve user. Please try again later.",
        ephemeral: true,
      })
    }

// Check if user has enough balance
    if (user.balance < amount) {
      return interaction.reply({
        content: `${targetUser.username} only has ${user.balance} coins. Cannot take ${amount} coins.`,
        ephemeral: true,
      })
    }

// Update user balance
    const { error: updateError } = await supabase
      .from("users")
      .update({ balance: user.balance - amount })
      .eq("discord_id", targetUser.id)

if (updateError) {
      return interaction.reply({
        content: "Failed to update user balance. Please try again later.",
        ephemeral: true,
      })
    }

// Add transaction
    await supabase.from("transactions").insert({
      user_id: user.id,
      amount: -amount,
      type: "admin",
      description: reason,
    })

// Get currency settings
    const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()

const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

// Create success embed
    const embed = new EmbedBuilder()
      .setColor(0xff0000)
      .setTitle("Coins Taken")
      .setDescription(`You have taken ${currency.symbol} ${amount.toLocaleString()} from ${targetUser.username}.`)
      .addFields({
        name: "New Balance",
        value: `${currency.symbol} ${(user.balance - amount).toLocaleString()}`,
      })
      .setTimestamp()

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/commands/use.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("use")
    .setDescription("Use an item from your inventory")
    .addStringOption((option) =>
      option.setName("item").setDescription("The name of the item to use").setRequired(true),
    ),

async execute(interaction, supabase) {
    const itemName = interaction.options.getString("item")

// Get user's inventory with the specified item
    const { data: inventoryItems, error: inventoryError } = await supabase
      .from("inventory")
      .select(
        `
        id,
        quantity,
        items (
          id,
          name,
          description,
          category
        )
      `,
      )
      .eq("user_id", interaction.user.id)
      .ilike("items.name", itemName)

if (inventoryError) {
      return interaction.reply({
        content: "Failed to retrieve your inventory. Please try again later.",
        ephemeral: true,
      })
    }

if (!inventoryItems || inventoryItems.length === 0) {
      return interaction.reply({
        content: `You don't have an item called "${itemName}" in your inventory.`,
        ephemeral: true,
      })
    }

const inventoryItem = inventoryItems[0]

// Check if the item is usable
    const usableCategories = ["Consumable", "Boosts", "Special"]
    if (!usableCategories.includes(inventoryItem.items.category)) {
      return interaction.reply({
        content: `The item "${inventoryItem.items.name}" cannot be used. Only items in these categories can be used: ${usableCategories.join(
          ", ",
        )}.`,
        ephemeral: true,
      })
    }

// Create embed for using the item
    const embed = new EmbedBuilder()
      .setColor(0x00ff00)
      .setTitle("Item Used")
      .setDescription(`You have used ${inventoryItem.items.name}.`)
      .addFields({
        name: "Effect",
        value: inventoryItem.items.description || "This item has been used.",
      })
      .setTimestamp()

// If the item is consumable, reduce the quantity
    if (inventoryItem.items.category === "Consumable") {
      if (inventoryItem.quantity > 1) {
        // Reduce quantity by 1
        await supabase
          .from("inventory")
          .update({ quantity: inventoryItem.quantity - 1 })
          .eq("id", inventoryItem.id)

embed.addFields({
          name: "Remaining",
          value: `${inventoryItem.quantity - 1}x ${inventoryItem.items.name}`,
        })
      } else {
        // Remove the item from inventory
        await supabase.from("inventory").delete().eq("id", inventoryItem.id)

embed.addFields({
          name: "Remaining",
          value: "Item consumed",
        })
      }
    } else {
      embed.addFields({
        name: "Remaining",
        value: `${inventoryItem.quantity}x ${inventoryItem.items.name}`,
      })
    }

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/commands/gift.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("gift")
    .setDescription("Gift an item from your inventory to another user")
    .addUserOption((option) => option.setName("user").setDescription("The user to gift the item to").setRequired(true))
    .addStringOption((option) =>
      option.setName("item").setDescription("The name of the item to gift").setRequired(true),
    )
    .addIntegerOption((option) =>
      option
        .setName("quantity")
        .setDescription("The quantity to gift")
        .setRequired(false)
        .setMinValue(1)
        .setMaxValue(100),
    ),

async execute(interaction, supabase) {
    const targetUser = interaction.options.getUser("user")
    const itemName = interaction.options.getString("item")
    const quantity = interaction.options.getInteger("quantity") || 1

// Check if trying to gift to self
    if (targetUser.id === interaction.user.id) {
      return interaction.reply({
        content: "You cannot gift items to yourself.",
        ephemeral: true,
      })
    }

if (inventoryError) {
      return interaction.reply({
        content: "Failed to retrieve your inventory. Please try again later.",
        ephemeral: true,
      })
    }

const inventoryItem = inventoryItems[0]

// Check if the user has enough of the item
    if (inventoryItem.quantity < quantity) {
      return interaction.reply({
        content: `You only have ${inventoryItem.quantity}x ${inventoryItem.items.name}. Cannot gift ${quantity}.`,
        ephemeral: true,
      })
    }

// Check if the item is giftable
    const nonGiftableCategories = ["Bound", "Soulbound"]
    if (nonGiftableCategories.includes(inventoryItem.items.category)) {
      return interaction.reply({
        content: `The item "${inventoryItem.items.name}" cannot be gifted because it is ${inventoryItem.items.category}.`,
        ephemeral: true,
      })
    }

// Check if recipient exists, create if not
    const { data: recipient, error: recipientError } = await supabase
      .from("users")
      .select("*")
      .eq("discord_id", targetUser.id)
      .single()

if (recipientError && recipientError.code === "PGRST116") {
      // Recipient doesn't exist, create them
      await supabase.from("users").insert({
        discord_id: targetUser.id,
        username: targetUser.username,
        avatar: targetUser.displayAvatarURL(),
      })
    }

// Get recipient again if we just created them
    const { data: updatedRecipient } = await supabase.from("users").select("*").eq("discord_id", targetUser.id).single()

// Start a transaction to update inventories
    try {
      // Update sender's inventory
      if (inventoryItem.quantity > quantity) {
        // Reduce quantity
        await supabase
          .from("inventory")
          .update({ quantity: inventoryItem.quantity - quantity })
          .eq("id", inventoryItem.id)
      } else {
        // Remove the item from inventory
        await supabase.from("inventory").delete().eq("id", inventoryItem.id)
      }

// Add to recipient's inventory or update quantity
      const { data: recipientInventory, error: recipientInventoryError } = await supabase
        .from("inventory")
        .select("*")
        .eq("user_id", updatedRecipient.id)
        .eq("item_id", inventoryItem.items.id)
        .single()

if (recipientInventoryError && recipientInventoryError.code === "PGRST116") {
        // Recipient doesn't have this item, add it
        await supabase.from("inventory").insert({
          user_id: updatedRecipient.id,
          item_id: inventoryItem.items.id,
          quantity: quantity,
        })
      } else {
        // Recipient already has this item, update quantity
        await supabase
          .from("inventory")
          .update({ quantity: recipientInventory.quantity + quantity })
          .eq("id", recipientInventory.id)
      }

// Create success embed
      const embed = new EmbedBuilder()
        .setColor(0x00ff00)
        .setTitle("Gift Sent")
        .setDescription(`You have gifted ${quantity}x ${inventoryItem.items.name} to ${targetUser.username}.`)
        .setTimestamp()

await interaction.reply({ embeds: [embed] })
    } catch (error) {
      console.error("Gift error:", error)
      return interaction.reply({
        content: "There was an error processing your gift. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]typescriptreact:file="app/dashboard/analytics/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { useToast } from "@/hooks/use-toast"
import { Loader2 } from "lucide-react"

export default function AnalyticsPage() {
  const [loading, setLoading] = useState(true)
  const [stats, setStats] = useState({
    userCount: 0,
    itemCount: 0,
    transactionCount: 0,
    totalVolume: 0,
    topItems: [],
    topUsers: [],
    recentTransactions: [],
  })
  const [currency, setCurrency] = useState({ symbol: "💰", name: "Coins" })

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadData() {
      try {
        // Get user count
        const { count: userCount, error: userError } = await supabase
          .from("users")
          .select("*", { count: "exact", head: true })

if (userError) throw userError

// Get item count
        const { count: itemCount, error: itemError } = await supabase
          .from("items")
          .select("*", { count: "exact", head: true })

if (itemError) throw itemError

// Get transaction stats
        const { data: transactionStats, error: transactionError } = await supabase.rpc("get_total_transactions")

if (transactionError) throw transactionError

// Get top items
        const { data: topItems, error: topItemsError } = await supabase
          .from("inventory")
          .select(
            `
            quantity,
            items (
              id,
              name,
              price
            )
          `,
          )
          .order("quantity", { ascending: false })
          .limit(5)

if (topItemsError) throw topItemsError

// Get top users
        const { data: topUsers, error: topUsersError } = await supabase
          .from("users")
          .select("id, username, balance")
          .order("balance", { ascending: false })
          .limit(5)

if (topUsersError) throw topUsersError

// Get recent transactions
        const { data: recentTransactions, error: recentTransactionsError } = await supabase
          .from("transactions")
          .select(
            `
            id,
            amount,
            type,
            description,
            created_at,
            users (
              username
            )
          `,
          )
          .order("created_at", { ascending: false })
          .limit(10)

if (recentTransactionsError) throw recentTransactionsError

// Get currency settings
        const { data: currencySetting, error: currencyError } = await supabase
          .from("settings")
          .select("value")
          .eq("key", "currency")
          .single()

if (!currencyError && currencySetting) {
          setCurrency(currencySetting.value)
        }

setStats({
          userCount: userCount || 0,
          itemCount: itemCount || 0,
          transactionCount: transactionStats?.count || 0,
          totalVolume: transactionStats?.total_amount || 0,
          topItems: topItems || [],
          topUsers: topUsers || [],
          recentTransactions: recentTransactions || [],
        })

setLoading(false)
      } catch (error) {
        console.error("Error loading analytics data:", error)
        toast({
          title: "Error loading data",
          description: "Failed to load analytics data. Please try again later.",
          variant: "destructive",
        })
        setLoading(false)
      }
    }

loadData()
  }, [supabase, toast])

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Analytics</h1>
        <p className="text-muted-foreground">View statistics and insights about your Discord Shop Bot</p>
      </div>

<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Users</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.userCount}</div>
            <p className="text-xs text-muted-foreground">Discord users registered</p>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Shop Items</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.itemCount}</div>
            <p className="text-xs text-muted-foreground">Items available in shop</p>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Transactions</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.transactionCount}</div>
            <p className="text-xs text-muted-foreground">Transactions processed</p>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Economy Volume</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">
              {currency.symbol} {stats.totalVolume.toLocaleString()}
            </div>
            <p className="text-xs text-muted-foreground">Total transaction volume</p>
          </CardContent>
        </Card>
      </div>

<Tabs defaultValue="overview">
        <TabsList>
          <TabsTrigger value="overview">Overview</TabsTrigger>
          <TabsTrigger value="users">Top Users</TabsTrigger>
          <TabsTrigger value="items">Top Items</TabsTrigger>
          <TabsTrigger value="transactions">Recent Transactions</TabsTrigger>
        </TabsList>

<TabsContent value="overview" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Economy Overview</CardTitle>
              <CardDescription>Key metrics about your economy</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="space-y-4">
                <div className="grid grid-cols-2 gap-4">
                  <div className="space-y-2">
                    <p className="text-sm font-medium">Average Balance</p>
                    <p className="text-2xl font-bold">
                      {currency.symbol}{" "}
                      {stats.userCount ? Math.round(stats.totalVolume / stats.userCount).toLocaleString() : 0}
                    </p>
                  </div>
                  <div className="space-y-2">
                    <p className="text-sm font-medium">Average Transaction</p>
                    <p className="text-2xl font-bold">
                      {currency.symbol}{" "}
                      {stats.transactionCount
                        ? Math.round(stats.totalVolume / stats.transactionCount).toLocaleString()
                        : 0}
                    </p>
                  </div>
                </div>
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="users" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Top Users by Balance</CardTitle>
              <CardDescription>Users with the highest balances</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="space-y-4">
                {stats.topUsers.map((user, index) => (
                  <div key={user.id} className="flex items-center justify-between">
                    <div className="flex items-center gap-2">
                      <div className="flex h-8 w-8 items-center justify-center rounded-full bg-primary text-primary-foreground">
                        {index + 1}
                      </div>
                      <div>
                        <p className="text-sm font-medium">{user.username}</p>
                      </div>
                    </div>
                    <p className="font-medium">
                      {currency.symbol} {user.balance.toLocaleString()}
                    </p>
                  </div>
                ))}
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="items" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Top Items by Ownership</CardTitle>
              <CardDescription>Most owned items across all users</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="space-y-4">
                {stats.topItems.map((item, index) => (
                  <div key={index} className="flex items-center justify-between">
                    <div className="flex items-center gap-2">
                      <div className="flex h-8 w-8 items-center justify-center rounded-full bg-primary text-primary-foreground">
                        {index + 1}
                      </div>
                      <div>
                        <p className="text-sm font-medium">{item.items.name}</p>
                        <p className="text-xs text-muted-foreground">
                          {currency.symbol} {item.items.price.toLocaleString()}
                        </p>
                      </div>
                    </div>
                    <p className="font-medium">x{item.quantity}</p>
                  </div>
                ))}
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="transactions" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Recent Transactions</CardTitle>
              <CardDescription>Latest activity in your economy</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="space-y-4">
                {stats.recentTransactions.map((transaction) => (
                  <div key={transaction.id} className="flex items-center justify-between">
                    <div>
                      <p className="text-sm font-medium">{transaction.users.username}</p>
                      <p className="text-xs text-muted-foreground">{transaction.description}</p>
                    </div>
                    <div className={`font-medium ${transaction.amount > 0 ? "text-green-600" : "text-red-600"}`}>
                      {transaction.amount > 0 ? "+" : ""}
                      {transaction.amount} {currency.symbol}
                    </div>
                  </div>
                ))}
              </div>
            </CardContent>
          </Card>
        </TabsContent>
      </Tabs>
    </div>
  )
}
[V0_FILE]javascript:file="bot/commands/rolereward.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("rolereward")
    .setDescription("Manage role rewards (Admin only)")
    .addSubcommand((subcommand) =>
      subcommand
        .setName("add")
        .setDescription("Add a role reward")
        .addRoleOption((option) => option.setName("role").setDescription("The role to reward").setRequired(true))
        .addIntegerOption((option) =>
          option.setName("amount").setDescription("The amount of coins to reward").setRequired(true).setMinValue(1),
        )
        .addStringOption((option) =>
          option.setName("description").setDescription("Description of the reward").setRequired(false),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("remove")
        .setDescription("Remove a role reward")
        .addRoleOption((option) => option.setName("role").setDescription("The role to remove").setRequired(true)),
    )
    .addSubcommand((subcommand) => subcommand.setName("list").setDescription("List all role rewards"))
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async execute(interaction, supabase) {
    const subcommand = interaction.options.getSubcommand()

// Get role rewards settings
    const { data: roleRewardsData, error: roleRewardsError } = await supabase
      .from("settings")
      .select("value")
      .eq("key", "role_rewards")
      .single()

let roleRewards = []
    if (!roleRewardsError && roleRewardsData) {
      roleRewards = roleRewardsData.value
    }

// Get currency settings
    const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()
    const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

if (subcommand === "add") {
      const role = interaction.options.getRole("role")
      const amount = interaction.options.getInteger("amount")
      const description = interaction.options.getString("description") || `Reward for having the ${role.name} role`

// Check if role already exists
      const existingRoleIndex = roleRewards.findIndex((reward) => reward.roleId === role.id)
      if (existingRoleIndex !== -1) {
        // Update existing role
        roleRewards[existingRoleIndex] = {
          roleId: role.id,
          roleName: role.name,
          amount,
          description,
        }
      } else {
        // Add new role
        roleRewards.push({
          roleId: role.id,
          roleName: role.name,
          amount,
          description,
        })
      }

// Save updated role rewards
      const { error: updateError } = await supabase.from("settings").upsert({ key: "role_rewards", value: roleRewards })

if (updateError) {
        return interaction.reply({
          content: "Failed to update role rewards. Please try again later.",
          ephemeral: true,
        })
      }

const embed = new EmbedBuilder()
        .setColor(0x00ff00)
        .setTitle("Role Reward Added")
        .setDescription(`Added reward for the ${role.name} role.`)
        .addFields(
          { name: "Role", value: role.name, inline: true },
          { name: "Amount", value: `${currency.symbol} ${amount.toLocaleString()}`, inline: true },
          { name: "Description", value: description },
        )
        .setTimestamp()

await interaction.reply({ embeds: [embed] })
    } else if (subcommand === "remove") {
      const role = interaction.options.getRole("role")

// Find and remove the role
      const existingRoleIndex = roleRewards.findIndex((reward) => reward.roleId === role.id)
      if (existingRoleIndex === -1) {
        return interaction.reply({
          content: `No reward found for the ${role.name} role.`,
          ephemeral: true,
        })
      }

// Remove the role
      roleRewards.splice(existingRoleIndex, 1)

// Save updated role rewards
      const { error: updateError } = await supabase.from("settings").upsert({ key: "role_rewards", value: roleRewards })

if (updateError) {
        return interaction.reply({
          content: "Failed to update role rewards. Please try again later.",
          ephemeral: true,
        })
      }

const embed = new EmbedBuilder()
        .setColor(0xff0000)
        .setTitle("Role Reward Removed")
        .setDescription(`Removed reward for the ${role.name} role.`)
        .setTimestamp()

await interaction.reply({ embeds: [embed] })
    } else if (subcommand === "list") {
      if (roleRewards.length === 0) {
        return interaction.reply({
          content: "No role rewards have been set up yet.",
          ephemeral: true,
        })
      }

const embed = new EmbedBuilder()
        .setColor(0x0099ff)
        .setTitle("Role Rewards")
        .setDescription("List of all role rewards")
        .setTimestamp()

roleRewards.forEach((reward) => {
        embed.addFields({
          name: reward.roleName,
          value: `${currency.symbol} ${reward.amount.toLocaleString()} - ${reward.description}`,
        })
      })

await interaction.reply({ embeds: [embed] })
    }
  },
}
[V0_FILE]javascript:file="bot/commands/claimrole.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder().setName("claimrole").setDescription("Claim rewards for your roles"),

async execute(interaction, supabase) {
    // Get role rewards settings
    const { data: roleRewardsData, error: roleRewardsError } = await supabase
      .from("settings")
      .select("value")
      .eq("key", "role_rewards")
      .single()

if (roleRewardsError || !roleRewardsData || roleRewardsData.value.length === 0) {
      return interaction.reply({
        content: "No role rewards have been set up yet.",
        ephemeral: true,
      })
    }

const roleRewards = roleRewardsData.value

// Get member's roles
    const member = interaction.member
    if (!member) {
      return interaction.reply({
        content: "Failed to retrieve your roles. Please try again later.",
        ephemeral: true,
      })
    }

// Find eligible roles
    const eligibleRewards = roleRewards.filter((reward) => member.roles.cache.has(reward.roleId))

if (eligibleRewards.length === 0) {
      return interaction.reply({
        content: "You don't have any roles that are eligible for rewards.",
        ephemeral: true,
      })
    }

// Check if user has already claimed today
    const today = new Date()
    today.setHours(0, 0, 0, 0)

const { data: transactions, error: transactionError } = await supabase
      .from("transactions")
      .select("created_at")
      .eq("user_id", interaction.user.id)
      .eq("type", "role_reward")
      .gte("created_at", today.toISOString())
      .limit(1)

if (transactionError) {
      return interaction.reply({
        content: "Failed to check your claim status. Please try again later.",
        ephemeral: true,
      })
    }

if (transactions && transactions.length > 0) {
      // User already claimed today
      const nextReset = new Date()
      nextReset.setDate(nextReset.getDate() + 1)
      nextReset.setHours(0, 0, 0, 0)

const timeRemaining = nextReset - new Date()
      const hoursRemaining = Math.floor(timeRemaining / (1000 * 60 * 60))
      const minutesRemaining = Math.floor((timeRemaining % (1000 * 60 * 60)) / (1000 * 60))

return interaction.reply({
        content: `You've already claimed your role rewards today. Next claim available in ${hoursRemaining}h ${minutesRemaining}m.`,
        ephemeral: true,
      })
    }

// Calculate total reward
    const totalReward = eligibleRewards.reduce((sum, reward) => sum + reward.amount, 0)

// Update user balance
    const { data: user, error: userError } = await supabase
      .from("users")
      .select("balance")
      .eq("discord_id", interaction.user.id)
      .single()

if (userError) {
      return interaction.reply({
        content: "Failed to retrieve your profile. Please try again later.",
        ephemeral: true,
      })
    }

// Update balance
    const { error: updateError } = await supabase
      .from("users")
      .update({ balance: user.balance + totalReward })
      .eq("discord_id", interaction.user.id)

if (updateError) {
      return interaction.reply({
        content: "Failed to update your balance. Please try again later.",
        ephemeral: true,
      })
    }

// Add transaction
    await supabase.from("transactions").insert({
      user_id: interaction.user.id,
      amount: totalReward,
      type: "role_reward",
      description: `Claimed rewards for ${eligibleRewards.length} roles`,
    })

// Create success embed
    const embed = new EmbedBuilder()
      .setColor(0x00ff00)
      .setTitle("Role Rewards Claimed")
      .setDescription(`You have claimed rewards for your roles.`)
      .addFields(
        {
          name: "Total Reward",
          value: `${currency.symbol} ${totalReward.toLocaleString()}`,
          inline: true,
        },
        {
          name: "New Balance",
          value: `${currency.symbol} ${(user.balance + totalReward).toLocaleString()}`,
          inline: true,
        },
      )
      .setTimestamp()

// Add fields for each role
    eligibleRewards.forEach((reward) => {
      embed.addFields({
        name: reward.roleName,
        value: `${currency.symbol} ${reward.amount.toLocaleString()}`,
        inline: true,
      })
    })

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/commands/categories.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder().setName("categories").setDescription("View all shop categories"),

async execute(interaction, supabase) {
    // Get shop categories
    const { data: categoriesData, error: categoriesError } = await supabase
      .from("settings")
      .select("value")
      .eq("key", "shop_categories")
      .single()

if (categoriesError || !categoriesData) {
      return interaction.reply({
        content: "Failed to retrieve shop categories. Please try again later.",
        ephemeral: true,
      })
    }

const categories = categoriesData.value

if (categories.length === 0) {
      return interaction.reply({
        content: "No shop categories have been set up yet.",
        ephemeral: true,
      })
    }

// Count items in each category
    const categoryPromises = categories.map(async (category) => {
      const { count, error } = await supabase
        .from("items")
        .select("*", { count: "exact", head: true })
        .eq("category", category)

return {
        name: category,
        count: error ? 0 : count,
      }
    })

const categoryResults = await Promise.all(categoryPromises)

// Create embed
    const embed = new EmbedBuilder()
      .setColor(0x0099ff)
      .setTitle("Shop Categories")
      .setDescription("Browse items by category using `/shop [category]`")
      .setTimestamp()

// Add fields for each category
    categoryResults.forEach((category) => {
      embed.addFields({
        name: category.name,
        value: `${category.count} items`,
        inline: true,
      })
    })

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]typescriptreact:file="app/dashboard/economy/rewards/page.tsx" isFixed="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, X } from "lucide-react"
import { Textarea } from "@/components/ui/textarea"
import {
  AlertDialog,
  AlertDialogAction,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogTrigger,
} from "@/components/ui/alert-dialog"

export default function RoleRewardsPage() {
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [roleRewards, setRoleRewards] = useState([])
  const [currency, setCurrency] = useState({ symbol: "💰", name: "Coins" })
  const [newReward, setNewReward] = useState({
    roleId: "",
    roleName: "",
    amount: 100,
    description: "",
  })
  const [rewardToDelete, setRewardToDelete] = useState(null)

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadData() {
      // Load role rewards
      const { data: roleRewardsData, error: roleRewardsError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "role_rewards")
        .single()

if (!roleRewardsError && roleRewardsData) {
        setRoleRewards(roleRewardsData.value || [])
      } else {
        // If no role rewards are found, create an empty array
        await supabase.from("settings").upsert(
          {
            key: "role_rewards",
            value: [],
          },
          { onConflict: "key" },
        )
      }

// Load currency settings
      const { data: currencySetting, error: currencyError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "currency")
        .single()

if (!currencyError && currencySetting) {
        setCurrency(currencySetting.value)
      }

setLoading(false)
    }

loadData()
  }, [supabase, toast])

const handleInputChange = (e) => {
    const { name, value } = e.target
    setNewReward({
      ...newReward,
      [name]: name === "amount" ? Number.parseInt(value) : value,
    })
  }

const handleAddReward = async () => {
    if (!newReward.roleId || !newReward.roleName || !newReward.amount) {
      toast({
        title: "Missing information",
        description: "Please fill in all required fields.",
        variant: "destructive",
      })
      return
    }

setSaving(true)

// Check if role already exists
    const existingRoleIndex = roleRewards.findIndex((reward) => reward.roleId === newReward.roleId)
    let updatedRewards = []

if (existingRoleIndex !== -1) {
      // Update existing role
      updatedRewards = [...roleRewards]
      updatedRewards[existingRoleIndex] = newReward
    } else {
      // Add new role
      updatedRewards = [...roleRewards, newReward]
    }

// Save updated role rewards
    const { error } = await supabase.from("settings").upsert(
      {
        key: "role_rewards",
        value: updatedRewards,
      },
      { onConflict: "key" },
    )

if (error) {
      toast({
        title: "Error saving role reward",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

setRoleRewards(updatedRewards)
    setNewReward({
      roleId: "",
      roleName: "",
      amount: 100,
      description: "",
    })

toast({
      title: "Role reward saved",
      description: "The role reward has been saved successfully.",
    })

setSaving(false)
  }

const handleDeleteReward = async () => {
    if (rewardToDelete === null) return

setSaving(true)

// Remove the role
    const updatedRewards = roleRewards.filter((_, index) => index !== rewardToDelete)

if (error) {
      toast({
        title: "Error deleting role reward",
        description: error.message,
        variant: "destructive",
      })
      setSaving(false)
      return
    }

setRoleRewards(updatedRewards)
    setRewardToDelete(null)

toast({
      title: "Role reward deleted",
      description: "The role reward has been deleted successfully.",
    })

setSaving(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Role Rewards</h1>
        <p className="text-muted-foreground">Configure rewards for Discord roles</p>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Add Role Reward</CardTitle>
          <CardDescription>Set up rewards for Discord roles</CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <div className="grid grid-cols-2 gap-4">
            <div className="space-y-2">
              <Label htmlFor="roleId">Role ID</Label>
              <Input
                id="roleId"
                name="roleId"
                placeholder="Discord Role ID"
                value={newReward.roleId}
                onChange={handleInputChange}
              />
              <p className="text-xs text-muted-foreground">Right-click on a role in Discord and select "Copy ID"</p>
            </div>
            <div className="space-y-2">
              <Label htmlFor="roleName">Role Name</Label>
              <Input
                id="roleName"
                name="roleName"
                placeholder="Role Name"
                value={newReward.roleName}
                onChange={handleInputChange}
              />
            </div>
          </div>
          <div className="space-y-2">
            <Label htmlFor="amount">Reward Amount</Label>
            <Input
              id="amount"
              name="amount"
              type="number"
              min="1"
              value={newReward.amount}
              onChange={handleInputChange}
            />
            <p className="text-xs text-muted-foreground">Amount of {currency.name} to reward when claimed</p>
          </div>
          <div className="space-y-2">
            <Label htmlFor="description">Description</Label>
            <Textarea
              id="description"
              name="description"
              placeholder="Reward description"
              value={newReward.description}
              onChange={handleInputChange}
            />
          </div>
        </CardContent>
        <CardFooter>
          <Button onClick={handleAddReward} disabled={saving}>
            {saving ? "Saving..." : "Add Role Reward"}
          </Button>
        </CardFooter>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>Existing Role Rewards</CardTitle>
          <CardDescription>Manage your role rewards</CardDescription>
        </CardHeader>
        <CardContent>
          {roleRewards.length === 0 ? (
            <p className="text-muted-foreground text-center py-4">
              No role rewards found. Add your first role reward above.
            </p>
          ) : (
            <div className="space-y-4">
              {roleRewards.map((reward, index) => (
                <div key={index} className="flex items-center justify-between p-3 rounded-lg border">
                  <div>
                    <p className="font-medium">{reward.roleName}</p>
                    <p className="text-sm text-muted-foreground">{reward.description}</p>
                  </div>
                  <div className="flex items-center gap-4">
                    <p className="font-medium">
                      {currency.symbol} {reward.amount.toLocaleString()}
                    </p>
                    <AlertDialog>
                      <AlertDialogTrigger asChild>
                        <Button variant="ghost" size="icon" onClick={() => setRewardToDelete(index)}>
                          <X className="h-4 w-4 text-destructive" />
                        </Button>
                      </AlertDialogTrigger>
                      <AlertDialogContent>
                        <AlertDialogHeader>
                          <AlertDialogTitle>Delete Role Reward</AlertDialogTitle>
                          <AlertDialogDescription>
                            Are you sure you want to delete the reward for the {reward.roleName} role? This action
                            cannot be undone.
                          </AlertDialogDescription>
                        </AlertDialogHeader>
                        <AlertDialogFooter>
                          <AlertDialogCancel onClick={() => setRewardToDelete(null)}>Cancel</AlertDialogCancel>
                          <AlertDialogAction onClick={handleDeleteReward} disabled={saving}>
                            {saving ? "Deleting..." : "Delete"}
                          </AlertDialogAction>
                        </AlertDialogFooter>
                      </AlertDialogContent>
                    </AlertDialog>
                  </div>
                </div>
              ))}
            </div>
          )}
        </CardContent>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>How Role Rewards Work</CardTitle>
          <CardDescription>Information about the role rewards system</CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <div className="space-y-2">
            <h3 className="font-medium">Claiming Rewards</h3>
            <p className="text-sm text-muted-foreground">
              Users can claim rewards for their roles once per day using the <code>/claimrole</code> command.
            </p>
          </div>
          <div className="space-y-2">
            <h3 className="font-medium">Multiple Roles</h3>
            <p className="text-sm text-muted-foreground">
              If a user has multiple roles with rewards, they will receive the sum of all role rewards when claiming.
            </p>
          </div>
          <div className="space-y-2">
            <h3 className="font-medium">Role IDs</h3>
            <p className="text-sm text-muted-foreground">
              To get a role ID, enable Developer Mode in Discord (Settings > Advanced), then right-click on a role
              and select "Copy ID".
            </p>
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]javascript:file="bot/commands/giveaway.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("giveaway")
    .setDescription("Create and manage giveaways")
    .addSubcommand((subcommand) =>
      subcommand
        .setName("create")
        .setDescription("Create a new giveaway")
        .addStringOption((option) =>
          option.setName("prize").setDescription("The prize for the giveaway").setRequired(true),
        )
        .addIntegerOption((option) =>
          option
            .setName("winners")
            .setDescription("Number of winners")
            .setRequired(true)
            .setMinValue(1)
            .setMaxValue(10),
        )
        .addIntegerOption((option) =>
          option
            .setName("duration")
            .setDescription("Duration in minutes")
            .setRequired(true)
            .setMinValue(1)
            .setMaxValue(10080),
        )
        .addStringOption((option) =>
          option.setName("description").setDescription("Description of the giveaway").setRequired(false),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("end")
        .setDescription("End a giveaway early")
        .addStringOption((option) =>
          option.setName("message_id").setDescription("The message ID of the giveaway").setRequired(true),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("reroll")
        .setDescription("Reroll a giveaway")
        .addStringOption((option) =>
          option.setName("message_id").setDescription("The message ID of the giveaway").setRequired(true),
        ),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageEvents),

async execute(interaction, supabase) {
    const subcommand = interaction.options.getSubcommand()

if (subcommand === "create") {
      const prize = interaction.options.getString("prize")
      const winners = interaction.options.getInteger("winners")
      const duration = interaction.options.getInteger("duration")
      const description = interaction.options.getString("description") || "React with 🎉 to enter!"

// Calculate end time
      const endTime = new Date()
      endTime.setMinutes(endTime.getMinutes() + duration)

// Create embed
      const embed = new EmbedBuilder()
        .setColor(0x00ffff)
        .setTitle("🎉 GIVEAWAY 🎉")
        .setDescription(`**${prize}**\n\n${description}`)
        .addFields(
          { name: "Winners", value: winners.toString(), inline: true },
          { name: "Ends", value: `<t:${Math.floor(endTime.getTime() / 1000)}:R>`, inline: true },
          { name: "Hosted by", value: `<@${interaction.user.id}>`, inline: true },
        )
        .setFooter({ text: "Ends" })
        .setTimestamp(endTime)

// Send giveaway message
      const message = await interaction.channel.send({ embeds: [embed] })
      await message.react("🎉")

// Store giveaway in database
      await supabase.from("giveaways").insert({
        message_id: message.id,
        channel_id: interaction.channelId,
        guild_id: interaction.guildId,
        prize,
        winners,
        description,
        end_time: endTime.toISOString(),
        host_id: interaction.user.id,
        ended: false,
      })

await interaction.reply({
        content: `Giveaway for **${prize}** created! It will end in ${duration} minutes.`,
        ephemeral: true,
      })
    } else if (subcommand === "end") {
      const messageId = interaction.options.getString("message_id")

// Get giveaway from database
      const { data: giveaway, error } = await supabase
        .from("giveaways")
        .select("*")
        .eq("message_id", messageId)
        .eq("ended", false)
        .single()

if (error || !giveaway) {
        return interaction.reply({
          content: "Giveaway not found or already ended.",
          ephemeral: true,
        })
      }

// End the giveaway
      await endGiveaway(interaction, supabase, giveaway)

await interaction.reply({
        content: `Giveaway for **${giveaway.prize}** has been ended.`,
        ephemeral: true,
      })
    } else if (subcommand === "reroll") {
      const messageId = interaction.options.getString("message_id")

// Get giveaway from database
      const { data: giveaway, error } = await supabase
        .from("giveaways")
        .select("*")
        .eq("message_id", messageId)
        .eq("ended", true)
        .single()

if (error || !giveaway) {
        return interaction.reply({
          content: "Giveaway not found or not ended yet.",
          ephemeral: true,
        })
      }

// Reroll the giveaway
      await rerollGiveaway(interaction, supabase, giveaway)

await interaction.reply({
        content: `Giveaway for **${giveaway.prize}** has been rerolled.`,
        ephemeral: true,
      })
    }
  },
}

async function endGiveaway(interaction, supabase, giveaway) {
  try {
    // Get the message
    const channel = await interaction.client.channels.fetch(giveaway.channel_id)
    const message = await channel.messages.fetch(giveaway.message_id)

// Get reactions
    const reaction = message.reactions.cache.get("🎉")
    await reaction.users.fetch()
    const users = reaction.users.cache.filter((user) => !user.bot)

// Select winners
    const winners = []
    if (users.size > 0) {
      const winnerCount = Math.min(giveaway.winners, users.size)
      const userArray = Array.from(users.values())

for (let i = 0; i < winnerCount; i++) {
        const winnerIndex = Math.floor(Math.random() * userArray.length)
        winners.push(userArray[winnerIndex])
        userArray.splice(winnerIndex, 1)
      }
    }

// Update embed
    const embed = EmbedBuilder.from(message.embeds[0])
      .setColor(winners.length > 0 ? 0x00ff00 : 0xff0000)
      .setTitle(winners.length > 0 ? "🎉 GIVEAWAY ENDED 🎉" : "🎉 GIVEAWAY ENDED (No Winners) 🎉")

if (winners.length > 0) {
      embed.addFields({ name: "Winners", value: winners.map((user) => `<@${user.id}>`).join(", "), inline: false })
    } else {
      embed.addFields({ name: "Winners", value: "No valid entries", inline: false })
    }

await message.edit({ embeds: [embed] })

// Send winner announcement
    if (winners.length > 0) {
      await channel.send({
        content: `Congratulations ${winners.map((user) => `<@${user.id}>`).join(", ")}! You won the **${
          giveaway.prize
        }**!`,
        reply: { messageReference: message.id },
      })
    } else {
      await channel.send({
        content: `No one won the giveaway for **${giveaway.prize}**!`,
        reply: { messageReference: message.id },
      })
    }

// Update database
    await supabase
      .from("giveaways")
      .update({
        ended: true,
        winner_ids: winners.map((user) => user.id),
      })
      .eq("id", giveaway.id)
  } catch (error) {
    console.error("Error ending giveaway:", error)
  }
}

async function rerollGiveaway(interaction, supabase, giveaway) {
  try {
    // Get the message
    const channel = await interaction.client.channels.fetch(giveaway.channel_id)
    const message = await channel.messages.fetch(giveaway.message_id)

// Get reactions
    const reaction = message.reactions.cache.get("🎉")
    await reaction.users.fetch()
    const users = reaction.users.cache.filter((user) => !user.bot)

// Select new winners
    const winners = []
    if (users.size > 0) {
      const winnerCount = Math.min(giveaway.winners, users.size)
      const userArray = Array.from(users.values())

// Send winner announcement
    if (winners.length > 0) {
      await channel.send({
        content: `Reroll! Congratulations ${winners.map((user) => `<@${user.id}>`).join(", ")}! You won the **${
          giveaway.prize
        }**!`,
        reply: { messageReference: message.id },
      })
    } else {
      await channel.send({
        content: `Reroll! No one won the giveaway for **${giveaway.prize}**!`,
        reply: { messageReference: message.id },
      })
    }

// Update database
    await supabase
      .from("giveaways")
      .update({
        winner_ids: winners.map((user) => user.id),
      })
      .eq("id", giveaway.id)
  } catch (error) {
    console.error("Error rerolling giveaway:", error)
  }
}
[V0_FILE]sql:file="supabase/schema.sql" isFixed="true" isEdit="true" isMerged="true"
-- Create users table
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  discord_id TEXT UNIQUE NOT NULL,
  username TEXT NOT NULL,
  avatar TEXT,
  balance INTEGER DEFAULT 0,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create items table for the shop
CREATE TABLE items (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  price INTEGER NOT NULL,
  image_url TEXT,
  stock INTEGER DEFAULT -1, -- -1 means unlimited
  category TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create inventory table to track user items
CREATE TABLE inventory (
  id SERIAL PRIMARY KEY,
  user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
  item_id INTEGER REFERENCES items(id) ON DELETE CASCADE,
  quantity INTEGER DEFAULT 1,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  UNIQUE(user_id, item_id)
);

-- Create transactions table for banking history
CREATE TABLE transactions (
  id SERIAL PRIMARY KEY,
  user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
  amount INTEGER NOT NULL,
  type TEXT NOT NULL, -- 'deposit', 'withdraw', 'transfer', 'purchase'
  description TEXT,
  reference_id TEXT, -- For transfers, this is the recipient's discord_id
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create settings table for bot configuration
CREATE TABLE settings (
  id SERIAL PRIMARY KEY,
  key TEXT UNIQUE NOT NULL,
  value JSONB NOT NULL,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create giveaways table
CREATE TABLE giveaways (
  id SERIAL PRIMARY KEY,
  message_id TEXT NOT NULL,
  channel_id TEXT NOT NULL,
  guild_id TEXT NOT NULL,
  prize TEXT NOT NULL,
  winners INTEGER NOT NULL,
  description TEXT,
  end_time TIMESTAMP WITH TIME ZONE NOT NULL,
  host_id TEXT NOT NULL,
  ended BOOLEAN DEFAULT FALSE,
  winner_ids JSONB,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Insert default settings
INSERT INTO settings (key, value) VALUES 
  ('currency', '{"symbol": "💰", "name": "Coins"}'),
  ('shop_categories', '["General", "Roles", "Special"]'),
  ('starting_balance', '1000');
[V0_FILE]javascript:file="bot/commands/giveaways.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder().setName("giveaways").setDescription("View active giveaways"),

async execute(interaction, supabase) {
    // Get active giveaways
    const { data: giveaways, error } = await supabase
      .from("giveaways")
      .select("*")
      .eq("guild_id", interaction.guildId)
      .eq("ended", false)
      .order("end_time", { ascending: true })

if (error) {
      return interaction.reply({
        content: "Failed to retrieve giveaways. Please try again later.",
        ephemeral: true,
      })
    }

if (!giveaways || giveaways.length === 0) {
      return interaction.reply({
        content: "There are no active giveaways in this server.",
        ephemeral: true,
      })
    }

// Create embed
    const embed = new EmbedBuilder()
      .setColor(0x00ffff)
      .setTitle("Active Giveaways")
      .setDescription(`There are ${giveaways.length} active giveaways in this server.`)
      .setTimestamp()

// Add fields for each giveaway
    giveaways.forEach((giveaway, index) => {
      const endTime = new Date(giveaway.end_time)
      embed.addFields({
        name: `${index + 1}. ${giveaway.prize}`,
        value: `Winners: ${giveaway.winners} | Ends: <t:${Math.floor(endTime.getTime() / 1000)}:R> | [Jump to Giveaway](https://discord.com/channels/${
          giveaway.guild_id
        }/${giveaway.channel_id}/${giveaway.message_id})`,
      })
    })

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]typescriptreact:file="app/dashboard/giveaways/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2 } from "lucide-react"
import { Badge } from "@/components/ui/badge"
import { formatDistanceToNow, format } from "date-fns"
import {
  AlertDialog,
  AlertDialogAction,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogTrigger,
} from "@/components/ui/alert-dialog"

export default function GiveawaysPage() {
  const [loading, setLoading] = useState(true)
  const [giveaways, setGiveaways] = useState([])
  const [endingGiveaway, setEndingGiveaway] = useState(null)
  const [processing, setProcessing] = useState(false)

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadGiveaways() {
      const { data, error } = await supabase.from("giveaways").select("*").order("created_at", { ascending: false })

if (error) {
        toast({
          title: "Error loading giveaways",
          description: error.message,
          variant: "destructive",
        })
        setLoading(false)
        return
      }

setGiveaways(data || [])
      setLoading(false)
    }

loadGiveaways()
  }, [supabase, toast])

const handleEndGiveaway = async () => {
    if (!endingGiveaway) return

setProcessing(true)

// Update giveaway status
    const { error } = await supabase.from("giveaways").update({ ended: true }).eq("id", endingGiveaway.id)

if (error) {
      toast({
        title: "Error ending giveaway",
        description: error.message,
        variant: "destructive",
      })
      setProcessing(false)
      return
    }

// Update local state
    setGiveaways(
      giveaways.map((giveaway) => (giveaway.id === endingGiveaway.id ? { ...giveaway, ended: true } : giveaway)),
    )

toast({
      title: "Giveaway ended",
      description: "The giveaway has been marked as ended.",
    })

setEndingGiveaway(null)
    setProcessing(false)
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Giveaways</h1>
        <p className="text-muted-foreground">Manage Discord giveaways</p>
      </div>

<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Giveaways</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{giveaways.length}</div>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Active Giveaways</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{giveaways.filter((g) => !g.ended).length}</div>
          </CardContent>
        </Card>
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Completed Giveaways</CardTitle>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{giveaways.filter((g) => g.ended).length}</div>
          </CardContent>
        </Card>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Giveaway List</CardTitle>
          <CardDescription>View and manage all giveaways</CardDescription>
        </CardHeader>
        <CardContent>
          {giveaways.length === 0 ? (
            <p className="text-muted-foreground text-center py-4">No giveaways found.</p>
          ) : (
            <div className="space-y-4">
              {giveaways.map((giveaway) => (
                <div key={giveaway.id} className="flex items-center justify-between p-3 rounded-lg border">
                  <div>
                    <div className="flex items-center gap-2">
                      <p className="font-medium">{giveaway.prize}</p>
                      <Badge variant={giveaway.ended ? "secondary" : "default"}>
                        {giveaway.ended ? "Ended" : "Active"}
                      </Badge>
                    </div>
                    <p className="text-sm text-muted-foreground">
                      {giveaway.winners} winner{giveaway.winners !== 1 ? "s" : ""} | Created{" "}
                      {formatDistanceToNow(new Date(giveaway.created_at), { addSuffix: true })}
                    </p>
                    <p className="text-xs text-muted-foreground">Ends: {format(new Date(giveaway.end_time), "PPp")}</p>
                  </div>
                  <div className="flex items-center gap-2">
                    {!giveaway.ended && (
                      <AlertDialog>
                        <AlertDialogTrigger asChild>
                          <Button variant="outline" size="sm" onClick={() => setEndingGiveaway(giveaway)}>
                            End Now
                          </Button>
                        </AlertDialogTrigger>
                        <AlertDialogContent>
                          <AlertDialogHeader>
                            <AlertDialogTitle>End Giveaway</AlertDialogTitle>
                            <AlertDialogDescription>
                              Are you sure you want to end the giveaway for "{giveaway.prize}"? This action cannot be
                              undone.
                            </AlertDialogDescription>
                          </AlertDialogHeader>
                          <AlertDialogFooter>
                            <AlertDialogCancel onClick={() => setEndingGiveaway(null)}>Cancel</AlertDialogCancel>
                            <AlertDialogAction onClick={handleEndGiveaway} disabled={processing}>
                              {processing ? "Ending..." : "End Giveaway"}
                            </AlertDialogAction>
                          </AlertDialogFooter>
                        </AlertDialogContent>
                      </AlertDialog>
                    )}
                    <Button
                      variant="ghost"
                      size="sm"
                      onClick={() => {
                        window.open(
                          `https://discord.com/channels/${giveaway.guild_id}/${giveaway.channel_id}/${giveaway.message_id}`,
                          "_blank",
                        )
                      }}
                    >
                      View
                    </Button>
                  </div>
                </div>
              ))}
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]javascript:file="bot/commands/status.js" isFixed="true" isQuickEdit="true" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")
const os = require("os")

module.exports = {
  data: new SlashCommandBuilder().setName("status").setDescription("Check the bot's status"),

async execute(interaction, supabase) {
    // Calculate uptime
    const uptime = process.uptime()
    const uptimeFormatted = formatUptime(uptime)

// Get memory usage
    const memoryUsage = process.memoryUsage()
    const memoryUsedMB = Math.round(memoryUsage.rss / 1024 / 1024)
    const memoryTotalMB = Math.round(os.totalmem() / 1024 / 1024)
    const memoryPercentage = ((memoryUsage.rss / os.totalmem()) * 100).toFixed(2)

// Get bot stats
    const { data: userCount } = await supabase.from("users").select("id", { count: "exact", head: true })
    const { data: itemCount } = await supabase.from("items").select("id", { count: "exact", head: true })
    const { data: transactionCount } = await supabase.from("transactions").select("id", { count: "exact", head: true })

// Create embed
    const embed = new EmbedBuilder()
      .setColor(0x00ff00)
      .setTitle("Bot Status")
      .setDescription("Current status and statistics of the bot")
      .addFields(
        { name: "Status", value: "Online", inline: true },
        { name: "Uptime", value: uptimeFormatted, inline: true },
        { name: "Memory", value: `${memoryUsedMB}MB / ${memoryTotalMB}MB (${memoryPercentage}%)`, inline: true },
        { name: "Users", value: userCount?.count?.toString() || "0", inline: true },
        { name: "Items", value: itemCount?.count?.toString() || "0", inline: true },
        { name: "Transactions", value: transactionCount?.count?.toString() || "0", inline: true },
        { name: "Discord.js", value: require("discord.js").version, inline: true },
        { name: "Node.js", value: process.version, inline: true },
        { name: "Platform", value: `${os.type()} ${os.release()}`, inline: true },
      )
      .setTimestamp()

await interaction.reply({ embeds: [embed] })
  },
}

function formatUptime(seconds) {
  const days = Math.floor(seconds / (3600 * 24))
  const hours = Math.floor((seconds % (3600 * 24)) / 3600)
  \
  const minutes = Math.floor((seconds % 3600) / 60)
  0
  ) / 60)
  const secs = Math.floor(seconds % 60)

let result = ""
  if (days > 0) result += `${days}d `
  if (hours > 0) result += `${hours}h `
  if (minutes > 0) result += `${minutes}m `
  if (secs > 0) result += `${secs}s`

return result.trim() || "0s"
}
[V0_FILE]javascript:file="bot/commands/economy.js" isMerged="true"
const { SlashCommandBuilder, EmbedBuilder } = require("discord.js")

module.exports = {
  data: new SlashCommandBuilder().setName("economy").setDescription("View economy statistics"),

async execute(interaction, supabase) {
    // Get currency settings
    const { data: currencySetting } = await supabase.from("settings").select("value").eq("key", "currency").single()
    const currency = currencySetting?.value || { symbol: "💰", name: "Coins" }

// Get user count and total balance
    const { data: users, error: userError } = await supabase.from("users").select("balance")

if (userError) {
      return interaction.reply({
        content: "Failed to retrieve economy statistics. Please try again later.",
        ephemeral: true,
      })
    }

const userCount = users.length
    const totalBalance = users.reduce((sum, user) => sum + user.balance, 0)
    const averageBalance = userCount > 0 ? Math.floor(totalBalance / userCount) : 0

// Get transaction count and volume
    const { data: transactionStats, error: transactionError } = await supabase.rpc("get_total_transactions")

if (transactionError) {
      return interaction.reply({
        content: "Failed to retrieve transaction statistics. Please try again later.",
        ephemeral: true,
      })
    }

// Get top 3 richest users
    const { data: topUsers, error: topUsersError } = await supabase
      .from("users")
      .select("username, balance")
      .order("balance", { ascending: false })
      .limit(3)

if (topUsersError) {
      return interaction.reply({
        content: "Failed to retrieve top users. Please try again later.",
        ephemeral: true,
      })
    }

// Create embed
    const embed = new EmbedBuilder()
      .setColor(0xf1c40f)
      .setTitle(`${currency.name} Economy Statistics`)
      .setDescription(`Overview of the server's economy`)
      .addFields(
        { name: "Total Users", value: userCount.toString(), inline: true },
        { name: `Total ${currency.name}`, value: `${currency.symbol} ${totalBalance.toLocaleString()}`, inline: true },
        { name: "Average Balance", value: `${currency.symbol} ${averageBalance.toLocaleString()}`, inline: true },
        {
          name: "Transaction Count",
          value: transactionStats?.count?.toString() || "0",
          inline: true,
        },
        {
          name: "Transaction Volume",
          value: `${currency.symbol} ${(transactionStats?.total_amount || 0).toLocaleString()}`,
          inline: true,
        },
        { name: "\u200B", value: "\u200B", inline: true },
      )
      .setTimestamp()

// Add top users
    if (topUsers && topUsers.length > 0) {
      embed.addFields({
        name: "Richest Users",
        value: topUsers
          .map((user, index) => `${index + 1}. ${user.username}: ${currency.symbol} ${user.balance.toLocaleString()}`)
          .join("\n"),
      })
    }

await interaction.reply({ embeds: [embed] })
  },
}
[V0_FILE]javascript:file="bot/admin-command-handler.js" isEdit="true"
const { PermissionFlagsBits } = require("discord.js")

// Admin command handler - processes admin commands with proper permission checks
async function handleAdminCommand(interaction, supabase) {
  try {
    // Check if user has admin permissions
    const isAdmin = interaction.member.permissions.has(PermissionFlagsBits.Administrator)

// Get admin roles from settings
    const { data: permissionsData, error } = await supabase
      .from("settings")
      .select("value")
      .eq("key", "permissions")
      .single()

if (error && error.code !== "PGRST116") {
      console.error("Error fetching permissions:", error)
      return interaction.reply({
        content: "An error occurred while checking permissions. Please try again later.",
        ephemeral: true,
      })
    }

const permissions = permissionsData?.value || { admin_roles: [], mod_roles: [] }
    const adminRoles = permissions.admin_roles || []
    const modRoles = permissions.mod_roles || []

// Check if user has admin or mod role
    const hasAdminRole = interaction.member.roles.cache.some((role) => adminRoles.includes(role.id))
    const hasModRole = interaction.member.roles.cache.some((role) => modRoles.includes(role.id))

// If user doesn't have admin permissions or roles, reject the command
    if (!isAdmin && !hasAdminRole && !hasModRole) {
      return interaction.reply({
        content: "You don't have permission to use admin commands.",
        ephemeral: true,
      })
    }

// Log admin command usage
    await supabase.from("admin_logs").insert({
      user_id: interaction.user.id,
      username: interaction.user.username,
      command: interaction.commandName,
      options: JSON.stringify(interaction.options.data),
      guild_id: interaction.guildId,
      channel_id: interaction.channelId,
      timestamp: new Date().toISOString(),
    })

// Continue with command execution
    return true
  } catch (error) {
    console.error("Error in admin command handler:", error)
    await interaction.reply({
      content: "An error occurred while processing the command. Please try again later.",
      ephemeral: true,
    })
    return false
  }
}

module.exports = { handleAdminCommand }
[V0_FILE]sql:file="supabase/admin-schema.sql" isEdit="true"
-- Create admin_logs table to track admin command usage
CREATE TABLE IF NOT EXISTS admin_logs (
  id SERIAL PRIMARY KEY,
  user_id TEXT NOT NULL,
  username TEXT NOT NULL,
  command TEXT NOT NULL,
  options JSONB,
  guild_id TEXT NOT NULL,
  channel_id TEXT NOT NULL,
  timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create bot_modules table to track enabled/disabled modules
CREATE TABLE IF NOT EXISTS bot_modules (
  id SERIAL PRIMARY KEY,
  name TEXT UNIQUE NOT NULL,
  display_name TEXT NOT NULL,
  description TEXT,
  enabled BOOLEAN DEFAULT TRUE,
  settings JSONB DEFAULT '{}'::jsonb,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_by TEXT
);

-- Insert default modules if they don't exist
INSERT INTO bot_modules (name, display_name, description, enabled, settings)
VALUES 
  ('economy', 'Economy System', 'Currency, shop, and transactions', true, '{"daily_reward": 200, "starting_balance": 1000}'),
  ('moderation', 'Moderation Tools', 'Moderation commands and auto-moderation', true, '{"log_channel": null, "auto_mod": false}'),
  ('giveaways', 'Giveaways', 'Create and manage giveaways', true, '{"default_duration": 60}'),
  ('leveling', 'Leveling System', 'XP and level progression', false, '{"xp_per_message": 5, "level_multiplier": 100}'),
  ('welcome', 'Welcome System', 'Welcome messages and role assignment', false, '{"welcome_channel": null, "welcome_message": "Welcome {user} to {server}!"}'),
  ('tickets', 'Ticket System', 'Support ticket management', false, '{"ticket_category": null, "support_role": null}')
ON CONFLICT (name) DO NOTHING;
[V0_FILE]typescript:file="app/api/admin/modules/route.ts" isEdit="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@/lib/supabase-server"

export async function GET() {
  try {
    const supabase = createServerClient()

// Check authentication
    const {
      data: { session },
    } = await supabase.auth.getSession()
    if (!session) {
      return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
    }

// Get all modules
    const { data: modules, error } = await supabase.from("bot_modules").select("*").order("display_name")

if (error) {
      console.error("Error fetching modules:", error)
      return NextResponse.json({ error: error.message }, { status: 500 })
    }

return NextResponse.json({ modules })
  } catch (error) {
    console.error("Error in GET /api/admin/modules:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}

export async function PUT(request: Request) {
  try {
    const supabase = createServerClient()

// Get request body
    const body = await request.json()
    const { id, enabled, settings } = body

if (!id) {
      return NextResponse.json({ error: "Module ID is required" }, { status: 400 })
    }

// Update module
    const updateData: any = {
      updated_at: new Date().toISOString(),
      updated_by: session.user.email,
    }

if (enabled !== undefined) updateData.enabled = enabled
    if (settings) updateData.settings = settings

const { error } = await supabase.from("bot_modules").update(updateData).eq("id", id)

if (error) {
      console.error("Error updating module:", error)
      return NextResponse.json({ error: error.message }, { status: 500 })
    }

return NextResponse.json({ success: true })
  } catch (error) {
    console.error("Error in PUT /api/admin/modules:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}
[V0_FILE]typescript:file="app/api/admin/logs/route.ts" isEdit="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@/lib/supabase-server"

export async function GET(request: Request) {
  try {
    const supabase = createServerClient()
    const url = new URL(request.url)

// Get query parameters
    const limit = Number.parseInt(url.searchParams.get("limit") || "50")
    const page = Number.parseInt(url.searchParams.get("page") || "0")
    const command = url.searchParams.get("command")

// Build query
    let query = supabase
      .from("admin_logs")
      .select("*", { count: "exact" })
      .order("timestamp", { ascending: false })
      .range(page * limit, (page + 1) * limit - 1)

if (command && command !== "all") {
      query = query.eq("command", command)
    }

// Execute query
    const { data: logs, error, count } = await query

if (error) {
      console.error("Error fetching logs:", error)
      return NextResponse.json({ error: error.message }, { status: 500 })
    }

return NextResponse.json({
      logs,
      pagination: {
        total: count || 0,
        page,
        limit,
        pages: Math.ceil((count || 0) / limit),
      },
    })
  } catch (error) {
    console.error("Error in GET /api/admin/logs:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}
[V0_FILE]typescript:file="app/api/admin/settings/route.ts" isEdit="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@/lib/supabase-server"

export async function GET(request: Request) {
  try {
    const supabase = createServerClient()
    const url = new URL(request.url)

// Get key from query parameters
    const key = url.searchParams.get("key")

// Build query
    let query = supabase.from("settings").select("*")

if (key) {
      query = query.eq("key", key)
    }

// Execute query
    const { data: settings, error } = await query

if (error) {
      console.error("Error fetching settings:", error)
      return NextResponse.json({ error: error.message }, { status: 500 })
    }

return NextResponse.json({ settings })
  } catch (error) {
    console.error("Error in GET /api/admin/settings:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}

export async function PUT(request: Request) {
  try {
    const supabase = createServerClient()

// Get request body
    const body = await request.json()
    const { key, value } = body

if (!key || value === undefined) {
      return NextResponse.json({ error: "Key and value are required" }, { status: 400 })
    }

// Update setting
    const { error } = await supabase.from("settings").upsert(
      {
        key,
        value,
        updated_at: new Date().toISOString(),
      },
      { onConflict: "key" },
    )

if (error) {
      console.error("Error updating setting:", error)
      return NextResponse.json({ error: error.message }, { status: 500 })
    }

return NextResponse.json({ success: true })
  } catch (error) {
    console.error("Error in PUT /api/admin/settings:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}
[V0_FILE]typescriptreact:file="app/dashboard/admin/modules/page.tsx" isEdit="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, Settings } from "lucide-react"
import { Switch } from "@/components/ui/switch"
import { Badge } from "@/components/ui/badge"
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
  DialogTrigger,
} from "@/components/ui/dialog"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Textarea } from "@/components/ui/textarea"

export default function ModulesPage() {
  const [loading, setLoading] = useState(true)
  const [modules, setModules] = useState([])
  const [selectedModule, setSelectedModule] = useState(null)
  const [saving, setSaving] = useState(false)

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadModules() {
      try {
        const response = await fetch("/api/admin/modules")
        if (!response.ok) {
          const errorData = await response.json()
          throw new Error(errorData.error || "Failed to load modules")
        }

const data = await response.json()
        setModules(data.modules || [])
      } catch (error) {
        toast({
          title: "Error loading modules",
          description: error.message,
          variant: "destructive",
        })
      } finally {
        setLoading(false)
      }
    }

loadModules()
  }, [toast])

const handleToggleModule = async (moduleId, enabled) => {
    setSaving(true)

try {
      const response = await fetch("/api/admin/modules", {
        method: "PUT",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          id: moduleId,
          enabled,
        }),
      })

if (!response.ok) {
        const errorData = await response.json()
        throw new Error(errorData.error || "Failed to update module")
      }

// Update local state
      setModules(modules.map((module) => (module.id === moduleId ? { ...module, enabled } : module)))

toast({
        title: "Module updated",
        description: `Module has been ${enabled ? "enabled" : "disabled"}.`,
      })
    } catch (error) {
      toast({
        title: "Error updating module",
        description: error.message,
        variant: "destructive",
      })
    } finally {
      setSaving(false)
    }
  }

const handleSaveSettings = async (moduleId, settings) => {
    setSaving(true)

try {
      const response = await fetch("/api/admin/modules", {
        method: "PUT",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          id: moduleId,
          settings,
        }),
      })

if (!response.ok) {
        const errorData = await response.json()
        throw new Error(errorData.error || "Failed to update module settings")
      }

// Update local state
      setModules(modules.map((module) => (module.id === moduleId ? { ...module, settings } : module)))

toast({
        title: "Settings saved",
        description: "Module settings have been updated.",
      })

setSelectedModule(null)
    } catch (error) {
      toast({
        title: "Error saving settings",
        description: error.message,
        variant: "destructive",
      })
    } finally {
      setSaving(false)
    }
  }

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Bot Modules</h1>
        <p className="text-muted-foreground">Enable, disable, and configure bot modules</p>
      </div>

<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
        {modules.map((module) => (
          <Card key={module.id} className={!module.enabled ? "opacity-75" : ""}>
            <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
              <CardTitle className="text-xl font-bold">{module.display_name}</CardTitle>
              <Badge variant={module.enabled ? "default" : "secondary"}>
                {module.enabled ? "Enabled" : "Disabled"}
              </Badge>
            </CardHeader>
            <CardContent>
              <p className="text-sm text-muted-foreground">{module.description}</p>
            </CardContent>
            <CardFooter className="flex justify-between">
              <Dialog>
                <DialogTrigger asChild>
                  <Button variant="outline" size="sm" onClick={() => setSelectedModule(module)}>
                    <Settings className="mr-2 h-4 w-4" />
                    Settings
                  </Button>
                </DialogTrigger>
                {selectedModule && selectedModule.id === module.id && (
                  <DialogContent className="sm:max-w-[425px]">
                    <DialogHeader>
                      <DialogTitle>{module.display_name} Settings</DialogTitle>
                      <DialogDescription>Configure settings for the {module.display_name} module.</DialogDescription>
                    </DialogHeader>
                    <div className="py-4">
                      <ModuleSettings
                        module={selectedModule}
                        onSave={(settings) => handleSaveSettings(module.id, settings)}
                        saving={saving}
                      />
                    </div>
                  </DialogContent>
                )}
              </Dialog>
              <div className="flex items-center space-x-2">
                <Switch
                  checked={module.enabled}
                  onCheckedChange={(checked) => handleToggleModule(module.id, checked)}
                  disabled={saving}
                />
                <span className="text-sm font-medium">{module.enabled ? "Enabled" : "Disabled"}</span>
              </div>
            </CardFooter>
          </Card>
        ))}
      </div>
    </div>
  )
}

function ModuleSettings({ module, onSave, saving }) {
  const [settings, setSettings] = useState(module.settings || {})

// Handle different module types with their specific settings
  const renderSettings = () => {
    switch (module.name) {
      case "economy":
        return (
          <div className="space-y-4">
            <div className="grid grid-cols-2 gap-4">
              <div className="space-y-2">
                <Label htmlFor="daily_reward">Daily Reward</Label>
                <Input
                  id="daily_reward"
                  type="number"
                  value={settings.daily_reward || 200}
                  onChange={(e) => setSettings({ ...settings, daily_reward: Number.parseInt(e.target.value) })}
                />
              </div>
              <div className="space-y-2">
                <Label htmlFor="starting_balance">Starting Balance</Label>
                <Input
                  id="starting_balance"
                  type="number"
                  value={settings.starting_balance || 1000}
                  onChange={(e) => setSettings({ ...settings, starting_balance: Number.parseInt(e.target.value) })}
                />
              </div>
            </div>
          </div>
        )

case "moderation":
        return (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="log_channel">Log Channel ID</Label>
              <Input
                id="log_channel"
                type="text"
                value={settings.log_channel || ""}
                onChange={(e) => setSettings({ ...settings, log_channel: e.target.value })}
                placeholder="Channel ID for logs"
              />
            </div>
            <div className="flex items-center space-x-2">
              <Switch
                id="auto_mod"
                checked={settings.auto_mod || false}
                onCheckedChange={(checked) => setSettings({ ...settings, auto_mod: checked })}
              />
              <Label htmlFor="auto_mod">Enable Auto-Moderation</Label>
            </div>
          </div>
        )

case "giveaways":
        return (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="default_duration">Default Duration (minutes)</Label>
              <Input
                id="default_duration"
                type="number"
                value={settings.default_duration || 60}
                onChange={(e) => setSettings({ ...settings, default_duration: Number.parseInt(e.target.value) })}
              />
            </div>
          </div>
        )

case "leveling":
        return (
          <div className="space-y-4">
            <div className="grid grid-cols-2 gap-4">
              <div className="space-y-2">
                <Label htmlFor="xp_per_message">XP Per Message</Label>
                <Input
                  id="xp_per_message"
                  type="number"
                  value={settings.xp_per_message || 5}
                  onChange={(e) => setSettings({ ...settings, xp_per_message: Number.parseInt(e.target.value) })}
                />
              </div>
              <div className="space-y-2">
                <Label htmlFor="level_multiplier">Level Multiplier</Label>
                <Input
                  id="level_multiplier"
                  type="number"
                  value={settings.level_multiplier || 100}
                  onChange={(e) => setSettings({ ...settings, level_multiplier: Number.parseInt(e.target.value) })}
                />
              </div>
            </div>
          </div>
        )

case "welcome":
        return (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="welcome_channel">Welcome Channel ID</Label>
              <Input
                id="welcome_channel"
                type="text"
                value={settings.welcome_channel || ""}
                onChange={(e) => setSettings({ ...settings, welcome_channel: e.target.value })}
                placeholder="Channel ID for welcome messages"
              />
            </div>
            <div className="space-y-2">
              <Label htmlFor="welcome_message">Welcome Message</Label>
              <Textarea
                id="welcome_message"
                value={settings.welcome_message || "Welcome {user} to {server}!"}
                onChange={(e) => setSettings({ ...settings, welcome_message: e.target.value })}
                placeholder="Welcome message template"
                rows={3}
              />
              <p className="text-xs text-muted-foreground">
                Use {user} for username and {server} for server name
              </p>
            </div>
          </div>
        )

case "tickets":
        return (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="ticket_category">Ticket Category ID</Label>
              <Input
                id="ticket_category"
                type="text"
                value={settings.ticket_category || ""}
                onChange={(e) => setSettings({ ...settings, ticket_category: e.target.value })}
                placeholder="Category ID for tickets"
              />
            </div>
            <div className="space-y-2">
              <Label htmlFor="support_role">Support Role ID</Label>
              <Input
                id="support_role"
                type="text"
                value={settings.support_role || ""}
                onChange={(e) => setSettings({ ...settings, support_role: e.target.value })}
                placeholder="Role ID for support staff"
              />
            </div>
          </div>
        )

default:
        return <div className="py-4 text-center text-muted-foreground">No configurable settings for this module.</div>
    }
  }

return (
    <div className="space-y-4">
      {renderSettings()}
      <DialogFooter>
        <Button onClick={() => onSave(settings)} disabled={saving}>
          {saving ? "Saving..." : "Save Changes"}
        </Button>
      </DialogFooter>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/admin/logs/page.tsx" isFixed="true" isEdit="true" isQuickEdit="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, ChevronLeft, ChevronRight, Download } from "lucide-react"
import { Badge } from "@/components/ui/badge"
import { format } from "date-fns"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"

export default function AdminLogsPage() {
  const [loading, setLoading] = useState(true)
  const [logs, setLogs] = useState([])
  const [pagination, setPagination] = useState({
    total: 0,
    page: 0,
    limit: 20,
    pages: 0,
  })
  const [filter, setFilter] = useState({
    command: "",
  })
  const [commands, setCommands] = useState([])

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    loadLogs()
    loadCommands()
  }, [pagination.page, filter.command])

const loadLogs = async () => {
    setLoading(true)

try {
      // Build query parameters
      const params = new URLSearchParams({
        page: pagination.page.toString(),
        limit: pagination.limit.toString(),
      })

if (filter.command && filter.command !== "all") {
        params.append("command", filter.command)
      }

const response = await fetch(`/api/admin/logs?${params.toString()}`)
      if (!response.ok) {
        const errorData = await response.json()
        throw new Error(errorData.error || "Failed to load logs")
      }

const data = await response.json()
      setLogs(data.logs || [])
      setPagination(data.pagination)
    } catch (error) {
      toast({
        title: "Error loading logs",
        description: error.message,
        variant: "destructive",
      })
    } finally {
      setLoading(false)
    }
  }

const loadCommands = async () => {
    try {
      const { data: commandsData, error } = await supabase.from("admin_logs").select("command").order("command")

if (error) throw error

if (commandsData) {
        const uniqueCommands = [...new Set(commandsData.map((log) => log.command))]
        setCommands(uniqueCommands)
      }
    } catch (error) {
      console.error("Error loading commands:", error)
    }
  }

const handlePageChange = (newPage) => {
    if (newPage >= 0 && newPage < pagination.pages) {
      setPagination({ ...pagination, page: newPage })
    }
  }

const handleExportLogs = () => {
    try {
      // Convert logs to CSV
      const headers = ["Timestamp", "User", "Command", "Options", "Guild ID", "Channel ID"]
      const csvContent = [
        headers.join(","),
        ...logs.map((log) =>
          [
            format(new Date(log.timestamp), "yyyy-MM-dd HH:mm:ss"),
            `${log.username} (${log.user_id})`,
            log.command,
            JSON.stringify(log.options || {}).replace(/,/g, ";"),
            log.guild_id,
            log.channel_id,
          ].join(","),
        ),
      ].join("\n")

// Create download link
      const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" })
      const url = URL.createObjectURL(blob)
      const link = document.createElement("a")
      link.setAttribute("href", url)
      link.setAttribute("download", `admin-logs-${format(new Date(), "yyyy-MM-dd")}.csv`)
      document.body.appendChild(link)
      link.click()
      document.body.removeChild(link)
    } catch (error) {
      toast({
        title: "Error exporting logs",
        description: "Failed to export logs to CSV",
        variant: "destructive",
      })
    }
  }

return (
    <div className="space-y-6">
      <div className="flex justify-between items-center">
        <div>
          <h1 className="text-3xl font-bold tracking-tight">Admin Logs</h1>
          <p className="text-muted-foreground">View admin command usage logs</p>
        </div>
        <Button variant="outline" onClick={handleExportLogs} disabled={logs.length === 0}>
          <Download className="mr-2 h-4 w-4" />
          Export Logs
        </Button>
      </div>

<Card>
        <CardHeader>
          <CardTitle>Filter Logs</CardTitle>
          <CardDescription>Filter logs by command</CardDescription>
        </CardHeader>
        <CardContent>
          <div className="flex gap-4">
            <div className="w-64">
              <Select value={filter.command} onValueChange={(value) => setFilter({ ...filter, command: value })}>
                <SelectTrigger>
                  <SelectValue placeholder="All Commands" />
                </SelectTrigger>
                <SelectContent>
                  <SelectItem value="all">All Commands</SelectItem>
                  {commands.map((command) => (
                    <SelectItem key={command} value={command}>
                      {command}
                    </SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>
            <Button variant="secondary" onClick={() => setFilter({ command: "" })}>
              Clear Filters
            </Button>
          </div>
        </CardContent>
      </Card>

<Card>
        <CardHeader>
          <CardTitle>Admin Command Logs</CardTitle>
          <CardDescription>
            Showing {logs.length} of {pagination.total} logs
          </CardDescription>
        </CardHeader>
        <CardContent>
          {loading ? (
            <div className="flex justify-center py-8">
              <Loader2 className="h-8 w-8 animate-spin text-primary" />
            </div>
          ) : logs.length === 0 ? (
            <div className="text-center py-8 text-muted-foreground">No logs found.</div>
          ) : (
            <div className="space-y-4">
              <div className="rounded-md border">
                <Table>
                  <TableHeader>
                    <TableRow>
                      <TableHead>Timestamp</TableHead>
                      <TableHead>User</TableHead>
                      <TableHead>Command</TableHead>
                      <TableHead>Options</TableHead>
                      <TableHead>Guild</TableHead>
                    </TableRow>
                  </TableHeader>
                  <TableBody>
                    {logs.map((log) => (
                      <TableRow key={log.id}>
                        <TableCell>{format(new Date(log.timestamp), "yyyy-MM-dd HH:mm:ss")}</TableCell>
                        <TableCell>{log.username}</TableCell>
                        <TableCell>
                          <Badge variant="outline">{log.command}</Badge>
                        </TableCell>
                        <TableCell>
                          <pre className="text-xs overflow-x-auto max-w-xs">
                            {JSON.stringify(log.options || {}, null, 2)}
                          </pre>
                        </TableCell>
                        <TableCell>{log.guild_id}</TableCell>
                      </TableRow>
                    ))}
                  </TableBody>
                </Table>
              </div>

<div className="flex items-center justify-between">
                <div className="text-sm text-muted-foreground">
                  Page {pagination.page + 1} of {pagination.pages || 1}
                </div>
                <div className="flex items-center space-x-2">
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={() => handlePageChange(pagination.page - 1)}
                    disabled={pagination.page === 0}
                  >
                    <ChevronLeft className="h-4 w-4 mr-2" />
                    Previous
                  </Button>
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={() => handlePageChange(pagination.page + 1)}
                    disabled={pagination.page === pagination.pages - 1 || pagination.pages === 0}
                  >
                    Next
                    <ChevronRight className="h-4 w-4 ml-2" />
                  </Button>
                </div>
              </div>
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/dashboard/admin/page.tsx" isEdit="true"
"use client"

import { useState, useEffect } from "react"
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { useToast } from "@/hooks/use-toast"
import { Loader2, Activity, Users, Server, MessageSquare, ShieldAlert, Settings } from "lucide-react"
import Link from "next/link"
import { Button } from "@/components/ui/button"

export default function AdminDashboardPage() {
  const [loading, setLoading] = useState(true)
  const [stats, setStats] = useState({
    totalUsers: 0,
    totalCommands: 0,
    totalGuilds: 0,
    activeModules: 0,
    recentLogs: [],
  })

const { toast } = useToast()
  const supabase = createClientComponentClient()

useEffect(() => {
    async function loadStats() {
      try {
        // Get user count
        const { count: userCount, error: userError } = await supabase
          .from("users")
          .select("*", { count: "exact", head: true })

if (userError) throw userError

// Get command count
        const { count: commandCount, error: commandError } = await supabase
          .from("admin_logs")
          .select("*", { count: "exact", head: true })

if (commandError) throw commandError

// Get active modules count
        const { data: modules, error: modulesError } = await supabase
          .from("bot_modules")
          .select("*")
          .eq("enabled", true)

if (modulesError) throw modulesError

// Get recent logs
        const { data: recentLogs, error: logsError } = await supabase
          .from("admin_logs")
          .select("*")
          .order("timestamp", { ascending: false })
          .limit(5)

if (logsError) throw logsError

// Get guild count (this would normally come from Discord bot)
        // For now, we'll use a placeholder
        const guildCount = 1

setStats({
          totalUsers: userCount || 0,
          totalCommands: commandCount || 0,
          totalGuilds: guildCount,
          activeModules: modules?.length || 0,
          recentLogs: recentLogs || [],
        })
      } catch (error) {
        console.error("Error loading stats:", error)
        toast({
          title: "Error loading stats",
          description: "Failed to load dashboard statistics",
          variant: "destructive",
        })
      } finally {
        setLoading(false)
      }
    }

loadStats()
  }, [supabase, toast])

if (loading) {
    return (
      <div className="flex justify-center items-center h-[calc(100vh-200px)]">
        <Loader2 className="h-8 w-8 animate-spin text-primary" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Admin Dashboard</h1>
        <p className="text-muted-foreground">Overview of your Discord bot</p>
      </div>

<div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
        <Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Total Users</CardTitle>
            <Users className="h-4 w-4 text-muted-foreground" />
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.totalUsers}</div>
          </CardContent>
        </Card>

<Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Active Modules</CardTitle>
            <Settings className="h-4 w-4 text-muted-foreground" />
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.activeModules}</div>
          </CardContent>
        </Card>

<Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Admin Commands</CardTitle>
            <MessageSquare className="h-4 w-4 text-muted-foreground" />
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.totalCommands}</div>
          </CardContent>
        </Card>

<Card>
          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
            <CardTitle className="text-sm font-medium">Discord Servers</CardTitle>
            <Server className="h-4 w-4 text-muted-foreground" />
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">{stats.totalGuilds}</div>
          </CardContent>
        </Card>
      </div>

<div className="grid gap-4 md:grid-cols-2">
        <Card className="col-span-1">
          <CardHeader>
            <CardTitle>Recent Admin Activity</CardTitle>
            <CardDescription>Latest admin commands executed</CardDescription>
          </CardHeader>
          <CardContent>
            {stats.recentLogs.length === 0 ? (
              <div className="text-center py-4 text-muted-foreground">No recent activity.</div>
            ) : (
              <div className="space-y-4">
                {stats.recentLogs.map((log) => (
                  <div key={log.id} className="flex items-center">
                    <div className="mr-4">
                      <ShieldAlert className="h-8 w-8 text-primary" />
                    </div>
                    <div className="space-y-1">
                      <p className="text-sm font-medium">{log.username}</p>
                      <p className="text-xs text-muted-foreground">
                        Used /{log.command} at {new Date(log.timestamp).toLocaleString()}
                      </p>
                    </div>
                  </div>
                ))}
              </div>
            )}
          </CardContent>
        </Card>

<Card className="col-span-1">
          <CardHeader>
            <CardTitle>Quick Actions</CardTitle>
            <CardDescription>Common admin tasks</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="grid grid-cols-2 gap-4">
              <Link href="/dashboard/admin/modules">
                <Button variant="outline" className="w-full justify-start">
                  <Settings className="mr-2 h-4 w-4" />
                  Manage Modules
                </Button>
              </Link>

<Link href="/dashboard/users">
                <Button variant="outline" className="w-full justify-start">
                  <Users className="mr-2 h-4 w-4" />
                  Manage Users
                </Button>
              </Link>

<Link href="/dashboard/bot-settings/general">
                <Button variant="outline" className="w-full justify-start">
                  <Server className="mr-2 h-4 w-4" />
                  Bot Settings
                </Button>
              </Link>
            </div>
          </CardContent>
        </Card>
      </div>
    </div>
  )
}
[V0_FILE]javascript:file="bot/commands/admin/module.js" isEdit="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")
const { handleAdminCommand } = require("../../admin-command-handler")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("module")
    .setDescription("Manage bot modules")
    .addSubcommand((subcommand) => subcommand.setName("list").setDescription("List all bot modules"))
    .addSubcommand((subcommand) =>
      subcommand
        .setName("enable")
        .setDescription("Enable a module")
        .addStringOption((option) =>
          option
            .setName("name")
            .setDescription("The name of the module to enable")
            .setRequired(true)
            .setAutocomplete(true),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("disable")
        .setDescription("Disable a module")
        .addStringOption((option) =>
          option
            .setName("name")
            .setDescription("The name of the module to disable")
            .setRequired(true)
            .setAutocomplete(true),
        ),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async autocomplete(interaction, supabase) {
    try {
      const focusedValue = interaction.options.getFocused()

// Get all modules
      const { data: modules, error } = await supabase.from("bot_modules").select("name, display_name")

if (error) {
        console.error("Error fetching modules for autocomplete:", error)
        return interaction.respond([{ name: "Error fetching modules", value: "error" }])
      }

const filtered = modules.filter(
        (module) =>
          module.name.includes(focusedValue.toLowerCase()) ||
          module.display_name.toLowerCase().includes(focusedValue.toLowerCase()),
      )

await interaction.respond(
        filtered.map((module) => ({ name: module.display_name, value: module.name })).slice(0, 25),
      )
    } catch (error) {
      console.error("Error in module autocomplete:", error)
      await interaction.respond([{ name: "Error", value: "error" }])
    }
  },

async execute(interaction, supabase) {
    try {
      // Check admin permissions
      const hasPermission = await handleAdminCommand(interaction, supabase)
      if (hasPermission !== true) return

const subcommand = interaction.options.getSubcommand()

if (subcommand === "list") {
        // Get all modules
        const { data: modules, error } = await supabase.from("bot_modules").select("*").order("display_name")

if (error) {
          console.error("Error fetching modules:", error)
          return interaction.reply({
            content: "Failed to retrieve modules. Please try again later.",
            ephemeral: true,
          })
        }

// Create embed
        const embed = new EmbedBuilder()
          .setColor(0x0099ff)
          .setTitle("Bot Modules")
          .setDescription("List of all bot modules and their status")
          .setTimestamp()

// Add fields for each module
        modules.forEach((module) => {
          embed.addFields({
            name: `${module.display_name} ${module.enabled ? "✅" : "❌"}`,
            value: module.description || "No description available",
          })
        })

return interaction.reply({ embeds: [embed] })
      } else if (subcommand === "enable" || subcommand === "disable") {
        const moduleName = interaction.options.getString("name")
        const enabled = subcommand === "enable"

// Get module
        const { data: module, error } = await supabase.from("bot_modules").select("*").eq("name", moduleName).single()

if (error) {
          console.error("Error fetching module:", error)
          return interaction.reply({
            content: `Module "${moduleName}" not found.`,
            ephemeral: true,
          })
        }

// Check if module is already in the desired state
        if (module.enabled === enabled) {
          return interaction.reply({
            content: `Module "${module.display_name}" is already ${enabled ? "enabled" : "disabled"}.`,
            ephemeral: true,
          })
        }

// Update module
        const { error: updateError } = await supabase
          .from("bot_modules")
          .update({
            enabled,
            updated_at: new Date().toISOString(),
            updated_by: interaction.user.tag,
          })
          .eq("name", moduleName)

if (updateError) {
          console.error("Error updating module:", updateError)
          return interaction.reply({
            content: `Failed to ${enabled ? "enable" : "disable"} module. Please try again later.`,
            ephemeral: true,
          })
        }

return interaction.reply({
          content: `Module "${module.display_name}" has been ${enabled ? "enabled" : "disabled"}.`,
          ephemeral: true,
        })
      }
    } catch (error) {
      console.error("Error in module command:", error)
      return interaction.reply({
        content: "An error occurred while processing the command. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]javascript:file="bot/commands/admin/settings.js" isEdit="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")
const { handleAdminCommand } = require("../../admin-command-handler")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("settings")
    .setDescription("Manage bot settings")
    .addSubcommand((subcommand) =>
      subcommand
        .setName("get")
        .setDescription("Get a setting value")
        .addStringOption((option) =>
          option.setName("key").setDescription("The setting key").setRequired(true).setAutocomplete(true),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("set")
        .setDescription("Set a setting value")
        .addStringOption((option) =>
          option.setName("key").setDescription("The setting key").setRequired(true).setAutocomplete(true),
        )
        .addStringOption((option) =>
          option.setName("value").setDescription("The setting value (JSON format)").setRequired(true),
        ),
    )
    .addSubcommand((subcommand) => subcommand.setName("list").setDescription("List all settings"))
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async autocomplete(interaction, supabase) {
    try {
      const focusedValue = interaction.options.getFocused()

// Get all settings
      const { data: settings, error } = await supabase.from("settings").select("key")

if (error) {
        console.error("Error fetching settings for autocomplete:", error)
        return interaction.respond([{ name: "Error fetching settings", value: "error" }])
      }

const filtered = settings.filter((setting) => setting.key.includes(focusedValue.toLowerCase()))

await interaction.respond(filtered.map((setting) => ({ name: setting.key, value: setting.key })).slice(0, 25))
    } catch (error) {
      console.error("Error in settings autocomplete:", error)
      await interaction.respond([{ name: "Error", value: "error" }])
    }
  },

async execute(interaction, supabase) {
    try {
      // Check admin permissions
      const hasPermission = await handleAdminCommand(interaction, supabase)
      if (hasPermission !== true) return

const subcommand = interaction.options.getSubcommand()

if (subcommand === "get") {
        const key = interaction.options.getString("key")

// Get setting
        const { data: setting, error } = await supabase.from("settings").select("*").eq("key", key).single()

if (error && error.code !== "PGRST116") {
          console.error("Error fetching setting:", error)
          return interaction.reply({
            content: `Setting "${key}" not found.`,
            ephemeral: true,
          })
        }

if (!setting) {
          return interaction.reply({
            content: `Setting "${key}" not found.`,
            ephemeral: true,
          })
        }

// Create embed
        const embed = new EmbedBuilder()
          .setColor(0x0099ff)
          .setTitle(`Setting: ${key}`)
          .setDescription("Current value:")
          .addFields({
            name: "Value",
            value: "```json\n" + JSON.stringify(setting.value, null, 2) + "\n```",
          })
          .setTimestamp()

return interaction.reply({ embeds: [embed] })
      } else if (subcommand === "set") {
        const key = interaction.options.getString("key")
        const valueString = interaction.options.getString("value")

// Parse JSON value
        let value
        try {
          value = JSON.parse(valueString)
        } catch (e) {
          return interaction.reply({
            content: "Invalid JSON format. Please provide a valid JSON value.",
            ephemeral: true,
          })
        }

// Update setting
        const { error } = await supabase.from("settings").upsert(
          {
            key,
            value,
            updated_at: new Date().toISOString(),
          },
          { onConflict: "key" },
        )

if (error) {
          console.error("Error updating setting:", error)
          return interaction.reply({
            content: `Failed to update setting. Please try again later.`,
            ephemeral: true,
          })
        }

return interaction.reply({
          content: `Setting "${key}" has been updated.`,
          ephemeral: true,
        })
      } else if (subcommand === "list") {
        // Get all settings
        const { data: settings, error } = await supabase.from("settings").select("*").order("key")

if (error) {
          console.error("Error fetching settings:", error)
          return interaction.reply({
            content: "Failed to retrieve settings. Please try again later.",
            ephemeral: true,
          })
        }

// Create embed
        const embed = new EmbedBuilder()
          .setColor(0x0099ff)
          .setTitle("Bot Settings")
          .setDescription("List of all bot settings")
          .setTimestamp()

// Add fields for each setting (limit to first 25 due to Discord embed limits)
        settings.slice(0, 25).forEach((setting) => {
          embed.addFields({
            name: setting.key,
            value:
              typeof setting.value === "object"
                ? JSON.stringify(setting.value).substring(0, 100) +
                  (JSON.stringify(setting.value).length > 100 ? "..." : "")
                : String(setting.value).substring(0, 100) + (String(setting.value).length > 100 ? "..." : ""),
          })
        })

if (settings.length > 25) {
          embed.setFooter({ text: `Showing 25 of ${settings.length} settings` })
        }

return interaction.reply({ embeds: [embed] })
      }
    } catch (error) {
      console.error("Error in settings command:", error)
      return interaction.reply({
        content: "An error occurred while processing the command. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]javascript:file="bot/commands/admin/reload.js" isEdit="true"
const { SlashCommandBuilder, PermissionFlagsBits } = require("discord.js")
const { handleAdminCommand } = require("../../admin-command-handler")
const fs = require("fs")
const path = require("path")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("reload")
    .setDescription("Reload a command")
    .addStringOption((option) =>
      option.setName("command").setDescription("The command to reload").setRequired(true).setAutocomplete(true),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async autocomplete(interaction, supabase) {
    try {
      const focusedValue = interaction.options.getFocused()
      const commands = interaction.client.commands.map((cmd) => cmd.data.name)

const filtered = commands.filter((command) => command.startsWith(focusedValue.toLowerCase()))

await interaction.respond(filtered.map((command) => ({ name: command, value: command })).slice(0, 25))
    } catch (error) {
      console.error("Error in reload autocomplete:", error)
      await interaction.respond([{ name: "Error", value: "error" }])
    }
  },

async execute(interaction, supabase) {
    try {
      // Check admin permissions
      const hasPermission = await handleAdminCommand(interaction, supabase)
      if (hasPermission !== true) return

const commandName = interaction.options.getString("command", true).toLowerCase()
      const command = interaction.client.commands.get(commandName)

if (!command) {
        return interaction.reply({
          content: `There is no command with name \`${commandName}\`!`,
          ephemeral: true,
        })
      }

// Find command file
      let commandPath
      const commandsPath = path.join(__dirname, "..")
      const commandFolders = fs.readdirSync(commandsPath)

for (const folder of commandFolders) {
        const folderPath = path.join(commandsPath, folder)
        if (fs.statSync(folderPath).isDirectory()) {
          const commandFiles = fs.readdirSync(folderPath).filter((file) => file.endsWith(".js"))
          for (const file of commandFiles) {
            if (file === `${commandName}.js` || file.startsWith(`${commandName}.`)) {
              commandPath = path.join(folderPath, file)
              break
            }
          }
        } else if (folder === `${commandName}.js` || folder.startsWith(`${commandName}.`)) {
          commandPath = path.join(commandsPath, folder)
        }

if (commandPath) break
      }

if (!commandPath) {
        return interaction.reply({
          content: `Could not find file for command \`${commandName}\`!`,
          ephemeral: true,
        })
      }

// Delete command from cache and reload
      delete require.cache[require.resolve(commandPath)]

try {
        const newCommand = require(commandPath)
        interaction.client.commands.set(newCommand.data.name, newCommand)
        await interaction.reply({
          content: `Command \`${newCommand.data.name}\` was reloaded!`,
          ephemeral: true,
        })
      } catch (error) {
        console.error("Error reloading command:", error)
        await interaction.reply({
          content: `There was an error while reloading a command \`${commandName}\`:\n\`${error.message}\``,
          ephemeral: true,
        })
      }
    } catch (error) {
      console.error("Error in reload command:", error)
      return interaction.reply({
        content: "An error occurred while processing the command. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]javascript:file="bot/commands/admin/status.js" isEdit="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")
const { handleAdminCommand } = require("../../admin-command-handler")
const os = require("os")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("status")
    .setDescription("View bot status and statistics")
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async execute(interaction, supabase) {
    try {
      // Check admin permissions
      const hasPermission = await handleAdminCommand(interaction, supabase)
      if (hasPermission !== true) return

// Calculate uptime
      const uptime = process.uptime()
      const days = Math.floor(uptime / 86400)
      const hours = Math.floor((uptime % 86400) / 3600)
      const minutes = Math.floor((uptime % 3600) / 60)
      const seconds = Math.floor(uptime % 60)
      const uptimeString = `${days}d ${hours}h ${minutes}m ${seconds}s`

// Get memory usage
      const memoryUsage = process.memoryUsage()
      const memoryUsedMB = Math.round(memoryUsage.rss / 1024 / 1024)
      const memoryTotalMB = Math.round(os.totalmem() / 1024 / 1024)
      const memoryPercentage = ((memoryUsage.rss / os.totalmem()) * 100).toFixed(2)

// Get database stats
      const { count: userCount, error: userError } = await supabase
        .from("users")
        .select("*", { count: "exact", head: true })

if (userError) throw userError

const { count: itemCount, error: itemError } = await supabase
        .from("items")
        .select("*", { count: "exact", head: true })

if (itemError) throw itemError

const { count: transactionCount, error: transactionError } = await supabase
        .from("transactions")
        .select("*", { count: "exact", head: true })

if (transactionError) throw transactionError

const { data: modules, error: modulesError } = await supabase.from("bot_modules").select("*").eq("enabled", true)

if (modulesError) throw modulesError

const { count: totalModules, error: totalModulesError } = await supabase
        .from("bot_modules")
        .select("*", { count: "exact", head: true })

if (totalModulesError) throw totalModulesError

// Create embed
      const embed = new EmbedBuilder()
        .setColor(0x00ff00)
        .setTitle("Bot Status")
        .setDescription("Current status and statistics")
        .addFields(
          { name: "Uptime", value: uptimeString, inline: true },
          { name: "Memory", value: `${memoryUsedMB}MB / ${memoryTotalMB}MB (${memoryPercentage}%)`, inline: true },
          { name: "Node.js", value: process.version, inline: true },
          { name: "Discord.js", value: require("discord.js").version, inline: true },
          { name: "Platform", value: `${os.type()} ${os.release()}`, inline: true },
          { name: "CPU", value: `${os.cpus()[0].model}`, inline: true },
          { name: "Users", value: `${userCount || 0}`, inline: true },
          { name: "Items", value: `${itemCount || 0}`, inline: true },
          { name: "Transactions", value: `${transactionCount || 0}`, inline: true },
          {
            name: "Active Modules",
            value: `${modules?.length || 0}/${totalModules || 0}`,
            inline: true,
          },
          { name: "Servers", value: `${interaction.client.guilds.cache.size}`, inline: true },
          { name: "Channels", value: `${interaction.client.channels.cache.size}`, inline: true },
        )
        .setTimestamp()

return interaction.reply({ embeds: [embed] })
    } catch (error) {
      console.error("Error in status command:", error)
      return interaction.reply({
        content: "An error occurred while processing the command. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]javascript:file="bot/commands/admin/permissions.js" isEdit="true"
const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require("discord.js")
const { handleAdminCommand } = require("../../admin-command-handler")

module.exports = {
  data: new SlashCommandBuilder()
    .setName("permissions")
    .setDescription("Manage bot permissions")
    .addSubcommand((subcommand) =>
      subcommand
        .setName("addrole")
        .setDescription("Add an admin or mod role")
        .addRoleOption((option) => option.setName("role").setDescription("The role to add").setRequired(true))
        .addStringOption((option) =>
          option
            .setName("type")
            .setDescription("The type of role")
            .setRequired(true)
            .addChoices({ name: "Admin", value: "admin" }, { name: "Moderator", value: "mod" }),
        ),
    )
    .addSubcommand((subcommand) =>
      subcommand
        .setName("removerole")
        .setDescription("Remove an admin or mod role")
        .addRoleOption((option) => option.setName("role").setDescription("The role to remove").setRequired(true))
        .addStringOption((option) =>
          option
            .setName("type")
            .setDescription("The type of role")
            .setRequired(true)
            .addChoices({ name: "Admin", value: "admin" }, { name: "Moderator", value: "mod" }),
        ),
    )
    .addSubcommand((subcommand) => subcommand.setName("list").setDescription("List all permission roles"))
    .addSubcommand((subcommand) =>
      subcommand
        .setName("blacklist")
        .setDescription("Add or remove a user from the blacklist")
        .addUserOption((option) =>
          option.setName("user").setDescription("The user to blacklist/unblacklist").setRequired(true),
        )
        .addBooleanOption((option) =>
          option
            .setName("blacklisted")
            .setDescription("Whether to blacklist or unblacklist the user")
            .setRequired(true),
        ),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),

async execute(interaction, supabase) {
    try {
      // Check admin permissions
      const hasPermission = await handleAdminCommand(interaction, supabase)
      if (hasPermission !== true) return

const subcommand = interaction.options.getSubcommand()

// Get current permissions
      const { data: permissionsData, error: permissionsError } = await supabase
        .from("settings")
        .select("value")
        .eq("key", "permissions")
        .single()

// Initialize permissions if they don't exist
      const permissions = permissionsData?.value || {
        admin_roles: [],
        mod_roles: [],
        blacklisted_users: [],
        blacklisted_channels: [],
        command_permissions: {},
      }

if (subcommand === "addrole") {
        const role = interaction.options.getRole("role")
        const type = interaction.options.getString("type")

// Check if role already exists
        const roleList = type === "admin" ? permissions.admin_roles : permissions.mod_roles
        if (roleList.includes(role.id)) {
          return interaction.reply({
            content: `Role ${role.name} is already ${type === "admin" ? "an admin" : "a mod"} role.`,
            ephemeral: true,
          })
        }

// Add role
        if (type === "admin") {
          permissions.admin_roles.push(role.id)
        } else {
          permissions.mod_roles.push(role.id)
        }

// Update permissions
        const { error } = await supabase.from("settings").upsert(
          {
            key: "permissions",
            value: permissions,
            updated_at: new Date().toISOString(),
          },
          { onConflict: "key" },
        )

if (error) {
          console.error("Error updating permissions:", error)
          return interaction.reply({
            content: `Failed to update permissions. Please try again later.`,
            ephemeral: true,
          })
        }

return interaction.reply({
          content: `Role ${role.name} has been added as ${type === "admin" ? "an admin" : "a mod"} role.`,
          ephemeral: true,
        })
      } else if (subcommand === "removerole") {
        const role = interaction.options.getRole("role")
        const type = interaction.options.getString("type")

// Check if role exists
        const roleList = type === "admin" ? permissions.admin_roles : permissions.mod_roles
        if (!roleList.includes(role.id)) {
          return interaction.reply({
            content: `Role ${role.name} is not ${type === "admin" ? "an admin" : "a mod"} role.`,
            ephemeral: true,
          })
        }

// Remove role
        if (type === "admin") {
          permissions.admin_roles = permissions.admin_roles.filter((id) => id !== role.id)
        } else {
          permissions.mod_roles = permissions.mod_roles.filter((id) => id !== role.id)
        }

return interaction.reply({
          content: `Role ${role.name} has been removed as ${type === "admin" ? "an admin" : "a mod"} role.`,
          ephemeral: true,
        })
      } else if (subcommand === "list") {
        // Create embed
        const embed = new EmbedBuilder()
          .setColor(0x0099ff)
          .setTitle("Bot Permissions")
          .setDescription("List of all permission roles")
          .setTimestamp()

// Add admin roles
        let adminRolesText = "None"
        if (permissions.admin_roles && permissions.admin_roles.length > 0) {
          adminRolesText = permissions.admin_roles
            .map((id) => {
              const role = interaction.guild.roles.cache.get(id)
              return role ? `<@&${id}>` : `Unknown Role (${id})`
            })
            .join("\n")
        }

embed.addFields({
          name: "Admin Roles",
          value: adminRolesText,
        })

// Add mod roles
        let modRolesText = "None"
        if (permissions.mod_roles && permissions.mod_roles.length > 0) {
          modRolesText = permissions.mod_roles
            .map((id) => {
              const role = interaction.guild.roles.cache.get(id)
              return role ? `<@&${id}>` : `Unknown Role (${id})`
            })
            .join("\n")
        }

embed.addFields({
          name: "Moderator Roles",
          value: modRolesText,
        })

// Add blacklisted users
        let blacklistedUsersText = "None"
        if (permissions.blacklisted_users && permissions.blacklisted_users.length > 0) {
          blacklistedUsersText = permissions.blacklisted_users.map((id) => `<@${id}>`).join("\n")
        }

embed.addFields({
          name: "Blacklisted Users",
          value: blacklistedUsersText,
        })

return interaction.reply({ embeds: [embed] })
      } else if (subcommand === "blacklist") {
        const user = interaction.options.getUser("user")
        const blacklisted = interaction.options.getBoolean("blacklisted")

// Initialize blacklisted_users if it doesn't exist
        if (!permissions.blacklisted_users) {
          permissions.blacklisted_users = []
        }

// Check if user is already blacklisted
        const isBlacklisted = permissions.blacklisted_users.includes(user.id)

if (blacklisted && isBlacklisted) {
          return interaction.reply({
            content: `User ${user.tag} is already blacklisted.`,
            ephemeral: true,
          })
        }

if (!blacklisted && !isBlacklisted) {
          return interaction.reply({
            content: `User ${user.tag} is not blacklisted.`,
            ephemeral: true,
          })
        }

// Update blacklist
        if (blacklisted) {
          permissions.blacklisted_users.push(user.id)
        } else {
          permissions.blacklisted_users = permissions.blacklisted_users.filter((id) => id !== user.id)
        }

return interaction.reply({
          content: `User ${user.tag} has been ${blacklisted ? "blacklisted" : "unblacklisted"}.`,
          ephemeral: true,
        })
      }
    } catch (error) {
      console.error("Error in permissions command:", error)
      return interaction.reply({
        content: "An error occurred while processing the command. Please try again later.",
        ephemeral: true,
      })
    }
  },
}
[V0_FILE]typescriptreact:file="components/dashboard/sidebar.tsx" isEdit="true"
"use client"

import Link from "next/link"
import { usePathname } from "next/navigation"
import { cn } from "@/lib/utils"
import { ScrollArea } from "@/components/ui/scroll-area"
import {
  LayoutDashboard,
  ShoppingCart,
  Users,
  Settings,
  BarChart4,
  Package,
  CreditCard,
  Gift,
  Shield,
  FileText,
} from "lucide-react"

const routes = [
  {
    label: "Dashboard",
    icon: LayoutDashboard,
    href: "/dashboard",
    color: "text-sky-500",
  },
  {
    label: "Admin",
    icon: Shield,
    href: "/dashboard/admin",
    color: "text-red-500",
    subRoutes: [
      {
        label: "Overview",
        href: "/dashboard/admin",
      },
      {
        label: "Modules",
        href: "/dashboard/admin/modules",
      },
      {
        label: "Logs",
        href: "/dashboard/admin/logs",
      },
    ],
  },
  {
    label: "Shop Management",
    icon: ShoppingCart,
    href: "/dashboard/shop",
    color: "text-violet-500",
    subRoutes: [
      {
        label: "Items",
        href: "/dashboard/shop/items",
      },
      {
        label: "Categories",
        href: "/dashboard/shop/categories",
      },
    ],
  },
  {
    label: "User Management",
    icon: Users,
    href: "/dashboard/users",
    color: "text-pink-700",
    subRoutes: [
      {
        label: "All Users",
        href: "/dashboard/users",
      },
      {
        label: "Inventory",
        href: "/dashboard/users/inventory",
      },
      {
        label: "Balances",
        href: "/dashboard/users/balances",
      },
    ],
  },
  {
    label: "Economy",
    icon: CreditCard,
    href: "/dashboard/economy",
    color: "text-green-600",
    subRoutes: [
      {
        label: "Transactions",
        href: "/dashboard/economy/transactions",
      },
      {
        label: "Currency Settings",
        href: "/dashboard/economy/currency",
      },
      {
        label: "Rewards",
        href: "/dashboard/economy/rewards",
      },
    ],
  },
  {
    label: "Giveaways",
    icon: Gift,
    href: "/dashboard/giveaways",
    color: "text-yellow-500",
  },
  {
    label: "Bot Settings",
    icon: Settings,
    href: "/dashboard/bot-settings",
    color: "text-orange-500",
    subRoutes: [
      {
        label: "General",
        href: "/dashboard/bot-settings/general",
      },
      {
        label: "Commands",
        href: "/dashboard/bot-settings/commands",
      },
      {
        label: "Permissions",
        href: "/dashboard/bot-settings/permissions",
      },
    ],
  },
  {
    label: "Analytics",
    icon: BarChart4,
    href: "/dashboard/analytics",
    color: "text-blue-600",
  },
  {
    label: "Documentation",
    icon: FileText,
    href: "/dashboard/docs",
    color: "text-indigo-500",
  },
]

export default function Sidebar() {
  const pathname = usePathname()

// Function to check if a route or its subroutes are active
  const isRouteActive = (route) => {
    if (pathname === route.href) return true
    if (route.subRoutes) {
      return route.subRoutes.some((subRoute) => pathname === subRoute.href)
    }
    return false
  }

return (
    <div className="border-r bg-background h-full">
      <div className="flex h-16 items-center border-b px-6">
        <Link href="/dashboard" className="flex items-center gap-2 font-semibold">
          <Package className="h-6 w-6" />
          <span>Shop Bot Admin</span>
        </Link>
      </div>
      <ScrollArea className="h-[calc(100vh-64px)]">
        <div className="px-3 py-2">
          <div className="space-y-1">
            {routes.map((route) => (
              <div key={route.href} className="space-y-1">
                <Link
                  href={route.href}
                  className={cn(
                    "flex items-center gap-3 rounded-lg px-3 py-2 text-sm font-medium hover:bg-accent hover:text-accent-foreground",
                    isRouteActive(route) ? "bg-accent text-accent-foreground" : "transparent",
                  )}
                >
                  <route.icon className={cn("h-5 w-5", route.color)} />
                  {route.label}
                </Link>

{/* Render subroutes if they exist and the parent route is active */}
                {route.subRoutes && isRouteActive(route) && (
                  <div className="pl-8 space-y-1">
                    {route.subRoutes.map((subRoute) => (
                      <Link
                        key={subRoute.href}
                        href={subRoute.href}
                        className={cn(
                          "flex items-center rounded-lg px-3 py-1.5 text-sm font-medium hover:bg-accent hover:text-accent-foreground",
                          pathname === subRoute.href ? "bg-accent/50 text-accent-foreground" : "text-muted-foreground",
                        )}
                      >
                        {subRoute.label}
                      </Link>
                    ))}
                  </div>
                )}
              </div>
            ))}
          </div>
        </div>
      </ScrollArea>
    </div>
  )
}
[V0_FILE]typescript:file="middleware.ts" isEdit="true"
import { NextResponse } from "next/server"
import type { NextRequest } from "next/server"
import { createMiddlewareClient } from "@supabase/auth-helpers-nextjs"

export async function middleware(req: NextRequest) {
  try {
    const res = NextResponse.next()
    const supabase = createMiddlewareClient({ req, res })

// Check if the route is an admin route
    if (req.nextUrl.pathname.startsWith("/dashboard/admin")) {
      // Check if user is authenticated
      const {
        data: { session },
      } = await supabase.auth.getSession()

if (!session) {
        // Redirect to login if not authenticated
        return NextResponse.redirect(new URL("/login", req.url))
      }

// Check if user has admin permissions
      const { data: userData } = await supabase.from("users").select("role").eq("id", session.user.id).single()

// If user is not an admin, redirect to dashboard
      if (!userData || userData.role !== "admin") {
        return NextResponse.redirect(new URL("/dashboard", req.url))
      }
    }

// For all dashboard routes, check authentication
    else if (req.nextUrl.pathname.startsWith("/dashboard")) {
      const {
        data: { session },
      } = await supabase.auth.getSession()

if (!session) {
        return NextResponse.redirect(new URL("/login", req.url))
      }
    }

return res
  } catch (error) {
    console.error("Middleware error:", error)
    // In case of error, redirect to login
    return NextResponse.redirect(new URL("/login", req.url))
  }
}

// Specify which routes this middleware should run on
export const config = {
  matcher: ["/dashboard/:path*"],
}
[V0_FILE]javascript:file="bot/index.js" isFixed="true" isEdit="true" isQuickEdit="true"
require("dotenv").config()
const { Client, GatewayIntentBits, Collection, REST, Routes } = require("discord.js")
const fs = require("fs")
const path = require("path")
const { createClient } = require("@supabase/supabase-js")

// Initialize Supabase client
const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY
const supabase = createClient(supabaseUrl, supabaseKey)

// Create Discord client
const client = new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
})

// Store commands in a collection
client.commands = new Collection()
const commands = []

// Read command files
const commandsPath = path.join(__dirname, "commands")
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)
    commands.push(command.data.toJSON())
  } else {
    console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`)
  }
}

// Register commands with Discord API
const rest = new REST({ version: "10" }).setToken(process.env.DISCORD_BOT_TOKEN)
;(async () => {
  try {
    console.log(`Started refreshing ${commands.length} application (/) commands.`)

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

console.log(`Successfully reloaded ${data.length} application (/) commands.`)
  } catch (error) {
    console.error(error)
  }
})()

// Event handler for when the bot is ready
client.once("ready", () => {
  console.log(`Logged in as ${client.user.tag}!`)
})

// Event handler for interaction (slash commands)
const { handleAdminCommand } = require("./admin-command-handler")

// In your interaction create event handler, add this check for admin commands:

client.on("interactionCreate", async (interaction) => {
  if (!interaction.isChatInputCommand()) return

const command = client.commands.get(interaction.commandName)
  if (!command) return

try {
    // Check if this is an admin command (commands in the admin folder)
    if (
      command.data.name === "module" ||
      command.data.name === "settings" ||
      command.data.name === "reload" ||
      command.data.name === "status" ||
      command.data.name === "permissions"
    ) {
      await command.execute(interaction, supabase)
    } else {
      // Handle regular commands
      const { data: user, error } = await supabase
        .from("users")
        .select("*")
        .eq("discord_id", interaction.user.id)
        .single()

if (error && error.code === "PGRST116") {
        // User doesn't exist, create them
        await supabase.from("users").insert({
          discord_id: interaction.user.id,
          username: interaction.user.username,
          avatar: interaction.user.displayAvatarURL(),
        })
      }
      await command.execute(interaction, supabase)
    }
  } catch (error) {
    console.error(error)
    await interaction.reply({
      content: "There was an error executing this command!",
      ephemeral: true,
    })
  }
})

// Also add this for autocomplete interactions:

client.on("interactionCreate", async (interaction) => {
  if (!interaction.isAutocomplete()) return

const command = client.commands.get(interaction.commandName)
  if (!command || !command.autocomplete) return

try {
    await command.autocomplete(interaction, supabase)
  } catch (error) {
    console.error(error)
  }
})

// Login to Discord
client.login(process.env.DISCORD_BOT_TOKEN)
[V0_FILE]typescriptreact:file="app/dashboard/docs/page.tsx" isEdit="true"
"use client"

import { useState } from "react"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"

export default function DocumentationPage() {
  const [activeTab, setActiveTab] = useState("overview")

return (
    <div className="space-y-6">
      <div>
        <h1 className="text-3xl font-bold tracking-tight">Documentation</h1>
        <p className="text-muted-foreground">Learn how to use and manage your Discord bot</p>
      </div>

<Tabs defaultValue="overview" value={activeTab} onValueChange={setActiveTab}>
        <TabsList className="grid grid-cols-5 w-full">
          <TabsTrigger value="overview">Overview</TabsTrigger>
          <TabsTrigger value="admin">Admin</TabsTrigger>
          <TabsTrigger value="commands">Commands</TabsTrigger>
          <TabsTrigger value="modules">Modules</TabsTrigger>
          <TabsTrigger value="api">API</TabsTrigger>
        </TabsList>

<TabsContent value="overview" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Discord Shop Bot</CardTitle>
              <CardDescription>A comprehensive Discord bot for shop and economy features</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <h3 className="text-lg font-medium">Introduction</h3>
                <p>
                  The Discord Shop Bot is a feature-rich bot designed to add economy and shop features to your Discord
                  server. It allows users to earn and spend virtual currency, purchase items from a shop, participate in
                  giveaways, and much more.
                </p>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Key Features</h3>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Virtual economy system with currency and transactions</li>
                  <li>Shop system with customizable items and categories</li>
                  <li>User inventory management</li>
                  <li>Role rewards and daily bonuses</li>
                  <li>Giveaways and special events</li>
                  <li>Comprehensive admin dashboard</li>
                  <li>Detailed analytics and reporting</li>
                </ul>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Getting Started</h3>
                <p>To get started with the Discord Shop Bot, follow these steps:</p>
                <ol className="list-decimal pl-6 space-y-1">
                  <li>Invite the bot to your Discord server</li>
                  <li>Configure the bot settings in the dashboard</li>
                  <li>Set up admin and moderator roles</li>
                  <li>Create shop items and categories</li>
                  <li>Announce the bot to your server members</li>
                </ol>
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="admin" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Admin Dashboard</CardTitle>
              <CardDescription>Managing your bot through the admin dashboard</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <h3 className="text-lg font-medium">Admin Overview</h3>
                <p>
                  The admin dashboard provides a comprehensive interface for managing all aspects of your Discord bot.
                  From here, you can monitor bot performance, manage modules, view logs, and configure settings.
                </p>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Module Management</h3>
                <p>
                  The Modules page allows you to enable or disable specific bot features and configure their settings.
                  Each module represents a distinct feature set, such as the economy system, giveaways, or moderation
                  tools.
                </p>
                <p>To manage modules:</p>
                <ol className="list-decimal pl-6 space-y-1">
                  <li>Navigate to Admin > Modules</li>
                  <li>Toggle the switch to enable or disable a module</li>
                  <li>Click the Settings button to configure module-specific settings</li>
                </ol>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Admin Logs</h3>
                <p>
                  The Logs page displays a record of all admin commands executed through Discord. This helps you track
                  administrative actions and troubleshoot issues.
                </p>
                <p>Log entries include:</p>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Timestamp of the action</li>
                  <li>User who executed the command</li>
                  <li>Command name and parameters</li>
                  <li>Server and channel where the command was used</li>
                </ul>
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="commands" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Bot Commands</CardTitle>
              <CardDescription>Available commands and how to use them</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <h3 className="text-lg font-medium">User Commands</h3>
                <div className="space-y-4">
                  <div>
                    <h4 className="font-medium">Economy Commands</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/balance</code> - Check your current balance
                      </li>
                      <li>
                        <code>/daily</code> - Claim your daily reward
                      </li>
                      <li>
                        <code>/transfer <user> <amount></code> - Transfer coins to another user
                      </li>
                      <li>
                        <code>/leaderboard</code> - View the richest users on the server
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Shop Commands</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/shop [category]</code> - Browse the shop, optionally filtered by category
                      </li>
                      <li>
                        <code>/categories</code> - View all shop categories
                      </li>
                      <li>
                        <code>/buy <item> [quantity]</code> - Purchase an item from the shop
                      </li>
                      <li>
                        <code>/inventory</code> - View your inventory
                      </li>
                      <li>
                        <code>/use <item></code> - Use an item from your inventory
                      </li>
                      <li>
                        <code>/gift <user> <item> [quantity]</code> - Gift an item to another user
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Role Commands</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/claimrole</code> - Claim rewards for your roles
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Giveaway Commands</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/giveaways</code> - View active giveaways
                      </li>
                    </ul>
                  </div>
                </div>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Admin Commands</h3>
                <div className="space-y-4">
                  <div>
                    <h4 className="font-medium">Module Management</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/module list</code> - List all bot modules
                      </li>
                      <li>
                        <code>/module enable <name></code> - Enable a module
                      </li>
                      <li>
                        <code>/module disable <name></code> - Disable a module
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Settings Management</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/settings list</code> - List all settings
                      </li>
                      <li>
                        <code>/settings get <key></code> - Get a setting value
                      </li>
                      <li>
                        <code>/settings set <key> <value></code> - Set a setting value
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Permission Management</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/permissions list</code> - List all permission roles
                      </li>
                      <li>
                        <code>/permissions addrole <role> <type></code> - Add an admin or mod role
                      </li>
                      <li>
                        <code>/permissions removerole <role> <type></code> - Remove an admin or mod role
                      </li>
                      <li>
                        <code>/permissions blacklist <user> <blacklisted></code> - Add or remove a user from
                        the blacklist
                      </li>
                    </ul>
                  </div>

<div>
                    <h4 className="font-medium">Other Admin Commands</h4>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>/status</code> - View bot status and statistics
                      </li>
                      <li>
                        <code>/reload <command></code> - Reload a command
                      </li>
                    </ul>
                  </div>
                </div>
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="modules" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>Bot Modules</CardTitle>
              <CardDescription>Overview of available modules and their features</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <h3 className="text-lg font-medium">Economy System</h3>
                <p>
                  The Economy module provides a virtual currency system for your Discord server. Users can earn coins
                  through various activities, check their balance, and transfer coins to other users.
                </p>
                <p>Key features:</p>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Virtual currency with customizable name and symbol</li>
                  <li>Daily rewards for active users</li>
                  <li>Balance tracking and leaderboards</li>
                  <li>Peer-to-peer transfers</li>
                </ul>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Shop System</h3>
                <p>
                  The Shop module allows users to purchase items using the virtual currency. Admins can create and
                  manage items, categories, and pricing.
                </p>
                <p>Key features:</p>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Customizable shop items with descriptions and prices</li>
                  <li>Category organization</li>
                  <li>Inventory management</li>
                  <li>Item usage and gifting</li>
                </ul>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Giveaways</h3>
                <p>
                  The Giveaways module enables server admins to create and manage giveaways. Users can enter giveaways
                  for a chance to win prizes.
                </p>
                <p>Key features:</p>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Customizable giveaway duration and winner count</li>
                  <li>Automatic winner selection</li>
                  <li>Reroll functionality</li>
                  <li>Active giveaway listing</li>
                </ul>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Role Rewards</h3>
                <p>
                  The Role Rewards feature allows users to claim daily rewards based on their Discord roles. Admins can
                  configure which roles receive rewards and how much.
                </p>
                <p>Key features:</p>
                <ul className="list-disc pl-6 space-y-1">
                  <li>Role-based reward amounts</li>
                  <li>Daily claiming system</li>
                  <li>Customizable reward descriptions</li>
                </ul>
              </div>
            </CardContent>
          </Card>
        </TabsContent>

<TabsContent value="api" className="space-y-4 mt-4">
          <Card>
            <CardHeader>
              <CardTitle>API Documentation</CardTitle>
              <CardDescription>Using the bot's API endpoints</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <h3 className="text-lg font-medium">API Overview</h3>
                <p>
                  The Discord Shop Bot provides a RESTful API for integrating with other services and applications. All
                  API endpoints require authentication using your API key.
                </p>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Authentication</h3>
                <p>To authenticate with the API, include your API key in the Authorization header:</p>
                <pre className="bg-muted p-2 rounded-md overflow-x-auto">Authorization: Bearer YOUR_API_KEY</pre>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">Admin Endpoints</h3>
                <div className="space-y-4">
                  <div>
                    <h4 className="font-medium">GET /api/admin/modules</h4>
                    <p>Retrieve a list of all bot modules and their status.</p>
                    <p>Response:</p>
                    <pre className="bg-muted p-2 rounded-md overflow-x-auto">
                      {`{
  "modules": [
    {
      "id": 1,
      "name": "economy",
      "display_name": "Economy System",
      "description": "Currency, shop, and transactions",
      "enabled": true,
      "settings": {
        "daily_reward": 200,
        "starting_balance": 1000
      }
    },
    ...
  ]
}`}
                    </pre>
                  </div>

<div>
                    <h4 className="font-medium">PUT /api/admin/modules</h4>
                    <p>Update a module's status or settings.</p>
                    <p>Request:</p>
                    <pre className="bg-muted p-2 rounded-md overflow-x-auto">
                      {`{
  "id": 1,
  "enabled": true,
  "settings": {
    "daily_reward": 300,
    "starting_balance": 1500
  }
}`}
                    </pre>
                  </div>

<div>
                    <h4 className="font-medium">GET /api/admin/logs</h4>
                    <p>Retrieve admin command logs.</p>
                    <p>Query parameters:</p>
                    <ul className="list-disc pl-6 space-y-1">
                      <li>
                        <code>limit</code> - Number of logs to return (default: 50)
                      </li>
                      <li>
                        <code>page</code> - Page number for pagination (default: 0)
                      </li>
                      <li>
                        <code>command</code> - Filter by command name
                      </li>
                    </ul>
                  </div>
                </div>
              </div>

<div className="space-y-2">
                <h3 className="text-lg font-medium">User Endpoints</h3>
                <div className="space-y-4">
                  <div>
                    <h4 className="font-medium">GET /api/users</h4>
                    <p>Retrieve a list of all users.</p>
                  </div>

<div>
                    <h4 className="font-medium">GET /api/users/:id</h4>
                    <p>Retrieve a specific user by ID.</p>
                  </div>

<div>
                    <h4 className="font-medium">PUT /api/users/:id</h4>
                    <p>Update a user's information.</p>
                  </div>
                </div>
              </div>
            </CardContent>
          </Card>
        </TabsContent>
      </Tabs>
    </div>
  )
}</article></body></html>