ai-chatbot/app/api/admin/ruxa-image-models/route.ts

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

export async function GET() {
  try {
    await requireAdmin();
    return NextResponse.json({
      presets: RUXA_IMAGE_MODEL_PRESETS,
      counts: {
        total: RUXA_IMAGE_MODEL_PRESETS.length,
      },
    });
  } catch (error: any) {
    console.error("[RUXA Image Models API] GET error:", error);
    return NextResponse.json(
      { error: error.message || "Failed to fetch RUXA image model presets" },
      { status: 500 }
    );
  }
}

export async function POST(request: Request) {
  try {
    await requireAdmin();

    const body = await request.json();
    const providerId = String(body?.providerId || "").trim();
    const modelIds = Array.isArray(body?.modelIds)
      ? body.modelIds
          .map((item: unknown) => String(item || "").trim())
          .filter(Boolean)
      : null;

    if (!providerId) {
      return NextResponse.json(
        { error: "Provider ID is required" },
        { status: 400 }
      );
    }

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

    const presetsToAdd = modelIds
      ? RUXA_IMAGE_MODEL_PRESETS.filter((preset) =>
          modelIds.includes(preset.modelId)
        )
      : RUXA_IMAGE_MODEL_PRESETS;

    const addedModels: AiModel[] = [];
    const errors: { modelId: string; error: string }[] = [];
    const updatedModels: AiModel[] = [];

    for (const preset of presetsToAdd) {
      try {
        const existing = await db.query.aiModel.findFirst({
          where: and(
            eq(aiModel.providerId, providerId),
            eq(aiModel.modelId, preset.modelId)
          ),
        });

        if (existing) {
          const [updated] = await db
            .update(aiModel)
            .set({
              displayName: preset.displayName,
              description: preset.description,
              supportsVision: preset.supportsVision,
              supportsImageGen: preset.supportsImageGen,
              isEnabled: true,
              isHidden: false,
              sortOrder: preset.sortOrder,
              capabilities: preset.capabilities || null,
              defaultParams: preset.defaultParams || null,
              imageGenConfig: preset.imageGenConfig || null,
            })
            .where(
              and(
                eq(aiModel.providerId, providerId),
                eq(aiModel.modelId, preset.modelId)
              )
            )
            .returning();

          if (updated) {
            updatedModels.push(updated);
          } else {
            errors.push({ modelId: preset.modelId, error: "Model exists but failed to sync" });
          }
          continue;
        }

        const [newModel] = await db
          .insert(aiModel)
          .values({
            providerId,
            modelId: preset.modelId,
            displayName: preset.displayName,
            description: preset.description,
            supportsVision: preset.supportsVision,
            supportsImageGen: preset.supportsImageGen,
            isEnabled: true,
            isHidden: false,
            isDefault: false,
            sortOrder: preset.sortOrder,
            capabilities: preset.capabilities || null,
            defaultParams: preset.defaultParams || null,
            imageGenConfig: preset.imageGenConfig || null,
            isSubModel: false,
            parentModelId: null,
          })
          .returning();

        addedModels.push(newModel);
      } catch (error: any) {
        console.error(
          `[RUXA Image Models API] Failed to add ${preset.modelId}:`,
          error
        );
        errors.push({
          modelId: preset.modelId,
          error: error.message || "Insert failed",
        });
      }
    }

    return NextResponse.json({
      success: true,
      addedCount: addedModels.length,
      updatedCount: updatedModels.length,
      addedModels,
      updatedModels,
      errors: errors.length > 0 ? errors : undefined,
      counts: {
        requested: presetsToAdd.length,
        total: RUXA_IMAGE_MODEL_PRESETS.length,
      },
    });
  } catch (error: any) {
    console.error("[RUXA Image Models API] POST error:", error);
    return NextResponse.json(
      { error: error.message || "Failed to add RUXA image models" },
      { status: 500 }
    );
  }
}