AI-Powered Push Notifications in React Native (2026)

// Architecture flow:
// 1. App collects behavioral signals  sends to backend
// 2. Backend stores user profile (activity patterns, preferences)
// 3. Nightly job: AI generates personalized notifications
//    - Determines optimal send time per user
//    - Generates personalized copy with LLM
//    - Schedules via FCM/APNs
// 4. User receives personalized notification
// 5. App reports open/dismiss  feedback loop

// hooks/useNotificationSetup.ts
import * as Notifications from 'expo-notifications'
import * as Device from 'expo-device'
import Constants from 'expo-constants'
import { useEffect } from 'react'
import { Platform } from 'react-native'

export async function registerForPushNotifications(): Promise<string | null> {
  if (!Device.isDevice) return null // Simulator, skip

  const { status: existingStatus } = await Notifications.getPermissionsAsync()
  let finalStatus = existingStatus

  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync()
    finalStatus = status
  }

  if (finalStatus !== 'granted') return null

  const projectId = Constants.expoConfig?.extra?.eas?.projectId
  const token = (await Notifications.getExpoPushTokenAsync({ projectId })).data

  if (Platform.OS === 'android') {
    await Notifications.setNotificationChannelAsync('default', {
      name: 'Default',
      importance: Notifications.AndroidImportance.MAX,
    })
  }

  return token
}

// Track user activity for personalization
export function trackNotificationEvent(
  userId: string,
  event: 'opened' | 'dismissed' | 'app_active',
  metadata?: Record<string, unknown>
) {
  fetch('/api/notification-events', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      userId,
      event,
      timestamp: new Date().toISOString(),
      hour: new Date().getHours(),
      dayOfWeek: new Date().getDay(),
      ...metadata,
    }),
  }).catch(console.error) // Fire-and-forget
}

// api/generate-notification.ts
import OpenAI from 'openai'

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })

interface UserProfile {
  name: string
  lastActive: string
  streakDays: number
  topFeatures: string[]
  avgOpenHour: number // e.g. 18 = most opens at 6pm
  openRate: number    // e.g. 0.45 = 45% historical open rate
  preferredTopics: string[]
}

export async function generatePersonalizedNotification(
  user: UserProfile,
  appContext: string // e.g. "fitness tracking app"
): Promise<{ title: string; body: string; sendAt: string }> {

  // Generate personalized copy
  const completion = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: `You generate short, engaging push notification copy.
App context: ${appContext}
Rules:
- Title: max 50 characters
- Body: max 100 characters
- Be personal, specific, and action-oriented
- Never use generic phrases like "Check out" or "Don't miss"
- Reference the user's specific data when relevant
- Output JSON only: { "title": "...", "body": "..." }`,
      },
      {
        role: 'user',
        content: `User profile:
Name: ${user.name}
Days active streak: ${user.streakDays}
Last active: ${user.lastActive}
Top features used: ${user.topFeatures.join(', ')}
Preferred topics: ${user.preferredTopics.join(', ')}

Generate a personalized re-engagement notification.`,
      },
    ],
    response_format: { type: 'json_object' },
    max_tokens: 100,
  })

  const { title, body } = JSON.parse(completion.choices[0].message.content!)

  // Calculate optimal send time (next occurrence of user's peak hour)
  const now = new Date()
  const sendAt = new Date(now)
  sendAt.setHours(user.avgOpenHour, 0, 0, 0)
  if (sendAt <= now) sendAt.setDate(sendAt.getDate() + 1)

  return { title, body, sendAt: sendAt.toISOString() }
}

// Example output:
// {
//   title: "Alex, 7-day streak! ",
//   body: "Your squat form has improved 12% this week. Keep it up.",
//   sendAt: "2026-04-13T18:00:00.000Z"
// }

// Batch send personalized notifications
import { Expo, ExpoPushMessage } from 'expo-server-sdk'

const expo = new Expo()

export async function sendPersonalizedNotifications(
  notifications: Array<{
    pushToken: string
    title: string
    body: string
    data?: Record<string, unknown>
  }>
) {
  const messages: ExpoPushMessage[] = notifications
    .filter(n => Expo.isExpoPushToken(n.pushToken))
    .map(n => ({
      to: n.pushToken,
      sound: 'default',
      title: n.title,
      body: n.body,
      data: n.data ?? {},
      priority: 'normal',
    }))

  // Expo recommends batches of 100
  const chunks = expo.chunkPushNotifications(messages)
  for (const chunk of chunks) {
    await expo.sendPushNotificationsAsync(chunk)
  }
}