portfolio/app/api/n8n/generate-image/route.ts

import { NextRequest, NextResponse } from "next/server";

/**
 * POST /api/n8n/generate-image
 *
 * Triggers AI image generation for a project via n8n workflow
 *
 * Body:
 * {
 *   projectId: number;
 *   regenerate?: boolean; // Force regenerate even if image exists
 * }
 */
export async function POST(req: NextRequest) {
  try {
    const body = await req.json();
    const { projectId, regenerate = false } = body;

    // Validate input
    if (!projectId) {
      return NextResponse.json(
        { error: "projectId is required" },
        { status: 400 },
      );
    }

    // Check environment variables
    const n8nWebhookUrl = process.env.N8N_WEBHOOK_URL;
    const n8nSecretToken = process.env.N8N_SECRET_TOKEN;

    if (!n8nWebhookUrl) {
      return NextResponse.json(
        {
          error: "N8N_WEBHOOK_URL not configured",
          message:
            "AI image generation is not set up. Please configure n8n webhooks.",
        },
        { status: 503 },
      );
    }

    // Optional: Check if project already has an image
    if (!regenerate) {
      const checkResponse = await fetch(
        `${process.env.NEXT_PUBLIC_API_URL || "http://localhost:3000"}/api/projects/${projectId}`,
        {
          method: "GET",
          cache: "no-store",
        },
      );

      if (checkResponse.ok) {
        const project = await checkResponse.json();
        if (project.imageUrl && project.imageUrl !== "") {
          return NextResponse.json(
            {
              success: true,
              message:
                "Project already has an image. Use regenerate=true to force regeneration.",
              projectId: projectId,
              existingImageUrl: project.imageUrl,
              regenerated: false,
            },
            { status: 200 },
          );
        }
      }
    }

    // Call n8n webhook to trigger AI image generation
    const n8nResponse = await fetch(`${n8nWebhookUrl}/ai-image-generation`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        ...(n8nSecretToken && {
          Authorization: `Bearer ${n8nSecretToken}`,
        }),
      },
      body: JSON.stringify({
        projectId: projectId,
        regenerate: regenerate,
        triggeredBy: "api",
        timestamp: new Date().toISOString(),
      }),
    });

    if (!n8nResponse.ok) {
      const errorText = await n8nResponse.text();
      console.error("n8n webhook error:", errorText);

      return NextResponse.json(
        {
          error: "Failed to trigger image generation",
          message: "n8n workflow failed to execute",
          details: errorText,
        },
        { status: 500 },
      );
    }

    const result = await n8nResponse.json();

    return NextResponse.json(
      {
        success: true,
        message: "AI image generation started successfully",
        projectId: projectId,
        imageUrl: result.imageUrl,
        generatedAt: result.generatedAt,
        fileSize: result.fileSize,
        regenerated: regenerate,
      },
      { status: 200 },
    );
  } catch (error) {
    console.error("Error in generate-image API:", error);
    return NextResponse.json(
      {
        error: "Internal server error",
        message: error instanceof Error ? error.message : "Unknown error",
      },
      { status: 500 },
    );
  }
}

/**
 * GET /api/n8n/generate-image?projectId=123
 *
 * Check the status of image generation for a project
 */
export async function GET(req: NextRequest) {
  try {
    const searchParams = req.nextUrl.searchParams;
    const projectId = searchParams.get("projectId");

    if (!projectId) {
      return NextResponse.json(
        { error: "projectId query parameter is required" },
        { status: 400 },
      );
    }

    // Fetch project to check image status
    const projectResponse = await fetch(
      `${process.env.NEXT_PUBLIC_API_URL || "http://localhost:3000"}/api/projects/${projectId}`,
      {
        method: "GET",
        cache: "no-store",
      },
    );

    if (!projectResponse.ok) {
      return NextResponse.json({ error: "Project not found" }, { status: 404 });
    }

    const project = await projectResponse.json();

    return NextResponse.json({
      projectId: parseInt(projectId),
      title: project.title,
      hasImage: !!project.imageUrl,
      imageUrl: project.imageUrl || null,
      updatedAt: project.updatedAt,
    });
  } catch (error) {
    console.error("Error checking image status:", error);
    return NextResponse.json(
      {
        error: "Internal server error",
        message: error instanceof Error ? error.message : "Unknown error",
      },
      { status: 500 },
    );
  }
}