import { NextRequest } from "next/server";
import { getServerSession } from "next-auth";
import { authOptions } from "../auth/authOptions";
import { prisma } from "@/lib/prisma";
import { DocumentSchema } 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();
    }
    if (session.user.role === "ADMIN") {
      const documents = await prisma.document.findMany({
        include: { partner: true }
      });
      return successResponse(documents);
    }
    const managerData = await prisma.managerData.findUnique({
      where: { userId: Number(session.user.id) }
    });
    if (!managerData) {
      return successResponse([]);
    }
    const documents = await prisma.document.findMany({
      where: { managerDataId: managerData.id },
      include: { partner: true }
    });
    return successResponse(documents);
  } catch (error: any) {
    return errorResponse("Erreur lors de la récupération des documents", 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 = 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 data = await req.json();
    
    const toNum = (v: any) => {
      const n = Number(v);
      return Number.isFinite(n) ? n : undefined;
    };

    const payload: any = {
      name: data.name,
      fileType: data.fileType,
      path: data.path,
      isPermanent: typeof data.isPermanent === 'string' ? data.isPermanent === 'true' : Boolean(data.isPermanent),
      documentType: data.documentType || undefined,
      uploadDate: data.uploadDate ? new Date(data.uploadDate) : new Date(),
      clientId: toNum(data.clientId),
      folderId: toNum(data.folderId),
      communicationId: toNum(data.communicationId),
      invoiceId: toNum(data.invoiceId),
      partnerId: toNum(data.partnerId),
      parentId: toNum(data.parentId),
      managerDataId,
    };

    try {
      DocumentSchema.parse(payload);
    } catch (validationError: any) {
      if (validationError instanceof z.ZodError) {
        return validationErrorResponse(validationError);
      }
    }

    const document = await prisma.document.create({
      data: payload,
    });
    
    return successResponse(document, 201);
  } catch (error: any) {
    return errorResponse("Erreur serveur lors de la création du document", error.message, 500);
  }
}