Eight prompt strategies for an 11.68:1 aspect ratio

// app/api/generate-insert/route.ts
import { SCENE_STYLE, IDENTITY_PRESERVATION, NEGATIVE_TAIL } from "@/lib/promptConstants";

type ApproachId = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

const APPROACHES: Record<ApproachId, (subject: string, scene: string) => string> = {
  // 1 — Control. Naive prompt; baseline for diffing against.
  1: (subject, scene) =>
    `${subject} in ${scene}. ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 2 — EWS + numeric crop constraint. "Establishing wide shot, vertically centered."
  2: (subject, scene) =>
    `Establishing wide shot of ${subject} in ${scene}. Subjects positioned in the middle
     distance, vertically centered. ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 3 — Panoramic mural / Bayeux Tapestry. Reframes the model's task as "paint a frieze."
  3: (subject, scene) =>
    `A panoramic horizontal mural in the style of a Bayeux Tapestry register: ${subject}
     within ${scene}, rendered as a continuous narrative band across the frame.
     ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 4 — High-overhead drone (45°). Ground plane fills 80%, subjects shrink naturally.
  4: (subject, scene) =>
    `High-overhead drone view (45-degree angle) of ${subject} in ${scene}. Ground plane
     fills approximately 80 percent of the frame; subjects appear small from this elevation.
     ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 5 — Letterbox display. "Format is letterboxed and content lives in the band."
  5: (subject, scene) =>
    `A letterbox display showing ${subject} in ${scene}. The format is letterboxed and all
     subject content lives within the central horizontal band. ${SCENE_STYLE}
     ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 6 — Tilt-shift diorama. Miniature world, razor sharp across the horizontal center.
  6: (subject, scene) =>
    `A detailed miniature tilt-shift diorama: ${subject} arranged within ${scene}, razor
     sharp across the horizontal center, soft falloff above and below. ${SCENE_STYLE}
     ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 7 — Mini / distant figures. Pure size language: "hundreds of yards away."
  7: (subject, scene) =>
    `${subject} appearing tiny and distant within ${scene}, like seeing them from hundreds
     of yards away. ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,

  // 8 — PRODUCTION WINNER. Stacks three independent biases:
  //   - vague size language ("tiny and distant, hundreds of yards away")
  //   - explicit numeric crop constraint ("43%–57% of image height")
  //   - complete-bodies-grouping language (head to feet, all together at center)
  8: (subject, scene) =>
    `Everything from the reference photo appears tiny and distant, far away in the
     landscape, like seeing it from hundreds of yards away. ${subject} are all close
     beside each other at the center of the frame, complete head to feet, roof to tires.
     All important content fits between 43 percent and 57 percent of the image height.
     The scene is ${scene}. ${SCENE_STYLE} ${IDENTITY_PRESERVATION} ${NEGATIVE_TAIL}`,
};

export function buildPrompt(
  variant: { subject: string; scene: string },
  approach: ApproachId = 8,
): string {
  return APPROACHES[approach](variant.subject, variant.scene)
    .replace(/\s+/g, " ")
    .trim();
}

// lib/promptConstants.ts

/**
 * Aesthetic lock — the same across all 8 approaches. Prevents the model
 * from drifting into photographic realism, cartoon, or digital painting
 * styles that don't match the airbrushed automotive product.
 */
export const SCENE_STYLE = `
Professional custom automotive airbrush illustration. Vibrant high-saturation colors,
visible brush technique, soft glow on highlights, subtle gradient backgrounds.
NOT photographic realism. NOT cartoon. NOT anime. NOT digital painting. NOT 3D render.
Render style: hand-painted automotive mural with airbrushed depth.
`.trim();

/**
 * Explicit list of what MUST survive into the generated image. Without this,
 * the model "improves" subjects by reshaping faces, dropping decals, or
 * changing brand markings — all of which break the use case (a customer's
 * own vehicle on their own light bar).
 */
export const IDENTITY_PRESERVATION = `
Preserve all of the following from the reference photo intact:
faces, hairstyles, fur and markings on pets, clothing, accessories,
body proportions, poses, expressions, vehicle make and model,
visible logos and brand marks, decals, text, paint colors and finishes.
Cast realistic shadows consistent with the scene's lighting direction.
`.trim();

/**
 * Negative-prompt tail. The "intended use" sentence at the end was a
 * surprise win — measurably nudges the model toward more dramatic,
 * display-aware compositions across every approach.
 */
export const NEGATIVE_TAIL = `
Do not add any text, words, watermarks, borders, logos, or signatures.
No frames, no captions, no UI overlays.
Intended use: a custom automotive LED light bar insert —
high-impact 51.4-inch panoramic display.
`.trim();

// app/api/expand-prompt/route.ts
import OpenAI from "openai";
import { z } from "zod";

const ExpansionSchema = z.object({
  variants: z
    .array(
      z.object({
        title: z.string().min(2).max(80),
        description: z.string().min(10).max(280),
      }),
    )
    .length(3),
});

const SYSTEM_PROMPT = `You expand a customer's one-line scene description into
exactly 3 fuller scene options for an AI image generator.

CRITICAL — WORD PRESERVATION RULE:
Preserve EVERY word the customer used. Copy their exact adjectives, modifiers,
and descriptors into ALL 3 options word-for-word. If they said
"upside down pineapples", write "upside down pineapples" — NOT just "pineapples"
and NOT "unusual pineapple-themed scene." Do not soften, generalize, or
"improve" their language. Their words are load-bearing.

Each option should:
  - Add atmosphere, environment, and mood AROUND the customer's exact words
  - Stay 1–2 sentences
  - Be visually concrete (lighting, surroundings, time of day)
  - Never invent subjects the customer didn't mention

Return JSON: { "variants": [ {"title", "description"}, ... ] } with exactly 3 entries.`;

export async function POST(req: Request) {
  const { rawDescription } = await req.json();

  const openai = new OpenAI();
  const MAX_ATTEMPTS = 3;
  let lastError: unknown = null;

  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
    try {
      const completion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        temperature: 1.0,
        response_format: { type: "json_object" },
        messages: [
          { role: "system", content: SYSTEM_PROMPT },
          { role: "user", content: rawDescription },
        ],
      });

      const json = JSON.parse(completion.choices[0].message.content ?? "{}");
      const parsed = ExpansionSchema.safeParse(json);
      if (!parsed.success) {
        lastError = parsed.error;
        continue;
      }

      // Bonus check: every variant must include each significant word from the
      // customer's input. Catches the model's most common cheat — paraphrasing
      // adjectives into synonyms.
      const significantWords = extractSignificant(rawDescription);
      const allPreserved = parsed.data.variants.every((v) =>
        significantWords.every((w) => v.description.toLowerCase().includes(w)),
      );
      if (!allPreserved) {
        lastError = new Error("word-preservation check failed");
        continue;
      }

      return Response.json({ variants: parsed.data.variants, attempts: attempt });
    } catch (err) {
      lastError = err;
    }
  }

  // Graceful degrade — after 3 failures the kiosk UI offers the user
  // a "skip expansion, use my exact words" path.
  return Response.json(
    { error: "expansion_failed", canUseRaw: true, lastError: String(lastError) },
    { status: 502 },
  );
}

function extractSignificant(input: string): string[] {
  // Strip stop words; lowercase. Keeps "upside", "down", "pineapples", "fire".
  const STOP = new Set(["a", "an", "the", "of", "in", "on", "at", "and", "or", "to", "with"]);
  return input
    .toLowerCase()
    .replace(/[^a-z0-9\s'-]/g, "")
    .split(/\s+/)
    .filter((w) => w.length > 2 && !STOP.has(w));
}