index.js

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import { GoogleGenerativeAI } from '@google/generative-ai';

// Charger les variables d'environnement
dotenv.config();

const app = express();
const PORT = process.env.PORT || 3001;

// Initialiser Gemini
let genAI;
if (process.env.GEMINI_API_KEY) {
  genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
}

// Middleware
app.use(cors());
app.use(express.json());

// Route pour générer un proverbe
app.post('/api/generate-proverb', async (req, res) => {
  try {
    const { language } = req.body;
    
    if (!process.env.GEMINI_API_KEY) {
      return res.status(500).json({ 
        error: 'Gemini API key not configured' 
      });
    }
    
    const prompt = language === 'fr' 
      ? "Génère un proverbe inspirant et original en français. Le proverbe doit être court (maximum 2-3 phrases), positif, et adapté à tout public. Il doit transmettre une leçon de vie ou une sagesse universelle. Ne pas inclure de guillemets dans la réponse. Réponds uniquement avec le proverbe, sans introduction ni explication."
      : "Generate an inspiring and original proverb in English. The proverb should be short (maximum 2-3 sentences), positive, and suitable for all audiences. It should convey a life lesson or universal wisdom. Do not include quotes in the response. Reply only with the proverb, without introduction or explanation.";

    const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
    
    const result = await model.generateContent(prompt);
    const response = await result.response;
    const proverb = response.text().trim();

    if (!proverb) {
      throw new Error("No proverb generated");
    }

    res.json({ proverb });
  } catch (error) {
    console.error("Error generating proverb:", error);
    res.status(500).json({ 
      error: "Failed to generate proverb",
      details: error.message 
    });
  }
});

// Route pour la synthèse vocale
app.post('/api/text-to-speech', async (req, res) => {
  try {
    const { text, language } = req.body;
    
    if (!process.env.ELEVENLABS_API_KEY) {
      return res.status(500).json({ 
        error: 'ElevenLabs API key not configured' 
      });
    }
    
    // Utiliser différentes voix pour français et anglais
    const voiceId = language === 'fr' 
      ? "pNInz6obpgDQGcFmaJgB" // Voix française (Adam)
      : "21m00Tcm4TlvDq8ikWAM"; // Voix anglaise (Rachel)

    const elevenlabsResponse = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
      method: "POST",
      headers: {
       
        "Content-Type": "application/json",
        "xi-api-key": process.env.ELEVENLABS_API_KEY,
      },
      body: JSON.stringify({
        text: text,
        model_id: "eleven_multilingual_v2",
        voice_settings: {
          stability: 0.5,
          similarity_boost: 0.8,
          style: 0.2,
          use_speaker_boost: true
        }
      }),
    });

    if (!elevenlabsResponse.ok) {
      const errorData = await elevenlabsResponse.text();
      console.error('ElevenLabs API Error:', errorData);
      throw new Error(`ElevenLabs API error: ${elevenlabsResponse.status}`);
    }

    const audioBuffer = await elevenlabsResponse.arrayBuffer();
    const buffer = Buffer.from(audioBuffer);

    res.set({
      'Content-Type': 'audio/mpeg',
      'Content-Length': buffer.length,
    });
    
    res.send(buffer);
  } catch (error) {
    console.error("Error generating speech:", error);
    res.status(500).json({ 
      error: "Failed to generate speech",
      details: error.message 
    });
  }
});

// Route de santé
app.get('/api/health', (req, res) => {
  res.json({ 
    status: 'OK', 
    message: 'Proverbs Generator API is running',
    timestamp: new Date().toISOString()
  });
});

app.listen(PORT, async () => {
  console.log(`🚀 Serveur démarré sur http://localhost:${PORT}`);
  console.log(`📡 API disponible sur http://localhost:${PORT}/api`);
  
  /* List available models if Gemini is configured
  if (genAI) {
    try {
      const models = await genAI.listModels();
      console.log('📋 Available Gemini models:');
      models.forEach(m => console.log(`  - ${m.name}`));
    } catch (error) {
      console.error('Error listing models:', error.message);
    }
  }
    */
  
  // Vérifier les clés API
  if (!process.env.GEMINI_API_KEY) {
    console.warn('⚠️  GEMINI_API_KEY non configurée');
  }
  if (!process.env.ELEVENLABS_API_KEY) {
    console.warn('⚠️  ELEVENLABS_API_KEY non configurée');
  }
});