import { NextRequest, NextResponse } from "next/server";
import { getServerSession } from "next-auth";
import { authOptions } from "@/app/api/auth/authOptions";
import { prisma } from "@/lib/prisma";
import { createHash } from "crypto";

async function createImpersonationToken(user: any, adminId: string) {
  // Créer un token JWT pour l'utilisateur usurpé
  return {
    name: `${user.firstName} ${user.lastName}`.trim(),
    email: user.email,
    sub: user.id.toString(),
    role: user.role,
    firstName: user.firstName,
    lastName: user.lastName,
    originalAdminId: adminId,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + 60 * 60, // 1h
    jti: createHash("sha256").update(`${user.id}-${Date.now()}`).digest("hex"),
  };
}

export async function POST(req: NextRequest) {
  try {
    // Vérifier que l'utilisateur actuel est un administrateur
    const session = await getServerSession(authOptions);
    if (!session?.user || session.user.role !== "ADMIN") {
      console.log("Tentative d'usurpation non autorisée");
      return NextResponse.json(
        { error: "Accès non autorisé. Privilèges administrateur requis." },
        { status: 403 }
      );
    }

    const { userId } = await req.json();
    if (!userId) {
      return NextResponse.json(
        { error: "L'ID de l'utilisateur est requis" },
        { status: 400 }
      );
    }

    // Récupérer le manager
    const user = await prisma.user.findUnique({
      where: { id: Number(userId) },
      select: {
        id: true,
        email: true,
        firstName: true,
        lastName: true,
        role: true,
      },
    });

    if (!user || user.role !== "MANAGER") {
      return NextResponse.json(
        { error: "Manager non trouvé" },
        { status: 404 }
      );
    }

    console.log(`Admin ${session.user.email} usurpe le compte manager: ${user.email}`);

    // Créer un token d'usurpation
    const token = await createImpersonationToken(user, session.user.id as string);

    // Signer le token avec NextAuth
    const secret = process.env.NEXTAUTH_SECRET;
    if (!secret) throw new Error("NEXTAUTH_SECRET is not defined");

    const { encode } = await import("next-auth/jwt");
    const cookieValue = await encode({
      token: {
        ...token,
        id: user.id.toString(),
      },
      secret: secret,
    });

    // Créer une réponse JSON avec les infos utilisateur et l'URL de redirection
    const response = NextResponse.json({ 
      success: true, 
      user: {
        id: user.id,
        firstName: user.firstName,
        lastName: user.lastName,
        email: user.email
      },
      redirectUrl: `/` 
    });

    // Définir les cookies
    response.cookies.set({
      name:
        process.env.NODE_ENV === "production"
          ? "__Secure-next-auth.session-token"
          : "next-auth.session-token",
      value: cookieValue,
      httpOnly: true,
      secure: process.env.NODE_ENV === "production",
      sameSite: "lax",
      path: "/",
      maxAge: 60 * 60,
    });

    response.cookies.set({
      name: "original_admin_id",
      value: session.user.id as string,
      httpOnly: true,
      secure: process.env.NODE_ENV === "production",
      sameSite: "lax",
      path: "/",
      maxAge: 60 * 60,
    });

    return response;
  } catch (error) {
    console.error("Erreur lors de l'usurpation:", error);
    return NextResponse.json(
      { error: "Une erreur est survenue lors de l'usurpation" },
      { status: 500 }
    );
  }
}

export async function GET() {
  return NextResponse.json(
    { error: "Méthode non autorisée" },
    { status: 405 }
  );
}