import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
import { createClient } from "https://esm.sh/@supabase/supabase-js@2";

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Headers":
    "authorization, x-client-info, apikey, content-type",
};

serve(async (req) => {
  // Handle CORS preflight requests
  if (req.method === "OPTIONS") {
    return new Response("ok", { headers: corsHeaders });
  }

  try {
    // Récupérer les variables d'environnement
    const supabaseUrl = Deno.env.get("SUPABASE_URL") ?? "";
    const supabaseServiceKey = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? "";

    // Vérifier que les variables d'environnement sont définies
    if (!supabaseUrl || !supabaseServiceKey) {
      console.error("Variables d'environnement Supabase manquantes");
      return new Response(
        JSON.stringify({ error: "Configuration serveur invalide" }),
        {
          status: 500,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Créer le client Supabase avec la clé de service pour avoir les permissions complètes
    const supabase = createClient(supabaseUrl, supabaseServiceKey, {
      auth: {
        autoRefreshToken: false,
        persistSession: false,
      },
    });

    // Parser le body de la requête
    let requestBody;
    try {
      requestBody = await req.json();
    } catch (parseError) {
      return new Response(
        JSON.stringify({ error: "Body JSON invalide" }),
        {
          status: 400,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    const { orderId, newStatus } = requestBody;

    // Valider les paramètres d'entrée
    if (!orderId || typeof orderId !== "string") {
      return new Response(
        JSON.stringify({ error: "orderId est requis et doit être une chaîne de caractères" }),
        {
          status: 400,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    if (!newStatus || typeof newStatus !== "string") {
      return new Response(
        JSON.stringify({ error: "newStatus est requis et doit être une chaîne de caractères" }),
        {
          status: 400,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Liste des statuts valides (correspond aux constantes du frontend)
    const validStatuses = [
      "En attente de traitement",
      "Traitement en cours", 
      "Commande traitée"
    ];
    if (!validStatuses.includes(newStatus)) {
      return new Response(
        JSON.stringify({ 
          error: `Statut invalide. Statuts acceptés: ${validStatuses.join(", ")}` 
        }),
        {
          status: 400,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Vérifier que la commande existe
    const { data: existingOrder, error: fetchError } = await supabase
      .from("orders")
      .select("id, status")
      .eq("id", orderId)
      .single();

    if (fetchError || !existingOrder) {
      console.error("Erreur lors de la récupération de la commande:", fetchError);
      return new Response(
        JSON.stringify({ error: "Commande introuvable" }),
        {
          status: 404,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Vérifier si le statut est déjà le même
    if (existingOrder.status === newStatus) {
      return new Response(
        JSON.stringify({ 
          error: `La commande a déjà le statut "${newStatus}"`,
          order: existingOrder 
        }),
        {
          status: 400,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Mettre à jour le statut de la commande
    const { data: updatedOrder, error: updateError } = await supabase
      .from("orders")
      .update({ 
        status: newStatus,
        updated_at: new Date().toISOString()
      })
      .eq("id", orderId)
      .select()
      .single();

    if (updateError) {
      console.error("Erreur lors de la mise à jour de la commande:", updateError);
      return new Response(
        JSON.stringify({ 
          error: "Erreur lors de la mise à jour du statut",
          details: updateError.message 
        }),
        {
          status: 500,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    if (!updatedOrder) {
      return new Response(
        JSON.stringify({ error: "Aucune commande mise à jour" }),
        {
          status: 500,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }

    // Succès
    console.log(`Commande ${orderId} mise à jour: ${existingOrder.status} -> ${newStatus}`);
    return new Response(
      JSON.stringify(updatedOrder),
      {
        status: 200,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      }
    );
  } catch (error) {
    console.error("Erreur dans update-order-status:", error);
    return new Response(
      JSON.stringify({
        error: "Erreur interne du serveur",
        details: error instanceof Error ? error.message : "Erreur inconnue",
      }),
      {
        status: 500,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      }
    );
  }
});