import { and, eq } from 'drizzle-orm';
import * as z from 'zod';
import { agents } from '~~/drizzle/schema';
import { db } from '~~/server/lib/db';
import { userEvents } from '~~/server/utils/events';

export default defineEventHandler(async (event) => {
    await protectRoute(event);
    const userId = event.context.user!.id;

    const result = await readValidatedBody(event, (body) =>
        z
            .object({
                name: z.string().optional(),
                systemPrompt: z.string().nullable().optional(),
                imageUrl: z.string().optional(),
                defaultModelId: z.string().optional(),
                config: z.object({
                    search: z.object({
                        enabled: z.boolean(),
                        rerank: z.boolean(),
                        maxResults: z.number().min(1).max(50),
                    }).optional(),
                    tools: z.object({
                        python: z.boolean().optional(),
                    }).optional(),
                }).optional(),
            })
            .safeParse(body),
    );

    if (!result.success) {
        throw createError({
            statusCode: 400,
            message: result.error.issues[0]!.message,
        });
    }

    const agentId = getRouterParam(event, 'id')!;

    const { name, systemPrompt, imageUrl, defaultModelId, config } = result.data;

    const updateData: Record<string, any> = {};
    if (name !== undefined) updateData.name = name;
    if (systemPrompt !== undefined) updateData.systemPrompt = systemPrompt;
    if (imageUrl !== undefined) updateData.imageUrl = imageUrl;
    if (defaultModelId !== undefined) updateData.defaultModelId = defaultModelId;
    if (config !== undefined) updateData.config = config;

    const res = await db.update(agents)
        .set(updateData)
        .where(
            and(
                eq(agents.id, agentId),
                eq(agents.userId, userId),
            )
        );

    if (res.rowCount === 0) {
        throw createError({
            statusCode: 400,
            statusMessage: 'Invalid agent',
        });
    }

    userEvents.emit(userId, 'agents', {
        op: 'update',
        payload: {
            id: agentId,
            ...updateData,
        },
    });

    return { ok: true };
});