import { and, desc, eq, inArray, ne } from "drizzle-orm";
import { NextRequest, NextResponse } from "next/server";
import { z } from "zod";
import { getDb } from "@/db";
import { conversationMembers, conversations, messages, notifications, users } from "@/db/schema";
import { ApiError, apiResponseError, readJsonObject, requireSameOrigin, requireUser } from "@/lib/api";

const messageSchema = z.object({
  conversationId: z.string().uuid().optional(),
  recipientId: z.string().uuid().optional(),
  body: z.string().trim().min(1).max(4000),
}).refine((value) => value.conversationId || value.recipientId, "conversationId or recipientId is required");

export async function GET(request: NextRequest) {
  try {
    const user = await requireUser(request);
    const db = getDb();
    const memberships = await db.select({ conversationId: conversationMembers.conversationId }).from(conversationMembers).where(eq(conversationMembers.userId, user.id));
    const ids = memberships.map((row) => row.conversationId);
    if (!ids.length) return NextResponse.json({ conversations: [] });
    const conversationRows = await db.select().from(conversations).where(inArray(conversations.id, ids)).orderBy(desc(conversations.updatedAt));
    const messageRows = await db.select().from(messages).where(inArray(messages.conversationId, ids)).orderBy(desc(messages.createdAt)).limit(80);
    const memberRows = await db.select({
      conversationId: conversationMembers.conversationId,
      user: { id: users.id, name: users.name, username: users.username, headline: users.headline, avatarUrl: users.avatarUrl },
    }).from(conversationMembers).innerJoin(users, eq(users.id, conversationMembers.userId)).where(inArray(conversationMembers.conversationId, ids));
    return NextResponse.json({
      conversations: conversationRows.map((conversation) => ({
        ...conversation,
        members: memberRows.filter((row) => row.conversationId === conversation.id).map((row) => row.user),
        messages: messageRows.filter((message) => message.conversationId === conversation.id).reverse(),
      })),
    });
  } catch (error) {
    return apiResponseError(error);
  }
}

export async function POST(request: NextRequest) {
  try {
    requireSameOrigin(request);
    const user = await requireUser(request);
    const payload = messageSchema.parse(await readJsonObject(request));
    const db = getDb();
    let conversationId = payload.conversationId;
    let notifyUserId = payload.recipientId;

    if (conversationId) {
      const [membership] = await db.select().from(conversationMembers)
        .where(and(eq(conversationMembers.conversationId, conversationId), eq(conversationMembers.userId, user.id)))
        .limit(1);
      if (!membership) throw new ApiError(403, "Conversation is unavailable.", "conversation_forbidden");
    } else if (payload.recipientId) {
      if (payload.recipientId === user.id) throw new ApiError(400, "Choose another member.", "validation_error");
      const [recipient] = await db.select().from(users).where(eq(users.id, payload.recipientId)).limit(1);
      if (!recipient) throw new ApiError(404, "Recipient not found.", "not_found");
      const [conversation] = await db.insert(conversations).values({ subject: "" }).returning();
      conversationId = conversation.id;
      await db.insert(conversationMembers).values([
        { conversationId, userId: user.id },
        { conversationId, userId: payload.recipientId },
      ]);
    }

    if (!conversationId) throw new ApiError(400, "Conversation is required.", "validation_error");
    const [message] = await db.insert(messages).values({ conversationId, senderId: user.id, body: payload.body }).returning();
    await db.update(conversations).set({ updatedAt: new Date() }).where(eq(conversations.id, conversationId));
    if (!notifyUserId) {
      const [other] = await db.select().from(conversationMembers).where(and(eq(conversationMembers.conversationId, conversationId), ne(conversationMembers.userId, user.id))).limit(1);
      notifyUserId = other?.userId;
    }
    if (notifyUserId && notifyUserId !== user.id) {
      await db.insert(notifications).values({
        userId: notifyUserId,
        actorId: user.id,
        type: "message",
        title: `${user.name} sent you a message`,
        body: payload.body.slice(0, 160),
        href: "/messages",
      });
    }
    return NextResponse.json({ message }, { status: 201 });
  } catch (error) {
    return apiResponseError(error);
  }
}