server.js

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import { GoogleGenAI } from '@google/genai';
import { CONFIG, validateBotData } from './config.js';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json({ limit: '10mb' }));

const PORT = process.env.PORT || 3001;

let botsData = null;

const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// Generate World Brain
app.post('/api/generate-world', async (req, res) => {
  try {
    const { topic, roles } = req.body;
    const apiKey = req.headers['x-api-key'];
    
    if (!apiKey) {
      return res.status(400).json({ error: 'API key required' });
    }

    const ai = new GoogleGenAI({ apiKey });
    
    const tools = [{ googleSearch: {} }];
    const config = {
      thinkingConfig: { thinkingLevel: CONFIG.THINKING_LEVEL },
      tools,
      temperature: CONFIG.TEMPERATURE,
      maxOutputTokens: CONFIG.MAX_OUTPUT_TOKENS_WORLD,
    };

    const contents = [{
      role: 'user',
      parts: [{
        text: `Create global rules and environment for a virtual world simulation.
Topic: ${topic}
Roles: ${roles.join(', ')}

Output a JSON object with:
- project: description of the project
- roles: array of roles
- rules: object with communication, knowledge_share, tasks
- knowledgeDomains: object mapping each role to their knowledge areas

Output ONLY valid JSON, no markdown.`,
      }],
    }];

    const response = await ai.models.generateContent({
      model: CONFIG.MODEL,
      config,
      contents,
    });

    const text = response.candidates[0].content.parts[0].text;
    const worldBrain = JSON.parse(text.replace(/```json\n?/g, '').replace(/```\n?/g, ''));
    
    res.json({ worldBrain });
  } catch (error) {
    console.error('World generation error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Generate Bots
app.post('/api/generate-bots', async (req, res) => {
  try {
    const { totalBots, topic, roles, worldBrain } = req.body;
    const apiKey = req.headers['x-api-key'];
    
    if (!apiKey) {
      return res.status(400).json({ error: 'API key required' });
    }

    const ai = new GoogleGenAI({ apiKey });
    const botsPerRole = Math.ceil(totalBots / roles.length);
    const allBots = [];
    let botIdCounter = 1;

    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');

    res.write(`data: ${JSON.stringify({ type: 'start', totalRoles: roles.length })}\n\n`);

    for (const role of roles) {
      res.write(`data: ${JSON.stringify({ type: 'role-start', role, botsPerRole })}\n\n`);

      const tools = [{ googleSearch: {} }];
      const config = {
        thinkingConfig: { thinkingLevel: CONFIG.THINKING_LEVEL },
        tools,
        temperature: 0.4,
        maxOutputTokens: CONFIG.MAX_OUTPUT_TOKENS_ROLE,
      };

      const contents = [{
        role: 'user',
        parts: [{
          text: `Generate ${botsPerRole} independent ${role} bots for a virtual world simulation.
Topic: ${topic}
World Rules: ${JSON.stringify(worldBrain)}

Each bot must have:
- id (number)
- role (string: "${role}")
- name (unique human name)
- knowledge (array of 3-5 expertise areas)
- personality (one of: analytical/creative/critical/optimistic/detail-oriented/pragmatic)
- bias (string: what they focus on)
- confidence (number between 0.5-1.0)

Output ONLY a valid JSON array of ${botsPerRole} bot objects, no markdown.`,
        }],
      }];

      const response = await ai.models.generateContent({
        model: CONFIG.MODEL,
        config,
        contents,
      });

      const text = response.candidates[0].content.parts[0].text;
      const bots = JSON.parse(text.replace(/```json\n?/g, '').replace(/```\n?/g, ''));
      
      bots.forEach(bot => {
        bot.id = botIdCounter++;
        allBots.push(bot);
      });

      res.write(`data: ${JSON.stringify({ type: 'role-complete', role, botsGenerated: bots.length })}\n\n`);
      await wait(2000);
    }

    const finalBots = allBots.slice(0, totalBots);
    botsData = {
      worldBrain,
      bots: finalBots,
      metadata: {
        totalBots: finalBots.length,
        topic,
        roles,
        generatedAt: new Date().toISOString()
      }
    };

    res.write(`data: ${JSON.stringify({ type: 'complete', bots: finalBots, metadata: botsData.metadata })}\n\n`);
    res.end();
  } catch (error) {
    console.error('Bot generation error:', error);
    res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\n\n`);
    res.end();
  }
});

// Review Post with Batch Processing
app.post('/api/review-post', async (req, res) => {
  try {
    const { postContent, batchSize = 10, cooldownMs = 3000, temperature = 0.4 } = req.body;
    const apiKey = req.headers['x-api-key'];
    
    if (!apiKey) {
      return res.status(400).json({ error: 'API key required' });
    }

    if (!botsData || !botsData.bots.length) {
      return res.status(400).json({ error: 'No bots generated yet. Generate bots first.' });
    }

    const ai = new GoogleGenAI({ apiKey });
    const bots = botsData.bots;
    const allReviews = [];
    const batches = [];
    
    for (let i = 0; i < bots.length; i += batchSize) {
      batches.push(bots.slice(i, i + batchSize));
    }

    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');

    res.write(`data: ${JSON.stringify({ type: 'start', totalBatches: batches.length, totalBots: bots.length })}\n\n`);

    for (let i = 0; i < batches.length; i++) {
      const batch = batches[i];
      const batchNum = i + 1;
      
      res.write(`data: ${JSON.stringify({ type: 'batch-start', batchNum, totalBatches: batches.length, botsInBatch: batch.length })}\n\n`);
      
      try {
        const botDescriptions = batch.map(b => 
          `Bot ${b.id}: ${b.name} (${b.role}) - Personality: ${b.personality}, Focus: ${b.bias || 'general'}, Confidence: ${b.confidence}`
        ).join('\n');

        const tools = [{ googleSearch: {} }];
        const config = {
          thinkingConfig: { thinkingLevel: CONFIG.THINKING_LEVEL },
          tools,
          temperature: temperature || 0.4,  // Use user-defined temperature
          maxOutputTokens: CONFIG.MAX_OUTPUT_TOKENS_REVIEW,
          responseMimeType: 'application/json',  // Force JSON response
        };

        const contents = [{
          role: 'user',
          parts: [{
            text: `You are simulating ${batch.length} independent AI bots reviewing a post.

BOTS:
${botDescriptions}

POST TO REVIEW:
${postContent}

Each bot must independently review this post based on their role, personality, and focus area.

Output ONLY a valid JSON array with ${batch.length} objects, one per bot:
[
  {
    "botId": 1,
    "botName": "Alice",
    "role": "Software Engineer",
    "review": "Brief review in 1-2 sentences",
    "score": 8,
    "sentiment": "positive",
    "keyPoints": ["point1", "point2"],
    "suggestions": "One brief suggestion"
  }
]

CRITICAL: 
- Output ONLY the JSON array, nothing else
- No markdown, no explanations, no extra text
- Keep reviews SHORT (1-2 sentences max)
- Each review must be unique and independent
- Ensure all JSON is properly closed with brackets`,
          }],
        }];

        const response = await ai.models.generateContent({
          model: CONFIG.MODEL,
          config,
          contents,
        });

        // Better response handling
        if (!response.candidates || !response.candidates[0]) {
          throw new Error('No response from Gemini API');
        }

        const candidate = response.candidates[0];
        if (!candidate.content || !candidate.content.parts || !candidate.content.parts[0]) {
          throw new Error('Invalid response structure from Gemini');
        }

        const text = candidate.content.parts[0].text;
        console.log(`[Batch ${batchNum}] Raw response:`, text.substring(0, 200) + '...');
        
        // Clean and parse JSON
        let cleanedText = text.trim();
        // Remove markdown code blocks
        cleanedText = cleanedText.replace(/```json\n?/g, '').replace(/```\n?/g, '');
        // Remove any leading/trailing whitespace
        cleanedText = cleanedText.trim();
        
        // Try to find JSON array in the text
        const jsonMatch = cleanedText.match(/\[[\s\S]*\]/);
        if (!jsonMatch) {
          console.error(`[Batch ${batchNum}] No JSON array found. Response:`, cleanedText.substring(0, 500));
          throw new Error('No JSON array found in response. Try reducing batch size to 5-10 bots.');
        }
        
        const reviews = JSON.parse(jsonMatch[0]);
        console.log(`[Batch ${batchNum}] Parsed ${reviews.length} reviews`);
        allReviews.push(...reviews);
        
        res.write(`data: ${JSON.stringify({ type: 'batch-complete', batchNum, reviews: reviews.length })}\n\n`);
      } catch (error) {
        console.error(`[Batch ${batchNum}] Error:`, error.message);
        res.write(`data: ${JSON.stringify({ type: 'batch-error', batchNum, error: error.message })}\n\n`);
      }
      
      if (i < batches.length - 1) {
        res.write(`data: ${JSON.stringify({ type: 'cooldown', ms: cooldownMs })}\n\n`);
        await wait(cooldownMs);
      }
    }

    res.write(`data: ${JSON.stringify({ type: 'generating-summary', totalReviews: allReviews.length })}\n\n`);

    console.log(`[Summary] Generating summary for ${allReviews.length} reviews`);

    // If no reviews collected, send error
    if (allReviews.length === 0) {
      console.error('[Summary] No reviews to summarize');
      res.write(`data: ${JSON.stringify({ type: 'error', error: 'No reviews were successfully generated. Please try again with a smaller batch size or check your API key.' })}\n\n`);
      res.end();
      return;
    }

    // Generate final summary
    const avgScore = (allReviews.reduce((sum, r) => sum + r.score, 0) / allReviews.length).toFixed(2);
    const sentimentCounts = allReviews.reduce((acc, r) => {
      acc[r.sentiment] = (acc[r.sentiment] || 0) + 1;
      return acc;
    }, {});

    const tools = [{ googleSearch: {} }];
    const config = {
      thinkingConfig: { thinkingLevel: CONFIG.THINKING_LEVEL },
      tools,
      temperature: 0.3,
      maxOutputTokens: CONFIG.MAX_OUTPUT_TOKENS_REVIEW,
      responseMimeType: 'application/json',  // Force JSON response
    };

    const contents = [{
      role: 'user',
      parts: [{
        text: `Analyze ${allReviews.length} bot reviews and create a comprehensive summary.

POST:
${postContent}

REVIEWS DATA:
- Average Score: ${avgScore}/10
- Sentiment: ${JSON.stringify(sentimentCounts)}
- Sample Reviews: ${JSON.stringify(allReviews.slice(0, 10))}

Create a final summary with:
1. Overall verdict (good/bad/mixed)
2. Top 3 strengths
3. Top 3 weaknesses
4. Key improvement suggestions
5. Role-specific insights
6. Actionable next steps

Output as JSON:
{
  "overallVerdict": "string",
  "averageScore": number,
  "sentiment": {...},
  "strengths": ["string"],
  "weaknesses": ["string"],
  "suggestions": ["string"],
  "roleInsights": {...},
  "nextSteps": ["string"]
}`,
      }],
    }];

    const summaryResponse = await ai.models.generateContent({
      model: CONFIG.MODEL,
      config,
      contents,
    });

    // Better response handling for summary
    if (!summaryResponse.candidates || !summaryResponse.candidates[0]) {
      throw new Error('No summary response from Gemini API');
    }

    const summaryCandidate = summaryResponse.candidates[0];
    if (!summaryCandidate.content || !summaryCandidate.content.parts || !summaryCandidate.content.parts[0]) {
      throw new Error('Invalid summary response structure');
    }

    const summaryText = summaryCandidate.content.parts[0].text;
    console.log('[Summary] Raw summary:', summaryText.substring(0, 200) + '...');
    
    // Clean and parse summary JSON
    let cleanedSummary = summaryText.trim();
    cleanedSummary = cleanedSummary.replace(/```json\n?/g, '').replace(/```\n?/g, '');
    cleanedSummary = cleanedSummary.trim();
    
    // Try to find JSON object in the text
    const summaryMatch = cleanedSummary.match(/\{[\s\S]*\}/);
    if (!summaryMatch) {
      throw new Error('No JSON object found in summary response');
    }
    
    const summary = JSON.parse(summaryMatch[0]);
    console.log('[Summary] Summary generated successfully');

    const finalData = { type: 'complete', reviews: allReviews, summary };
    console.log('[Complete] Sending final data:', { reviewsCount: allReviews.length, hasSummary: !!summary });
    
    res.write(`data: ${JSON.stringify(finalData)}\n\n`);
    res.end();
  } catch (error) {
    console.error('Review error:', error);
    res.write(`data: ${JSON.stringify({ type: 'error', error: error.message, stack: error.stack })}\n\n`);
    res.end();
  }
});

// API: Get current bots
app.get('/api/bots', (req, res) => {
  if (!botsData) {
    return res.json({ bots: [], metadata: null });
  }
  res.json(botsData);
});

// API: Set bots (for imported bots)
app.post('/api/set-bots', (req, res) => {
  try {
    const { bots, metadata } = req.body;
    
    // Validate bot data
    const validation = validateBotData({ bots, metadata });
    if (!validation.valid) {
      console.error('Bot validation failed:', validation.error);
      return res.status(400).json({ error: `Invalid bot data: ${validation.error}` });
    }
    
    if (!bots || !Array.isArray(bots)) {
      return res.status(400).json({ error: 'Invalid bots data' });
    }

    botsData = {
      worldBrain: metadata?.worldBrain || {},
      bots,
      metadata: metadata || {
        totalBots: bots.length,
        topic: 'Imported',
        roles: [...new Set(bots.map(b => b.role))],
        importedAt: new Date().toISOString()
      }
    };

    console.log(`✅ Imported ${bots.length} bots to server (validated)`);
    res.json({ success: true, botsCount: bots.length });
  } catch (error) {
    console.error('Error setting bots:', error);
    res.status(500).json({ error: error.message });
  }
});

app.listen(PORT, () => {
  console.log(`\n🚀 Virtual World Bot Reviewer API`);
  console.log(`📡 Server: http://localhost:${PORT}`);
  console.log(`🔑 Model: ${CONFIG.MODEL}\n`);
});