Integrating AI Into a Discord Bot: Ultimate Guide

DISCORD_BOT_TOKEN="" # Paste in here your Discord bot token.
GEMINI_API_KEY="" # Paste in here your Gemini API key.
CHANNEL_ID="" # Paste in here the channel ID you want the bot to listen to.

// Simple Discord AI Chatbot
// Responds to messages in a specific channel with AI responses

// Import packages
const { Client, GatewayIntentBits } = require('discord.js');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const dotenv = require('dotenv');

// Load environment variables
dotenv.config();

// Initialize Gemini AI
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

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

// Bot ready event
client.once('ready', () => {
    console.log('Bot is online!');
});

// Message event handler
client.on('messageCreate', async (message) => {
    // Ignore bot messages
    if (message.author.bot) return;

    // Only respond in the specific channel
    if (message.channel.id !== process.env.CHANNEL_ID) return;

    try {
        // Generate AI response
        const result = await model.generateContent(message.content);
        const aiResponse = result.response.text();

        // Send response
        await message.reply(aiResponse);

        console.log(`Responded to ${message.author.username}: "${message.content}"`);

    } catch (error) {
        console.error('Error:', error);
        await message.reply('Sorry, I had an error processing your message.');
    }
});

// Login to Discord
client.login(process.env.DISCORD_BOT_TOKEN);

// Simple Discord AI Chatbot
// Responds to mentions in any channel with AI responses

// Import packages
const { Client, GatewayIntentBits } = require('discord.js');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const dotenv = require('dotenv');

// Load environment variables
dotenv.config();

// Initialize Gemini AI
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

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

// Bot ready event
client.once('ready', () => {
    console.log('Bot is online!');
});

// Message event handler
client.on('messageCreate', async (message) => {
    // Ignore bot messages
    if (message.author.bot) return;

    // Only respond when mentioned
    if (!message.mentions.has(client.user)) return;

    try {
        // Generate AI response
        const result = await model.generateContent(message.content);
        const aiResponse = result.response.text();

        // Send response
        await message.reply(aiResponse);

        console.log(`Responded to ${message.author.username}: "${message.content}"`);

    } catch (error) {
        console.error('Error:', error);
        await message.reply('Sorry, I had an error processing your message.');
    }
});

// Login to Discord
client.login(process.env.DISCORD_BOT_TOKEN);

{
  "prompt": "You are a helpful AI assistant Discord bot. You should be conversational, engaging, and provide accurate information while maintaining a professional yet approachable tone.",
  "rules": [
    "Keep responses under 2000 characters to fit Discord's message limit",
    "Be respectful and polite to all users",
    "Stay on topic and provide relevant responses",
    "If you don't know something, be honest about it",
    "Follow Discord's community guidelines",
    "Don't share personal information about users",
    "Don't engage in harmful or inappropriate conversations",
    "Use emojis sparingly and appropriately",
    "Be helpful and try to solve user problems",
    "Maintain a friendly and professional tone",
    "Only mention your name (GG Bot) and creator (programmers) if specifically asked about your identity or who made you",
    "Don't introduce yourself unless asked"
  ]
}

/**
 * Generate AI response using Gemini model
 * @param {string} userMessage - The user's message
 * @param {Object} model - The Gemini AI model instance
 * @param {string} systemPrompt - The system prompt with rules
 * @returns {Promise<string>} - The AI response
 */
async function generateAIResponse(userMessage, model, systemPrompt) {
  try {
    // Clean user message (remove mentions)
    const cleanedUserMessage = cleanUserMessage(userMessage);

    // Create the full prompt with context
    const fullPrompt = `${systemPrompt}\n\nUser message: ${cleanedUserMessage}`;

    // Generate response from AI
    const result = await model.generateContent(fullPrompt);
    const aiResponse = result.response.text();

    // Clean and validate response
    const cleanedResponse = cleanResponse(aiResponse);

    return cleanedResponse;

  } catch (error) {
    console.error('AI Response Error:', error);
    throw new Error('Failed to generate AI response');
  }
}

/**
 * Clean user message (remove mentions and extra whitespace)
 * @param {string} message - Raw user message
 * @returns {string} - Cleaned message
 */
function cleanUserMessage(message) {
  if (!message || typeof message !== 'string') {
    return '';
  }

  // Remove mentions (like <@123456789>)
  let cleaned = message.replace(/<@!?\d+>/g, '').trim();

  // Remove extra whitespace
  cleaned = cleaned.replace(/\s+/g, ' ').trim();

  return cleaned || 'hi';
}

/**
 * Clean and validate the AI response
 * @param {string} response - Raw AI response
 * @returns {string} - Cleaned response
 */
function cleanResponse(response) {
  if (!response || typeof response !== 'string') {
    return 'Sorry, I couldn\'t generate a proper response.';
  }

  // Trim whitespace
  let cleaned = response.trim();

  // Ensure response is not too long for Discord (2000 char limit)
  if (cleaned.length > 1900) {
    cleaned = cleaned.substring(0, 1900) + '...';
  }

  // Remove any potential harmful content markers
  cleaned = cleaned.replace(/\[HARMFUL\]|\[NSFW\]|\[INAPPROPRIATE\]/gi, '');

  return cleaned || 'Sorry, I couldn\'t generate a response.';
}

/**
 * Build system prompt from config
 * @param {Object} config - Configuration object with prompt and rules
 * @returns {string} - Complete system prompt
 */
function buildSystemPrompt(config) {
  let systemPrompt = config.prompt || 'You are a helpful AI assistant.';

  if (config.rules && Array.isArray(config.rules)) {
    systemPrompt += '\n\nRules you must follow:\n';
    config.rules.forEach((rule, index) => {
      systemPrompt += `${index + 1}. ${rule}\n`;
    });
  }

  return systemPrompt;
}

module.exports = {
  generateAIResponse,
  cleanResponse,
  cleanUserMessage,
  buildSystemPrompt
};

// Import packages
const { Client, GatewayIntentBits } = require('discord.js');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const dotenv = require('dotenv');
const fs = require('fs');

// Import utilities
const aiResponse = require('./utils/aiResponse.js');

// Load environment variables
dotenv.config();

// Load configuration
const config = JSON.parse(fs.readFileSync('./config.json', 'utf8'));

// Initialize Gemini AI
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

// Build system prompt from config
const systemPrompt = aiResponse.buildSystemPrompt(config);

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

// Bot ready event
client.once('ready', () => {
    console.log('CybranceBot is online!');
    console.log(`System prompt loaded: ${systemPrompt.substring(0, 100)}...`);
});

// Track processed messages to prevent duplicates
const processedMessages = new Set();

// Message event handler
client.on('messageCreate', async (message) => {
    // Ignore bot messages
    if (message.author.bot) return;

    // Only respond when mentioned
    if (!message.mentions.has(client.user)) return;

    // Prevent duplicate processing
    if (processedMessages.has(message.id)) return;
    processedMessages.add(message.id);

    // Clean up old message IDs (keep only last 100)
    if (processedMessages.size > 100) {
        const oldIds = Array.from(processedMessages).slice(0, processedMessages.size - 100);
        oldIds.forEach(id => processedMessages.delete(id));
    }

    try {
        console.log(`Processing message from ${message.author.username}: "${message.content}"`);

        // Generate AI response using utility
        const response = await aiResponse.generateAIResponse(
            message.content,
            model,
            systemPrompt
        );

        // Send response
        await message.reply(response);

        console.log(`✅ Responded to ${message.author.username}`);

    } catch (error) {
        console.error('❌ Error:', error);
        await message.reply('Sorry, I had an error processing your message.');
    }
});

// Login to Discord
client.login(process.env.DISCORD_BOT_TOKEN);

// In-memory storage for user conversations
// Structure: { userId: [{ user: "message", bot: "response", timestamp: Date }] }
const userMemories = new Map();

// Maximum number of conversations to store per user
const MAX_CONVERSATIONS = 10;

/**
 * Add a conversation to the user's memory
 * @param {string} userId - Discord user ID
 * @param {string} userMessage - User's message
 * @param {string} botResponse - Bot's response
 */
function addToMemory(userId, userMessage, botResponse) {
  try {
    // Get existing memory or create a new array
    let userConversations = userMemories.get(userId) || [];

    // Create conversation entry
    const conversation = {
      user: userMessage,
      bot: botResponse,
      timestamp: new Date()
    };

    // Add to memory
    userConversations.push(conversation);

    // Keep only the last MAX_CONVERSATIONS
    if (userConversations.length > MAX_CONVERSATIONS) {
      userConversations = userConversations.slice(-MAX_CONVERSATIONS);
    }

    // Update memory
    userMemories.set(userId, userConversations);

    console.log(`💾 Stored conversation for user ${userId} (${userConversations.length}/${MAX_CONVERSATIONS})`);

  } catch (error) {
    console.error('Memory storage error:', error);
  }
}

/**
 * Get the user's conversation history
 * @param {string} userId - Discord user ID
 * @returns {Array} - Array of conversation objects
 */
function getMemory(userId) {
  return userMemories.get(userId) || [];
}

/**
 * Format memory for AI context
 * @param {string} userId - Discord user ID
 * @returns {string} - Formatted conversation history
 */
function formatMemoryForAI(userId) {
  const conversations = getMemory(userId);

  if (conversations.length === 0) {
    return '';
  }

  let memoryContext = '\n\nPrevious conversation history:\n';

  conversations.forEach((conv, index) => {
    memoryContext += `${index + 1}. User: ${conv.user}\n`;
    memoryContext += `   Bot: ${conv.bot}\n`;
  });

  memoryContext += '\nUse this context to provide more relevant and personalized responses.\n';

  return memoryContext;
}

/**
 * Clear memory for a specific user
 * @param {string} userId - Discord user ID
 */
function clearMemory(userId) {
  userMemories.delete(userId);
  console.log(`🗑️ Cleared memory for user ${userId}`);
}

/**
 * Get memory statistics
 * @returns {Object} - Memory usage statistics
 */
function getMemoryStats() {
  const totalUsers = userMemories.size;
  let totalConversations = 0;

  userMemories.forEach(conversations => {
    totalConversations += conversations.length;
  });

  return {
    totalUsers,
    totalConversations,
    averageConversationsPerUser: totalUsers > 0 ? (totalConversations / totalUsers).toFixed(2) : 0
  };
}

/**
 * Clean old memories (optional - for memory management)
 * Remove conversations older than specified days
 * @param {number} daysOld - Days to keep conversations
 */
function cleanOldMemories(daysOld = 7) {
  const cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - daysOld);

  let cleanedCount = 0;

  userMemories.forEach((conversations, userId) => {
    const filteredConversations = conversations.filter(conv => conv.timestamp > cutoffDate);

    if (filteredConversations.length !== conversations.length) {
      if (filteredConversations.length === 0) {
        userMemories.delete(userId);
      } else {
        userMemories.set(userId, filteredConversations);
      }
      cleanedCount++;
    }
  });

  console.log(`🧹 Cleaned old memories for ${cleanedCount} users`);
  return cleanedCount;
}

module.exports = {
  addToMemory,
  getMemory,
  formatMemoryForAI,
  clearMemory,
  getMemoryStats,
  cleanOldMemories
};

const memory = require('./memory.js');

/**
 * Generate AI response using Gemini model with memory context
 * @param {string} userMessage - The user's message
 * @param {Object} model - The Gemini AI model instance
 * @param {string} systemPrompt - The system prompt with rules
 * @param {string} userId - Discord user ID for memory context
 * @returns {Promise<string>} - The AI response
 */
async function generateAIResponse(userMessage, model, systemPrompt, userId) {
  try {
    // Clean user message (remove mentions)
    const cleanedUserMessage = cleanUserMessage(userMessage);

    // Get memory context for this user
    const memoryContext = memory.formatMemoryForAI(userId);

    // Create the full prompt with system prompt, memory context, and current message
    const fullPrompt = `${systemPrompt}${memoryContext}\n\nCurrent user message: ${cleanedUserMessage}`;

    // Generate response from AI
    const result = await model.generateContent(fullPrompt);
    const aiResponse = result.response.text();

    // Clean and validate response
    const cleanedResponse = cleanResponse(aiResponse);

    // Store this conversation in memory
    memory.addToMemory(userId, cleanedUserMessage, cleanedResponse);

    return cleanedResponse;

  } catch (error) {
    console.error('AI Response Error:', error);
    throw new Error('Failed to generate AI response');
  }
}

/**
 * Clean user message (remove mentions and extra whitespace)
 * @param {string} message - Raw user message
 * @returns {string} - Cleaned message
 */
function cleanUserMessage(message) {
  if (!message || typeof message !== 'string') {
    return '';
  }

  // Remove mentions (like <@123456789>)
  let cleaned = message.replace(/<@!?\d+>/g, '').trim();

  // Remove extra whitespace
  cleaned = cleaned.replace(/\s+/g, ' ').trim();

  return cleaned || 'hi';
}

/**
 * Clean and validate the AI response
 * @param {string} response - Raw AI response
 * @returns {string} - Cleaned response
 */
function cleanResponse(response) {
  if (!response || typeof response !== 'string') {
    return 'Sorry, I couldn\'t generate a proper response.';
  }

  // Trim whitespace
  let cleaned = response.trim();

  // Ensure response is not too long for Discord (2000 char limit)
  if (cleaned.length > 1900) {
    cleaned = cleaned.substring(0, 1900) + '...';
  }

  // Remove any potential harmful content markers
  cleaned = cleaned.replace(/\[HARMFUL\]|\[NSFW\]|\[INAPPROPRIATE\]/gi, '');

  return cleaned || 'Sorry, I couldn\'t generate a response.';
}

/**
 * Build system prompt from config
 * @param {Object} config - Configuration object with prompt and rules
 * @returns {string} - Complete system prompt
 */
function buildSystemPrompt(config) {
  let systemPrompt = config.prompt || 'You are a helpful AI assistant.';

  if (config.rules && Array.isArray(config.rules)) {
    systemPrompt += '\n\nRules you must follow:\n';
    config.rules.forEach((rule, index) => {
      systemPrompt += `${index + 1}. ${rule}\n`;
    });
  }

  return systemPrompt;
}

module.exports = {
  generateAIResponse,
  cleanResponse,
  cleanUserMessage,
  buildSystemPrompt
};

// Import packages
const { Client, GatewayIntentBits } = require('discord.js');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const dotenv = require('dotenv');
const fs = require('fs');

// Import utilities
const aiResponse = require('./utils/aiResponse.js');

// Load environment variables
dotenv.config();

// Load configuration
const config = JSON.parse(fs.readFileSync('./config.json', 'utf8'));

// Initialize Gemini AI
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

// Build system prompt from config
const systemPrompt = aiResponse.buildSystemPrompt(config);

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

// Bot ready event
client.once('ready', () => {
    console.log('CybranceBot is online!');
    console.log(`System prompt loaded: ${systemPrompt.substring(0, 100)}...`);
});

// Track processed messages to prevent duplicates
const processedMessages = new Set();

// Message event handler
client.on('messageCreate', async (message) => {
    // Ignore bot messages
    if (message.author.bot) return;

    // Only respond when mentioned
    if (!message.mentions.has(client.user)) return;

    // Prevent duplicate processing
    if (processedMessages.has(message.id)) return;
    processedMessages.add(message.id);

    // Clean up old message IDs (keep only last 100)
    if (processedMessages.size > 100) {
        const oldIds = Array.from(processedMessages).slice(0, processedMessages.size - 100);
        oldIds.forEach(id => processedMessages.delete(id));
    }

    try {
        console.log(`Processing message from ${message.author.username}: "${message.content}"`);

        // Generate AI response using utility with memory
        const response = await aiResponse.generateAIResponse(
            message.content,
            model,
            systemPrompt,
            message.author.id // Pass the user ID for memory handling
        );

        // Send response
        await message.reply(response);

        console.log(`✅ Responded to ${message.author.username}`);

    } catch (error) {
        console.error('❌ Error:', error);
        await message.reply('Sorry, I had an error processing your message.');
    }
});

// Login to Discord
client.login(process.env.DISCORD_BOT_TOKEN);

DISCORD_BOT_TOKEN="" # Paste in here your Discord bot token.
GEMINI_API_KEY="" # Paste in here your Gemini API key.
SERPER_API_KEY="" # Paste in here your Serper API key.

/**
 * Perform a web search using the Serper API
 * @param {string} query - Search query
 * @returns {Promise<Object>} - Search results object
 */
async function performSearch(query) {
  try {
    const response = await fetch('https://google.serper.dev/search', {
      method: 'POST',
      headers: {
        'X-API-KEY': process.env.SERPER_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        q: query,
        num: 5 // Get top 5 results
      })
    });

    if (!response.ok) {
      throw new Error(`Serper API error: ${response.status} ${response.statusText}`);
    }

    const data = await response.json();
    return {
      success: true,
      query: query,
      results: data
    };

  } catch (error) {
    console.error('Search error:', error);
    return {
      success: false,
      query: query,
      error: error.message
    };
  }
}

/**
 * Detect if the user message needs a web search
 * @param {string} message - User's message
 * @returns {boolean} - Whether search is needed
 */
function detectSearchIntent(message) {
  if (!message || typeof message !== 'string') {
    return false;
  }

  const searchKeywords = [
    // Direct search requests
    'search for', 'look up', 'find information', 'google', 'search',

    // Current information requests
    'latest', 'recent', 'current', 'today', 'now', 'this year', 'new',

    // News and events
    'news', 'breaking', 'happened', 'event', 'update',

    // Weather and time-sensitive
    'weather', 'temperature', 'forecast', 'stock price', 'exchange rate',

    // Questions about the current state
    'what is happening', 'what happened', 'tell me about', 'information about',

    // Specific domains that need current info
    'price of', 'cost of', 'how much', 'when did', 'who is', 'where is'
  ];

  const lowerMessage = message.toLowerCase();

  // Check for search keywords
  const hasSearchKeywords = searchKeywords.some(keyword =>
    lowerMessage.includes(keyword)
  );

  // Check for question patterns that might need current info
  const questionPatterns = [
    /what.*(?:latest|recent|current|new|today)/i,
    /when.*(?:did|will|does)/i,
    /who.*(?:is|was|are|were)/i,
    /where.*(?:is|are|can)/i,
    /how.*(?:much|many|to)/i,
    /why.*(?:did|is|are)/i
  ];

  const hasQuestionPattern = questionPatterns.some(pattern =>
    pattern.test(message)
  );

  return hasSearchKeywords || hasQuestionPattern;
}

/**
 * Format search results for AI context
 * @param {Object} searchData - Search results from Serper API
 * @returns {string} - Formatted search context
 */
function formatSearchResults(searchData) {
  if (!searchData.success || !searchData.results) {
    return '';
  }

  const { results } = searchData;
  let formattedResults = `\n\nCurrent web search results for "${searchData.query}":\n`;

  // Add organic search results
  if (results.organic && results.organic.length > 0) {
    formattedResults += '\nTop search results:\n';
    results.organic.slice(0, 3).forEach((result, index) => {
      formattedResults += `${index + 1}. ${result.title}\n`;
      formattedResults += `   ${result.snippet}\n`;
      formattedResults += `   Source: ${result.link}\n\n`;
    });
  }

  // Add knowledge graph if available
  if (results.knowledgeGraph) {
    const kg = results.knowledgeGraph;
    formattedResults += `Knowledge Graph:\n`;
    formattedResults += `Title: ${kg.title}\n`;
    if (kg.description) {
      formattedResults += `Description: ${kg.description}\n`;
    }
    if (kg.attributes) {
      Object.entries(kg.attributes).forEach(([key, value]) => {
        formattedResults += `${key}: ${value}\n`;
      });
    }
    formattedResults += '\n';
  }

  // Add people also ask if available
  if (results.peopleAlsoAsk && results.peopleAlsoAsk.length > 0) {
    formattedResults += 'Related questions:\n';
    results.peopleAlsoAsk.slice(0, 2).forEach((item, index) => {
      formattedResults += `${index + 1}. ${item.question}\n`;
    });
    formattedResults += '\n';
  }

  formattedResults += 'Use this current information to provide an accurate and up-to-date response.\n';

  return formattedResults;
}

/**
 * Perform search and format results (main function)
 * @param {string} query - Search query
 * @returns {Promise<Object>} - Formatted search results
 */
async function searchAndFormat(query) {
  const searchResults = await performSearch(query);

  if (searchResults.success) {
    const formattedContext = formatSearchResults(searchResults);
    return {
      success: true,
      query: query,
      context: formattedContext,
      rawResults: searchResults.results
    };
  } else {
    return {
      success: false,
      query: query,
      error: searchResults.error
    };
  }
}

module.exports = {
  performSearch,
  detectSearchIntent,
  formatSearchResults,
  searchAndFormat
};

const memory = require('./memory.js');
const search = require('./search.js');

/**
 * Generate AI response using Gemini model with memory context
 * @param {string} userMessage - The user's message
 * @param {Object} model - The Gemini AI model instance
 * @param {string} systemPrompt - The system prompt with rules
 * @param {string} userId - Discord user ID for memory context
 * @returns {Promise<string>} - The AI response
 */
async function generateAIResponse(userMessage, model, systemPrompt, userId) {
  try {
    // Clean user message (remove mentions)
    const cleanedUserMessage = cleanUserMessage(userMessage);

    // Get memory context for this user
    const memoryContext = memory.formatMemoryForAI(userId);

    // Check if search is needed and perform search
    let searchContext = '';
    const needsSearch = search.detectSearchIntent(cleanedUserMessage);

    if (needsSearch) {
      console.log(`🔍 Search detected for: "${cleanedUserMessage}"`);
      const searchResults = await search.searchAndFormat(cleanedUserMessage);

      if (searchResults.success) {
        searchContext = searchResults.context;
        console.log(`✅ Search completed successfully`);
      } else {
        console.log(`❌ Search failed: ${searchResults.error}`);
      }
    }

    // Create the full prompt with system prompt, memory context, search context, and current message
    const fullPrompt = `${systemPrompt}${memoryContext}${searchContext}\n\nCurrent user message: ${cleanedUserMessage}`;

    // Generate response from AI
    const result = await model.generateContent(fullPrompt);
    const aiResponse = result.response.text();

    // Clean and validate response
    const cleanedResponse = cleanResponse(aiResponse);

    // Store this conversation in memory
    memory.addToMemory(userId, cleanedUserMessage, cleanedResponse);

    return cleanedResponse;

  } catch (error) {
    console.error('AI Response Error:', error);
    throw new Error('Failed to generate AI response');
  }
}

/**
 * Clean user message (remove mentions and extra whitespace)
 * @param {string} message - Raw user message
 * @returns {string} - Cleaned message
 */
function cleanUserMessage(message) {
  if (!message || typeof message !== 'string') {
    return '';
  }

  // Remove mentions (like <@123456789>)
  let cleaned = message.replace(/<@!?\d+>/g, '').trim();

  // Remove extra whitespace
  cleaned = cleaned.replace(/\s+/g, ' ').trim();

  return cleaned || 'hi';
}

/**
 * Clean and validate the AI response
 * @param {string} response - Raw AI response
 * @returns {string} - Cleaned response
 */
function cleanResponse(response) {
  if (!response || typeof response !== 'string') {
    return 'Sorry, I couldn\'t generate a proper response.';
  }

  // Trim whitespace
  let cleaned = response.trim();

  // Ensure response is not too long for Discord (2000 char limit)
  if (cleaned.length > 1900) {
    cleaned = cleaned.substring(0, 1900) + '...';
  }

  // Remove any potential harmful content markers
  cleaned = cleaned.replace(/\[HARMFUL\]|\[NSFW\]|\[INAPPROPRIATE\]/gi, '');

  return cleaned || 'Sorry, I couldn\'t generate a response.';
}

/**
 * Build system prompt from config
 * @param {Object} config - Configuration object with prompt and rules
 * @returns {string} - Complete system prompt
 */
function buildSystemPrompt(config) {
  let systemPrompt = config.prompt || 'You are a helpful AI assistant.';

  if (config.rules && Array.isArray(config.rules)) {
    systemPrompt += '\n\nRules you must follow:\n';
    config.rules.forEach((rule, index) => {
      systemPrompt += `${index + 1}. ${rule}\n`;
    });
  }

  return systemPrompt;
}

module.exports = {
  generateAIResponse,
  cleanResponse,
  cleanUserMessage,
  buildSystemPrompt
};

/**
 * Supported image types and their MIME types
 */
const SUPPORTED_IMAGE_TYPES = {
  // Common formats
  'image/jpeg': ['.jpg', '.jpeg'],
  'image/png': ['.png'],
  'image/gif': ['.gif'],
  'image/webp': ['.webp'],
  'image/bmp': ['.bmp'],
  'image/tiff': ['.tiff', '.tif'],
  'image/svg+xml': ['.svg'],

  // Additional formats
  'image/x-icon': ['.ico'],
  'image/vnd.microsoft.icon': ['.ico'],
  'image/avif': ['.avif'],
  'image/heic': ['.heic'],
  'image/heif': ['.heif']
};

/**
 * Check if the attachment is a supported image
 * @param {Object} attachment - Discord attachment object
 * @returns {boolean} - Whether the attachment is a supported image
 */
function isSupportedImage(attachment) {
  if (!attachment) {
    return false;
  }

  // Check by content type first
  if (attachment.contentType) {
    const contentType = attachment.contentType.toLowerCase();
    const isSupported = Object.keys(SUPPORTED_IMAGE_TYPES).includes(contentType);
    if (isSupported) {
      return true;
    }
  }

  // Fallback to filename extension check
  if (attachment.name) {
    const extension = getFileExtension(attachment.name);
    const isSupported = Object.values(SUPPORTED_IMAGE_TYPES).some(extensions =>
      extensions.includes(extension)
    );
    return isSupported;
  }

  // Last resort: check URL extension
  if (attachment.url) {
    const extension = getFileExtension(attachment.url);
    const isSupported = Object.values(SUPPORTED_IMAGE_TYPES).some(extensions =>
      extensions.includes(extension)
    );
    return isSupported;
  }

  return false;
}

/**
 * Get file extension from filename
 * @param {string} filename - The filename
 * @returns {string} - File extension with dot (e.g., '.jpg')
 */
function getFileExtension(filename) {
  if (!filename || typeof filename !== 'string') {
    return '';
  }

  const lastDot = filename.lastIndexOf('.');
  if (lastDot === -1) {
    return '';
  }

  return filename.substring(lastDot).toLowerCase();
}

/**
 * Download image and convert to base64
 * @param {string} imageUrl - URL of the image
 * @returns {Promise<string>} - Base64 encoded image data
 */
async function downloadImageAsBase64(imageUrl) {
  try {
    console.log(`📥 Downloading image: ${imageUrl}`);

    const response = await fetch(imageUrl);

    if (!response.ok) {
      throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
    }

    // Get the image data as an array buffer
    const arrayBuffer = await response.arrayBuffer();

    // Convert to base64
    const base64 = Buffer.from(arrayBuffer).toString('base64');

    // Get content type from response or guess from URL
    let mimeType = response.headers.get('content-type');
    if (!mimeType) {
      mimeType = guessMimeTypeFromUrl(imageUrl);
    }

    console.log(`✅ Image downloaded successfully (${arrayBuffer.byteLength} bytes, ${mimeType})`);

    return {
      base64: base64,
      mimeType: mimeType,
      size: arrayBuffer.byteLength
    };

  } catch (error) {
    console.error('❌ Error downloading image:', error);
    throw new Error(`Failed to download image: ${error.message}`);
  }
}

/**
 * Guess MIME type from URL extension
 * @param {string} url - Image URL
 * @returns {string} - Guessed MIME type
 */
function guessMimeTypeFromUrl(url) {
  const extension = getFileExtension(url.split('?')[0]); // Remove query params

  for (const [mimeType, extensions] of Object.entries(SUPPORTED_IMAGE_TYPES)) {
    if (extensions.includes(extension)) {
      return mimeType;
    }
  }

  return 'image/jpeg'; // Default fallback
}

/**
 * Validate image size and type
 * @param {Object} attachment - Discord attachment object
 * @returns {Object} - Validation result
 */
function validateImage(attachment) {
  const MAX_SIZE = 20 * 1024 * 1024; // 20MB limit

  const result = {
    valid: true,
    errors: []
  };

  // Check if it's a supported image type
  const isSupported = isSupportedImage(attachment);
  if (!isSupported) {
    result.valid = false;
    result.errors.push(`Unsupported image format (${attachment.contentType || 'unknown type'})`);
  }

  // Check file size
  if (attachment.size && attachment.size > MAX_SIZE) {
    result.valid = false;
    result.errors.push(`Image too large (${(attachment.size / 1024 / 1024).toFixed(2)}MB). Maximum size is 20MB`);
  }

  return result;
}

/**
 * Get image information
 * @param {Object} attachment - Discord attachment object
 * @returns {Object} - Image information
 */
function getImageInfo(attachment) {
  return {
    name: attachment.name || 'unknown',
    size: attachment.size || 0,
    contentType: attachment.contentType || guessMimeTypeFromUrl(attachment.url),
    url: attachment.url,
    width: attachment.width || null,
    height: attachment.height || null,
    extension: getFileExtension(attachment.name || attachment.url)
  };
}

module.exports = {
  isSupportedImage,
  downloadImageAsBase64,
  validateImage,
  getImageInfo,
  getFileExtension,
  guessMimeTypeFromUrl,
  SUPPORTED_IMAGE_TYPES
};

const memory = require('./memory.js');
const search = require('./search.js');
const imageRead = require('./imageRead.js');

/**
 * Generate an AI response with image analysis
 * @param {string} userMessage - The user's message
 * @param {Object} model - The Gemini AI model instance
 * @param {string} systemPrompt - The system prompt with rules
 * @param {string} userId - Discord user ID for memory context
 * @param {Array} imageAttachments - Array of Discord image attachments
 * @returns {Promise<string>} - The AI response
 */
async function generateAIResponseWithImages(userMessage, model, systemPrompt, userId, imageAttachments) {
  try {
    // Clean user message (remove mentions)
    const cleanedUserMessage = cleanUserMessage(userMessage);

    // Get memory context for this user
    const memoryContext = memory.formatMemoryForAI(userId);

    // Process images if any
    let imageContext = '';
    const imageParts = [];

    if (imageAttachments && imageAttachments.length > 0) {
      console.log(`🖼️ Processing ${imageAttachments.length} image(s)`);

      for (const attachment of imageAttachments) {
        // Validate image
        const validation = imageRead.validateImage(attachment);
        if (!validation.valid) {
          console.log(`❌ Invalid image: ${validation.errors.join(', ')}`);
          continue;
        }

        try {
          // Download and convert the image
          const imageData = await imageRead.downloadImageAsBase64(attachment.url);
          const imageInfo = imageRead.getImageInfo(attachment);

          // Add image to Gemini parts
          imageParts.push({
            inlineData: {
              data: imageData.base64,
              mimeType: imageData.mimeType
            }
          });

          // Add image context for AI
          imageContext += `\nImage attached: ${imageInfo.name} (${imageInfo.extension}, ${(imageInfo.size / 1024).toFixed(1)}KB)`;

        } catch (error) {
          console.error(`❌ Error processing image ${attachment.name}:`, error);
          imageContext += `\nNote: Could not process image ${attachment.name || 'unknown'}`;
        }
      }
    }

    // Check if search is needed and perform search
    let searchContext = '';
    const needsSearch = search.detectSearchIntent(cleanedUserMessage);

    if (needsSearch) {
      console.log(`🔍 Search detected for: "${cleanedUserMessage}"`);
      const searchResults = await search.searchAndFormat(cleanedUserMessage);

      if (searchResults.success) {
        searchContext = searchResults.context;
        console.log(`✅ Search completed successfully`);
      } else {
        console.log(`❌ Search failed: ${searchResults.error}`);
      }
    }

    // Create the full prompt with all contexts
    const textPrompt = `${systemPrompt}${memoryContext}${searchContext}${imageContext}\n\nCurrent user message: ${cleanedUserMessage}`;

    // Prepare content for Gemini
    const content = [{ text: textPrompt }, ...imageParts];

    // Generate response from AI
    const result = await model.generateContent(content);
    const aiResponse = result.response.text();

    // Clean and validate response
    const cleanedResponse = cleanResponse(aiResponse);

    // Store this conversation in memory
    memory.addToMemory(userId, cleanedUserMessage, cleanedResponse);

    return cleanedResponse;

  } catch (error) {
    console.error('AI Response Error:', error);
    throw new Error('Failed to generate AI response');
  }
}

/**
 * Generate AI response using Gemini model with memory context (text only)
 * @param {string} userMessage - The user's message
 * @param {Object} model - The Gemini AI model instance
 * @param {string} systemPrompt - The system prompt with rules
 * @param {string} userId - Discord user ID for memory context
 * @returns {Promise<string>} - The AI response
 */
async function generateAIResponse(userMessage, model, systemPrompt, userId) {
  try {
    // Clean user message (remove mentions)
    const cleanedUserMessage = cleanUserMessage(userMessage);

    // Get memory context for this user
    const memoryContext = memory.formatMemoryForAI(userId);

    // Check if search is needed and perform search
    let searchContext = '';
    const needsSearch = search.detectSearchIntent(cleanedUserMessage);

    if (needsSearch) {
      console.log(`🔍 Search detected for: "${cleanedUserMessage}"`);
      const searchResults = await search.searchAndFormat(cleanedUserMessage);

      if (searchResults.success) {
        searchContext = searchResults.context;
        console.log(`✅ Search completed successfully`);
      } else {
        console.log(`❌ Search failed: ${searchResults.error}`);
      }
    }

    // Create the full prompt with system prompt, memory context, search context, and current message
    const fullPrompt = `${systemPrompt}${memoryContext}${searchContext}\n\nCurrent user message: ${cleanedUserMessage}`;

    // Generate response from AI
    const result = await model.generateContent(fullPrompt);
    const aiResponse = result.response.text();

    // Clean and validate response
    const cleanedResponse = cleanResponse(aiResponse);

    // Store this conversation in memory
    memory.addToMemory(userId, cleanedUserMessage, cleanedResponse);

    return cleanedResponse;

  } catch (error) {
    console.error('AI Response Error:', error);
    throw new Error('Failed to generate AI response');
  }
}

/**
 * Clean user message (remove mentions and extra whitespace)
 * @param {string} message - Raw user message
 * @returns {string} - Cleaned message
 */
function cleanUserMessage(message) {
  if (!message || typeof message !== 'string') {
    return '';
  }

  // Remove mentions (like <@123456789>)
  let cleaned = message.replace(/<@!?\d+>/g, '').trim();

  // Remove extra whitespace
  cleaned = cleaned.replace(/\s+/g, ' ').trim();

  return cleaned || 'hi';
}

/**
 * Clean and validate AI response
 * @param {string} response - Raw AI response
 * @returns {string} - Cleaned response
 */
function cleanResponse(response) {
  if (!response || typeof response !== 'string') {
    return 'Sorry, I couldn\'t generate a proper response.';
  }

  // Trim whitespace
  let cleaned = response.trim();

  // Ensure response is not too long for Discord (2000 char limit)
  if (cleaned.length > 1900) {
    cleaned = cleaned.substring(0, 1900) + '...';
  }

  // Remove any potential harmful content markers
  cleaned = cleaned.replace(/\[HARMFUL\]|\[NSFW\]|\[INAPPROPRIATE\]/gi, '');

  return cleaned || 'Sorry, I couldn\'t generate a response.';
}

/**
 * Build system prompt from config
 * @param {Object} config - Configuration object with prompt and rules
 * @returns {string} - Complete system prompt
 */
function buildSystemPrompt(config) {
  let systemPrompt = config.prompt || 'You are a helpful AI assistant.';

  if (config.rules && Array.isArray(config.rules)) {
    systemPrompt += '\n\nRules you must follow:\n';
    config.rules.forEach((rule, index) => {
      systemPrompt += `${index + 1}. ${rule}\n`;
    });
  }

  return systemPrompt;
}

module.exports = {
  generateAIResponse,
  generateAIResponseWithImages,
  cleanResponse,
  cleanUserMessage,
  buildSystemPrompt
};