import { nanoid } from "nanoid";
import { db } from "~~/server/lib/db";
import { providers as providersSchema } from "~~/drizzle/schema";
import { eq } from "drizzle-orm";
import { getAllProviders, getProviderBaseUrl } from "~~/server/utils/providers";

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

    const providerIds = getAllProviders().map(p => p.id);

    let providers = await db.query.providers.findMany({
        where: {
            userId,
        },
        with: {
            models: true,
        },
    });

    const createPromises: Promise<any>[] = [];
    providerIds.forEach(p => {
        if (!providers.find(provider => provider.type === p)) {
            createPromises.push(
                db.insert(providersSchema).values({
                    id: nanoid(),
                    userId,
                    type: p,
                    name: p,
                    enabled: false,
                    config: {},
                    createdAt: new Date(),
                    updatedAt: new Date(),
                }).returning() as any
            );
        }
    });

    const createdResults = await Promise.all(createPromises);
    for (const created of createdResults) {
        if (created && created[0]) {
            created[0].models = [];
            providers.push(created[0]);
        }
    }

    const deletePromises: Promise<any>[] = [];
    providers.forEach(provider => {
        if (!providerIds.includes(provider.type)) {
            deletePromises.push(db.delete(providersSchema).where(eq(providersSchema.id, provider.id)));
            providers = providers.filter(p => p.id !== provider.id);
        }
    });

    await Promise.all(deletePromises);

    const enrichedProviders = providers.map(p => ({
        ...p,
        defaultBaseUrl: getProviderBaseUrl(p.type),
    }));

    return enrichedProviders;
});