{
  "internacional": true,
  "quantidade": 10,
  "shuffle": true,
  "page": 0,
  "pageSize": 20,
  "origem": "GRU",
  "destino": "LIS",
  "apenasMilhas": false
}

{
  "success": true,
  "data": [
    {
      "id": "oferta_123",
      "origem": {
        "iata": "GRU",
        "cidade": "São Paulo",
        "estado": "SP",
        "pais": "Brasil",
        "aeroporto": "Aeroporto Internacional de São Paulo/Guarulhos",
        "urlImagens": [
          "repository/places/são paulo - guarulhos/0"
        ]
      },
      "destino": {
        "iata": "MIA",
        "cidade": "Miami",
        "estado": "FL",
        "pais": "Estados Unidos",
        "aeroporto": "Miami International Airport",
        "urlImagens": [
          "repository/places/miami/2",
          "repository/places/miami/3"
        ]
      },
      "precoMinimo": 1299.00,
      "moeda": "BRL",
      "companhiaAerea": {
        "codigo": "LA",
        "nome": "LATAM Airlines"
      },
      "tipo": "round_trip",
      "internacional": true,
      "pontosAdulto": 1,
      "valorOriginalMilhas": 35000,
      "dataInicio": "2026-03-01",
      "dataFim": "2026-06-30",
      "restricoes": [
        "Antecedência mínima de 7 dias",
        "Permanência mínima de 3 dias"
      ],
      "disponivel": true
    }
  ],
  "totalItens": 150,
  "page": 0,
  "pageSize": 10,
  "message": "Ofertas encontradas com sucesso"
}

"repository/places/nome-da-cidade/0"
"repository/places/nome-da-cidade/1"
"repository/places/nome-da-cidade/2"

https://mbxrepo.azureedge.net/prod/repository/places/nome-da-cidade/0_298x160.webp

const MOBLIX_CDN_BASE_URL = 'https://mbxrepo.azureedge.net/prod';
const IMAGE_SIZE = '_298x160.webp';

function buildImageUrl(imagePath) {
  if (!imagePath) return null;
  
  // Remove "repository/" se estiver no início
  let cleanPath = imagePath.replace(/^repository\//, '');
  
  // Converte para minúsculas (CDN é case-sensitive)
  cleanPath = cleanPath.toLowerCase();
  
  // Adiciona tamanho se não tiver extensão
  if (!cleanPath.includes('.webp') && !cleanPath.includes('.jpg')) {
    cleanPath = `${cleanPath}${IMAGE_SIZE}`;
  }
  
  // Encode para URL
  const pathParts = cleanPath.split('/');
  const encodedPath = pathParts.map(part => encodeURIComponent(part)).join('/');
  
  return `${MOBLIX_CDN_BASE_URL}/${encodedPath}`;
}

// Função para obter primeira imagem válida
function getFirstValidImage(imagePaths) {
  if (!imagePaths || !Array.isArray(imagePaths) || imagePaths.length === 0) {
    return null;
  }
  
  // Retorna a primeira imagem válida do array
  for (const path of imagePaths) {
    const url = buildImageUrl(path);
    if (url) return url;
  }
  
  return null;
}

// Função para obter imagem aleatória (recomendado para variedade visual)
// Usa seed para garantir que mesma oferta sempre mostre mesma imagem
// mas diferentes ofertas mostrem imagens diferentes
function getRandomValidImage(imagePaths, seed) {
  if (!imagePaths || !Array.isArray(imagePaths) || imagePaths.length === 0) {
    return null;
  }

  // Filtrar apenas imagens válidas
  const validImages = [];
  for (const path of imagePaths) {
    const url = buildImageUrl(path);
    if (url) validImages.push(url);
  }

  if (validImages.length === 0) return null;
  if (validImages.length === 1) return validImages[0];

  // Usar seed para seleção determinística mas variada
  let randomIndex;
  if (seed !== undefined) {
    // Gerar número pseudo-aleatório baseado no seed
    const seedStr = String(seed);
    let hash = 0;
    for (let i = 0; i < seedStr.length; i++) {
      const char = seedStr.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32bit integer
    }
    randomIndex = Math.abs(hash) % validImages.length;
  } else {
    randomIndex = Math.floor(Math.random() * validImages.length);
  }

  return validImages[randomIndex];
}

// Uso: Seleção aleatória com seed (recomendado)
// O seed garante que cards com mesmo origem/destino mostrem imagens diferentes
const seed = oferta.idGeral || oferta.id || `${oferta.origem.iata}-${oferta.destino.iata}`;
const imagemDestino = getRandomValidImage(oferta.destino.urlImagens, seed);
const imagemOrigem = getRandomValidImage(oferta.origem.urlImagens, seed);
const imagemPrincipal = imagemDestino || imagemOrigem;

// Alternativa: Usar primeira imagem (mais simples, menos variedade)
// const imagemDestino = getFirstValidImage(oferta.destino.urlImagens);
// const imagemOrigem = getFirstValidImage(oferta.origem.urlImagens);
// const imagemPrincipal = imagemDestino || imagemOrigem;

function OfertaCard({ oferta }) {
  // Obter primeira imagem válida (destino tem prioridade)
  const imagemDestino = getFirstValidImage(oferta.destino.urlImagens);
  const imagemOrigem = getFirstValidImage(oferta.origem.urlImagens);
  const imagemPrincipal = imagemDestino || imagemOrigem;

  return (
    <div className="oferta-card">
      {imagemPrincipal ? (
        <img 
          src={imagemPrincipal} 
          alt={`${oferta.destino.cidade}, ${oferta.destino.pais}`}
          className="w-full h-48 object-cover"
        />
      ) : (
        <div className="w-full h-48 bg-gray-200 flex items-center justify-center">
          <PlaneIcon />
        </div>
      )}
      {/* resto do card */}
    </div>
  );
}

curl -X POST https://app.apidevoos.dev/api/ofertas/buscar \
  -H "Authorization: Bearer sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "internacional": true,
    "quantidade": 20,
    "shuffle": true
  }'

curl -X POST https://app.apidevoos.dev/api/ofertas/buscar \
  -H "Authorization: Bearer sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "internacional": false,
    "quantidade": 15,
    "shuffle": false
  }'

curl -X POST https://app.apidevoos.dev/api/ofertas/buscar \
  -H "Authorization: Bearer sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "internacional": true,
    "page": 1,
    "pageSize": 10
  }'

curl -X POST https://app.apidevoos.dev/api/ofertas/buscar \
  -H "Authorization: Bearer sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "internacional": true,
    "origem": "GRU",
    "destino": "LIS",
    "quantidade": 20,
    "shuffle": true
  }'

curl -X POST https://app.apidevoos.dev/api/ofertas/buscar \
  -H "Authorization: Bearer sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "internacional": true,
    "apenasMilhas": true,
    "quantidade": 20,
    "shuffle": true
  }'

// Buscar 6 ofertas internacionais aleatórias
const response = await fetch('/api/ofertas/buscar', {
  method: 'POST',
  body: JSON.stringify({
    internacional: true,
    quantidade: 6,
    shuffle: true
  })
});

// Buscar ofertas de São Paulo para Miami
const response = await fetch('/api/ofertas/buscar', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    internacional: true,
    origem: 'GRU',
    destino: 'MIA',
    quantidade: 10,
    shuffle: true
  })
});

const ofertas = await response.json();

// Sem shuffle para manter consistência
const response = await fetch('/api/ofertas/buscar', {
  method: 'POST',
  body: JSON.stringify({
    internacional: true,
    quantidade: 10,
    shuffle: false
  })
});

const [nacionais, internacionais] = await Promise.all([
  fetch('/api/ofertas/buscar', {
    method: 'POST',
    body: JSON.stringify({ internacional: false, quantidade: 20 })
  }).then(r => r.json()),
  
  fetch('/api/ofertas/buscar', {
    method: 'POST',
    body: JSON.stringify({ internacional: true, quantidade: 20 })
  }).then(r => r.json())
]);

// Buscar apenas ofertas com milhas
const response = await fetch('/api/ofertas/buscar', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    internacional: true,
    apenasMilhas: true,
    quantidade: 15,
    shuffle: true
  })
});

const data = await response.json();

// As ofertas retornadas terão pontosAdulto > 0
// indicando que aceitam pagamento com milhas

function handleOfertaClick(oferta) {
  // Calcular data de partida (ex: 30 dias à frente)
  const departureDate = new Date();
  departureDate.setDate(departureDate.getDate() + 30);
  
  // Calcular data de retorno (ex: 7 dias depois)
  const returnDate = new Date(departureDate);
  returnDate.setDate(returnDate.getDate() + 7);
  
  // Redirecionar para busca
  const searchParams = new URLSearchParams({
    origin: oferta.origem.iata,
    destination: oferta.destino.iata,
    departureDate: departureDate.toISOString().split('T')[0],
    returnDate: returnDate.toISOString().split('T')[0],
    passengers: '1',
    cabinClass: 'economy'
  });
  
  window.location.href = `/voos/buscar?${searchParams.toString()}`;
}

┌───────────────────────────────────┐
│     [Imagem do Destino]           │
│                                   │
├───────────────────────────────────┤
│ São Paulo → Miami                 │
│                                   │
│ R$ 1.299,00                       │
│ LATAM Airlines                    │
│                                   │
│ [ Ver Voos ]                      │
└───────────────────────────────────┘

// Próximo.js - Cache de 2 horas
export const revalidate = 7200;

// Ou usar SWR
import useSWR from 'swr';

function OfertasVoos() {
  const { data, error } = useSWR(
    'ofertas',
    () => fetch('/api/ofertas/buscar', { 
      method: 'POST',
      body: JSON.stringify({ internacional: true, quantidade: 12 })
    }).then(r => r.json()),
    {
      refreshInterval: 7200000, // 2 horas
      revalidateOnFocus: false
    }
  );
}