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 '@/types/types';

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

    const { searchParams } = new URL(req.url);
    const chatType = searchParams.get('type'); // 'group' ou 'private'
    const recipientId = searchParams.get('recipientId');
    const limit = searchParams.get('limit') || '50';

    let whereClause: any = {};

    if (chatType === 'group') {
      whereClause.isGroupMessage = true;
    } else if (chatType === 'private' && recipientId) {
      whereClause.OR = [
        { senderId: parseInt(session.user.id), recipientId: parseInt(recipientId) },
        { senderId: parseInt(recipientId), recipientId: parseInt(session.user.id) }
      ];
      whereClause.isGroupMessage = false;
    }

    const messages = await prisma.message.findMany({
      where: whereClause,
      orderBy: { createdAt: 'desc' },
      take: parseInt(limit),
      include: {
        sender: {
          select: {
            id: true,
            firstName: true,
            lastName: true
          }
        }
      }
    });

    return NextResponse.json(messages.reverse()); // Retourner dans l'ordre chronologique
  } catch (error) {
    console.error('Erreur lors de la récupération des messages:', error);
    return NextResponse.json(
      { error: "Erreur lors de la récupération des messages" },
      { status: 500 }
    );
  }
}

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

    const { content, recipientId, isGroupMessage, fileUrl, fileName, fileSize } = await req.json();

    if (!content && !fileUrl) {
      return NextResponse.json({ error: "Contenu du message requis" }, { status: 400 });
    }

    // Pour les fichiers, en production vous devriez uploader vers un service de stockage
    // et stocker l'URL permanente dans la base de données
    // Pour l'instant, on stocke les informations du fichier
    const message = await prisma.message.create({
      data: {
        senderId: parseInt(session.user.id),
        recipientId: recipientId ? parseInt(recipientId) : null,
        content: content || '',
        isGroupMessage: isGroupMessage || false,
        fileUrl: fileUrl || null,
        fileName: fileName || null,
        fileSize: fileSize ? parseInt(fileSize.toString()) : null
      },
      include: {
        sender: {
          select: {
            id: true,
            firstName: true,
            lastName: true
          }
        }
      }
    });

    // Créer des notifications pour les destinataires
    if (isGroupMessage) {
      // Notification pour tous les utilisateurs sauf l'expéditeur
      const allUsers = await prisma.user.findMany({
        where: { id: { not: parseInt(session.user.id) } }
      });

      const notifications = allUsers.map(user => ({
        userId: user.id,
        type: NotificationType.MESSAGE_RECEIVED,
        content: `Nouveau message de ${session.user.firstName} ${session.user.lastName} dans le chat de groupe`,
        relatedType: 'message',
        relatedId: message.id
      }));

      await prisma.notification.createMany({
        data: notifications
      });
    } else if (recipientId) {
      // Notification pour le destinataire spécifique
      await prisma.notification.create({
        data: {
          userId: parseInt(recipientId),
          type: NotificationType.MESSAGE_RECEIVED,
          content: `Nouveau message de ${session.user.firstName} ${session.user.lastName}`,
          relatedType: 'message',
          relatedId: message.id
        }
      });
    }

    return NextResponse.json({ success: true, message });
  } catch (error) {
    console.error('Erreur lors de l\'envoi du message:', error);
    return NextResponse.json(
      { error: "Erreur lors de l'envoi du message" },
      { status: 500 }
    );
  }
}