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

export async function POST(req: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user || session.user.role !== "ADMIN") {
      return NextResponse.json({ error: "Accès refusé" }, { status: 403 });
    }

    const { type, itemId, fromManagerId, toManagerId } = await req.json();

    if (!type || !itemId || !fromManagerId || !toManagerId) {
      return NextResponse.json({ error: "Paramètres manquants" }, { status: 400 });
    }

    if (fromManagerId === toManagerId) {
      return NextResponse.json({ error: "Le manager source et destination ne peuvent pas être identiques" }, { status: 400 });
    }

    // Vérifier que les managers existent
    const [fromManager, toManager] = await Promise.all([
      prisma.user.findUnique({ where: { id: parseInt(fromManagerId), role: "MANAGER" } }),
      prisma.user.findUnique({ where: { id: parseInt(toManagerId), role: "MANAGER" } })
    ]);

    if (!fromManager || !toManager) {
      return NextResponse.json({ error: "Manager non trouvé" }, { status: 404 });
    }

    let transferredItem;
    let notificationMessage = "";

    switch (type) {
      case "client":
        // Récupérer le ManagerData du manager de destination
        let toManagerDataForClient = await prisma.managerData.findUnique({
          where: { userId: parseInt(toManagerId) }
        });
        // Créer ManagerData si manquant pour éviter 404
        if (!toManagerDataForClient) {
          toManagerDataForClient = await prisma.managerData.create({
            data: { userId: parseInt(toManagerId) }
          });
        }

        transferredItem = await prisma.client.update({
          where: { id: parseInt(itemId) },
          data: { 
            managerId: parseInt(toManagerId),
            managerDataId: toManagerDataForClient.id 
          },
          include: { manager: true }
        });
        notificationMessage = `Le client ${transferredItem.firstName} ${transferredItem.lastName} vous a été transféré par l'administrateur`;
        break;

      case "task":
        // Récupérer le ManagerData du manager de destination
        let toManagerData = await prisma.managerData.findUnique({
          where: { userId: parseInt(toManagerId) }
        });
        if (!toManagerData) {
          toManagerData = await prisma.managerData.create({
            data: { userId: parseInt(toManagerId) }
          });
        }

        transferredItem = await prisma.task.update({
          where: { id: parseInt(itemId) },
          data: { managerDataId: toManagerData.id }
        });
        notificationMessage = `La tâche "${transferredItem.title}" vous a été transférée par l'administrateur`;
        break;

      case "invoice":
        // Récupérer le ManagerData du manager de destination
        let toManagerDataForInvoice = await prisma.managerData.findUnique({
          where: { userId: parseInt(toManagerId) }
        });
        if (!toManagerDataForInvoice) {
          toManagerDataForInvoice = await prisma.managerData.create({
            data: { userId: parseInt(toManagerId) }
          });
        }

        transferredItem = await prisma.invoice.update({
          where: { id: parseInt(itemId) },
          data: { managerDataId: toManagerDataForInvoice.id }
        });
        notificationMessage = `La facture ${transferredItem.invoiceNumber} vous a été transférée par l'administrateur`;
        break;

      case "partner":
        // Pour les partenaires, on doit d'abord trouver le client associé
        const partner = await prisma.partner.findUnique({
          where: { id: parseInt(itemId) },
          include: { client: true }
        });
        
        if (!partner) {
          return NextResponse.json({ error: "Partenaire non trouvé" }, { status: 404 });
        }

        // Récupérer le ManagerData du manager de destination
        let toManagerDataForPartner = await prisma.managerData.findUnique({
          where: { userId: parseInt(toManagerId) }
        });
        if (!toManagerDataForPartner) {
          toManagerDataForPartner = await prisma.managerData.create({
            data: { userId: parseInt(toManagerId) }
          });
        }

        // Transférer le client associé au partenaire
        transferredItem = await prisma.client.update({
          where: { id: partner.client.id },
          data: { 
            managerId: parseInt(toManagerId),
            managerDataId: toManagerDataForPartner.id 
          }
        });
        notificationMessage = `Le partenaire ${partner.name} vous a été transféré par l'administrateur`;
        break;

      default:
        return NextResponse.json({ error: "Type de transfert non supporté" }, { status: 400 });
    }

    // Créer une notification pour le manager de destination
    await prisma.notification.create({
      data: {
        userId: parseInt(toManagerId),
        content: notificationMessage,
        type: NotificationType.TRANSFER,
        isRead: false
      }
    });

    // Créer une notification pour le manager source (si différent)
    if (fromManagerId !== toManagerId) {
      let sourceNotificationMessage = "";
      
      if (type === "client") {
        sourceNotificationMessage = `Le client ${transferredItem.firstName} ${transferredItem.lastName} a été transféré à ${toManager.firstName} ${toManager.lastName}`;
      } else if (type === "task") {
        sourceNotificationMessage = `La tâche "${transferredItem.title}" a été transférée à ${toManager.firstName} ${toManager.lastName}`;
      } else if (type === "invoice") {
        sourceNotificationMessage = `La facture ${transferredItem.invoiceNumber} a été transférée à ${toManager.firstName} ${toManager.lastName}`;
      } else if (type === "partner") {
        // Pour les partenaires, on doit récupérer le nom du partenaire
        const partner = await prisma.partner.findUnique({
          where: { id: parseInt(itemId) }
        });
        sourceNotificationMessage = `Le partenaire ${partner?.name || "inconnu"} a été transféré à ${toManager.firstName} ${toManager.lastName}`;
      }

      await prisma.notification.create({
        data: {
          userId: parseInt(fromManagerId),
          content: sourceNotificationMessage,
          type: NotificationType.TRANSFER,
          isRead: false
        }
      });
    }

    return NextResponse.json({ 
      success: true, 
      message: "Transfert effectué avec succès",
      transferredItem 
    });

  } catch (error) {
    console.error('Erreur lors du transfert:', error);
    return NextResponse.json(
      { error: "Erreur lors du transfert" },
      { status: 500 }
    );
  }
}