REPLICATE_API_KEY=r8_xxxxxxxxxxxxxxxxxxxxxxxxxx

// lib/ai/mockup.ts
export const AI_MODELS = {
  "nano-banana": {
    name: "Fast",
    description: "Quick iterations, good for exploration",
    tokens: 12,
  },
  "nano-banana-pro": {
    name: "Quality",
    description: "Higher quality for final designs",
    tokens: 45,
  },
  "nano-banana-pro-4k": {
    name: "Print Ready",
    description: "4K resolution for production",
    tokens: 90,
  },
};

const REMOVE_BG_MODEL = "recraft-ai/recraft-remove-background";
// Tokens: 3

const UPSCALE_MODEL = "nightmareai/real-esrgan";
// Tokens: 1

import Replicate from "replicate";

const replicate = new Replicate({
  auth: process.env.REPLICATE_API_KEY,
});

const output = await replicate.run("google/nano-banana", {
  input: {
    prompt: "vintage surf logo with palm trees",
    aspect_ratio: "1:1",
    num_outputs: 1,
  },
});

// Returns array of image URLs
const imageUrl = output[0];

// lib/ai/mockup.ts
export async function generateUnified({
  prompt,
  referenceImages,
  garmentUrls,
  designUrls,
  mockupCount,
  modelKey,
}) {
  // Step 1: Generate isolated design graphic
  const designPrompt = buildDesignPrompt(prompt);
  const graphicResult = await generateWithReplicate({
    prompt: designPrompt,
    referenceImages: designUrls,
  });
  
  const graphicUrl = graphicResult.images[0];
  
  // Step 2: Composite onto garment (if garment provided)
  if (garmentUrls?.length) {
    const mockupPrompt = buildMockupPrompt(prompt);
    const mockupResult = await generateWithReplicate({
      prompt: mockupPrompt,
      referenceImages: [graphicUrl, ...garmentUrls],
    });
    
    return {
      graphicUrl,
      mockups: mockupResult.images,
      jobId: mockupResult.jobId,
      provider: "replicate",
    };
  }
  
  return {
    graphicUrl,
    mockups: [],
    jobId: graphicResult.jobId,
    provider: "replicate",
  };
}

// lib/ai/replicate.ts
export async function removeBackground({ imageUrl }) {
  const replicate = new Replicate({
    auth: process.env.REPLICATE_API_KEY,
  });

  const output = await replicate.run(
    "recraft-ai/recraft-remove-background",
    { input: { image: imageUrl } }
  );

  // Returns URL of transparent PNG
  return {
    imageUrl: String(output),
    provider: "replicate",
  };
}

// Remove background from AI-generated design
const result = await removeBackground({
  imageUrl: generatedDesign.url,
});

// result.imageUrl is transparent PNG
const printAsset = await uploadImage(result.imageUrl, "print-asset.png", {
  preserveAlpha: true,
});

export async function upscaleImage({ imageUrl, scale = 2 }) {
  const replicate = new Replicate({
    auth: process.env.REPLICATE_API_KEY,
  });

  const output = await replicate.run(
    "nightmareai/real-esrgan:f121d640bd...",
    {
      input: {
        image: imageUrl,
        scale: scale, // 2x or 4x
        face_enhance: false,
      },
    }
  );

  return {
    imageUrl: String(output),
    provider: "replicate",
  };
}

// Build Replicate input with references
function buildReplicateInput(prompt, referenceImages) {
  const input: Record<string, unknown> = {
    prompt,
    aspect_ratio: "1:1",
    num_outputs: 1,
    output_format: "png",
  };

  // Add image references if provided
  if (referenceImages?.length) {
    // nano-banana supports image prompt
    input.image_prompt = referenceImages[0];
    
    // Additional images as style reference
    if (referenceImages.length > 1) {
      input.style_reference = referenceImages[1];
    }
  }

  return input;
}

// lib/ai/mockup.ts
export async function generateMockup(params) {
  try {
    return await generateWithReplicate(params);
  } catch (error) {
    if (hasFal) {
      console.warn("Replicate failed, trying fal.ai fallback");
      return await generateWithFal(params);
    }
    throw error;
  }
}

async function generateWithFal({ prompt, referenceImages }) {
  const result = await fal.subscribe("fal-ai/flux-pro/v1.1", {
    input: {
      prompt,
      image_size: "square",
      num_images: 1,
    },
  });

  return {
    images: result.images.map(img => img.url),
    jobId: result.request_id,
    provider: "fal",
  };
}

try {
  const output = await replicate.run(modelSlug, { input });
  return processOutput(output);
} catch (error) {
  if (error.message?.includes("rate limit")) {
    // Wait and retry
    await sleep(2000);
    return replicate.run(modelSlug, { input });
  }
  
  if (error.message?.includes("model not found")) {
    console.error("Model unavailable:", modelSlug);
    throw new Error("AI generation temporarily unavailable");
  }
  
  throw error;
}

const TOKEN_COSTS = {
  ai_generation: {
    "nano-banana": 12,
    "nano-banana-pro": 45,
    "nano-banana-pro-4k": 90,
  },
  background_removal: 3,
  upscale: 1,
};

// Deduct tokens after successful generation
await recordUsage({
  userId,
  eventType: "ai_generation",
  tokens: TOKEN_COSTS.ai_generation[modelKey],
  model: modelKey,
});

// Log all API calls
console.log("[replicate] Model:", modelSlug);
console.log("[replicate] Input:", JSON.stringify(input, null, 2));
console.log("[replicate] Output:", JSON.stringify(output, null, 2));

# Using Replicate CLI
replicate models get google/nano-banana