import { NextRequest } from "next/server";
import { getServerSession } from "next-auth";
import { authOptions } from "../auth/authOptions";
import { prisma } from "@/lib/prisma";
import { ClientSchema } from "@/lib/validations/schemas";
import { successResponse, errorResponse, unauthorizedResponse, validationErrorResponse } from "@/lib/api-response";
import { z } from "zod";

export async function GET(req: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    if (!session) {
      return unauthorizedResponse();
    }

    const { searchParams } = new URL(req.url);
    const managerId = searchParams.get('managerId');

    if (session.user.role === "ADMIN") {
      const whereClause = managerId ? { managerId: parseInt(managerId) } : {};
      const clients = await prisma.client.findMany({
        where: whereClause,
        select: {
          id: true,
          firstName: true,
          lastName: true,
          email: true,
          mobilePhone: true,
          employer: true,
          street: true,
          stateCanton: true,
          country: true,
          creationDate: true
        },
        orderBy: { creationDate: 'desc' }
      });
      return successResponse(clients);
    }

    const managerData = await prisma.managerData.findUnique({
      where: { userId: Number(session.user.id) }
    });
    
    if (!managerData) {
      return successResponse([]);
    }
    
    const clients = await prisma.client.findMany({
      where: { managerDataId: managerData.id }
    });
    
    return successResponse(clients);
  } catch (error: any) {
    return errorResponse("Erreur lors de la récupération des clients", error.message);
  }
}

export async function POST(req: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    
    if (!session || (session.user.role !== "MANAGER" && session.user.role !== "ADMIN")) {
      return unauthorizedResponse();
    }
    
    let managerDataId: number | null = null;
    
    if (session.user.role === "ADMIN") {
      const defaultManager = await prisma.managerData.findFirst();
      if (!defaultManager) {
        return errorResponse("Aucun manager disponible", undefined, 400);
      }
      managerDataId = defaultManager.id;
    } else {
      const managerData = await prisma.managerData.findUnique({
        where: { userId: Number(session.user.id) }
      });
      
      if (!managerData) {
        return errorResponse("Espace manager introuvable", undefined, 400);
      }
      managerDataId = managerData.id;
    }
    
    const rawData = await req.json();
    
    // Zod validation
    try {
      ClientSchema.parse(rawData);
    } catch (validationError: any) {
      if (validationError instanceof z.ZodError) {
        return validationErrorResponse(validationError);
      }
    }
    
    const processedData = {
      ...rawData,
      dateOfBirth: rawData.dateOfBirth ? new Date(rawData.dateOfBirth) : null,
      contractStart: rawData.contractStart ? new Date(rawData.contractStart) : null,
      contractEnd: rawData.contractEnd ? new Date(rawData.contractEnd) : null,
      managerDataId: managerDataId
    };
    
    const client = await prisma.client.create({
      data: processedData
    });
    
    return successResponse(client, 201);
  } catch (error: any) {
    return errorResponse("Erreur lors de la création du client", error.message);
  }
}