import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs";
import { cookies } from "next/headers";
import { NextResponse } from "next/server";
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

const s3Client = new S3Client({
  region: process.env.AWS_REGION || "eu-west-3",
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
  },
});

const BUCKET = (process.env.AWS_S3_BUCKET || "odentas-docs").trim();

/**
 * GET /api/contrats/[id]/avenants
 * Récupère les avenants signés d'un contrat avec leurs URLs presignées
 */
export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  try {
    const contractId = params.id;
    
    if (!contractId) {
      return NextResponse.json(
        { error: "Contract ID manquant" },
        { status: 400 }
      );
    }

    const supabase = createRouteHandlerClient({ cookies });

    // Vérifier l'authentification
    const { data: { session } } = await supabase.auth.getSession();
    if (!session) {
      return NextResponse.json(
        { error: "Non authentifié" },
        { status: 401 }
      );
    }

    // Vérifier que l'utilisateur a accès au contrat
    const { data: contract, error: contractError } = await supabase
      .from("cddu_contracts")
      .select("id, org_id")
      .eq("id", contractId)
      .single();

    if (contractError || !contract) {
      return NextResponse.json(
        { error: "Contrat non trouvé ou accès refusé" },
        { status: 404 }
      );
    }

    // Récupérer les avenants signés du contrat
    const { data: avenants, error: avenantError } = await supabase
      .from("avenants")
      .select(`
        id,
        numero_avenant,
        date_avenant,
        date_effet,
        type_avenant,
        motif_avenant,
        elements_avenantes,
        signature_status,
        pdf_s3_key,
        created_at
      `)
      .eq("contract_id", contractId)
      .eq("signature_status", "signed")
      .order("date_avenant", { ascending: false });

    if (avenantError) {
      console.error("Erreur récupération avenants:", avenantError);
      return NextResponse.json(
        { error: "Erreur lors de la récupération des avenants" },
        { status: 500 }
      );
    }

    // Générer les URLs presignées pour les avenants qui ont un PDF
    const avenantWithUrls = await Promise.all(
      (avenants || []).map(async (avenant) => {
        let presignedUrl = null;
        
        if (avenant.pdf_s3_key) {
          try {
            const command = new GetObjectCommand({
              Bucket: BUCKET,
              Key: avenant.pdf_s3_key,
            });
            
            presignedUrl = await getSignedUrl(s3Client, command, {
              expiresIn: 3600, // 1 heure
            });
          } catch (error) {
            console.error(`Erreur génération URL presignée pour avenant ${avenant.id}:`, error);
          }
        }

        return {
          id: avenant.id,
          numero_avenant: avenant.numero_avenant,
          date_avenant: avenant.date_avenant,
          date_effet: avenant.date_effet,
          type_avenant: avenant.type_avenant,
          motif_avenant: avenant.motif_avenant,
          elements_avenantes: avenant.elements_avenantes,
          signature_status: avenant.signature_status,
          has_pdf: !!avenant.pdf_s3_key,
          signed_url: presignedUrl,
          created_at: avenant.created_at,
        };
      })
    );

    // Filtrer pour ne garder que ceux qui ont un PDF disponible
    const avenantAvailable = avenantWithUrls.filter(a => a.has_pdf && a.signed_url);

    return NextResponse.json({
      avenants: avenantAvailable,
      count: avenantAvailable.length,
    });
  } catch (error) {
    console.error("Erreur API avenants:", error);
    return NextResponse.json(
      { error: "Erreur serveur" },
      { status: 500 }
    );
  }
}
