Multi-Language Discord Bot: Global Community Support with AI

class MultiLanguageBot {
    constructor() {
        this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
        this.userLanguages = new Map(); // Cache user preferences
        this.serverLanguages = new Map(); // Track server language stats
    }
    
    async detectLanguage(text) {
        // Skip very short messages or those with mostly emojis/links
        if (text.length < 10 || this.isNonLinguistic(text)) {
            return null;
        }
        
        const prompt = `
        Detect the language of this text and return only the ISO 639-1 code (en, es, fr, etc.).
        If unsure or mixed languages, return the dominant language.
        If not a real language (code, random characters), return "unknown".
        
        Text: "${text}"
        `;
        
        try {
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-3.5-turbo',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.1,
                max_tokens: 10
            });
            
            const detectedLang = completion.choices[0].message.content.trim().toLowerCase();
            return this.validateLanguageCode(detectedLang);
            
        } catch (error) {
            console.error('Language detection failed:', error);
            return 'en'; // Default to English
        }
    }
    
    async translateMessage(text, fromLang, toLang) {
        // Don't translate if languages are the same
        if (fromLang === toLang) return null;
        
        const prompt = `
        Translate this text from ${fromLang} to ${toLang}.
        Preserve:
        - Discord mentions (@user, #channel) 
        - Emojis and emoji codes
        - URLs and links
        - Code blocks and formatting
        - Tone and context
        
        Original: "${text}"
        `;
        
        try {
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-4',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.3,
                max_tokens: Math.max(text.length * 2, 100)
            });
            
            return completion.choices[0].message.content.trim();
            
        } catch (error) {
            console.error('Translation failed:', error);
            return null;
        }
    }
    
    async handleMessage(message) {
        const content = message.content;
        const userId = message.author.id;
        const guildId = message.guild.id;
        
        // Detect message language
        const detectedLang = await this.detectLanguage(content);
        if (!detectedLang || detectedLang === 'unknown') return;
        
        // Update user language preference
        this.updateUserLanguage(userId, detectedLang);
        
        // Get server's primary languages (top 3 most used)
        const serverLanguages = await this.getServerLanguages(guildId);
        
        // Translate to other common languages if needed
        const translations = await this.generateTranslations(
            content, detectedLang, serverLanguages
        );
        
        if (translations.length > 0) {
            await this.sendTranslations(message, translations);
        }
    }
}

class SmartTranslationManager {
    async shouldTranslate(message, detectedLang, serverStats) {
        const factors = {
            // Server diversity - translate more in diverse servers
            languageDiversity: serverStats.uniqueLanguages / serverStats.totalUsers,
            
            // Message importance - translate commands, questions, announcements
            messageImportance: await this.assessImportance(message.content),
            
            // User engagement - translate for active community members
            userEngagement: await this.getUserEngagement(message.author.id),
            
            // Channel type - always translate in help channels
            channelType: this.getChannelType(message.channel),
            
            // Recent activity - translate more during active conversations
            conversationActivity: await this.getRecentActivity(message.channel.id)
        };
        
        const score = this.calculateTranslationScore(factors);
        return score > 0.6; // Threshold for translation
    }
    
    async assessImportance(content) {
        // Check for question words, commands, urgent keywords
        const importanceMarkers = [
            '?', '!help', '@everyone', '@here',
            'urgent', 'important', 'please', 'help',
            '❗', '🆘', '⚠️'
        ];
        
        let score = 0.3; // Base importance
        
        importanceMarkers.forEach(marker => {
            if (content.toLowerCase().includes(marker)) {
                score += 0.2;
            }
        });
        
        return Math.min(score, 1.0);
    }
    
    async generateContextualTranslations(text, fromLang, targetLangs) {
        const translations = [];
        
        for (const toLang of targetLangs) {
            const prompt = \`
            Translate this Discord message from \${fromLang} to \${toLang}.
            
            Context considerations:
            - This is a Discord community message
            - Maintain casual/informal tone appropriate for \${toLang}
            - Preserve Discord formatting (@mentions, #channels, **bold**, etc.)
            - Adapt cultural references if needed
            - Keep emojis and reactions
            
            Original (\${fromLang}): "\${text}"
            
            Provide only the translation:
            \`;
            
            try {
                const completion = await this.openai.chat.completions.create({
                    model: 'gpt-4',
                    messages: [{ role: 'user', content: prompt }],
                    temperature: 0.4,
                    max_tokens: text.length * 2
                });
                
                translations.push({
                    language: toLang,
                    text: completion.choices[0].message.content.trim(),
                    flag: this.getLanguageFlag(toLang)
                });
                
            } catch (error) {
                console.error(\`Translation to \${toLang} failed:\`, error);
            }
        }
        
        return translations;
    }
}

class TranslationQualityManager {
    async validateTranslation(original, translated, fromLang, toLang) {
        const prompt = \`
        Rate the quality of this translation on a scale of 1-10:
        
        Original (\${fromLang}): "\${original}"
        Translation (\${toLang}): "\${translated}"
        
        Consider:
        - Accuracy of meaning
        - Natural language flow
        - Preservation of tone
        - Cultural appropriateness
        
        Respond with only a number 1-10:
        \`;
        
        try {
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-3.5-turbo',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.1,
                max_tokens: 5
            });
            
            const score = parseInt(completion.choices[0].message.content.trim());
            return isNaN(score) ? 5 : Math.max(1, Math.min(10, score));
            
        } catch (error) {
            return 5; // Default to average quality
        }
    }
    
    async improveTranslation(original, translation, fromLang, toLang, issues) {
        const prompt = \`
        Improve this translation by addressing these issues: \${issues.join(', ')}
        
        Original (\${fromLang}): "\${original}"
        Current translation (\${toLang}): "\${translation}"
        
        Provide an improved version:
        \`;
        
        try {
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-4',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.3,
                max_tokens: original.length * 2
            });
            
            return completion.choices[0].message.content.trim();
            
        } catch (error) {
            return translation; // Return original if improvement fails
        }
    }
}

// Slash Commands for Translation Control

// /translate [text] [to_language] - Translate specific text
await interaction.reply({
    content: \`🌐 **Translation (\${targetLang.flag} \${targetLang.name})**\\n\${translatedText}\`,
    ephemeral: ephemeral // Only visible to command user
});

// /auto-translate [on/off] - Toggle automatic translation
const userSettings = await this.getUserSettings(userId);
userSettings.autoTranslate = !userSettings.autoTranslate;
await this.saveUserSettings(userId, userSettings);

// /language-stats - Show server language statistics  
const stats = await this.getServerLanguageStats(guildId);
const embed = this.createLanguageStatsEmbed(stats);

// /set-language [language] - Set your primary language
await this.setUserLanguage(userId, languageCode);
await interaction.reply(\`Your language has been set to \${languageInfo.flag} \${languageInfo.name}\`);

// React with flag emojis for quick translation
message.react('🇫🇷'); // React to translate to French
message.react('🇪🇸'); // React to translate to Spanish
message.react('🇩🇪'); // React to translate to German

class CulturalContextManager {
    async adaptResponseToLanguage(response, targetLang, userContext) {
        const prompt = \`
        Adapt this bot response to be culturally appropriate for \${targetLang} speakers:
        
        Original response: "\${response}"
        Target language: \${targetLang}
        User context: \${JSON.stringify(userContext)}
        
        Consider:
        - Appropriate level of formality
        - Cultural references and examples
        - Local customs and etiquette
        - Humor and communication style
        
        Provide the culturally adapted response:
        \`;
        
        try {
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-4',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.6,
                max_tokens: response.length * 2
            });
            
            return completion.choices[0].message.content.trim();
            
        } catch (error) {
            // Fallback to basic translation
            return await this.translateMessage(response, 'en', targetLang);
        }
    }
    
    getLocalizedGreeting(languageCode, timeOfDay, userName) {
        const greetings = {
            'en': { morning: 'Good morning', afternoon: 'Good afternoon', evening: 'Good evening' },
            'es': { morning: 'Buenos días', afternoon: 'Buenas tardes', evening: 'Buenas noches' },
            'fr': { morning: 'Bonjour', afternoon: 'Bon après-midi', evening: 'Bonsoir' },
            'de': { morning: 'Guten Morgen', afternoon: 'Guten Tag', evening: 'Guten Abend' },
            'ja': { morning: 'おはよう', afternoon: 'こんにちは', evening: 'こんばんは' },
            'tr': { morning: 'Günaydın', afternoon: 'İyi günler', evening: 'İyi akşamlar' }
        };
        
        const langGreetings = greetings[languageCode] || greetings['en'];
        return \`\${langGreetings[timeOfDay]}, \${userName}! \${this.getLanguageFlag(languageCode)}\`;
    }
}