import { modelMessageSchema } from 'ai';
import * as z from 'zod';
import { attachments, messages } from '~~/drizzle/schema';
import { db } from '~~/server/lib/db';

export default defineEventHandler(async (event) => {
    await protectRoute(event);

    const topicId = getRouterParam(event, 'topicId')!;
    const userId = event.context.user!.id;

    const result = await readValidatedBody(event, z.object({
        message: z.intersection(
            z.object({
                id: z.string(),
                fileIds: z.array(z.string()).optional(),
            }),
            modelMessageSchema
        ),
    }).safeParse);
    if (!result.success) {
        throw createError({
            statusCode: 400,
            statusMessage: 'Bad Request',
            message: result.error.issues.map(issue => issue.message).join(', '),
        });
    }

    const { message } = result.data;

    await db.insert(messages).values({
        // @ts-ignore - drizzle bug
        id: message.id,
        userId,
        topicId,
        parentMessageId: null,
        generationId: null,
        role: message.role,
        content: message.content,
    });

    for (const fileId of message.fileIds || []) {
        await db.insert(attachments).values({
            userId,
            topicId,
            messageId: message.id,
            fileId,
        });
    }

    const usermessage = await db.query.messages.findFirst({
        where: {
            id: message.id,
        },
        with: {
            attachments: {
                with: {
                    file: true,
                }
            }
        },
    });

    if (!usermessage) {
        throw createError({
            statusCode: 500,
            statusMessage: 'Failed to insert message',
            message: 'Failed to insert message',
        });
    }
    topicEvents.emit(topicId, { type: 'MESSAGE_CREATED', payload: usermessage });

    return {
        ok: true
    };
})