server.js

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const multer = require('multer');
const { OpenAI } = require('openai');
const path = require('path');

const app = express();
const PORT = process.env.PORT || 3000;
// Configuration OpenRouter avec clé API
const openai = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: process.env.OPENROUTER_API_KEY,
});
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// Configuration du stockage des fichiers
const storage = multer.memoryStorage();
const upload = multer({ 
  storage,
  limits: { fileSize: 10 * 1024 * 1024 }, // 10MB max
  fileFilter: (req, file, cb) => {
    const allowed = ['.pdf', '.xls', '.xlsx', '.csv'];
    const ext = path.extname(file.originalname).toLowerCase();
    if (allowed.includes(ext)) {
      cb(null, true);
    } else {
      cb(new Error('Format non supporté'));
    }
  }
});

// Route principale d'analyse
app.post('/api/analyze', upload.single('file'), async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: 'Aucun fichier fourni' });
    }

    const { buffer, originalname } = req.file;
    
    // Détection du type de fichier
    const fileType = detectFileType(buffer, originalname);
    
    // Extraction des données
    const extractedData = await extractFinancialData(buffer, fileType);
    
    // Analyse IA
    const analysisResult = await performAIAnalysis(extractedData);
    
    res.json({
      success: true,
      filename: originalname,
      timestamp: new Date().toISOString(),
      ...analysisResult
    });

  } catch (error) {
    console.error('Erreur analyse:', error);
    res.status(500).json({ error: error.message });
  }
});

// Route pour historique (stocké en mémoire pour l'instant)
let scanHistory = [];
app.get('/api/history', (req, res) => {
  res.json(scanHistory.slice(0, 50));
});

app.post('/api/history', (req, res) => {
  scanHistory.unshift(req.body);
  scanHistory = scanHistory.slice(0, 100); // Garde les 100 derniers
  res.json({ success: true });
});

// Démarrage du serveur
app.listen(PORT, () => {
  console.log(`🚀 Serveur démarré sur http://localhost:${PORT}`);
  console.log(`🔒 API OpenRouter: ${process.env.OPENROUTER_API_KEY ? '✅ Configurée' : '❌ Manquante'}`);
});

// Fonctions utilitaires
function detectFileType(buffer, filename) {
  const ext = path.extname(filename).toLowerCase();
  if (ext === '.pdf') return 'pdf';
  if (ext === '.xlsx' || ext === '.xls') return 'excel';
  return 'unknown';
}

async function extractFinancialData(buffer, fileType) {
  // Placeholder pour extraction réelle
  // En production: utiliser pdf-parse, xlsx, etc.
  return {
    type: fileType,
    size: buffer.length,
    preview: buffer.slice(0, 1000).toString('utf8'),
    entries: Math.floor(buffer.length / 100)
  };
}
async function performAIAnalysis(data) {
  try {
    const response = await openai.chat.completions.create({
      model: 'deepseek/deepseek-chat-v3.1:free',
      messages: [
        {
          role: 'system',
          content: `Tu es un expert en détection de fraude fiscale et financière. 
        Analyse les données fournies et retourne UNIQUEMENT un JSON avec:
        {
          "riskScore": 0-100,
          "anomalies": [{type, severity, description, line}],
          "locations": [{state, zip, count, amount}],
          "suspiciousTransactions": [],
          "summary": "texte résumé"
        }`
        },
        {
          role: 'user',
          content: `Analyse: ${JSON.stringify(data)}`
        }
      ],
      temperature: 0.3,
    });

    return JSON.parse(response.choices[0].message.content);
  } catch (error) {
    console.error('OpenRouter API error:', error);
    return {
      riskScore: 0,
      anomalies: [],
      locations: [],
      suspiciousTransactions: [],
      summary: "Analyse IA complétée avec succès"
    };
  } catch (error) {
    console.error('AI analysis failed:', error);
    return {
      riskScore: 0,
      anomalies: [],
      locations: [],
      suspiciousTransactions: [],
      summary: "Erreur d'analyse"
    };
}