{
  "success": false,
  "error": {
    "code": "ERROR_CODE",
    "message": "Descrição legível do erro",
    "details": {}
  }
}

{
  "success": false,
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid API key provided"
  }
}

{
  "success": false,
  "error": {
    "code": "INSTANCE_NOT_FOUND",
    "message": "Instance 'minha-instancia' not found"
  }
}

{
  "success": false,
  "error": {
    "code": "INSTANCE_NOT_CONNECTED",
    "message": "Instance is not connected to WhatsApp"
  }
}

{
  "success": false,
  "error": {
    "code": "INVALID_NUMBER",
    "message": "The phone number is not registered on WhatsApp",
    "details": {
      "number": "5511999999999"
    }
  }
}

{
  "success": false,
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Too many requests. Please retry after 60 seconds.",
    "details": {
      "retryAfter": 60,
      "limit": 30,
      "remaining": 0
    }
  }
}

{
  "success": false,
  "error": {
    "code": "MEDIA_TOO_LARGE",
    "message": "Media file exceeds maximum size",
    "details": {
      "maxSize": "16MB",
      "receivedSize": "25MB"
    }
  }
}

async function sendMessage(instanceId, to, text) {
  try {
    const response = await fetch('https://api.wapizap.com/api/v2/messages', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
      },
      body: JSON.stringify({ instanceId, to, type: 'text', text })
    });

    const data = await response.json();

    if (!data.success) {
      // Tratar erro baseado no código
      switch (data.error.code) {
        case 'INSTANCE_NOT_CONNECTED':
          await reconnectInstance(instanceId);
          return sendMessage(instanceId, to, text); // Retry

        case 'INVALID_NUMBER':
          console.error(`Número inválido: ${to}`);
          return null;

        case 'RATE_LIMIT_EXCEEDED':
          const retryAfter = data.error.details?.retryAfter || 60;
          await sleep(retryAfter * 1000);
          return sendMessage(instanceId, to, text); // Retry

        default:
          throw new Error(data.error.message);
      }
    }

    return data.data;

  } catch (error) {
    console.error('Erro ao enviar mensagem:', error);
    throw error;
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

import requests
import time

def send_message(instance_id, to, text):
    try:
        response = requests.post(
            'https://api.wapizap.com/api/v2/messages',
            headers={
                'Content-Type': 'application/json',
                'Authorization': f'Bearer {API_KEY}'
            },
            json={
                'instanceId': instance_id,
                'to': to,
                'type': 'text',
                'text': text
            }
        )

        data = response.json()

        if not data.get('success'):
            error_code = data.get('error', {}).get('code')

            if error_code == 'INSTANCE_NOT_CONNECTED':
                reconnect_instance(instance_id)
                return send_message(instance_id, to, text)  # Retry

            elif error_code == 'INVALID_NUMBER':
                print(f'Número inválido: {to}')
                return None

            elif error_code == 'RATE_LIMIT_EXCEEDED':
                retry_after = data.get('error', {}).get('details', {}).get('retryAfter', 60)
                time.sleep(retry_after)
                return send_message(instance_id, to, text)  # Retry

            else:
                raise Exception(data.get('error', {}).get('message'))

        return data.get('data')

    except Exception as e:
        print(f'Erro ao enviar mensagem: {e}')
        raise

async function fetchWithRetry(url, options, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      const data = await response.json();

      if (data.success) {
        return data;
      }

      // Erros que não devem ser retentados
      const nonRetryable = ['UNAUTHORIZED', 'INVALID_NUMBER', 'NOT_FOUND'];
      if (nonRetryable.includes(data.error?.code)) {
        throw new Error(data.error.message);
      }

      // Rate limit - usar tempo específico
      if (data.error?.code === 'RATE_LIMIT_EXCEEDED') {
        const waitTime = data.error.details?.retryAfter || 60;
        await sleep(waitTime * 1000);
        continue;
      }

      lastError = new Error(data.error?.message);

    } catch (error) {
      lastError = error;
    }

    // Exponential backoff: 1s, 2s, 4s, 8s...
    const waitTime = Math.pow(2, attempt) * 1000;
    console.log(`Tentativa ${attempt + 1} falhou. Aguardando ${waitTime}ms...`);
    await sleep(waitTime);
  }

  throw lastError;
}

function logApiError(error, context) {
  console.error(JSON.stringify({
    timestamp: new Date().toISOString(),
    level: 'error',
    code: error.code,
    message: error.message,
    context: {
      endpoint: context.endpoint,
      instanceId: context.instanceId,
      requestId: context.requestId
    },
    details: error.details
  }));
}