espace-paie-odentas/app/api/dl-contrat-signe/route.ts

// app/api/dl-contrat-signe/route.ts
import { NextRequest, NextResponse } from "next/server";
import { createClient } from "@supabase/supabase-js";
import { getS3SignedUrlIfExists } from "@/lib/aws-s3";
import AWS from "aws-sdk";

// Configuration AWS pour DynamoDB
const dynamoDB = new AWS.DynamoDB.DocumentClient({
  region: process.env.AWS_REGION || 'eu-west-3',
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
});

// Fonction pour récupérer le docusealSubID depuis DynamoDB
async function getDocusealSubIdFromDynamoDB(submissionId: string): Promise<string | null> {
  try {
    console.log("🔍 Recherche dans DynamoDB pour submission_id:", submissionId);
    
    const params = {
      TableName: 'DocuSealNotification',
      Key: { submission_id: submissionId }
    };

    const result = await dynamoDB.get(params).promise();
    
    if (result.Item) {
      const docusealSubID = result.Item.docusealSubID || result.Item.docuseal_submission_id;
      console.log("✅ DocusealSubID trouvé dans DynamoDB:", docusealSubID);
      return docusealSubID;
    } else {
      console.log("❌ Aucune entrée trouvée dans DynamoDB pour:", submissionId);
      return null;
    }
  } catch (error) {
    console.error("❌ Erreur lors de la recherche DynamoDB:", error);
    return null;
  }
}

export async function GET(request: NextRequest) {
  try {
    const url = new URL(request.url);
    const contractId = url.searchParams.get("contract_id");

    if (!contractId) {
      return NextResponse.json(
        { error: "Le paramètre contract_id est requis" },
        { status: 400 }
      );
    }

    // Utiliser le service role pour accéder aux données sans authentification
    const supabaseUrl = process.env.SUPABASE_URL;
    const supabaseServiceRole = process.env.SUPABASE_SERVICE_ROLE_KEY;

    if (!supabaseUrl || !supabaseServiceRole) {
      console.error("Configuration Supabase manquante");
      return NextResponse.json(
        { error: "Configuration serveur incomplète" },
        { status: 500 }
      );
    }

    const sb = createClient(supabaseUrl, supabaseServiceRole, {
      auth: {
        autoRefreshToken: false,
        persistSession: false
      }
    });

    // Rechercher le contrat par différentes méthodes
    let contract = null;
    let contractError = null;
    let searchMethod = "";

    // 1. Essayer par docuseal_submission_id direct
    console.log("🔍 Recherche par docuseal_submission_id:", contractId);
    const { data: contractBySubmission, error: errorBySubmission } = await sb
      .from("cddu_contracts")
      .select("id, contract_pdf_s3_key, contract_number, docuseal_submission_id")
      .eq("docuseal_submission_id", contractId)
      .single();

    if (contractBySubmission) {
      contract = contractBySubmission;
      searchMethod = "docuseal_submission_id_direct";
      console.log("✅ Contrat trouvé par docuseal_submission_id direct");
    } else {
      console.log("❌ Pas de contrat trouvé par docuseal_submission_id direct:", errorBySubmission?.message);

      // 2. Si ça ressemble à un submission_id DynamoDB (format: contrats/contrat_cddu_XXX_YYY)
      if (contractId.includes('contrats/contrat_cddu_')) {
        console.log("🔍 Format DynamoDB détecté, recherche dans DynamoDB...");
        const docusealSubID = await getDocusealSubIdFromDynamoDB(contractId);
        
        if (docusealSubID) {
          console.log("🔍 Recherche par docusealSubID depuis DynamoDB:", docusealSubID);
          const { data: contractByDynamoDB, error: errorByDynamoDB } = await sb
            .from("cddu_contracts")
            .select("id, contract_pdf_s3_key, contract_number, docuseal_submission_id")
            .eq("docuseal_submission_id", docusealSubID)
            .single();

          if (contractByDynamoDB) {
            contract = contractByDynamoDB;
            searchMethod = "dynamodb_lookup";
            console.log("✅ Contrat trouvé via DynamoDB lookup");
          } else {
            console.log("❌ Pas de contrat trouvé avec docusealSubID depuis DynamoDB:", errorByDynamoDB?.message);
          }
        }
      }

      // 3. Si ça ressemble à une clé S3, essayer par contract_pdf_s3_key
      if (!contract && contractId.includes('/') && contractId.includes('.')) {
        console.log("🔍 Recherche par contract_pdf_s3_key:", contractId);
        const { data: contractByS3Key, error: errorByS3Key } = await sb
          .from("cddu_contracts")
          .select("id, contract_pdf_s3_key, contract_number, docuseal_submission_id")
          .eq("contract_pdf_s3_key", contractId)
          .single();

        if (contractByS3Key) {
          contract = contractByS3Key;
          searchMethod = "contract_pdf_s3_key";
          console.log("✅ Contrat trouvé par contract_pdf_s3_key");
        } else {
          console.log("❌ Pas de contrat trouvé par contract_pdf_s3_key:", errorByS3Key?.message);
        }
      }

      // 4. Essayer par contract_number si c'est un simple string
      if (!contract) {
        console.log("🔍 Recherche par contract_number:", contractId);
        const { data: contractByNumber, error: errorByNumber } = await sb
          .from("cddu_contracts")
          .select("id, contract_pdf_s3_key, contract_number, docuseal_submission_id")
          .eq("contract_number", contractId)
          .single();

        if (contractByNumber) {
          contract = contractByNumber;
          searchMethod = "contract_number";
          console.log("✅ Contrat trouvé par contract_number");
        } else {
          console.log("❌ Pas de contrat trouvé par contract_number:", errorByNumber?.message);
        }
      }
    }

    if (!contract) {
      console.error("❌ Contrat introuvable par aucune méthode pour:", contractId);
      return NextResponse.json(
        { 
          error: "Contrat introuvable",
          debug: {
            searchedValue: contractId,
            searchMethods: ["docuseal_submission_id_direct", "dynamodb_lookup", "contract_pdf_s3_key", "contract_number"]
          }
        },
        { status: 404 }
      );
    }

    // Vérification de la présence de la clé S3
    if (!contract.contract_pdf_s3_key) {
      console.log("❌ Aucune clé S3 trouvée pour le contrat:", contract.id);
      return NextResponse.json(
        { 
          error: "Aucun contrat signé disponible",
          debug: {
            contractId: contract.id,
            contractNumber: contract.contract_number,
            hasS3Key: false
          }
        },
        { status: 404 }
      );
    }

    console.log("🔑 Clé S3 trouvée:", contract.contract_pdf_s3_key);

    // Génération de l'URL pré-signée
    const presignedUrl = await getS3SignedUrlIfExists(contract.contract_pdf_s3_key, 3600);
    
    if (!presignedUrl) {
      console.log("❌ Fichier non trouvé dans S3 pour la clé:", contract.contract_pdf_s3_key);
      return NextResponse.json(
        { 
          error: "Contrat signé non trouvé dans le stockage",
          debug: {
            s3Key: contract.contract_pdf_s3_key,
            contractNumber: contract.contract_number
          }
        },
        { status: 404 }
      );
    }

    console.log("✅ URL pré-signée générée avec succès");
    return NextResponse.json({
      body: {
        presignedUrl,
        contractNumber: contract.contract_number
      },
      debug: {
        foundBy: searchMethod,
        originalSearchValue: contractId,
        s3Key: contract.contract_pdf_s3_key,
        docusealSubmissionId: contract.docuseal_submission_id
      }
    });

  } catch (error) {
    console.error("Erreur lors de la récupération du contrat:", error);
    return NextResponse.json(
      { error: "Erreur interne du serveur" },
      { status: 500 }
    );
  }
}