// Recommended implementation
const getMessage = async (key: WAMessageKey): Promise<WAMessageContent | undefined> => {
  // Check your message store/database
  const msg = await messageStore.get(key.remoteJid!, key.id!)
  return msg?.message || undefined
}

const sock = makeWASocket({
  // ... other options
  getMessage,
})

// Current: Manual cache exists but not connected to socket
// Recommended: Pass cache to socket constructor

const groupMetadataCache = new Map<string, GroupMetadata>()

const sock = makeWASocket({
  // ... other options
  cachedGroupMetadata: async (jid) => {
    return groupMetadataCache.get(jid)
  },
})

// Listen for group events to keep cache fresh
sock.ev.on('groups.upsert', (groups) => {
  for (const group of groups) {
    groupMetadataCache.set(group.id, group)
    logger.debug(`Group cached: ${group.subject}`)
  }
})

sock.ev.on('groups.update', (updates) => {
  for (const update of updates) {
    const existing = groupMetadataCache.get(update.id!)
    if (existing) {
      groupMetadataCache.set(update.id!, { ...existing, ...update })
      logger.debug(`Group updated: ${update.id}`)
    }
  }
})

// Also handle participant updates
sock.ev.on('group-participants.update', async ({ id, participants, action }) => {
  const cached = groupMetadataCache.get(id)
  if (cached) {
    // Update participant list based on action (add/remove/promote/demote)
    // ... update logic
  }
})

// Persist LID mappings for consistent identity resolution
const lidMap = new Map<string, string>() // LID -> JID

sock.ev.on('lid-mapping.update', (mapping) => {
  for (const [lid, jid] of Object.entries(mapping)) {
    lidMap.set(lid, jid)
    logger.debug(`LID mapping: ${lid} -> ${jid}`)
  }
  // Optionally persist to database for cross-session continuity
})

// Helper to resolve LID to JID
function resolveJid(identifier: string): string {
  if (identifier.includes('@lid')) {
    return lidMap.get(identifier) || identifier
  }
  return identifier
}

import makeWASocket, {
  DisconnectReason,
  makeCacheableSignalKeyStore,
  WAMessageKey,
  GroupMetadata,
} from '@whiskeysockets/baileys'

// Caches
const groupMetadataCache = new Map<string, GroupMetadata>()
const messageStore = new Map<string, WAMessage>() // Or use database
const lidMap = new Map<string, string>()

// getMessage callback for retry handling
const getMessage = async (key: WAMessageKey) => {
  const storeKey = `${key.remoteJid}:${key.id}`
  const msg = messageStore.get(storeKey)
  return msg?.message || undefined
}

const sock = makeWASocket({
  auth: state,
  printQRInTerminal: true,
  
  // Pass getMessage for retry support
  getMessage,
  
  // Connect group cache to socket
  cachedGroupMetadata: async (jid) => groupMetadataCache.get(jid),
  
  // Use cacheable signal key store
  keys: makeCacheableSignalKeyStore(state.keys, logger),
})

// Store messages for retry support
sock.ev.on('messages.upsert', ({ messages }) => {
  for (const msg of messages) {
    if (msg.key.id && msg.key.remoteJid) {
      messageStore.set(`${msg.key.remoteJid}:${msg.key.id}`, msg)
    }
  }
})

// Proactive group cache updates
sock.ev.on('groups.upsert', (groups) => {
  for (const group of groups) {
    groupMetadataCache.set(group.id, group)
  }
})

sock.ev.on('groups.update', (updates) => {
  for (const update of updates) {
    const existing = groupMetadataCache.get(update.id!)
    if (existing) {
      groupMetadataCache.set(update.id!, { ...existing, ...update })
    }
  }
})

// Persist LID mappings
sock.ev.on('lid-mapping.update', (mapping) => {
  for (const [lid, jid] of Object.entries(mapping)) {
    lidMap.set(lid, jid)
  }
})