import { NextRequest, NextResponse } from "next/server";
import { getServerSession } from "next-auth";
import { authOptions } from "../auth/authOptions";
import { prisma } from "@/lib/prisma";
import { TaskSchema } 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');

    const selectFields = {
      id: true,
      title: true,
      description: true,
      status: true,
      dueDate: true,
      priority: true,
      startDate: true,
      completedAt: true,
      responsible: {
        select: { firstName: true, lastName: true }
      },
      client: {
        select: { firstName: true, lastName: true }
      },
      collaborators: {
        select: {
          userId: true,
          user: {
            select: { firstName: true, lastName: true, email: true }
          }
        }
      }
    };

    if (session.user.role === "ADMIN") {
      let whereClause = {};
      if (managerId) {
        const managerData = await prisma.managerData.findUnique({
          where: { userId: parseInt(managerId) }
        });
        if (managerData) {
          whereClause = { managerDataId: managerData.id };
        }
      }
      
      const tasks = await prisma.task.findMany({
        where: whereClause,
        select: selectFields,
        orderBy: { dueDate: 'asc' }
      });
      return successResponse(tasks);
    }

    const managerData = await prisma.managerData.findUnique({
      where: { userId: Number(session.user.id) }
    });
    
    if (!managerData) {
      return successResponse([]);
    }
    
    const tasks = await prisma.task.findMany({
      where: { managerDataId: managerData.id },
      select: selectFields,
      orderBy: { dueDate: 'asc' }
    });
    
    return successResponse(tasks);
  } catch (error: any) {
    return errorResponse("Erreur lors de la récupération des tâches", 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();
    }
    
    const rawData = await req.json();
    
    // Normalisation basique avant validation
    const payload: any = {
      ...rawData,
      title: rawData.title,
      description: rawData.description,
      status: rawData.status,
      priority: rawData.priority,
      isAutomatic: Boolean(rawData.isAutomatic),
      isPrivate: Boolean(rawData.isPrivate),
      startDate: rawData.startDate ? new Date(rawData.startDate) : undefined,
      dueDate: rawData.dueDate ? new Date(rawData.dueDate) : undefined,
      completedAt: rawData.completedAt ? new Date(rawData.completedAt) : undefined,
      duration: rawData.duration ? String(rawData.duration) : undefined,
      appreciation: rawData.appreciation,
      clientId: rawData.clientId ? Number(rawData.clientId) : null,
      folderId: rawData.folderId ? Number(rawData.folderId) : null,
      responsibleId: rawData.responsibleId ? Number(rawData.responsibleId) : parseInt(session.user.id),
    };

    try {
      TaskSchema.parse(payload);
    } catch (validationError: any) {
      if (validationError instanceof z.ZodError) {
        return validationErrorResponse(validationError);
      }
    }
    
    const task = await prisma.task.create({
      data: payload,
    });
    
    return successResponse(task, 201);
  } catch (error: any) {
    return errorResponse("Erreur serveur lors de la création de la tâche", error.message, 500);
  }
}