How to fix messaging/invalid-argument in Firebase

const registrationToken = '...'; // Should be ~152 characters

// Check token format
if (!registrationToken || registrationToken.length < 100) {
  console.error('Token appears invalid - too short or missing');
}

// Token format validation
const fcmTokenRegex = /^[a-zA-Z0-9_-]{100,200}$/;
if (!fcmTokenRegex.test(registrationToken)) {
  console.warn('Token format may be invalid');
}

// Verify token before sending
console.log('Token length:', registrationToken.length); // Should be ~152
console.log('Token start:', registrationToken.substring(0, 20));

const registrationTokens = [/* array of tokens */];

// Check batch size
if (registrationTokens.length > 1000) {
  console.warn(`Batch size is ${registrationTokens.length} - exceeds FCM limit of 1000`);
}

// Correct way to send to 1000+ devices
async function sendToLargeDeviceSet(tokens, message) {
  const BATCH_SIZE = 500; // Use smaller batches for reliability

  for (let i = 0; i < tokens.length; i += BATCH_SIZE) {
    const batch = tokens.slice(i, i + BATCH_SIZE);

    try {
      const response = await admin.messaging().sendMulticast({
        tokens: batch,
        notification: message.notification,
        data: message.data,
        android: message.android,
        apns: message.apns,
        webpush: message.webpush
      });

      console.log(`Batch ${Math.floor(i / BATCH_SIZE) + 1}: Success: ${response.successCount}, Failed: ${response.failureCount}`);

      // Handle failures
      response.responses.forEach((resp, index) => {
        if (!resp.success && resp.error) {
          const token = batch[index];
          console.error(`Failed to send to ${token}: ${resp.error.code}`);

          // Delete invalid tokens
          if (resp.error.code === 'messaging/invalid-registration-token' ||
              resp.error.code === 'messaging/invalid-argument') {
            // Delete from your database
            await deleteTokenFromDatabase(token);
          }
        }
      });
    } catch (error) {
      console.error(`Batch ${Math.floor(i / BATCH_SIZE) + 1} failed:`, error);
    }
  }
}

// Send to device set
await sendToLargeDeviceSet(registrationTokens, message);

const message = {
  token: registrationToken,
  notification: {
    title: 'Notification Title',
    body: 'Notification body text'
  },
  data: {
    key1: 'value1',
    key2: 'value2'
  }
};

// Check payload size
function checkMessageSize(message) {
  const serialized = JSON.stringify(message);
  const bytes = new TextEncoder().encode(serialized).length;

  console.log(`Total payload size: ${bytes} bytes`);
  console.log('FCM limits:');
  console.log('  - Notification: 4000 bytes');
  console.log('  - Data object: 4000 bytes');
  console.log('  - Total message: 4096 bytes');

  if (bytes > 4096) {
    console.error('ERROR: Message exceeds 4096 byte limit');
    return false;
  }

  if (message.notification) {
    const notifSize = JSON.stringify(message.notification).length;
    if (notifSize > 4000) {
      console.error('ERROR: Notification payload exceeds 4000 bytes');
      return false;
    }
  }

  if (message.data) {
    const dataSize = JSON.stringify(message.data).length;
    if (dataSize > 4000) {
      console.error('ERROR: Data payload exceeds 4000 bytes');
      return false;
    }
  }

  return true;
}

// Validate before sending
if (!checkMessageSize(message)) {
  console.error('Message is too large - reduce content or split into multiple messages');
  // Truncate or remove non-essential data
  message.data = message.data ? { /* essential fields only */ } : undefined;
}

await admin.messaging().send(message);

const message = {
  token: apnsToken,
  notification: {
    title: 'Title',
    body: 'Body'
  },
  data: {
    customKey: 'customValue'
  }
};

// WRONG: High priority for data-only message on iOS
// await messaging.send({
//   token: apnsToken,
//   data: { key: 'value' },
//   webpush: { headers: { TTL: '3600' } },
//   // Missing apns, causes INVALID_ARGUMENT
// });

// CORRECT: Proper priority handling for different platforms
const correctMessage = {
  token: apnsToken,
  notification: {
    title: 'Push Title',
    body: 'Push Body'
  },
  data: {
    action: 'open_details',
    id: '123'
  },
  // For iOS/APNs: Priority MUST be normal (5) or omitted for silent
  apns: {
    headers: {
      'apns-priority': '10' // 10 for alerts, 5 for background
    },
    payload: {
      aps: {
        alert: {
          title: 'Push Title',
          body: 'Push Body'
        },
        sound: 'default',
        'content-available': 0 // Set to 1 only for silent notifications
      }
    }
  },
  // For Android: Can use high priority
  android: {
    priority: 'high', // Only use high for time-sensitive messages
    notification: {
      title: 'Push Title',
      body: 'Push Body'
    }
  }
};

await admin.messaging().send(correctMessage);

// Platform-specific sending
async function sendPlatformSpecific(token, isIOS) {
  if (isIOS) {
    // iOS: Use normal priority, support content-available
    return messaging.send({
      token,
      notification: { title: 't', body: 'b' },
      apns: {
        headers: { 'apns-priority': '10' },
        payload: { aps: { sound: 'default' } }
      }
    });
  } else {
    // Android: Can use high priority
    return messaging.send({
      token,
      notification: { title: 't', body: 'b' },
      android: { priority: 'high' }
    });
  }
}

// Track token age
interface TokenRecord {
  token: string;
  userId: string;
  createdAt: Date;
  lastUsedAt: Date;
  platform: 'ios' | 'android' | 'web';
}

// Mark tokens as stale if inactive for 270+ days
async function removeStaleTokens() {
  const STALE_THRESHOLD = 270 * 24 * 60 * 60 * 1000; // 270 days in ms
  const now = new Date();

  const staleTokens = await db.tokens.find({
    lastUsedAt: {
      $lt: new Date(now - STALE_THRESHOLD)
    }
  });

  console.log(`Found ${staleTokens.length} stale tokens`);

  // Delete stale tokens
  for (const token of staleTokens) {
    await db.tokens.deleteOne({ token: token.token });
  }
}

// Handle token errors during send
async function sendWithTokenCleanup(token, message) {
  try {
    return await admin.messaging().send({
      token,
      ...message
    });
  } catch (error) {
    // Delete invalid or unregistered tokens
    if (error.code === 'messaging/invalid-registration-token' ||
        error.code === 'messaging/registration-token-not-registered' ||
        error.code === 'messaging/invalid-argument') {

      console.log(`Deleting invalid token: ${token}`);
      await db.tokens.deleteOne({ token });

      // Notify user or re-request token
      await db.users.updateOne(
        { tokens: token },
        { $pull: { tokens: token } }
      );
    }
    throw error;
  }
}

// Periodic cleanup
setInterval(removeStaleTokens, 24 * 60 * 60 * 1000); // Daily

// On successful send, update lastUsedAt
async function sendAndTrack(token, message) {
  const result = await sendWithTokenCleanup(token, message);

  await db.tokens.updateOne(
    { token },
    { lastUsedAt: new Date() }
  );

  return result;
}

async function debugInvalidArgument(token, message) {
  try {
    const response = await admin.messaging().send({
      token,
      ...message
    });
    console.log('Send successful:', response);
  } catch (error) {
    console.error('FCM Error Details:');
    console.error('  Code:', error.code); // messaging/invalid-argument
    console.error('  Message:', error.message); // Full error message
    console.error('  Full error:', JSON.stringify(error, null, 2));

    // Check error.errorInfo for FCM-specific details
    if (error.errorInfo) {
      console.error('  Error Info:', error.errorInfo);
    }

    // Response from HTTP v1 API includes details array
    if (error.cause && error.cause.response) {
      console.error('  Response status:', error.cause.response.status);
      console.error('  Response data:', error.cause.response.data);

      const { details } = error.cause.response.data.error;
      if (details && details.length > 0) {
        console.error('  FCM details:', details);
        details.forEach(detail => {
          console.error('    -', detail['@type'], ':', detail);
        });
      }
    }

    // Analyze the error message
    const errorMsg = error.message || '';
    if (errorMsg.includes('registration token')) {
      console.error('ROOT CAUSE: Invalid registration token');
    } else if (errorMsg.includes('data too large')) {
      console.error('ROOT CAUSE: Message payload exceeds limits');
    } else if (errorMsg.includes('1000')) {
      console.error('ROOT CAUSE: Batch size exceeds 1000 tokens');
    } else if (errorMsg.includes('priority') || errorMsg.includes('high')) {
      console.error('ROOT CAUSE: Invalid priority for message type/platform');
    }
  }
}

// Test with sample data
const testToken = 'your-test-token-here';
const testMessage = {
  notification: { title: 'Test', body: 'Message' }
};

await debugInvalidArgument(testToken, testMessage);