import { NextResponse } from "next/server";
import { cookies } from "next/headers";
import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs";
import { createClient } from "@supabase/supabase-js";
import { sendUniversalEmailV2 } from "@/lib/emailTemplateService";

/**
 * POST /api/staff/users/create-staff
 * Crée un nouvel utilisateur staff avec notification email
 * Réservé aux utilisateurs staff existants
 */
export async function POST(req: Request) {
  try {
    const sb = createRouteHandlerClient({ cookies });
    const { data: { user } } = await sb.auth.getUser();
    if (!user) return new NextResponse("Unauthorized", { status: 401 });

    // Vérifier que l'utilisateur courant est staff
    const { data: staff } = await sb
      .from("staff_users")
      .select("is_staff, super_staff")
      .eq("user_id", user.id)
      .maybeSingle();

    if (!staff?.is_staff) return new NextResponse("Forbidden", { status: 403 });

    // Récupérer les données
    const body = await req.json();
    const email = String(body.email || "").trim().toLowerCase();
    const firstName = String(body.firstName || "").trim();
    const isSuperStaff = Boolean(body.isSuperStaff || false);

    if (!email) {
      return NextResponse.json({ error: "Email requis" }, { status: 400 });
    }

    // Seul un super_staff peut créer un autre super_staff
    if (isSuperStaff && !staff.super_staff) {
      return NextResponse.json({ 
        error: "Seul un Super Staff peut créer un autre Super Staff" 
      }, { status: 403 });
    }

    // Créer le client admin pour gérer les utilisateurs
    const admin = createClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.SUPABASE_SERVICE_ROLE_KEY!,
      { auth: { autoRefreshToken: false, persistSession: false } }
    );

    const origin = process.env.NEXT_PUBLIC_BASE_URL || "https://paie.odentas.fr";

    // Créer l'utilisateur avec confirmation d'email automatique (pour les staff)
    const { data: createData, error: createError } = await admin.auth.admin.createUser({
      email,
      email_confirm: true, // Confirmer automatiquement l'email pour les staff
      user_metadata: {
        first_name: firstName || null,
        is_staff: true,
      },
    });

    if (createError) {
      console.error("Erreur création utilisateur:", createError);
      return NextResponse.json({ 
        error: "Erreur lors de la création de l'utilisateur", 
        message: createError.message 
      }, { status: 400 });
    }

    const newUserId = createData?.user?.id;

    if (!newUserId) {
      return NextResponse.json({ error: "Erreur lors de la création de l'utilisateur" }, { status: 400 });
    }

    // Générer un lien d'activation pour le premier mot de passe
    const { data: linkData, error: linkError } = await admin.auth.admin.generateLink({
      type: "magiclink",
      email,
      options: {
        redirectTo: `${origin}/`,
      }
    });

    if (linkError) {
      console.error("Erreur génération lien:", linkError);
      // Ne pas bloquer si l'email échoue, l'utilisateur est déjà créé et confirmé
    }

    const actionLink = linkData?.properties?.action_link || null;

    // Ajouter l'utilisateur à la table staff_users
    const { error: staffError } = await admin
      .from("staff_users")
      .insert({ 
        user_id: newUserId, 
        is_staff: true,
        super_staff: isSuperStaff 
      });

    if (staffError) {
      console.error("Erreur insertion staff_users:", staffError);
      return NextResponse.json({ 
        error: "Erreur lors de l'ajout aux utilisateurs staff", 
        message: staffError.message 
      }, { status: 400 });
    }

    // Configurer les préférences d'authentification
    await admin
      .from("user_auth_prefs")
      .upsert({ user_id: newUserId, allow_magic_link: true, allow_password: false });

    // Envoyer l'email de notification avec le système universel V2
    try {
      const creatorName = (user.user_metadata as any)?.first_name || user.email || 'Administrateur';
      
      // Forcer le domaine production dans le lien d'activation si disponible
      let productionLink = null;
      if (actionLink) {
        productionLink = actionLink
          .replace(/http:\/\/localhost:\d+/, 'https://paie.odentas.fr')
          .replace(/https?:\/\/app-paie\.odentas\.fr/, 'https://paie.odentas.fr')
          .replace(/https?:\/\/[^/]+\//, 'https://paie.odentas.fr/');
      }

      await sendUniversalEmailV2({
        type: 'staff-account-created',
        toEmail: email,
        data: {
          firstName: firstName || undefined,
          userEmail: email,
          accountType: isSuperStaff ? 'Super Administrateur Staff' : 'Administrateur Staff',
          createdBy: creatorName,
          createdAt: new Date().toLocaleDateString('fr-FR', {
            day: '2-digit',
            month: 'long',
            year: 'numeric',
          }),
          linkValidity: '7 jours',
          ctaUrl: productionLink || 'https://paie.odentas.fr',
          note: 'Votre compte est déjà activé. Utilisez le lien ci-dessous pour vous connecter et définir votre mot de passe.',
        }
      });

      console.log(`Email d'activation envoyé à ${email}`);
    } catch (emailError) {
      console.error("Erreur envoi email:", emailError);
      // On ne bloque pas la création si l'email échoue
    }

    return NextResponse.json({
      success: true,
      userId: newUserId,
      email,
      message: "Utilisateur staff créé avec succès"
    });

  } catch (e: any) {
    console.error("Erreur create-staff:", e);
    return NextResponse.json({ 
      error: "Erreur serveur", 
      message: e?.message || "Erreur interne" 
    }, { status: 500 });
  }
}
