Events

#[derive(Default, Clone)]
pub struct CoreEventBus {
    handlers: Arc<RwLock<Vec<Arc<dyn EventHandler>>>>,
}

impl CoreEventBus {
    pub fn dispatch(&self, event: Event) {
        let handlers = self.handlers.read().expect("...").clone();
        if handlers.is_empty() {
            return;
        }
        let event = Arc::new(event);
        for handler in &handlers {
            handler.handle_event(Arc::clone(&event));
        }
    }

    pub fn has_handlers(&self) -> bool {
        !self.handlers.read().expect("...").is_empty()
    }
}

pub trait EventHandler: Send + Sync {
    fn handle_event(&self, event: Arc<Event>);

    /// Which event kinds this handler wants. Defaults to all kinds.
    /// Override to let the bus skip materializing events you don't want.
    fn interest(&self) -> EventInterest {
        EventInterest::ALL
    }
}

use wacore::types::events::{Event, InboundMessage};
use std::sync::Arc;

struct MyHandler;

impl EventHandler for MyHandler {
    fn handle_event(&self, event: Arc<Event>) {
        match &*event {
            Event::Messages(batch) => {
                for InboundMessage { message: msg, info, .. } in batch.iter() {
                    println!("Message from {}: {:?}", info.source.sender, msg);
                }
            }
            _ => {}
        }
    }
}

client.register_handler(Arc::new(MyHandler));

use wacore::types::events::{EventInterest, EventKind};

impl EventHandler for MyHandler {
    fn handle_event(&self, event: Arc<Event>) { /* … */ }

    fn interest(&self) -> EventInterest {
        // Only Messages and Connected events reach this handler.
        EventInterest::of(&[EventKind::Messages, EventKind::Connected])
    }
}

bot.on_event_for(&[EventKind::Messages], |event, client| async move {
    // only Messages events
});

#[derive(Debug, Clone, Serialize)]
#[non_exhaustive]
pub enum Event {
    // Connection
    Connected(Connected),
    Disconnected(Disconnected),
    StreamReplaced(StreamReplaced),
    StreamError(StreamError),
    ConnectFailure(ConnectFailure),
    TemporaryBan(TemporaryBan),

    // Pairing
    PairingQrCode(PairingQrCode),
    PairingCode(PairingCode),
    PairingCodeRefresh(PairingCodeRefresh),
    PairingCodeError(PairingCodeError),
    PairingQrCodesExhausted(PairingQrCodesExhausted),
    PairSuccess(PairSuccess),
    PairError(PairError),
    QrScannedWithoutMultidevice(QrScannedWithoutMultidevice),
    ClientOutdated(ClientOutdated),
    LoggedOut(LoggedOut),

    // Messages
    Messages(MessageBatch),
    Receipt(Receipt),
    UndecryptableMessage(UndecryptableMessage),
    Notification(Arc<OwnedNodeRef>),
    ServerAck(ServerAck),

    // Presence
    ChatPresence(ChatPresenceUpdate),
    Presence(PresenceUpdate),

    // User Updates
    PictureUpdate(PictureUpdate),
    UserAboutUpdate(UserAboutUpdate),
    PushNameUpdate(PushNameUpdate),
    SelfPushNameUpdated(SelfPushNameUpdated),

    // Group Updates
    GroupUpdate(GroupUpdate),

    // Contact Updates
    ContactUpdated(ContactUpdated),
    ContactNumberChanged(ContactNumberChanged),
    ContactSyncRequested(ContactSyncRequested),
    ContactUpdate(ContactUpdate),
    ContactRemoved(ContactRemoved),

    // Chat State
    PinUpdate(PinUpdate),
    MuteUpdate(MuteUpdate),
    ArchiveUpdate(ArchiveUpdate),
    StarUpdate(StarUpdate),
    MarkChatAsReadUpdate(MarkChatAsReadUpdate),
    DeleteChatUpdate(DeleteChatUpdate),
    ClearChatUpdate(ClearChatUpdate),
    UserStatusMuteUpdate(UserStatusMuteUpdate),
    DeleteMessageForMeUpdate(DeleteMessageForMeUpdate),
    LabelEditUpdate(LabelEditUpdate),
    LabelAssociationUpdate(LabelAssociationUpdate),
    MessageLabelAssociationUpdate(MessageLabelAssociationUpdate),
    QuickReplyUpdate(QuickReplyUpdate),

    // History Sync
    HistorySync(Box<LazyHistorySync>),
    OfflineSyncPreview(OfflineSyncPreview),
    OfflineSyncCompleted(OfflineSyncCompleted),
    DirtyState(DirtyState),
    AppStateSyncFailed(AppStateSyncFailed),

    // Device Updates
    DeviceListUpdate(DeviceListUpdate),
    IdentityChange(IdentityChange),
    BusinessStatusUpdate(BusinessStatusUpdate),

    // Newsletter
    NewsletterLiveUpdate(NewsletterLiveUpdate),

    // Calls
    IncomingCall(IncomingCall),

    // Notification Updates
    DisappearingModeChanged(DisappearingModeChanged),

    // Privacy
    DisableLinkPreviewsUpdate(DisableLinkPreviewsUpdate),

    // Raw stanza (opt-in)
    RawNode(Arc<OwnedNodeRef>),

    // Passkey linking (SHORTCAKE_PASSKEY)
    PairPasskeyRequest(PairPasskeyRequest),
    PairPasskeyConfirmation(PairPasskeyConfirmation),
    PairPasskeyError(PairPasskeyError),

    // Decrypted payload (opt-in)
    DecryptedPayload(DecryptedPayload),

    // Sent frame (opt-in)
    SentFrame(SentFrame),

    // Enc decrypt failure (opt-in)
    EncDecryptFailed(EncDecryptFailed),
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct Connected {}

Event::Connected(Connected::builder().build())

Event::Connected(_) => {
    println!("✅ Connected to WhatsApp");
    // Safe to send messages now. The push name and blocklist may still be
    // syncing in the background — watch for AppStateSyncFailed if that gap
    // matters to your use case.
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct Disconnected {
    pub reason: DisconnectReason,
}

Event::Disconnected(Disconnected::builder().reason(reason).build())

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ConnectFailure {
    pub reason: ConnectFailureReason,
    /// The server's `message` attribute on the `<failure>` stanza, when present.
    pub message: Option<String>,
    pub raw: Option<Node>,
}

#[derive(Debug, Clone, PartialEq, Eq, Copy, Serialize)]
pub enum ConnectFailureReason {
    Generic,                // 400
    LoggedOut,              // 401
    TempBanned,             // 402
    AccountLocked,          // 403 — WA Web REASON_LOCKED (account/device locked)
    UnknownLogout,          // 406
    ClientOutdated,         // 405
    BadUserAgent,           // 409
    CatExpired,             // 413
    CatInvalid,             // 414
    NotFound,               // 415
    ClientUnknown,          // 418
    InternalServerError,    // 500
    Experimental,           // 501
    ServiceUnavailable,     // 503
    Unknown(i32),
}

if reason.is_logged_out() {
    // Clear session and re-pair
}

if reason.should_reconnect() {
    // Retry connection
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct TemporaryBan {
    pub code: TempBanReason,
    /// How long the ban lasts — the wire's `expire` is a duration in seconds,
    /// not a deadline.
    pub expire: chrono::Duration,
    /// The server's `message` attribute, when present.
    pub message: Option<String>,
    /// Support/appeal link the official ban screen opens.
    pub url: Option<String>,
    /// The whole `<failure>` stanza.
    pub raw: Option<Node>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub enum TempBanReason {
    SentToTooManyPeople,        // 101
    BlockedByUsers,             // 102
    CreatedTooManyGroups,       // 103
    SentTooManySameMessage,     // 104
    BroadcastList,              // 106
    Unknown(i32),
}

Event::TemporaryBan(ban) => {
    eprintln!("Banned: {} (expires in {:?})", ban.code, ban.expire);
    if let Some(url) = &ban.url {
        eprintln!("Learn more: {url}");
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct StreamReplaced {}

Event::StreamReplaced(_) => {
    println!("⚠️ Another instance connected - disconnecting");
    // Auto-reconnect is disabled — reconnecting would displace the other client
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct LoggedOut {
    pub on_connect: bool,
    pub reason: ConnectFailureReason,
    /// Server-supplied logout copy, when it sent any. Present in practice on
    /// `ConnectFailureReason::AccountLocked`.
    pub logout_message: Option<LogoutMessage>,
    /// The stanza that caused the logout, when one was received.
    pub raw: Option<Node>,
}

/// Localized text the server wants shown when it forces a logout, from
/// `logout_message_header` / `logout_message_subtext` on `<failure>`.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct LogoutMessage {
    pub header: Option<String>,
    pub subtext: Option<String>,
    /// e.g. `"pt_BR"`. Compare against the consumer's locale before rendering.
    pub locale: Option<String>,
}

Event::LoggedOut(logout) => {
    eprintln!("Logged out (reason: {:?})", logout.reason);
    if let Some(msg) = &logout.logout_message {
        eprintln!("Server message: {:?} / {:?}", msg.header, msg.subtext);
    }
    // Session is invalid — you must re-pair the device
    // Auto-reconnect is disabled
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct StreamError {
    pub code: String,
    pub raw: Option<Node>,
}

Event::StreamError(err) => {
    eprintln!("Stream error: {} (raw: {:?})", err.code, err.raw);
}

/// A QR code the consumer renders during multi-device pairing.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairingQrCode {
    /// The QR payload to render — ASCII art QR or data string.
    pub code: String,
    /// How long this code stays valid before the next one rotates in (60s first, 20s subsequent).
    pub timeout: std::time::Duration,
}

Event::PairingQrCode(PairingQrCode { code, timeout, .. }) => {
    println!("Scan this QR (valid {}s):", timeout.as_secs());
    println!("{}", code);
}

/// Generated pair code for phone number linking.
/// User should enter this code on their phone in WhatsApp > Linked Devices.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairingCode {
    /// The 8-character pairing code to display.
    pub code: String,
    /// Approximate validity duration (~180 seconds).
    pub timeout: std::time::Duration,
}

Event::PairingCode(PairingCode { code, .. }) => {
    println!("Enter {} on your phone", code);
}

/// The in-progress phone-number pairing code should be replaced.
///
/// Emitted for the two cases WA Web regenerates on: the server asking for it
/// (`refreshAltLinkingCode` / `forceManualRefresh`, ref-gated against the
/// outstanding flow), and pair-success going unanswered after a
/// non-refused `companion_finish` (accepted, or itself unanswered).
///
/// The outstanding flow is cleared before this fires, so the consumer can call
/// `pair_with_code` straight away. The previous code is no longer valid.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairingCodeRefresh {
    /// `true` when the server set `force_manual_refresh` — the code must be
    /// re-requested explicitly rather than auto-rotated. Always `false` for
    /// the silent-`pair-success` timeout trigger.
    pub force_manual: bool,
}

Event::PairingCodeRefresh(PairingCodeRefresh { force_manual, .. }) => {
    // The previous code is no longer valid, and the flow is already clear —
    // request a new one, e.g. by calling `client.pair_with_code(options)` again.
    println!("Pair code needs a refresh (force_manual={force_manual})");
}

/// A phone-number pair-code flow failed, so no linking will come of it.
///
/// Fires for every stage-1 failure, including local validation (a too-short
/// phone number never reaches the server), and — since the `companion_finish`
/// round trip started waiting for its answer — for a stage-2 refusal too. Both
/// round trips report through the same event because the consumer's move is
/// the same either way: this code is finished, request another or fall back to
/// the QR. Silence at stage 2 is not this event, because nothing was refused;
/// it surfaces as `PairingCodeRefresh` once the one-minute `pair-success` timer
/// runs out.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairingCodeError {
    /// The server's refusal, when it answered with one. `None` when the
    /// failure was local (validation, no connection) or the request went
    /// unanswered (timeout) — nothing was refused, so there is no status to
    /// report.
    pub rejection: Option<PairCodeRejection>,
    /// How long the server asked the client to wait, from the `backoff`
    /// attribute. Usually absent.
    pub backoff: Option<std::time::Duration>,
    /// The failure rendered for logs. Do not branch on it; use `rejection`.
    pub error: String,
}

Event::PairingCodeError(PairingCodeError { rejection, backoff, error, .. }) => {
    eprintln!("Pair code request failed: {error}");
    if rejection.is_some_and(PairCodeRejection::is_throttled) {
        // Back off, then retry — using the server's own delay when it named one.
    }
}

/// The server's `<pair-device>` refs are used up: there is no QR left to
/// render until the connection is re-established.
#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairingQrCodesExhausted {
    /// `true` when the client closed the connection itself, which it only does
    /// with no pair-code flow outstanding. `false` means the socket was left
    /// up and reconnecting is the consumer's call.
    pub disconnected: bool,
}

Event::PairingQrCodesExhausted(PairingQrCodesExhausted { disconnected, .. }) => {
    if disconnected {
        // No pair-code flow was outstanding, so the client is tearing its own
        // socket down and won't auto-reconnect. As of PR #1258, disconnect()
        // is final on this Client instance — build a fresh one against the
        // same persistence_manager and call connect() on it for a fresh
        // batch of refs.
        println!("QR refs exhausted, disconnecting — build a fresh Client to retry");
    } else {
        // A pair-code flow is still outstanding, so the socket is being left
        // up to keep carrying it. There is simply no QR to show right now.
        println!("QR refs exhausted, but a pair code is still in progress");
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairSuccess {
    pub id: Jid,
    pub lid: Jid,
    pub business_name: String,
    pub platform: String,
}

Event::PairSuccess(info) => {
    println!("✅ Paired as {}", info.id);
    println!("LID: {}", info.lid);
    println!("Name: {}", info.business_name);
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairError {
    pub id: Jid,
    pub lid: Jid,
    pub business_name: String,
    pub platform: String,
    pub error: String,
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairPasskeyRequest {
    pub request_options_json: String, // verbatim PublicKeyCredentialRequestOptions JSON
}

Event::PairPasskeyRequest(req) => {
    let assertion = my_get_assertion_from_json(&req.request_options_json).await?;
    client.send_passkey_response(assertion).await?;
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairPasskeyConfirmation {
    pub code: String,          // 8-char "XXXX-XXXX" verification code
    pub skip_handoff_ux: bool, // true on a proven re-link: continuity means the code need not be shown
}

Event::PairPasskeyConfirmation(conf) => {
    if conf.skip_handoff_ux {
        client.send_passkey_confirmation().await?;
    } else {
        println!("Confirm {} matches on your phone", conf.code);
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PairPasskeyError {
    pub error: String,
    pub continuation: bool, // false = failed during the initial request, true = during continuation/verification
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct QrScannedWithoutMultidevice {}

Event::QrScannedWithoutMultidevice(_) => {
    println!("QR scanned but device does not support multi-device");
    // Prompt the user to update their WhatsApp app
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ClientOutdated {
    /// The whole `<failure>` stanza, so no attribute is lost to a log line.
    pub raw: Option<Node>,
}

Event::ClientOutdated(_) => {
    eprintln!("Client version is outdated — update whatsapp-rust");
    // Auto-reconnect is disabled
}

Event::Messages(MessageBatch)

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct InboundMessage {
    pub message: Arc<wa::Message>,
    pub info: Arc<MessageInfo>,
}

pub enum BatchOrigin {
    Live,          // delivered immediately, batch of one
    OfflineDrain,  // accumulated batch from the offline drain
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct MessageBatch {
    pub messages: Arc<[InboundMessage]>,
    pub origin: BatchOrigin,
    #[builder(default)]
    pub hook_committed: bool,
}

#[derive(Debug, Clone, Default, Serialize)]
pub struct MessageInfo {
    pub source: MessageSource,
    pub id: MessageId,
    pub server_id: MessageServerId,
    pub r#type: String,
    pub push_name: String,
    pub timestamp: DateTime<Utc>,
    pub server_timestamp_us: Option<i64>,
    pub category: MessageCategory,
    pub multicast: bool,
    pub media_type: String,
    pub edit: EditAttribute,
    pub bot_info: Option<MsgBotInfo>,
    pub meta_info: MsgMetaInfo,
    pub verified_name: Option<Box<VerifiedName>>,
    pub verified_level: Option<String>,
    pub verified_name_serial: Option<String>,
    pub device_sent_meta: Option<DeviceSentMeta>,
    pub ephemeral_expiration: Option<u32>,
    pub is_offline: bool,
    pub peer_recipient_pn: Option<Jid>,
    pub unavailable_request_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize)]
pub struct MessageSource {
    pub chat: Jid,             // Where it was sent (group or DM)
    pub sender: Jid,           // Who sent the message
    pub is_from_me: bool,
    pub is_group: bool,
    pub addressing_mode: Option<AddressingMode>,
    pub sender_alt: Option<Jid>,
    pub recipient_alt: Option<Jid>,
    pub broadcast_list_owner: Option<Jid>,
    pub recipient: Option<Jid>,
}

pub enum MessageCategory {
    Empty,        // Default (empty string on the wire)
    Peer,         // Self-synced message from primary phone
    Other(String), // Unknown category (forward compatibility)
}

pub enum EditAttribute {
    Empty,            // "" — no edit (default)
    MessageEdit,      // "1" — message text was edited
    PinInChat,        // "2" — message was pinned/unpinned
    AdminEdit,        // "3" — admin edited the message
    SenderRevoke,     // "7" — sender deleted for everyone
    AdminRevoke,      // "8" — admin deleted for everyone
    Unknown(String),  // Forward-compatible fallback
}

pub struct MsgBotInfo {
    pub edit_type: Option<BotEditType>,
    pub edit_target_id: Option<MessageId>,
    pub edit_sender_timestamp_ms: Option<DateTime<Utc>>,
}

pub enum BotEditType {
    First,  // Initial bot response
    Inner,  // Streaming update (intermediate chunk)
    Last,   // Final streaming update
}

pub struct MsgMetaInfo {
    pub target_id: Option<MessageId>,
    pub target_sender: Option<Jid>,
    pub deprecated_lid_session: Option<bool>,
    pub thread_message_id: Option<MessageId>,
    pub thread_message_sender_jid: Option<Jid>,
    pub content_type: Option<String>,
    pub appdata: Option<String>,
    pub reporting_tag: Option<String>,
    pub reporting_token: Option<Bytes>,
    pub reporting_token_version: Option<i32>,
}

pub struct DeviceSentMeta {
    pub destination_jid: String,
    pub phash: String,
}

use waproto::whatsapp as wa;

Event::Messages(batch) => {
    for InboundMessage { message: msg, info, .. } in batch.iter() {
        println!("From: {} in {}", info.source.sender, info.source.chat);

        // Text message
        if let Some(text) = &msg.conversation {
            println!("Text: {}", text);
        }

        // Extended text (with link preview, quoted message, etc.)
        if let Some(ext) = &msg.extended_text_message {
            println!("Text: {}", ext.text.as_deref().unwrap_or(""));

            if let Some(context) = &ext.context_info {
                if let Some(quoted) = &context.quoted_message {
                    println!("Quoted: {:?}", quoted);
                }
            }
        }

        // Image message
        if let Some(img) = &msg.image_message {
            println!("Image: {} ({}x{})", 
                img.caption.as_deref().unwrap_or(""),
                img.width.unwrap_or(0),
                img.height.unwrap_or(0)
            );
        }

        // Video, audio, document, sticker, etc.
        // See waproto::whatsapp::Message for all types
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct Receipt {
    pub source: MessageSource,
    pub message_ids: Vec<MessageId>,
    pub timestamp: DateTime<Utc>,
    pub r#type: ReceiptType,
    /// `true` when the receipt was drained from the server's offline queue on
    /// reconnect (carried the `offline` attribute) rather than delivered live.
    pub offline: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[non_exhaustive]
pub enum ReceiptType {
    Delivered,
    Sender,
    Retry,
    EncRekeyRetry,
    Read,
    ReadSelf,
    Played,
    PlayedSelf,
    ServerError,
    Inactive,
    PeerMsg,
    HistorySync,
    Other(String),
}

Event::Receipt(receipt) => {
    match receipt.r#type {
        ReceiptType::Read => {
            println!("✓✓ Read by {}", receipt.source.sender);
        }
        ReceiptType::Delivered => {
            println!("✓ Delivered to {}", receipt.source.sender);
        }
        _ => {}
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct UndecryptableMessage {
    pub info: Arc<MessageInfo>,
    pub is_unavailable: bool,
    pub unavailable_type: UnavailableType,
    pub decrypt_fail_mode: DecryptFailMode,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum UnavailableType {
    Unknown,
    ViewOnce,       // View-once media already viewed
    Hosted,         // Hosted content the phone won't fan out to companions
    Bot,            // AI bot message fanout
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum DecryptFailMode {
    Show,           // Show placeholder in chat
    Hide,           // Hide from chat
}

Event::Notification(Arc<OwnedNodeRef>)

Event::Notification(node) => {
    let node_ref = node.get();
    println!("Raw notification tag: {}", node_ref.tag);
}

Event::UndecryptableMessage(undec) => {
    match undec.decrypt_fail_mode {
        DecryptFailMode::Hide => {
            // Silently ignore — infrastructure message (reaction, poll vote, etc.)
        }
        DecryptFailMode::Show => {
            match undec.unavailable_type {
                UnavailableType::ViewOnce => println!("View-once message already consumed"),
                UnavailableType::Hosted => println!("Hosted content unavailable"),
                UnavailableType::Bot => println!("Bot message unavailable"),
                UnavailableType::Unknown => {
                    eprintln!("Failed to decrypt message from {}", undec.info.source.sender);
                }
            }
        }
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ServerAck {
    pub id: String,
    pub class: Option<String>,
    pub from: Option<Jid>,
    pub timestamp: Option<DateTime<Utc>>,
    pub error: Option<String>,
}

Event::ServerAck(ack) => {
    if ack.class.as_deref() == Some("message") {
        if let Some(err) = &ack.error {
            eprintln!("Message {} nacked: {err}", ack.id);
        } else {
            println!("Message {} accepted by the server", ack.id);
        }
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ChatPresenceUpdate {
    pub source: MessageSource,
    pub state: ChatPresence,
    pub media: ChatPresenceMedia,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum ChatPresence {
    Composing,
    Paused,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum ChatPresenceMedia {
    Text,
    Audio,
}

Event::ChatPresence(update) => {
    match (update.state, update.media) {
        (ChatPresence::Composing, ChatPresenceMedia::Text) => {
            println!("{} is typing...", update.source.sender);
        }
        (ChatPresence::Composing, ChatPresenceMedia::Audio) => {
            println!("{} is recording audio...", update.source.sender);
        }
        (ChatPresence::Paused, _) => {
            println!("{} stopped typing", update.source.sender);
        }
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PresenceUpdate {
    pub from: Jid,
    pub unavailable: bool,
    pub last_seen: Option<DateTime<Utc>>,
}

Event::Presence(update) => {
    if update.unavailable {
        println!("{} is offline", update.from);
        if let Some(last_seen) = update.last_seen {
            println!("Last seen: {}", last_seen);
        }
    } else {
        println!("{} is online", update.from);
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PictureUpdate {
    pub jid: Jid,
    pub author: Option<Jid>,
    pub timestamp: DateTime<Utc>,
    pub removed: bool,
    pub picture_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct UserAboutUpdate {
    pub jid: Jid,
    pub status: String,
    pub timestamp: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct PushNameUpdate {
    pub jid: Jid,
    pub message: Box<MessageInfo>,
    pub old_push_name: String,
    pub new_push_name: String,
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct SelfPushNameUpdated {
    pub from_server: bool,
    pub old_name: String,
    pub new_name: String,
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct GroupUpdate {
    pub group_jid: Jid,
    pub participant: Option<Jid>,
    pub participant_pn: Option<Jid>,
    pub timestamp: DateTime<Utc>,
    pub is_lid_addressing_mode: bool,
    pub action: GroupNotificationAction,
}

Event::GroupUpdate(update) => {
    println!("Group {} updated by {:?}: {:?}", 
        update.group_jid, update.participant, update.action);
}

pub struct GroupParticipantInfo {
    pub jid: Jid,
    pub phone_number: Option<Jid>,
    pub display_name: Option<String>,
}

pub enum MembershipRequestMethod {
    InviteLink,        // User clicked an invite link
    LinkedGroupJoin,   // User joined via a linked community subgroup
    NonAdminAdd,       // A non-admin member tried to add the user
}

use wacore::stanza::groups::GroupNotificationAction;

Event::GroupUpdate(update) => {
    match &update.action {
        GroupNotificationAction::Add { participants, .. } => {
            for p in participants {
                println!("{} was added to {}", p.jid, update.group_jid);
            }
        }
        GroupNotificationAction::Subject { subject, .. } => {
            println!("Group {} renamed to {}", update.group_jid, subject);
        }
        GroupNotificationAction::Ephemeral { expiration, .. } => {
            if *expiration == 0 {
                println!("Disappearing messages disabled in {}", update.group_jid);
            } else {
                println!("Disappearing messages set to {}s in {}", expiration, update.group_jid);
            }
        }
        GroupNotificationAction::MembershipApprovalRequest { request_method, parent_group_jid } => {
            println!("Join request in {} via {:?}", update.group_jid, request_method);
            if let Some(parent) = parent_group_jid {
                println!("From community: {}", parent);
            }
        }
        GroupNotificationAction::CreatedMembershipRequests { requests, request_method, .. } => {
            println!("{} new join requests in {} via {:?}",
                requests.len(), update.group_jid, request_method);
        }
        GroupNotificationAction::RevokedMembershipRequests { participants } => {
            println!("{} membership requests revoked in {}",
                participants.len(), update.group_jid);
        }
        _ => {}
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ContactUpdated {
    pub jid: Jid,
    pub timestamp: DateTime<Utc>,
}

Event::ContactUpdated(update) => {
    println!("Contact {} profile changed at {}", update.jid, update.timestamp);
    // Invalidate cached presence/profile data
    // Re-fetch profile picture if needed
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ContactNumberChanged {
    /// Old phone number JID.
    pub old_jid: Jid,
    /// New phone number JID.
    pub new_jid: Jid,
    /// Old LID (if provided by server).
    pub old_lid: Option<Jid>,
    /// New LID (if provided by server).
    pub new_lid: Option<Jid>,
    pub timestamp: DateTime<Utc>,
}

Event::ContactNumberChanged(change) => {
    println!("Contact changed number: {} -> {}", change.old_jid, change.new_jid);
    if let Some(new_lid) = &change.new_lid {
        println!("New LID: {}", new_lid);
    }
    // Update your contact records to use the new JID
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ContactSyncRequested {
    /// If present, only sync contacts modified after this timestamp.
    pub after: Option<DateTime<Utc>>,
    pub timestamp: DateTime<Utc>,
}

Event::ContactSyncRequested(sync) => {
    if let Some(after) = sync.after {
        println!("Server requests contact sync for changes after {}", after);
    } else {
        println!("Server requests full contact sync");
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ContactUpdate {
    pub jid: Jid,
    pub timestamp: DateTime<Utc>,
    pub action: Box<wa::sync_action_value::ContactAction>,
    pub from_full_sync: bool,
}

Event::ContactUpdate(update) => {
    println!("Contact {} updated at {}", update.jid, update.timestamp);
    if let Some(name) = &update.action.full_name {
        println!("Full name: {}", name);
    }
    if update.from_full_sync {
        println!("(from full sync)");
    }
}

#[derive(Debug, Clone, Serialize, bon::Builder)]
#[non_exhaustive]
pub struct ContactRemoved {
    pub jid: Jid,
    pub timestamp: DateTime<Utc>,
    pub from_full_sync: bool,
}