import { prisma } from "@/lib/prisma";
import { getCurrentUser } from "@/lib/auth";

/**
 * POST /api/messages/read
 *
 * Marks all unread messages in a conversation as read by the current user.
 * Creates MessageReadReceipt records and pushes read_receipt SSE events
 * to message senders so they see "Seen" status.
 *
 * Body: { conversationId: string }
 */
export async function POST(req: Request) {
    const user = await getCurrentUser();
    if (!user) {
        return Response.json({ error: "Unauthorized" }, { status: 401 });
    }

    try {
        const { conversationId } = await req.json();

        if (!conversationId) {
            return Response.json(
                { error: "conversationId required" },
                { status: 400 }
            );
        }

        // Verify user is a participant
        const membership = await prisma.conversationParticipant.findUnique({
            where: {
                conversation_id_user_id: {
                    conversation_id: conversationId,
                    user_id: user.id,
                },
            },
        });

        if (!membership || membership.left_at) {
            return Response.json(
                { error: "Not a participant" },
                { status: 403 }
            );
        }

        // Find all messages in this conversation NOT sent by current user
        // that don't already have a read receipt from this user
        const unreadMessages = await prisma.message.findMany({
            where: {
                conversation_id: conversationId,
                sender_id: { not: user.id },
                is_deleted: false,
                read_receipts: {
                    none: {
                        user_id: user.id,
                    },
                },
            },
            select: {
                id: true,
                sender_id: true,
            },
            orderBy: { created_at: "asc" },
        });

        if (unreadMessages.length === 0) {
            return Response.json({ success: true, markedCount: 0 });
        }

        const now = new Date();

        // Batch create read receipts
        await prisma.messageReadReceipt.createMany({
            data: unreadMessages.map((msg) => ({
                message_id: msg.id,
                user_id: user.id,
                read_at: now,
            })),
            skipDuplicates: true,
        });

        // Update participant's read tracking
        const lastMessageId = unreadMessages[unreadMessages.length - 1].id;
        await prisma.conversationParticipant.update({
            where: { id: membership.id },
            data: {
                unread_count: 0,
                last_read_at: now,
                last_read_message_id: lastMessageId,
            },
        });

        // Collect unique sender IDs to notify
        const senderIds = [...new Set(unreadMessages.map((m) => m.sender_id))];
        const messageIds = unreadMessages.map((m) => m.id);

        // Push read_receipt event to each sender via the internal push API
        const baseUrl =
            process.env.NEXTAUTH_URL ||
            process.env.NEXT_PUBLIC_APP_URL ||
            "http://localhost:3000";

        for (const senderId of senderIds) {
            const senderMessageIds = unreadMessages
                .filter((m) => m.sender_id === senderId)
                .map((m) => m.id);

            fetch(`${baseUrl}/api/messages/push`, {
                method: "POST",
                headers: {
                    "Content-Type": "application/json",
                    "x-internal-secret":
                        process.env.INTERNAL_API_SECRET ||
                        "internal-push-secret-key",
                },
                body: JSON.stringify({
                    conversationId,
                    event: {
                        type: "read_receipt",
                        data: {
                            conversationId,
                            readerId: user.id,
                            readerName: user.name || "Unknown",
                            messageIds: senderMessageIds,
                            readAt: now.toISOString(),
                        },
                        conversationId,
                        timestamp: now.toISOString(),
                    },
                    // Push to the sender so they see "Seen" — exclude the reader
                    excludeUserId: user.id,
                }),
            }).catch((err) =>
                console.error("[ReadReceipt] Push failed:", err)
            );
        }

        return Response.json({
            success: true,
            markedCount: messageIds.length,
            lastReadMessageId: lastMessageId,
        });
    } catch (error) {
        console.error("[ReadReceipt] Error:", error);
        return Response.json(
            { error: "Failed to mark messages as read" },
            { status: 500 }
        );
    }
}
