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";

// GET : Récupérer un client par ID (avec ses dossiers)
export async function GET(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
    try {
        const session = await getServerSession(authOptions);
        if (!session) {
            return unauthorizedResponse();
        }

        const resolvedParams = await params;
        const clientId = parseInt(resolvedParams.id);

        if (isNaN(clientId)) {
            return errorResponse("ID invalide", undefined, 400);
        }

        const client = await prisma.client.findUnique({
            where: { id: clientId },
            include: { folders: true },
        });

        if (!client) {
            return errorResponse("Client non trouvé", undefined, 404);
        }

        return successResponse(client);
    } catch (error: any) {
        return errorResponse("Erreur GET client", error.message);
    }
}

// DELETE : Supprimer un client
export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
    try {
        const session = await getServerSession(authOptions);
        
        if (!session || (session.user.role !== "MANAGER" && session.user.role !== "ADMIN")) {
            return unauthorizedResponse();
        }

        const resolvedParams = await params;
        const clientId = parseInt(resolvedParams.id);

        if (isNaN(clientId)) {
            return errorResponse("ID invalide", undefined, 400);
        }

        await prisma.client.delete({
            where: { id: clientId },
        });

        return successResponse({ message: "Client supprimé avec succès" });
    } catch (error: any) {
        return errorResponse("Erreur lors de la suppression", error.message);
    }
}

// PUT : Mettre à jour un client
export async function PUT(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
    try {
        const session = await getServerSession(authOptions);
        if (!session || (session.user.role !== "MANAGER" && session.user.role !== "ADMIN")) {
            return unauthorizedResponse();
        }

        const resolvedParams = await params;
        const clientId = parseInt(resolvedParams.id);

        if (isNaN(clientId)) {
            return errorResponse("ID invalide", undefined, 400);
        }

        const rawData = await req.json();

        // Validation Zod
        try {
            ClientSchema.parse(rawData);
        } catch (validationError: any) {
            if (validationError instanceof z.ZodError) {
                return validationErrorResponse(validationError);
            }
        }

        const processedData = {
            firstName: rawData.firstName,
            lastName: rawData.lastName,
            email: rawData.email,
            postalCode: rawData.postalCode,
            dateOfBirth: rawData.dateOfBirth ? new Date(rawData.dateOfBirth) : null,
            country: rawData.country,
            mobilePhone: rawData.mobilePhone,
            socialSecurityNumber: rawData.socialSecurityNumber,
            street: rawData.street,
            nationality: rawData.nationality,
            streetNumber: rawData.streetNumber,
            stateCanton: rawData.stateCanton,
            otherPhone: rawData.otherPhone,
            taxIdentificationNumber: rawData.taxIdentificationNumber,
            monthlySalary: rawData.monthlySalary,
            bank: rawData.bank,
            accountNumber: rawData.accountNumber,
            accountHolder: rawData.accountHolder,
            accountPurpose: rawData.accountPurpose,
            accountStatus: rawData.accountStatus,
            financialOther: rawData.financialOther,
            employer: rawData.employer,
            professionalResponsible: rawData.professionalResponsible,
            professionalPhone: rawData.professionalPhone,
            professionalCity: rawData.professionalCity,
            professionalCountry: rawData.professionalCountry,
            contractStart: rawData.contractStart ? new Date(rawData.contractStart) : null,
            contractType: rawData.contractType,
            contractEnd: rawData.contractEnd ? new Date(rawData.contractEnd) : null,
            professionalCanton: rawData.professionalCanton,
            professionalStatus: rawData.professionalStatus,
            professionalOther: rawData.professionalOther,
            fatherName: rawData.fatherName,
            fatherContact: rawData.fatherContact,
            fatherCountry: rawData.fatherCountry,
            motherName: rawData.motherName,
            motherContact: rawData.motherContact,
            motherCountry: rawData.motherCountry,
            partnerName: rawData.partnerName,
            partnerContact: rawData.partnerContact,
            partnerCountry: rawData.partnerCountry,
            spouseName: rawData.spouseName,
            spouseContact: rawData.spouseContact,
            relationOther: rawData.relationOther,
            customFields: rawData.customFields || {},
        };

        const updatedClient = await prisma.client.update({
            where: { id: clientId },
            data: processedData,
        });

        return successResponse(updatedClient);
    } catch (error: any) {
        return errorResponse("Erreur lors de la mise à jour", error.message);
    }
}