#!/usr/bin/env node
/**
 * Serveur MCP (HTTP, Streamable HTTP transport) — Crowdlending Tracker
 *
 * Point d'entrée unique, que ce soit en développement local (`npm run dev`,
 * comme le backend et le frontend) ou déployé à distance en production
 * (mcp.crowdlending.croguennec.net, service `crowdlending-mcp` du
 * docker-compose). Un seul modèle de transport, un seul fichier à
 * maintenir : les outils eux-mêmes vivent dans tools.js.
 *
 * AUTHENTIFICATION : aucune clé API fixe côté serveur, contrairement à
 * l'ancien serveur stdio. Un même process peut servir plusieurs
 * utilisateurs/sessions en parallèle (typiquement un seul en dev local,
 * potentiellement plusieurs en déploiement distant) — chaque session MCP est
 * initialisée à partir de la clé API fournie dans l'en-tête `X-API-Key` de
 * la requête HTTP qui l'a créée, puis cette clé est fermée dans le closure
 * des outils de CETTE session uniquement (voir createSession). Deux sessions
 * ne partagent jamais d'état ni de données.
 *
 * Connexion depuis Claude Desktop (dev comme prod) : ce fichier expose du
 * HTTP pur, mais claude_desktop_config.json n'accepte que des entrées
 * command/args — la connexion passe donc par le pont mcp-remote
 * (https://github.com/geelen/mcp-remote), voir README.md pour la config
 * exacte (et le wrapper cmd /c obligatoire sous Windows).
 */

import { randomUUID } from 'node:crypto';
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
import rateLimit from 'express-rate-limit';
import { registerDataTools, registerFetchUrlTool } from './tools.js';

const PORT = Number(process.env.PORT || 4100);
const API_BASE = (process.env.CROWDLENDING_API_URL || 'http://localhost:4000/api/v1').replace(/\/$/, '');

// Étiquette facultative pour distinguer plusieurs instances connectées en
// même temps à Claude Desktop (ex. dev local + prod distante). Affiche
// "[DEV]"/"[PROD]" dans le titre de chaque outil et la source exacte en fin
// de description — comme l'ancien CROWDLENDING_LABEL du serveur stdio.
const LABEL = (process.env.MCP_LABEL || '').trim();

// Désactivé par défaut : cet outil lit une URL arbitraire fournie par
// l'appelant, sûr pour un usage perso (vous seul avez la clé API et
// n'atteignez que ce process) mais risqué si le serveur est exposé à des
// tiers non maîtrisés (SSRF). À activer explicitement pour le développement
// local — jamais sur le déploiement distant public (voir docker-compose.yml).
const ENABLE_FETCH_URL = ['1', 'true', 'yes'].includes((process.env.MCP_ENABLE_FETCH_URL || '').toLowerCase());

// Nom(s) d'hôte attendus dans l'en-tête Host — protection anti DNS-rebinding.
// `localhost` est inclus par défaut : nécessaire en développement local
// (connexion directe à localhost:4100) et pour que le HEALTHCHECK Docker
// (qui interroge http://localhost:4100/health depuis l'intérieur du
// container) ne soit pas lui-même bloqué. Sans risque côté externe en
// production : Traefik ne route vers ce service que les requêtes portant le
// Host public configuré sur son router.
const ALLOWED_HOSTS = (process.env.MCP_ALLOWED_HOSTS || 'mcp.crowdlending.croguennec.net,localhost')
  .split(',').map((h) => h.trim()).filter(Boolean);

// Durée d'inactivité au-delà de laquelle une session orpheline est fermée
// (client parti sans DELETE explicite — évite une fuite mémoire lente).
const SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 min

console.error(`[crowdlending-mcp${LABEL ? `-${LABEL}` : ''}] démarrage — API cible : ${API_BASE}, hôtes autorisés : ${ALLOWED_HOSTS.join(', ')}, fetch_url : ${ENABLE_FETCH_URL ? 'activé' : 'désactivé'}`);

/** Préfixe commun à toutes les lignes de log applicatif. */
const LOG_PREFIX = `[crowdlending-mcp${LABEL ? `-${LABEL}` : ''}]`;

/** Résumé lisible d'une requête JSON-RPC entrante (nom d'outil pour un
 *  tools/call, méthode sinon), pour le log applicatif — jamais la clé API. */
function describeRequest(body) {
  if (!body || typeof body !== 'object') return 'requête inconnue';
  if (body.method === 'tools/call') return `tools/call ${body.params?.name || '?'}`;
  return body.method || 'requête inconnue';
}

/** Ajoute le libellé d'environnement au titre d'un outil (ex. "[PROD]"). */
const withLabel = (title) => LABEL ? `${title} [${LABEL.toUpperCase()}]` : title;

/** Ajoute la source (URL API + libellé) en fin de description. */
const withSource = (description) =>
  `${description}\n\nSource de données : ${API_BASE}${LABEL ? ` (environnement : ${LABEL})` : ''}`;

/* ── Client API : une closure par session, liée à LA clé API de cette
   session (jamais un module-level constant). ── */
function makeApiGet(apiKey) {
  return async function apiGet(path, params) {
    const url = new URL(API_BASE + path);
    if (params) {
      for (const [k, v] of Object.entries(params)) {
        if (v !== undefined && v !== null && v !== '') url.searchParams.set(k, String(v));
      }
    }

    let res;
    try {
      res = await fetch(url, {
        headers: { 'X-API-Key': apiKey, 'Accept': 'application/json' },
        signal: AbortSignal.timeout(15000),
      });
    } catch (e) {
      throw new Error(`Impossible de joindre l'API (${API_BASE}) : ${e.message}`);
    }

    const text = await res.text();
    let body;
    try { body = text ? JSON.parse(text) : null; } catch { body = text; }

    if (!res.ok) {
      const msg = (body && body.error) || res.statusText || 'Requête échouée';
      if (res.status === 401) throw new Error(`Clé API invalide ou révoquée (${msg}). Générez-en une nouvelle dans Mon compte → Clés API.`);
      if (res.status === 404) throw new Error(`Ressource introuvable : ${msg}`);
      throw new Error(`Erreur API (${res.status}) : ${msg}`);
    }
    return body;
  };
}

/* ── Gestion des sessions ─────────────────────────────────────────────── */
// sessionId -> { transport, apiKey, lastActivity }
const sessions = new Map();

function touchSession(sessionId) {
  const s = sessions.get(sessionId);
  if (s) s.lastActivity = Date.now();
}

setInterval(() => {
  const now = Date.now();
  for (const [sessionId, s] of sessions.entries()) {
    if (now - s.lastActivity > SESSION_IDLE_TIMEOUT_MS) {
      console.error(`${LOG_PREFIX} session ${sessionId.slice(0, 8)} inactive depuis plus de 30 min, fermeture.`);
      s.transport.close();
      sessions.delete(sessionId);
    }
  }
}, 5 * 60 * 1000).unref();

/** Crée un serveur MCP + transport pour une nouvelle session, lié à `apiKey`. */
async function createSession(apiKey) {
  const server = new McpServer({ name: 'crowdlending-mcp' + (LABEL ? `-${LABEL}` : ''), version: '0.2.0' });
  registerDataTools(server, { apiGet: makeApiGet(apiKey), withLabel, withSource });
  if (ENABLE_FETCH_URL) registerFetchUrlTool(server);

  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: () => randomUUID(),
    onsessioninitialized: (sessionId) => {
      sessions.set(sessionId, { transport, apiKey, lastActivity: Date.now() });
    },
  });
  transport.onclose = () => {
    if (transport.sessionId) sessions.delete(transport.sessionId);
  };

  await server.connect(transport);
  return transport;
}

/* ── Application Express ──────────────────────────────────────────────── */
const app = createMcpExpressApp({ host: '0.0.0.0', allowedHosts: ALLOWED_HOSTS });

// Limite basique anti-abus : une clé compromise ou un client buggé ne doit
// pas pouvoir marteler l'API backend sans frein.
app.use(rateLimit({
  windowMs: 60 * 1000,
  limit: 60,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: 'Trop de requêtes — réessayez dans une minute.' },
}));

app.get('/health', (req, res) => res.json({ status: 'ok', sessions: sessions.size }));

app.post('/mcp', async (req, res) => {
  try {
    const sessionId = req.headers['mcp-session-id'];

    if (sessionId) {
      const session = sessions.get(sessionId);
      if (!session) {
        res.status(404).json({ jsonrpc: '2.0', error: { code: -32001, message: 'Session inconnue ou expirée' }, id: null });
        return;
      }
      // Garde-fou : si le client envoie une clé API différente de celle qui a
      // créé la session, on refuse plutôt que de silencieusement continuer
      // avec l'ancienne clé.
      const headerKey = req.headers['x-api-key'];
      if (headerKey && headerKey !== session.apiKey) {
        res.status(403).json({ jsonrpc: '2.0', error: { code: -32002, message: 'Clé API différente de celle ayant initialisé cette session' }, id: null });
        return;
      }
      touchSession(sessionId);
      const label = describeRequest(req.body);
      const startedAt = Date.now();
      await session.transport.handleRequest(req, res, req.body);
      console.error(`${LOG_PREFIX} session ${sessionId.slice(0, 8)} — ${label} — ${res.statusCode} (${Date.now() - startedAt}ms)`);
      return;
    }

    if (!isInitializeRequest(req.body)) {
      res.status(400).json({ jsonrpc: '2.0', error: { code: -32000, message: 'Requête invalide : aucun identifiant de session fourni' }, id: null });
      return;
    }

    const apiKey = req.headers['x-api-key'];
    if (!apiKey) {
      res.status(401).json({ jsonrpc: '2.0', error: { code: -32003, message: "En-tête X-API-Key manquant. Générez une clé dans Mon compte → Clés API." }, id: null });
      return;
    }

    const transport = await createSession(apiKey);
    const startedAt = Date.now();
    await transport.handleRequest(req, res, req.body);
    console.error(`${LOG_PREFIX} nouvelle session ${transport.sessionId ? transport.sessionId.slice(0, 8) : '?'} — initialize — ${res.statusCode} (${Date.now() - startedAt}ms)`);
  } catch (e) {
    console.error(`${LOG_PREFIX} erreur /mcp POST :`, e);
    if (!res.headersSent) res.status(500).json({ jsonrpc: '2.0', error: { code: -32603, message: e.message }, id: null });
  }
});

/** GET (flux SSE de notifications) et DELETE (fin de session) délèguent au
 *  transport existant, identifié par `mcp-session-id` — jamais de création
 *  de session sur ces deux méthodes. */
async function handleExistingSession(req, res) {
  const sessionId = req.headers['mcp-session-id'];
  const session = sessionId && sessions.get(sessionId);
  if (!session) {
    res.status(404).json({ error: 'Session inconnue ou expirée' });
    return;
  }
  touchSession(sessionId);
  await session.transport.handleRequest(req, res);
}

app.get('/mcp', handleExistingSession);
app.delete('/mcp', handleExistingSession);

app.listen(PORT, '0.0.0.0', () => {
  console.error(`${LOG_PREFIX} à l'écoute sur le port ${PORT}`);
});