ai-chatbot/app/api/admin/vip98k-models/route.ts

import { and, eq } from "drizzle-orm";
import { NextResponse } from "next/server";
import {
  fetchVip98kModelPresets,
  type Vip98kModelPreset,
} from "@/lib/ai/vip98k-models";
import { db } from "@/lib/db";
import { getAiProviderById } from "@/lib/db/queries";
import { aiModel, type AiModel } from "@/lib/db/schema";
import { requireAdmin } from "@/lib/middleware/admin";

export const runtime = "nodejs";
export const maxDuration = 300;

function summarizeByType(presets: Vip98kModelPreset[]) {
  return presets.reduce<Record<string, number>>((acc, preset) => {
    const type = String(preset.type || "model");
    acc[type] = (acc[type] || 0) + 1;
    return acc;
  }, {});
}

export async function GET(request: Request) {
  try {
    await requireAdmin();
    const { searchParams } = new URL(request.url);
    const providerId = String(searchParams.get("providerId") || "").trim();
    if (!providerId) {
      return NextResponse.json(
        { error: "Provider ID is required to fetch VIP98K catalog" },
        { status: 400 },
      );
    }

    const provider = await getAiProviderById({ id: providerId });
    if (!provider || provider.type !== "vip98k") {
      return NextResponse.json(
        { error: "Provider must be a VIP98K provider" },
        { status: 400 },
      );
    }

    const presets = await fetchVip98kModelPresets({
      baseURL: provider.baseUrl,
      apiKey: provider.apiKey,
    });
    return NextResponse.json({
      presets,
      counts: {
        total: presets.length,
        byType: summarizeByType(presets),
      },
    });
  } catch (error) {
    console.error("[VIP98K Models API] GET error:", error);
    return NextResponse.json(
      {
        error:
          error instanceof Error
            ? error.message
            : "Failed to fetch VIP98K models",
      },
      { status: 500 },
    );
  }
}

export async function POST(request: Request) {
  try {
    await requireAdmin();
    const body = await request.json();
    const providerId = String(body?.providerId || "").trim();
    const requestedModelIds = Array.isArray(body?.modelIds)
      ? new Set(
          body.modelIds.map((item: unknown) => String(item || "").trim()).filter(Boolean),
        )
      : null;
    const preserveDeletedModels = body?.preserveDeletedModels !== false;
    if (!providerId) {
      return NextResponse.json({ error: "Provider ID is required" }, { status: 400 });
    }

    const provider = await getAiProviderById({ id: providerId });
    if (!provider || provider.type !== "vip98k") {
      return NextResponse.json(
        { error: "Provider must be a VIP98K provider" },
        { status: 400 },
      );
    }

    const catalogPresets = await fetchVip98kModelPresets({
      baseURL: provider.baseUrl,
      apiKey: provider.apiKey,
    });
    const existingModels = await db.query.aiModel.findMany({
      where: eq(aiModel.providerId, providerId),
    });
    const existingModelIds = new Set(existingModels.map((model) => model.modelId));
    const preserveExistingCatalog =
      requestedModelIds === null &&
      preserveDeletedModels &&
      existingModels.length > 0;
    const presets = requestedModelIds
      ? catalogPresets.filter((preset) => requestedModelIds.has(preset.modelId))
      : preserveExistingCatalog
        ? catalogPresets.filter((preset) => existingModelIds.has(preset.modelId))
        : catalogPresets;

    if (body?.dryRun === true) {
      const catalogIds = new Set(catalogPresets.map(preset => preset.modelId));
      const fields = ["displayName", "description", "supportsVision", "supportsImageGen", "isHidden", "sortOrder", "capabilities", "defaultParams", "imageGenConfig"] as const;
      const added = presets.filter(preset => !existingModelIds.has(preset.modelId)).map(preset => ({ modelId: preset.modelId, displayName: preset.displayName }));
      const updated = presets.flatMap(preset => {
        const existing = existingModels.find(model => model.modelId === preset.modelId);
        if (!existing) return [];
        const changedFields: string[] = fields.filter(field => preset[field] !== undefined && JSON.stringify(existing[field]) !== JSON.stringify(preset[field]));
        if (existing.avatarUrl) changedFields.push("avatarUrl");
        if (requestedModelIds !== null && !existing.isEnabled) changedFields.push("isEnabled");
        return changedFields.length ? [{ modelId: preset.modelId, displayName: existing.displayName, changedFields }] : [];
      });
      const disabled = requestedModelIds === null ? existingModels.filter(model => !catalogIds.has(model.modelId) && (model.isEnabled || !model.isHidden)).map(model => ({ modelId: model.modelId, displayName: model.displayName })) : [];
      return NextResponse.json({ preview: { added, updated, disabled }, total: catalogPresets.length });
    }

    const addedModels: AiModel[] = [];
    const updatedModels: AiModel[] = [];
    const disabledModels: AiModel[] = [];
    const errors: Array<{ modelId: string; error: string }> = [];

    if (requestedModelIds === null) {
      const catalogModelIds = new Set(catalogPresets.map((preset) => preset.modelId));
      for (const existing of existingModels) {
        if (catalogModelIds.has(existing.modelId)) continue;
        const [disabled] = await db
          .update(aiModel)
          .set({ isEnabled: false, isHidden: true, updatedAt: new Date() })
          .where(eq(aiModel.id, existing.id))
          .returning();
        if (disabled) disabledModels.push(disabled);
      }
    }

    for (const preset of presets) {
      try {
        const existing = await db.query.aiModel.findFirst({
          where: and(
            eq(aiModel.providerId, providerId),
            eq(aiModel.modelId, preset.modelId),
          ),
        });
        const values = {
          displayName: preset.displayName,
          avatarUrl: null,
          description: preset.description,
          supportsVision: preset.supportsVision,
          supportsImageGen: preset.supportsImageGen,
          isEnabled:
            requestedModelIds !== null ? true : (existing?.isEnabled ?? true),
          isHidden: preset.isHidden,
          sortOrder: preset.sortOrder,
          capabilities: preset.capabilities,
          defaultParams: preset.defaultParams,
          imageGenConfig: preset.imageGenConfig,
          updatedAt: new Date(),
        };

        if (existing) {
          const [updated] = await db
            .update(aiModel)
            .set(values)
            .where(
              and(
                eq(aiModel.providerId, providerId),
                eq(aiModel.modelId, preset.modelId),
              ),
            )
            .returning();
          if (updated) updatedModels.push(updated);
        } else {
          const [created] = await db
            .insert(aiModel)
            .values({
              providerId,
              modelId: preset.modelId,
              ...values,
              isDefault: false,
              isSubModel: false,
              parentModelId: null,
            })
            .returning();
          if (created) addedModels.push(created);
        }
      } catch (error) {
        console.error(`[VIP98K Models API] Failed to sync ${preset.modelId}:`, error);
        errors.push({
          modelId: preset.modelId,
          error: error instanceof Error ? error.message : "Sync failed",
        });
      }
    }

    return NextResponse.json({
      success: true,
      addedCount: addedModels.length,
      updatedCount: updatedModels.length,
      disabledCount: disabledModels.length,
      addedModels,
      updatedModels,
      disabledModelIds: disabledModels.map((model) => model.modelId),
      errors: errors.length > 0 ? errors : undefined,
      counts: {
        requested: presets.length,
        total: catalogPresets.length,
        byType: summarizeByType(catalogPresets),
      },
    });
  } catch (error) {
    console.error("[VIP98K Models API] POST error:", error);
    return NextResponse.json(
      {
        error:
          error instanceof Error
            ? error.message
            : "Failed to sync VIP98K models",
      },
      { status: 500 },
    );
  }
}