bot.js

const { Client, GatewayIntentBits } = require('discord.js');
const fs = require('fs');
const path = require('path');
const dotenv = require('dotenv');

class BotManager {
  constructor() {
    this.clients = new Map(); // Map of botId to client
    this.currentBotId = null;
    this.logs = [];
    this.botConfigs = [];
    this.loadBotConfigs();
  }

  // Load bot configurations from config folder
  loadBotConfigs() {
    const configDir = path.join(__dirname, 'config');
    if (!fs.existsSync(configDir)) {
      fs.mkdirSync(configDir, { recursive: true });
      // Create example config
      this.createExampleConfig();
      return;
    }

    const items = fs.readdirSync(configDir);
    for (const item of items) {
      const itemPath = path.join(configDir, item);
      const stat = fs.statSync(itemPath);
      if (stat.isDirectory()) {
        const envPath = path.join(itemPath, '.env');
        if (fs.existsSync(envPath)) {
          this.botConfigs.push({
            id: item,
            name: item,
            path: itemPath
          });
        }
      }
    }
  }

  createExampleConfig() {
    const exampleDir = path.join(__dirname, 'config', 'example-bot');
    fs.mkdirSync(exampleDir, { recursive: true });
    const envContent = `# Discord Bot Token - Get this from https://discord.com/developers/applications
DISCORD_TOKEN=your_bot_token_here

# Bot Configuration
BOT_PREFIX=!
BOT_NAME=Example Bot
`;
    fs.writeFileSync(path.join(exampleDir, '.env'), envContent);
    this.log('Created example bot config in config/example-bot/.env');
  }

  init() {
    if (this.botConfigs.length > 0) {
      this.switchBot(this.botConfigs[0].id);
    } else {
      this.log('No bot configurations found. Please add a .env file in config/your-bot-name/');
    }
  }

  switchBot(botId) {
    // Cleanup current bot
    if (this.currentBotId && this.clients.has(this.currentBotId)) {
      const client = this.clients.get(this.currentBotId);
      client.destroy();
      this.clients.delete(this.currentBotId);
    }

    this.currentBotId = botId;
    const config = this.botConfigs.find(c => c.id === botId);
    if (!config) {
      this.log(`Bot config ${botId} not found`);
      return;
    }

    this.createClient(config);
  }

  createClient(config) {
    // Load environment variables
    const envPath = path.join(config.path, '.env');
    const envConfig = dotenv.config({ path: envPath });

    if (envConfig.error) {
      this.log(`Error loading .env for ${config.id}: ${envConfig.error.message}`);
      return;
    }

    const token = process.env.DISCORD_TOKEN;
    if (!token) {
      this.log(`No DISCORD_TOKEN found in ${envPath}`);
      return;
    }

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

    // Event handlers
    client.on('ready', () => {
      this.log(`Bot ${config.name} is ready! Logged in as ${client.user.tag}`);
    });

    client.on('messageCreate', (message) => {
      if (message.author.bot) return;
      this.log(`Message from ${message.author.tag} in ${message.channel.name}: ${message.content}`);
    });

    client.on('error', (error) => {
      this.log(`Bot error: ${error.message}`);
    });

    client.on('disconnect', () => {
      this.log('Bot disconnected');
    });

    client.on('reconnecting', () => {
      this.log('Bot reconnecting...');
    });

    // Login
    client.login(token).catch(error => {
      this.log(`Failed to login: ${error.message}`);
    });

    this.clients.set(config.id, client);
  }

  reconnect() {
    if (this.currentBotId) {
      this.switchBot(this.currentBotId);
    }
  }

  getGuilds() {
    const client = this.clients.get(this.currentBotId);
    if (!client) return [];
    return client.guilds.cache.map(guild => ({
      id: guild.id,
      name: guild.name,
      iconURL: guild.iconURL()
    }));
  }

  getChannels(guildId) {
    const client = this.clients.get(this.currentBotId);
    if (!client) return [];
    const guild = client.guilds.cache.get(guildId);
    if (!guild) return [];
    return guild.channels.cache
      .filter(channel => channel.type === 0) // TEXT channels
      .map(channel => ({
        id: channel.id,
        name: channel.name,
        type: channel.type
      }));
  }

  async sendMessage(channelId, message) {
    const client = this.clients.get(this.currentBotId);
    if (!client) {
      this.log('No active bot client');
      return false;
    }

    try {
      const channel = client.channels.cache.get(channelId);
      if (!channel) {
        this.log(`Channel ${channelId} not found`);
        return false;
      }

      await channel.send(message);
      this.log(`Message sent to ${channel.name}: ${message}`);
      return true;
    } catch (error) {
      this.log(`Error sending message: ${error.message}`);
      return false;
    }
  }

  getLogs() {
    return this.logs.slice(-100); // Last 100 logs
  }

  getBotConfigs() {
    return this.botConfigs;
  }

  log(message) {
    const timestamp = new Date().toISOString();
    const logEntry = `[${timestamp}] ${message}`;
    this.logs.push(logEntry);
    console.log(logEntry);
  }

  // Save bot configuration from UI input
  saveBotConfig(token, name) {
    try {
      const botId = `ui-bot-${Date.now()}`;
      const botDir = path.join(__dirname, 'config', botId);
      fs.mkdirSync(botDir, { recursive: true });

      const envContent = `# Discord Bot Token - Saved from UI
DISCORD_TOKEN=${token}

# Bot Configuration
BOT_PREFIX=!
BOT_NAME=${name}
`;

      fs.writeFileSync(path.join(botDir, '.env'), envContent);

      // Add to bot configs
      this.botConfigs.push({
        id: botId,
        name: name,
        path: botDir
      });

      this.log(`Bot configuration saved for ${name}`);
      return true;
    } catch (error) {
      this.log(`Error saving bot config: ${error.message}`);
      return false;
    }
  }

  // Get stored tokens (without exposing the actual tokens)
  getStoredTokens() {
    return this.botConfigs.map(config => ({
      id: config.id,
      name: config.name,
      created: fs.statSync(config.path).birthtime
    }));
  }

  // Clear all stored data
  clearAllData() {
    try {
      // Remove all config directories except example
      const configDir = path.join(__dirname, 'config');
      const items = fs.readdirSync(configDir);

      for (const item of items) {
        if (item !== 'example-bot') {
          const itemPath = path.join(configDir, item);
          fs.rmSync(itemPath, { recursive: true, force: true });
        }
      }

      // Clear clients and configs
      this.clients.clear();
      this.botConfigs = [];
      this.currentBotId = null;
      this.logs = [];

      this.log('All data cleared');
      return true;
    } catch (error) {
      this.log(`Error clearing data: ${error.message}`);
      return false;
    }
  }

  cleanup() {
    for (const [id, client] of this.clients) {
      client.destroy();
    }
    this.clients.clear();
  }
}

module.exports = BotManager;