espace-paie-odentas/app/api/odentas-sign/webhooks/completion/route.ts

import { NextRequest, NextResponse } from 'next/server';
import { supabaseAdmin, logSignEvent, getSignEvents } from '@/lib/odentas-sign/supabase';
import { uploadEvidenceBundle } from '@/lib/odentas-sign/s3';
import type { EvidenceBundle } from '@/lib/odentas-sign/types';

/**
 * POST /api/odentas-sign/webhooks/completion
 * 
 * Webhook appelé quand tous les signataires ont signé
 * Lance le workflow de scellage : injection signatures → PAdES → TSA → Archive
 */
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const { requestId } = body;
    
    if (!requestId) {
      return NextResponse.json(
        { error: 'requestId manquant' },
        { status: 400 }
      );
    }
    
    console.log(`[WEBHOOK COMPLETION] Début traitement pour request ${requestId}`);
    
    // 1. Récupérer toutes les données de la demande
    const { data: signRequest, error: requestError } = await supabaseAdmin
      .from('sign_requests')
      .select(`
        *,
        signers(*),
        sign_positions(*)
      `)
      .eq('id', requestId)
      .single();
    
    // Détecter si c'est une demande de test
    const isTestMode = signRequest?.source_s3_key?.includes('/test/') || signRequest?.ref?.startsWith('TEST-');
    
    if (isTestMode) {
      console.log(`[WEBHOOK COMPLETION] 🧪 MODE TEST détecté - scellage PAdES désactivé`);
    }
    
    if (requestError || !signRequest) {
      console.error('[WEBHOOK] Erreur récupération demande:', requestError);
      return NextResponse.json(
        { error: 'Demande introuvable' },
        { status: 404 }
      );
    }
    
    // Vérifier que tous ont bien signé
    const allSigned = signRequest.signers.every((s: any) => s.signed_at !== null);
    if (!allSigned) {
      return NextResponse.json(
        { error: 'Tous les signataires n\'ont pas encore signé' },
        { status: 400 }
      );
    }
    
    // 2. Logger l'événement de début de scellage
    await logSignEvent({
      requestId: signRequest.id,
      event: 'sealing_started',
      metadata: {
        signers_count: signRequest.signers.length,
      },
    });
    
    // 3. Récupérer tous les événements pour le bundle de preuves
    const events = await getSignEvents(requestId);
    
    // 4. Créer le bundle de preuves (evidence)
    const evidenceBundle: EvidenceBundle = {
      request_id: signRequest.id,
      request_ref: signRequest.ref,
      title: signRequest.title,
      created_at: signRequest.created_at,
      completed_at: new Date().toISOString(),
      eidas_level: 'SES', // Signature Électronique Simple pour le moment
      signers: signRequest.signers.map((s: any) => ({
        id: s.id,
        role: s.role,
        name: s.name,
        email: s.email,
        signed_at: s.signed_at,
        ip_address: s.ip_signed || 'N/A',
        user_agent: s.user_agent || 'N/A',
        consent_text: s.consent_text,
        consent_at: s.consent_at,
        signature_method: 'drawn', // TODO: détecter drawn vs uploaded
        authentication: {
          method: 'OTP',
          otp_sent_at: events.find((e: any) => e.event === 'otp_sent' && e.signer_id === s.id)?.ts || 'N/A',
          otp_verified_at: events.find((e: any) => e.event === 'otp_verified' && e.signer_id === s.id)?.ts || 'N/A',
          email_verified: true,
        },
      })),
      events: events.map((e: any) => ({
        timestamp: e.ts,
        event: e.event,
        actor: e.signer_id || null,
        ip: e.ip || null,
        metadata: e.metadata,
      })),
      seal: {
        algorithm: 'RSASSA_PSS_SHA_256',
        kms_key_id: process.env.KMS_KEY_ID || 'N/A',
        sealed_at: '',
        pdf_sha256: '',
      },
      tsa: {
        url: process.env.TSA_URL || 'https://timestamp.sectigo.com',
        tsr_sha256: '',
        policy_oid: null,
        serial: null,
      },
      retention: {
        archive_key: '',
        retain_until: '',
        compliance_mode: 'COMPLIANCE',
      },
    };
    
    // 5. Upload du bundle de preuves initial (sera mis à jour après scellage)
    const evidenceKey = await uploadEvidenceBundle({
      requestRef: signRequest.ref,
      evidence: evidenceBundle,
    });
    
    console.log(`[WEBHOOK] ✅ Evidence bundle uploadé: ${evidenceKey}`);
    
    // 6. Workflow de scellage (sauté en mode test)
    if (isTestMode) {
      console.log(`[WEBHOOK] 🧪 MODE TEST : Scellage PAdES/TSA/Archive SAUTE`);
      console.log(`[WEBHOOK] En production, les étapes suivantes seraient exécutées :`);
      console.log(`  1. Injection des signatures visuelles dans le PDF`);
      console.log(`  2. Scellage PAdES avec lambda-odentas-pades-sign`);
      console.log(`  3. Horodatage TSA avec lambda-tsaStamp`);
      console.log(`  4. Archivage avec Object Lock 10 ans`);
      
      // Mise à jour du statut seulement
      const { error: updateError } = await supabaseAdmin
        .from('sign_requests')
        .update({ status: 'completed' })
        .eq('id', requestId);
      
      if (updateError) {
        console.error('[WEBHOOK] Erreur mise à jour statut:', updateError);
      }
      
      // Créer un enregistrement de test dans sign_assets
      const { error: assetsError } = await supabaseAdmin
        .from('sign_assets')
        .insert({
          request_id: requestId,
          evidence_json_s3_key: evidenceKey,
          // Pas de PDF signé ni de TSA en mode test
        });
      
      if (assetsError) {
        console.error('[WEBHOOK] Erreur création sign_assets:', assetsError);
      }
      
    } else {
      // MODE PRODUCTION : Appeler la Lambda d'orchestration
      // TODO: Implémenter l'appel à la Lambda qui va :
      //    - Injecter les signatures visuelles dans le PDF
      //    - Sceller avec PAdES (lambda-odentas-pades-sign)
      //    - Horodater avec TSA (lambda-tsaStamp)
      //    - Archiver avec Object Lock (10 ans)
      
      console.log(`[WEBHOOK] TODO: Appeler lambda-odentas-sign-orchestrator`);
      
      const { error: updateError } = await supabaseAdmin
        .from('sign_requests')
        .update({ status: 'completed' })
        .eq('id', requestId);
      
      if (updateError) {
        console.error('[WEBHOOK] Erreur mise à jour statut:', updateError);
      }
      
      // Créer l'enregistrement dans sign_assets (sera complété par la Lambda)
      const retainUntilDate = new Date();
      retainUntilDate.setFullYear(retainUntilDate.getFullYear() + 10);
      
      const { error: assetsError } = await supabaseAdmin
        .from('sign_assets')
        .insert({
          request_id: requestId,
          evidence_json_s3_key: evidenceKey,
          retain_until: retainUntilDate.toISOString(),
        });
      
      if (assetsError) {
        console.error('[WEBHOOK] Erreur création sign_assets:', assetsError);
      }
    }
    
    // 8. Logger la completion
    await logSignEvent({
      requestId: signRequest.id,
      event: isTestMode ? 'test_request_completed' : 'request_completed',
      metadata: {
        evidence_key: evidenceKey,
        status: 'completed',
        test_mode: isTestMode,
      },
    });
    
    // 9. TODO: Envoyer les emails de notification aux signataires
    if (isTestMode) {
      console.log(`[WEBHOOK] 🧪 MODE TEST : Envoi d'emails désactivé`);
    } else {
      console.log(`[WEBHOOK] TODO: Envoyer emails de completion`);
    }
    
    console.log(`[WEBHOOK COMPLETION] ✅ Traitement terminé pour ${signRequest.ref}${isTestMode ? ' (MODE TEST)' : ''}`);
    
    return NextResponse.json({
      success: true,
      message: isTestMode ? 'Test complété (scellage désactivé)' : 'Workflow de scellage lancé',
      test_mode: isTestMode,
      request: {
        id: signRequest.id,
        ref: signRequest.ref,
        status: 'completed',
      },
      evidence_key: evidenceKey,
    });
    
  } catch (error) {
    console.error('[WEBHOOK COMPLETION] Erreur:', error);
    return NextResponse.json(
      { error: 'Erreur serveur', details: error instanceof Error ? error.message : String(error) },
      { status: 500 }
    );
  }
}