wacore 0.7.0

//! Group notification stanza types.
//!
//! Parses `<notification type="w:gp2">` stanzas for group updates.
//!
//! Reference: WhatsApp Web `WAWebHandleGroupNotification` (Ri7Gf1BxhsX.js:12556-12962)
//! Tag names: `WAWebHandleGroupNotificationConst.GROUP_NOTIFICATION_TAG` (hE1cdfp8vOc.js:2460-2506)
//!
//! Key behaviors:
//! - A single notification can contain MULTIPLE child actions (mapChildren pattern)
//! - Root `participant` attribute identifies the admin/author who triggered the change
//! - Participant lists are nested `<participant jid="..." />` children

use crate::WireEnum;
use serde::Serialize;
use wacore_binary::Jid;
use wacore_binary::{Node, NodeRef};

const MISSING_PARTICIPANT_IDENTIFICATION_TAG: &str = "missing_participant_identification";

/// How a membership request was initiated.
///
/// Maps to `WAWebRequestMethodType` in WhatsApp Web JS.
#[derive(Debug, Clone, PartialEq, Eq, WireEnum)]
pub enum MembershipRequestMethod {
    #[wire_default]
    #[wire = "invite_link"]
    InviteLink,
    #[wire = "linked_group_join"]
    LinkedGroupJoin,
    #[wire = "non_admin_add"]
    NonAdminAdd,
}

/// Parsed group notification containing one or more actions.
#[derive(Debug, Clone)]
pub struct GroupNotification {
    /// Group JID (from `from` attribute)
    pub group_jid: Jid,
    /// Notification stanza identifier (from `id`).
    pub notification_id: Option<String>,
    /// Display name supplied with the notification.
    pub notify: Option<String>,
    /// Raw offline-delivery marker supplied with the notification.
    pub offline: Option<String>,
    /// Admin/user who triggered the notification (from `participant` attribute)
    pub participant: Option<Jid>,
    /// Phone number JID of the participant (from `participant_pn` attribute, for LID groups)
    pub participant_pn: Option<Jid>,
    /// Username of the participant (from `participant_username`, when username
    /// addressing is enabled for the account).
    pub participant_username: Option<String>,
    /// ISO country code supplied for the participant on newer group notifications.
    pub participant_country_code: Option<String>,
    /// Timestamp (from `t` attribute, unix seconds)
    pub timestamp: u64,
    /// Whether the group uses LID addressing mode (from `addressing_mode="lid"`)
    pub is_lid_addressing_mode: bool,
    /// Whether at least one participant identity was omitted by the server.
    pub has_incomplete_participant_information: bool,
    /// One or more actions in this notification
    pub actions: Vec<GroupNotificationAction>,
}

/// Admin tier from `<participant type="...">`. Mirrors
/// `GROUP_PARTICIPANT_TYPES` in `WAWebGroupApiConst`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, WireEnum)]
pub enum GroupParticipantType {
    #[wire_default]
    #[wire = "participant"]
    Participant,
    #[wire = "admin"]
    Admin,
    #[wire = "superadmin"]
    SuperAdmin,
}

/// Delivery state for history shared with a newly joined participant.
#[derive(Debug, Clone, Copy, PartialEq, Eq, WireEnum)]
pub enum GroupHistorySentState {
    #[wire = "HISTORY_NOT_SENT"]
    HistoryNotSent,
    #[wire = "HISTORY_SENT"]
    HistorySent,
    #[wire = "NOTICE_SENT"]
    NoticeSent,
}

/// Participant info extracted from `<participant>` child elements.
///
/// Wire format:
/// ```xml
/// <participant jid="..." type="..." lid="..." phone_number="..."
///              username="..." display_name="..." join_time="..."/>
/// ```
///
/// `display_name` is the server-rendered label (e.g. `"+55∙∙∙∙∙∙∙∙∙79"` when
/// the requester is not in the participant's contacts). `type` flags
/// admin/superadmin tier; LID-addressed groups also carry `lid` and
/// `username`. WA Web's `WAWebHandleGroupNotification` y() reads all of
/// these into the participant model so the UI can render notifications
/// and patch admin caches without resolving the contact locally.
#[derive(Debug, Clone, Serialize)]
pub struct GroupParticipantInfo {
    pub jid: Jid,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<Jid>,
    /// Server-provided display label for this participant. Only populated for
    /// `<participant>` children inside group notifications; `None` for
    /// `<requested_user>` (WA Web doesn't read it there either).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    /// Admin tier. Defaults to `Participant` when the attr is missing.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<GroupParticipantType>,
    /// LID JID when this `<participant>` carries a separate `lid` attr.
    /// Distinct from `jid` which may already be a LID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lid: Option<Jid>,
    /// Username, gated by `WAWebUsernameGatingUtils`. Empty in classic
    /// PN-addressed groups.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    /// Unix seconds since the participant joined the group. Used by
    /// admin UI for tenure display.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_time: Option<u64>,
    /// Delivery state for post-join group history.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group_history_sent_state: Option<GroupHistorySentState>,
}

/// All possible group notification action types.
///
/// Maps 1:1 to `GROUP_NOTIFICATION_TAG` child element tags from WhatsApp Web.
///
/// The `#[wire = "..."]` attribute is the SINGLE source of truth for each
/// variant's wire tag: the JSON discriminator (via the auto-derived
/// `Serialize`), the parser dispatch (via the auto-generated sibling
/// `GroupNotificationActionTag` enum), and `wire_tag()` / `tag_name()` all
/// read from the same table.
#[derive(Debug, Clone, WireEnum)]
#[wire(tag = "type")]
pub enum GroupNotificationAction {
    // -- Participant management --
    /// `<add>` — Members added to group
    #[wire = "add"]
    Add {
        participants: Vec<GroupParticipantInfo>,
        reason: Option<String>,
    },
    /// `<remove>` — Members removed from group
    #[wire = "remove"]
    Remove {
        participants: Vec<GroupParticipantInfo>,
        reason: Option<String>,
    },
    /// `<promote>` — Members promoted to admin
    #[wire = "promote"]
    Promote {
        participants: Vec<GroupParticipantInfo>,
    },
    /// `<demote>` — Members demoted from admin
    #[wire = "demote"]
    Demote {
        participants: Vec<GroupParticipantInfo>,
    },
    /// `<modify>` — Member changed phone number
    #[wire = "modify"]
    Modify {
        participants: Vec<GroupParticipantInfo>,
    },

    // -- Metadata --
    /// `<subject subject="..." s_o="..." s_t="..."/>` — Group name changed
    #[wire = "subject"]
    Subject {
        subject: String,
        subject_owner: Option<Jid>,
        subject_time: Option<u64>,
    },
    /// `<description id="..."><body>text</body></description>` or `<description id="..."><delete/></description>`
    #[wire = "description"]
    Description {
        id: String,
        /// `Some(text)` = added/updated, `None` = deleted
        description: Option<String>,
    },

    // -- Settings --
    /// `<locked threshold="..."/>` — Only admins can edit group info
    #[wire = "locked"]
    Locked { threshold: Option<String> },
    /// `<unlocked/>` — All members can edit group info
    #[wire = "unlocked"]
    Unlocked,
    /// `<announcement/>` — Only admins can send messages
    #[wire = "announcement"]
    Announce,
    /// `<not_announcement/>` — All members can send messages
    #[wire = "not_announcement"]
    NotAnnounce,
    /// `<ephemeral expiration="..." trigger="..."/>` — and the alias
    /// `<not_ephemeral/>` which parses into `Ephemeral { expiration: 0 }`,
    /// matching WA Web's collapsing of the two tags into one action type.
    #[wire = "ephemeral"]
    #[wire_alias = "not_ephemeral"]
    Ephemeral {
        expiration: u32,
        trigger: Option<u32>,
    },
    /// `<membership_approval_mode><group_join state="on|off"/></membership_approval_mode>`
    #[wire = "membership_approval_mode"]
    MembershipApprovalMode { enabled: bool },
    /// `<membership_approval_request request_method="..." parent_group_jid="..."/>`
    /// A user requested to join. Requester is on parent [`GroupNotification::participant`].
    #[wire = "membership_approval_request"]
    MembershipApprovalRequest {
        request_method: MembershipRequestMethod,
        parent_group_jid: Option<Jid>,
    },
    /// `<created_membership_requests request_method="..." parent_group_jid="...">` —
    /// admin-side notification: new join requests appeared.
    #[wire = "created_membership_requests"]
    CreatedMembershipRequests {
        request_method: MembershipRequestMethod,
        parent_group_jid: Option<Jid>,
        /// `<requested_user>` children (not `<participant>`).
        requests: Vec<GroupParticipantInfo>,
    },
    /// `<revoked_membership_requests>` — requests rejected by admin or cancelled by requester.
    #[wire = "revoked_membership_requests"]
    RevokedMembershipRequests { participants: Vec<Jid> },
    /// `<member_add_mode>admin_add|all_member_add</member_add_mode>`
    #[wire = "member_add_mode"]
    MemberAddMode { mode: String },
    /// `<no_frequently_forwarded/>` — Forwarding restricted
    #[wire = "no_frequently_forwarded"]
    NoFrequentlyForwarded,
    /// `<frequently_forwarded_ok/>` — Forwarding allowed
    #[wire = "frequently_forwarded_ok"]
    FrequentlyForwardedOk,

    // -- Invites --
    /// `<invite code="..."/>` — Joined via invite link
    #[wire = "invite"]
    Invite { code: String },
    /// `<revoke>` — Invite link revoked
    #[wire = "revoke"]
    RevokeInvite,
    /// `<growth_locked expiration="..." type="..."/>` — Invite links unavailable
    #[wire = "growth_locked"]
    GrowthLocked { expiration: u32, lock_type: String },
    /// `<growth_unlocked/>` — Invite links available again
    #[wire = "growth_unlocked"]
    GrowthUnlocked,

    // -- Group lifecycle --
    /// `<create>` — Group created (complex structure, raw node preserved)
    #[wire = "create"]
    Create {
        #[wire(skip)]
        raw: Node,
    },
    /// `<delete>` — Group deleted
    #[wire = "delete"]
    Delete { reason: Option<String> },

    // -- Community linking --
    /// `<link link_type="...">` — Subgroup linked
    #[wire = "link"]
    Link {
        link_type: String,
        #[wire(skip)]
        raw: Node,
    },
    /// `<unlink unlink_type="..." unlink_reason="...">` — Subgroup unlinked
    #[wire = "unlink"]
    Unlink {
        unlink_type: String,
        unlink_reason: Option<String>,
        #[wire(skip)]
        raw: Node,
    },
    /// `<linked_group_promote>` — Subgroup admin elevated (community parent).
    #[wire = "linked_group_promote"]
    LinkedGroupPromote {
        participants: Vec<GroupParticipantInfo>,
    },
    /// `<linked_group_demote>` — Subgroup admin demoted.
    #[wire = "linked_group_demote"]
    LinkedGroupDemote {
        participants: Vec<GroupParticipantInfo>,
    },

    // -- State toggles --
    /// `<suspended/>` — Group suspended by Meta moderation.
    #[wire = "suspended"]
    Suspended,
    /// `<unsuspended/>` — Suspension lifted.
    #[wire = "unsuspended"]
    Unsuspended,
    /// `<auto_add_disabled/>` — Community auto-add to general chat disabled.
    #[wire = "auto_add_disabled"]
    AutoAddDisabled,
    /// `<is_capi_hosted_group/>` — Group routed through CAPI hosted server.
    #[wire = "is_capi_hosted_group"]
    IsCapiHostedGroup,
    /// `<group_safety_check/>` — Integrity check toggle.
    #[wire = "group_safety_check"]
    GroupSafetyCheck,
    /// `<limit_sharing_enabled trigger="..."/>` — Limit sharing toggle. The
    /// optional `trigger` attribute (range 0..20 per
    /// `WASmaxInGroupsGroupInfoMixin`) identifies the source of the change.
    #[wire = "limit_sharing_enabled"]
    LimitSharingEnabled { trigger: Option<u32> },
    /// `<allow_admin_reports/>` — Admins may receive report alerts.
    #[wire = "allow_admin_reports"]
    AllowAdminReports,
    /// `<not_allow_admin_reports/>` — Admin reports disabled.
    #[wire = "not_allow_admin_reports"]
    NotAllowAdminReports,
    /// `<reports/>` — Generic reports notification.
    #[wire = "reports"]
    Reports,
    /// `<allow_non_admin_sub_group_creation/>` — Community permits members to
    /// create subgroups without admin approval.
    #[wire = "allow_non_admin_sub_group_creation"]
    AllowNonAdminSubGroupCreation,
    /// `<not_allow_non_admin_sub_group_creation/>` — Community restricts
    /// subgroup creation to admins.
    #[wire = "not_allow_non_admin_sub_group_creation"]
    NotAllowNonAdminSubGroupCreation,

    // -- Subgroup suggestions (community) --
    /// `<created_sub_group_suggestion>` — Suggested subgroup added.
    #[wire = "created_sub_group_suggestion"]
    CreatedSubGroupSuggestion {
        #[wire(skip)]
        raw: Node,
    },
    /// `<revoked_sub_group_suggestions>` — Subgroup suggestion revoked.
    #[wire = "revoked_sub_group_suggestions"]
    RevokedSubGroupSuggestions {
        #[wire(skip)]
        raw: Node,
    },

    /// `<change_number>` — Owner of subgroup suggestions migrated to a new
    /// number. The old owner is in the parent notification's `participant`
    /// attribute; the new owner is in the `jid` attribute on the child.
    /// `sub_group_suggestions` lists the affected subgroup JIDs.
    #[wire = "change_number"]
    ChangeNumber {
        new_owner: Option<Jid>,
        sub_group_suggestions: Vec<Jid>,
    },

    // -- Catch-all --
    /// Unknown child tag — preserved for forward compatibility. The `tag`
    /// field is what `wire_tag()` returns, so roundtrips stay intact.
    #[wire_fallback]
    Unknown { tag: String },
}

impl GroupNotification {
    /// Parse from a `NodeRef`. Most fields are zero-copy; `Create`, `Link`,
    /// `Unlink`, `CreatedSubGroupSuggestion` and `RevokedSubGroupSuggestions`
    /// call `.to_owned()` to store their child as `raw: Node`.
    pub fn try_from_node_ref(node: &NodeRef<'_>) -> Option<Self> {
        let mut attrs = node.attrs();
        let group_jid = attrs.optional_jid("from")?;
        let notification_id = attrs.optional_string("id").map(|value| value.into_owned());
        let notify = attrs
            .optional_string("notify")
            .map(|value| value.into_owned());
        let offline = attrs
            .optional_string("offline")
            .map(|value| value.into_owned());
        let participant = attrs.optional_jid("participant");
        let participant_pn = attrs.optional_jid("participant_pn");
        let participant_username = attrs
            .optional_string("participant_username")
            .map(|value| value.into_owned());
        let participant_country_code = attrs
            .optional_string("participant_country_code")
            .map(|value| value.into_owned());
        let timestamp = attrs.optional_u64("t").unwrap_or(0);
        let is_lid_addressing_mode = node
            .get_attr("addressing_mode")
            .map(|v| v.as_str())
            .is_some_and(|s| s == "lid");

        let mut has_incomplete_participant_information = false;
        let actions = node
            .children()
            .map(|children| {
                let mut actions = Vec::with_capacity(children.len());
                for child in children {
                    if child.tag.as_ref() == MISSING_PARTICIPANT_IDENTIFICATION_TAG {
                        has_incomplete_participant_information = true;
                    } else if let Some(action) = parse_action(child) {
                        actions.push(action);
                    }
                }
                actions
            })
            .unwrap_or_default();

        Some(Self {
            group_jid,
            notification_id,
            notify,
            offline,
            participant,
            participant_pn,
            participant_username,
            participant_country_code,
            timestamp,
            is_lid_addressing_mode,
            has_incomplete_participant_information,
            actions,
        })
    }
}

/// Parse a single child element into a GroupNotificationAction.
///
/// Dispatches via [`GroupNotificationActionTag`] (auto-generated by
/// `#[derive(WireEnum)]`) — no wire-tag string literal appears in this
/// function. If the `#[wire = "..."]` attribute on a variant changes, both
/// the serializer and this dispatcher track it automatically.
///
/// `Create`, `Link`, `Unlink`, `CreatedSubGroupSuggestion` and
/// `RevokedSubGroupSuggestions` call `.to_owned()` because those variants
/// store `raw: Node`.
fn parse_action(node: &NodeRef<'_>) -> Option<GroupNotificationAction> {
    use GroupNotificationActionTag as T;
    use wacore_binary::NodeContentRef;

    // WA Web drops this child entirely; mirror that behavior.
    if node.tag.as_ref() == MISSING_PARTICIPANT_IDENTIFICATION_TAG {
        return None;
    }

    let tag = T::from(node.tag.as_ref());

    let action = match tag {
        T::Add => GroupNotificationAction::Add {
            participants: parse_participants(node),
            reason: node
                .attrs()
                .optional_string("reason")
                .map(|s| s.into_owned()),
        },
        T::Remove => GroupNotificationAction::Remove {
            participants: parse_participants(node),
            reason: node
                .attrs()
                .optional_string("reason")
                .map(|s| s.into_owned()),
        },
        T::Promote => GroupNotificationAction::Promote {
            participants: parse_participants(node),
        },
        T::Demote => GroupNotificationAction::Demote {
            participants: parse_participants(node),
        },
        T::Modify => GroupNotificationAction::Modify {
            participants: parse_participants(node),
        },
        T::Subject => GroupNotificationAction::Subject {
            subject: node
                .attrs()
                .optional_string("subject")
                .as_deref()
                .unwrap_or_default()
                .to_string(),
            subject_owner: node.attrs().optional_jid("s_o"),
            subject_time: node.attrs().optional_u64("s_t"),
        },
        T::Description => {
            let id = node
                .attrs()
                .optional_string("id")
                .as_deref()
                .unwrap_or_default()
                .to_string();
            let description = if node.get_optional_child("delete").is_some() {
                None
            } else {
                node.get_optional_child("body")
                    .and_then(|body| body.content_as_string())
                    .map(|s| s.to_string())
            };
            GroupNotificationAction::Description { id, description }
        }
        T::Locked => GroupNotificationAction::Locked {
            threshold: node
                .attrs()
                .optional_string("threshold")
                .map(|s| s.into_owned()),
        },
        T::Unlocked => GroupNotificationAction::Unlocked,
        T::Announce => GroupNotificationAction::Announce,
        T::NotAnnounce => GroupNotificationAction::NotAnnounce,
        // Both `<ephemeral .../>` and the alias `<not_ephemeral/>` land here —
        // the alias carries no `expiration`/`trigger` attrs, so the fallbacks
        // below produce `Ephemeral { expiration: 0, trigger: None }`, matching
        // WA Web's collapse of the two wire tags into one action.
        T::Ephemeral => GroupNotificationAction::Ephemeral {
            expiration: node
                .attrs()
                .optional_u64("expiration")
                .and_then(|t| t.try_into().ok())
                .unwrap_or(0),
            trigger: node
                .attrs()
                .optional_u64("trigger")
                .and_then(|t| t.try_into().ok()),
        },
        T::MembershipApprovalMode => {
            let enabled = node
                .get_optional_child("group_join")
                .and_then(|gj| gj.attrs().optional_string("state"))
                .is_some_and(|s| s == "on");
            GroupNotificationAction::MembershipApprovalMode { enabled }
        }
        T::MembershipApprovalRequest => {
            let request_method = parse_request_method(node);
            let parent_group_jid = node.attrs().optional_jid("parent_group_jid");
            GroupNotificationAction::MembershipApprovalRequest {
                request_method,
                parent_group_jid,
            }
        }
        T::CreatedMembershipRequests => {
            let request_method = parse_request_method(node);
            let parent_group_jid = node.attrs().optional_jid("parent_group_jid");
            let requests = parse_requested_users(node);
            GroupNotificationAction::CreatedMembershipRequests {
                request_method,
                parent_group_jid,
                requests,
            }
        }
        T::RevokedMembershipRequests => {
            let participants = parse_participant_jids(node);
            GroupNotificationAction::RevokedMembershipRequests { participants }
        }
        T::MemberAddMode => {
            let mode = match node.content.as_ref() {
                Some(NodeContentRef::String(s)) => s.to_string(),
                Some(NodeContentRef::Bytes(b)) => String::from_utf8_lossy(b.as_ref()).into_owned(),
                _ => String::new(),
            };
            GroupNotificationAction::MemberAddMode { mode }
        }
        T::NoFrequentlyForwarded => GroupNotificationAction::NoFrequentlyForwarded,
        T::FrequentlyForwardedOk => GroupNotificationAction::FrequentlyForwardedOk,
        T::Invite => GroupNotificationAction::Invite {
            code: node
                .attrs()
                .optional_string("code")
                .as_deref()
                .unwrap_or_default()
                .to_string(),
        },
        T::RevokeInvite => GroupNotificationAction::RevokeInvite,
        T::GrowthLocked => GroupNotificationAction::GrowthLocked {
            expiration: node
                .attrs()
                .optional_u64("expiration")
                .and_then(|t| t.try_into().ok())
                .unwrap_or(0),
            lock_type: node
                .attrs()
                .optional_string("type")
                .as_deref()
                .unwrap_or_default()
                .to_string(),
        },
        T::GrowthUnlocked => GroupNotificationAction::GrowthUnlocked,
        T::Create => GroupNotificationAction::Create {
            raw: node.to_owned(),
        },
        T::Delete => GroupNotificationAction::Delete {
            reason: node
                .attrs()
                .optional_string("reason")
                .map(|s| s.into_owned()),
        },
        T::Link => GroupNotificationAction::Link {
            link_type: node
                .attrs()
                .optional_string("link_type")
                .as_deref()
                .unwrap_or_default()
                .to_string(),
            raw: node.to_owned(),
        },
        T::Unlink => GroupNotificationAction::Unlink {
            unlink_type: node
                .attrs()
                .optional_string("unlink_type")
                .as_deref()
                .unwrap_or_default()
                .to_string(),
            unlink_reason: node
                .attrs()
                .optional_string("unlink_reason")
                .map(|s| s.into_owned()),
            raw: node.to_owned(),
        },
        T::LinkedGroupPromote => GroupNotificationAction::LinkedGroupPromote {
            participants: parse_participants(node),
        },
        T::LinkedGroupDemote => GroupNotificationAction::LinkedGroupDemote {
            participants: parse_participants(node),
        },
        T::Suspended => GroupNotificationAction::Suspended,
        T::Unsuspended => GroupNotificationAction::Unsuspended,
        T::AutoAddDisabled => GroupNotificationAction::AutoAddDisabled,
        T::IsCapiHostedGroup => GroupNotificationAction::IsCapiHostedGroup,
        T::GroupSafetyCheck => GroupNotificationAction::GroupSafetyCheck,
        T::LimitSharingEnabled => GroupNotificationAction::LimitSharingEnabled {
            // try_into so >u32::MAX yields None instead of silently truncating.
            trigger: node
                .attrs()
                .optional_u64("trigger")
                .and_then(|t| t.try_into().ok()),
        },
        T::AllowAdminReports => GroupNotificationAction::AllowAdminReports,
        T::NotAllowAdminReports => GroupNotificationAction::NotAllowAdminReports,
        T::Reports => GroupNotificationAction::Reports,
        T::AllowNonAdminSubGroupCreation => GroupNotificationAction::AllowNonAdminSubGroupCreation,
        T::NotAllowNonAdminSubGroupCreation => {
            GroupNotificationAction::NotAllowNonAdminSubGroupCreation
        }
        T::CreatedSubGroupSuggestion => GroupNotificationAction::CreatedSubGroupSuggestion {
            raw: node.to_owned(),
        },
        T::RevokedSubGroupSuggestions => GroupNotificationAction::RevokedSubGroupSuggestions {
            raw: node.to_owned(),
        },
        T::ChangeNumber => GroupNotificationAction::ChangeNumber {
            new_owner: node.attrs().optional_jid("jid"),
            sub_group_suggestions: parse_sub_group_suggestion_jids(node),
        },
        T::Unknown(_) => GroupNotificationAction::Unknown {
            tag: node.tag.to_string(),
        },
    };
    Some(action)
}

fn parse_participants(node: &NodeRef<'_>) -> Vec<GroupParticipantInfo> {
    node.children()
        .map(|children| {
            children
                .iter()
                .filter(|c| c.tag == "participant")
                .filter_map(|c| {
                    let mut attrs = c.attrs();
                    let jid = attrs.optional_jid("jid")?;
                    let phone_number = attrs.optional_jid("phone_number");
                    let display_name = attrs
                        .optional_string("display_name")
                        .map(|s| s.into_owned());
                    // WA Web y(): `maybeAttrEnum("type", GROUP_PARTICIPANT_TYPES)
                    // != null ? _ : "participant"`. Missing and unknown both
                    // collapse to `Participant`, so the field is always Some.
                    let r#type = Some(
                        attrs
                            .optional_string("type")
                            .and_then(|s| GroupParticipantType::try_from(s.as_ref()).ok())
                            .unwrap_or(GroupParticipantType::Participant),
                    );
                    let lid = attrs.optional_jid("lid");
                    let username = attrs
                        .optional_string("username")
                        .or_else(|| attrs.optional_string("participant_username"))
                        .map(|s| s.into_owned());
                    let join_time = attrs.optional_u64("join_time");
                    let group_history_sent_state = attrs
                        .optional_string("group_history_sent_state")
                        .and_then(|value| GroupHistorySentState::try_from(value.as_ref()).ok());
                    Some(GroupParticipantInfo {
                        jid,
                        phone_number,
                        display_name,
                        r#type,
                        lid,
                        username,
                        join_time,
                        group_history_sent_state,
                    })
                })
                .collect()
        })
        .unwrap_or_default()
}

/// Parses `<requested_user>` children from `<created_membership_requests>`.
/// WA Web's `WAWebHandleGroupNotification` reads only `jid`, `phone_number`,
/// and `username` from these (`y()` is not called); other fields stay `None`.
fn parse_requested_users(node: &NodeRef<'_>) -> Vec<GroupParticipantInfo> {
    node.children()
        .map(|children| {
            children
                .iter()
                .filter(|c| c.tag == "requested_user")
                .filter_map(|c| {
                    let mut attrs = c.attrs();
                    let jid = attrs.optional_jid("jid")?;
                    let phone_number = attrs.optional_jid("phone_number");
                    let username = attrs.optional_string("username").map(|s| s.into_owned());
                    Some(GroupParticipantInfo {
                        jid,
                        phone_number,
                        display_name: None,
                        r#type: None,
                        lid: None,
                        username,
                        join_time: None,
                        group_history_sent_state: None,
                    })
                })
                .collect()
        })
        .unwrap_or_default()
}

/// Parses `<sub_group_suggestion jid="..."/>` children into subgroup JIDs.
fn parse_sub_group_suggestion_jids(node: &NodeRef<'_>) -> Vec<Jid> {
    node.children()
        .map(|children| {
            children
                .iter()
                .filter(|c| c.tag == "sub_group_suggestion")
                .filter_map(|c| c.attrs().optional_jid("jid"))
                .collect()
        })
        .unwrap_or_default()
}

/// Parses `<participant jid="..."/>` children into plain JIDs.
fn parse_participant_jids(node: &NodeRef<'_>) -> Vec<Jid> {
    node.children()
        .map(|children| {
            children
                .iter()
                .filter(|c| c.tag == "participant")
                .filter_map(|c| c.attrs().optional_jid("jid"))
                .collect()
        })
        .unwrap_or_default()
}

/// Maps the `request_method` attribute to [`MembershipRequestMethod`].
/// Defaults to `InviteLink` when absent or unknown — matches WA Web's fallback.
/// Wire strings come from the derived `TryFrom<&str>` impl; this function has
/// no hard-coded tags of its own.
fn parse_request_method(node: &NodeRef<'_>) -> MembershipRequestMethod {
    node.attrs()
        .optional_string("request_method")
        .as_deref()
        .and_then(|s| MembershipRequestMethod::try_from(s).ok())
        .unwrap_or_default()
}

#[cfg(test)]
mod tests {
    use super::*;
    use wacore_binary::Jid;
    use wacore_binary::builder::NodeBuilder;

    fn group_jid() -> Jid {
        "120363012345678901@g.us".parse().unwrap()
    }

    fn user_jid() -> Jid {
        "5511999999999@s.whatsapp.net".parse().unwrap()
    }

    fn admin_jid() -> Jid {
        "5511888888888@s.whatsapp.net".parse().unwrap()
    }

    fn make_notification(children: Vec<Node>) -> Node {
        NodeBuilder::new("notification")
            .attr("type", "w:gp2")
            .attr("from", group_jid())
            .attr("participant", admin_jid())
            .attr("t", "1704067200")
            .children(children)
            .build()
    }

    #[test]
    fn test_parse_root_participant_identity_attributes() {
        let participant_pn: Jid = "5511888888888@s.whatsapp.net".parse().unwrap();
        let node = NodeBuilder::new("notification")
            .attr("type", "w:gp2")
            .attr("from", group_jid())
            .attr("id", "GP-ROOT-1")
            .attr("participant", "271060335329480@lid")
            .attr("participant_pn", participant_pn.clone())
            .attr("participant_username", "group-admin")
            .attr("participant_country_code", "BR")
            .attr("notify", "Group Admin")
            .attr("offline", "1")
            .attr("t", "1704067200")
            .children(vec![
                NodeBuilder::new(MISSING_PARTICIPANT_IDENTIFICATION_TAG).build(),
                NodeBuilder::new("announcement").build(),
            ])
            .build();

        let notification = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notification.notification_id.as_deref(), Some("GP-ROOT-1"));
        assert_eq!(notification.notify.as_deref(), Some("Group Admin"));
        assert_eq!(notification.offline.as_deref(), Some("1"));
        assert_eq!(notification.participant_pn, Some(participant_pn));
        assert_eq!(
            notification.participant_username.as_deref(),
            Some("group-admin")
        );
        assert_eq!(notification.participant_country_code.as_deref(), Some("BR"));
        assert!(notification.has_incomplete_participant_information);
        assert_eq!(notification.actions.len(), 1);
    }

    #[test]
    fn test_parse_add_notification() {
        let node = make_notification(vec![
            NodeBuilder::new("add")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.group_jid, group_jid());
        assert_eq!(notif.participant, Some(admin_jid()));
        assert_eq!(notif.timestamp, 1704067200);
        assert_eq!(notif.actions.len(), 1);

        match &notif.actions[0] {
            GroupNotificationAction::Add {
                participants,
                reason,
            } => {
                assert_eq!(participants.len(), 1);
                assert_eq!(participants[0].jid, user_jid());
                assert!(reason.is_none());
            }
            other => panic!("expected Add, got {:?}", other),
        }
    }

    /// Mirrors the wire shape seen on `<modify>` in `w:gp2`: versioning
    /// attrs `v_id`/`prev_v_id` (ignored) plus a `<participant>` carrying
    /// `display_name`. The label is the server-rendered masked variant
    /// using U+2219 (bullet operator) when the requester is not in the
    /// participant's contacts.
    #[test]
    fn test_parse_modify_carries_display_name() {
        let masked =
            "+55\u{2219}\u{2219}\u{2219}\u{2219}\u{2219}\u{2219}\u{2219}\u{2219}\u{2219}00";
        let node = make_notification(vec![
            NodeBuilder::new("modify")
                .attr("v_id", "1700000000000001")
                .attr("prev_v_id", "1700000000000000")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", "999000000000001@lid")
                        .attr("display_name", masked)
                        .build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Modify { participants } => {
                assert_eq!(participants.len(), 1);
                assert_eq!(participants[0].display_name.as_deref(), Some(masked));
            }
            other => panic!("expected Modify, got {:?}", other),
        }
    }

    /// `<add>`/`<remove>` etc. with no `display_name` attr yield `None`,
    /// which serializes as omitted thanks to `skip_serializing_if`.
    #[test]
    fn test_parse_participant_without_display_name_is_none() {
        let node = make_notification(vec![
            NodeBuilder::new("add")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Add { participants, .. } => {
                assert!(participants[0].display_name.is_none());
            }
            other => panic!("expected Add, got {:?}", other),
        }
    }

    /// `<participant type="admin" lid="..." username="..." join_time="...">`
    /// surface all extras. Real shape used by `WAWebHandleGroupNotification`
    /// when admin tier and LID addressing are set.
    #[test]
    fn test_parse_participant_with_admin_extras() {
        let node = make_notification(vec![
            NodeBuilder::new("add")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", "55510000001@s.whatsapp.net")
                        .attr("type", "admin")
                        .attr("lid", "99900000000001@lid")
                        .attr("participant_username", "legacy-alice")
                        .attr("username", "alice")
                        .attr("join_time", "1700000000")
                        .attr("group_history_sent_state", "NOTICE_SENT")
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Add { participants, .. } => {
                assert_eq!(participants.len(), 1);
                let p = &participants[0];
                assert_eq!(p.r#type, Some(GroupParticipantType::Admin));
                assert_eq!(
                    p.lid.as_ref().map(|j| j.user.as_str()),
                    Some("99900000000001")
                );
                assert_eq!(p.username.as_deref(), Some("alice"));
                assert_eq!(p.join_time, Some(1700000000));
                assert_eq!(
                    p.group_history_sent_state,
                    Some(GroupHistorySentState::NoticeSent)
                );
            }
            other => panic!("expected Add, got {:?}", other),
        }
    }

    /// Missing `type` attr collapses to `Some(Participant)` (not `None`).
    /// Mirrors WA Web y()'s `maybeAttrEnum("type") != null ? _ : "participant"`.
    #[test]
    fn test_participant_missing_type_defaults_to_participant() {
        let node = make_notification(vec![
            NodeBuilder::new("add")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", "55510000004@s.whatsapp.net")
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Add { participants, .. } => {
                assert_eq!(
                    participants[0].r#type,
                    Some(GroupParticipantType::Participant)
                );
            }
            other => panic!("expected Add, got {:?}", other),
        }
    }

    /// `type="superadmin"` parses correctly, and `type` survives an unknown
    /// future value by defaulting to `Participant` instead of dropping the
    /// participant.
    #[test]
    fn test_participant_type_superadmin_and_unknown_fallback() {
        let node = make_notification(vec![
            NodeBuilder::new("add")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", "55510000002@s.whatsapp.net")
                        .attr("type", "superadmin")
                        .build(),
                    NodeBuilder::new("participant")
                        .attr("jid", "55510000003@s.whatsapp.net")
                        .attr("type", "future_role")
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Add { participants, .. } => {
                assert_eq!(
                    participants[0].r#type,
                    Some(GroupParticipantType::SuperAdmin)
                );
                assert_eq!(
                    participants[1].r#type,
                    Some(GroupParticipantType::Participant)
                );
            }
            other => panic!("expected Add, got {:?}", other),
        }
    }

    /// `<requested_user>` only reads `jid`, `phone_number`, `username` per
    /// WA Web; the other new fields stay `None`.
    #[test]
    fn test_requested_user_does_not_read_admin_extras() {
        let node = make_notification(vec![
            NodeBuilder::new("created_membership_requests")
                .children(vec![
                    NodeBuilder::new("requested_user")
                        .attr("jid", "55510000005@s.whatsapp.net")
                        .attr("type", "admin")
                        .attr("lid", "99900000000005@lid")
                        .attr("username", "bob")
                        .attr("join_time", "1700000005")
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::CreatedMembershipRequests { requests, .. } => {
                assert_eq!(requests.len(), 1);
                let r = &requests[0];
                assert!(
                    r.r#type.is_none(),
                    "type must NOT be read on requested_user"
                );
                assert!(r.lid.is_none());
                assert!(r.join_time.is_none());
                assert_eq!(r.username.as_deref(), Some("bob"));
            }
            other => panic!("expected CreatedMembershipRequests, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_subject_notification() {
        let node = make_notification(vec![
            NodeBuilder::new("subject")
                .attr("subject", "New Group Name")
                .attr("s_o", admin_jid())
                .attr("s_t", "1704067200")
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.actions.len(), 1);

        match &notif.actions[0] {
            GroupNotificationAction::Subject {
                subject,
                subject_owner,
                subject_time,
            } => {
                assert_eq!(subject, "New Group Name");
                assert_eq!(*subject_owner, Some(admin_jid()));
                assert_eq!(*subject_time, Some(1704067200));
            }
            other => panic!("expected Subject, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_description_add() {
        let node = make_notification(vec![
            NodeBuilder::new("description")
                .attr("id", "desc123")
                .children(vec![
                    NodeBuilder::new("body")
                        .string_content("Group description text")
                        .build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Description { id, description } => {
                assert_eq!(id, "desc123");
                assert_eq!(description.as_deref(), Some("Group description text"));
            }
            other => panic!("expected Description, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_description_delete() {
        let node = make_notification(vec![
            NodeBuilder::new("description")
                .attr("id", "desc123")
                .children(vec![NodeBuilder::new("delete").build()])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Description { id, description } => {
                assert_eq!(id, "desc123");
                assert!(description.is_none());
            }
            other => panic!("expected Description, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_settings_notifications() {
        // Test multiple actions in one notification
        let node = make_notification(vec![
            NodeBuilder::new("locked").attr("threshold", "100").build(),
            NodeBuilder::new("announcement").build(),
            NodeBuilder::new("ephemeral")
                .attr("expiration", "604800")
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.actions.len(), 3);

        match &notif.actions[0] {
            GroupNotificationAction::Locked { threshold } => {
                assert_eq!(threshold.as_deref(), Some("100"));
            }
            other => panic!("expected Locked, got {:?}", other),
        }
        assert!(matches!(
            notif.actions[1],
            GroupNotificationAction::Announce
        ));
        match &notif.actions[2] {
            GroupNotificationAction::Ephemeral {
                expiration,
                trigger,
            } => {
                assert_eq!(*expiration, 604800);
                assert!(trigger.is_none());
            }
            other => panic!("expected Ephemeral, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_not_ephemeral() {
        let node = make_notification(vec![NodeBuilder::new("not_ephemeral").build()]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Ephemeral {
                expiration,
                trigger,
            } => {
                assert_eq!(*expiration, 0);
                assert!(trigger.is_none());
            }
            other => panic!("expected Ephemeral, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_membership_approval_mode() {
        let node = make_notification(vec![
            NodeBuilder::new("membership_approval_mode")
                .children(vec![
                    NodeBuilder::new("group_join").attr("state", "on").build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::MembershipApprovalMode { enabled } => {
                assert!(*enabled);
            }
            other => panic!("expected MembershipApprovalMode, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_membership_approval_request() {
        // User requested to join — flat node with attrs only, actor is the requester.
        let node = make_notification(vec![
            NodeBuilder::new("membership_approval_request")
                .attr("request_method", "invite_link")
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.participant, Some(admin_jid()));
        match &notif.actions[0] {
            GroupNotificationAction::MembershipApprovalRequest {
                request_method,
                parent_group_jid,
            } => {
                assert_eq!(*request_method, MembershipRequestMethod::InviteLink);
                assert!(parent_group_jid.is_none());
            }
            other => panic!("expected MembershipApprovalRequest, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_created_membership_requests() {
        // Admin-side: new requests appeared — uses <requested_user> children.
        let node = make_notification(vec![
            NodeBuilder::new("created_membership_requests")
                .attr("request_method", "non_admin_add")
                .children(vec![
                    NodeBuilder::new("requested_user")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.participant, Some(admin_jid()));
        match &notif.actions[0] {
            GroupNotificationAction::CreatedMembershipRequests {
                request_method,
                parent_group_jid,
                requests,
            } => {
                assert_eq!(*request_method, MembershipRequestMethod::NonAdminAdd);
                assert!(parent_group_jid.is_none());
                assert_eq!(requests.len(), 1);
                assert_eq!(requests[0].jid, user_jid());
            }
            other => panic!("expected CreatedMembershipRequests, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_revoked_membership_requests() {
        // Requests rejected by admin — uses <participant jid="..."/> children.
        let node = make_notification(vec![
            NodeBuilder::new("revoked_membership_requests")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.participant, Some(admin_jid()));
        match &notif.actions[0] {
            GroupNotificationAction::RevokedMembershipRequests { participants } => {
                assert_eq!(participants.len(), 1);
                assert_eq!(participants[0], user_jid());
            }
            other => panic!("expected RevokedMembershipRequests, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_membership_approval_request_default_method() {
        // No request_method attr → defaults to InviteLink (matches WA Web fallback).
        let node = make_notification(vec![
            NodeBuilder::new("membership_approval_request").build(),
        ]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        assert_eq!(notif.participant, Some(admin_jid()));
        match &notif.actions[0] {
            GroupNotificationAction::MembershipApprovalRequest {
                request_method,
                parent_group_jid,
            } => {
                assert_eq!(*request_method, MembershipRequestMethod::InviteLink);
                assert!(parent_group_jid.is_none());
            }
            other => panic!("expected MembershipApprovalRequest, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_membership_request_with_parent_group_jid() {
        // Community-linked join — both variants carry parent_group_jid.
        let parent_jid: Jid = "999999999999999999@g.us".parse().unwrap();

        let approval_node = make_notification(vec![
            NodeBuilder::new("membership_approval_request")
                .attr("request_method", "linked_group_join")
                .attr("parent_group_jid", parent_jid.clone())
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&approval_node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::MembershipApprovalRequest {
                request_method,
                parent_group_jid,
            } => {
                assert_eq!(*request_method, MembershipRequestMethod::LinkedGroupJoin);
                assert_eq!(*parent_group_jid, Some(parent_jid.clone()));
            }
            other => panic!("expected MembershipApprovalRequest, got {:?}", other),
        }

        let created_node = make_notification(vec![
            NodeBuilder::new("created_membership_requests")
                .attr("request_method", "linked_group_join")
                .attr("parent_group_jid", parent_jid.clone())
                .children(vec![
                    NodeBuilder::new("requested_user")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);
        let notif2 = GroupNotification::try_from_node_ref(&created_node.as_node_ref()).unwrap();
        match &notif2.actions[0] {
            GroupNotificationAction::CreatedMembershipRequests {
                request_method,
                parent_group_jid,
                requests,
            } => {
                assert_eq!(*request_method, MembershipRequestMethod::LinkedGroupJoin);
                assert_eq!(*parent_group_jid, Some(parent_jid));
                assert_eq!(requests.len(), 1);
                assert_eq!(requests[0].jid, user_jid());
            }
            other => panic!("expected CreatedMembershipRequests, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_linked_group_promote_demote_carry_participants() {
        let promote_node = make_notification(vec![
            NodeBuilder::new("linked_group_promote")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&promote_node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::LinkedGroupPromote { participants } => {
                assert_eq!(participants.len(), 1);
                assert_eq!(participants[0].jid, user_jid());
            }
            other => panic!("expected LinkedGroupPromote, got {:?}", other),
        }

        let demote_node = make_notification(vec![
            NodeBuilder::new("linked_group_demote")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&demote_node.as_node_ref()).unwrap();
        assert!(matches!(
            notif.actions[0],
            GroupNotificationAction::LinkedGroupDemote { .. }
        ));
    }

    #[test]
    fn test_parse_suspended_toggle_variants() {
        type Matcher = fn(&GroupNotificationAction) -> bool;
        let table: &[(&str, Matcher)] = &[
            ("suspended", |a| {
                matches!(a, GroupNotificationAction::Suspended)
            }),
            ("unsuspended", |a| {
                matches!(a, GroupNotificationAction::Unsuspended)
            }),
            ("auto_add_disabled", |a| {
                matches!(a, GroupNotificationAction::AutoAddDisabled)
            }),
            ("is_capi_hosted_group", |a| {
                matches!(a, GroupNotificationAction::IsCapiHostedGroup)
            }),
            ("group_safety_check", |a| {
                matches!(a, GroupNotificationAction::GroupSafetyCheck)
            }),
            ("limit_sharing_enabled", |a| {
                matches!(a, GroupNotificationAction::LimitSharingEnabled { .. })
            }),
            ("allow_admin_reports", |a| {
                matches!(a, GroupNotificationAction::AllowAdminReports)
            }),
            ("not_allow_admin_reports", |a| {
                matches!(a, GroupNotificationAction::NotAllowAdminReports)
            }),
            ("reports", |a| matches!(a, GroupNotificationAction::Reports)),
            ("allow_non_admin_sub_group_creation", |a| {
                matches!(a, GroupNotificationAction::AllowNonAdminSubGroupCreation)
            }),
            ("not_allow_non_admin_sub_group_creation", |a| {
                matches!(a, GroupNotificationAction::NotAllowNonAdminSubGroupCreation)
            }),
        ];
        for (tag, matcher) in table {
            let node = make_notification(vec![NodeBuilder::new(tag).build()]);
            let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
            assert!(
                matcher(&notif.actions[0]),
                "wire tag {tag} parsed to unexpected variant: {:?}",
                notif.actions[0]
            );
        }
    }

    #[test]
    fn test_parse_limit_sharing_enabled_captures_trigger() {
        let with_trigger = make_notification(vec![
            NodeBuilder::new("limit_sharing_enabled")
                .attr("trigger", "5")
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&with_trigger.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::LimitSharingEnabled { trigger } => {
                assert_eq!(*trigger, Some(5));
            }
            other => panic!("expected LimitSharingEnabled, got {:?}", other),
        }

        let no_trigger = make_notification(vec![NodeBuilder::new("limit_sharing_enabled").build()]);
        let notif = GroupNotification::try_from_node_ref(&no_trigger.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::LimitSharingEnabled { trigger } => assert!(trigger.is_none()),
            other => panic!("expected LimitSharingEnabled, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_limit_sharing_enabled_overflow_yields_none() {
        // trigger > u32::MAX must yield None instead of truncating.
        let node = make_notification(vec![
            NodeBuilder::new("limit_sharing_enabled")
                .attr("trigger", "4294967296")
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::LimitSharingEnabled { trigger } => assert!(trigger.is_none()),
            other => panic!("expected LimitSharingEnabled, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_ephemeral_overflow_yields_zero_and_none() {
        // expiration > u32::MAX falls back to 0; trigger > u32::MAX yields None.
        let node = make_notification(vec![
            NodeBuilder::new("ephemeral")
                .attr("expiration", "4294967296")
                .attr("trigger", "4294967296")
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Ephemeral {
                expiration,
                trigger,
            } => {
                assert_eq!(*expiration, 0);
                assert!(trigger.is_none());
            }
            other => panic!("expected Ephemeral, got {:?}", other),
        }
    }

    /// Verifies the actual wire shape from `WAWebHandleGroupNotification`:
    /// `<change_number jid="<new_owner>"><sub_group_suggestion jid="<sg>"/>...`.
    /// The old owner stays in `notification.participant`.
    #[test]
    fn test_parse_change_number_real_shape() {
        let new_owner_jid = "5511888888888@s.whatsapp.net";
        let sg_a = "111111111111111@g.us";
        let sg_b = "222222222222222@g.us";
        let node = make_notification(vec![
            NodeBuilder::new("change_number")
                .attr("jid", new_owner_jid)
                .children(vec![
                    NodeBuilder::new("sub_group_suggestion")
                        .attr("jid", sg_a)
                        .build(),
                    NodeBuilder::new("sub_group_suggestion")
                        .attr("jid", sg_b)
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::ChangeNumber {
                new_owner,
                sub_group_suggestions,
            } => {
                assert_eq!(
                    new_owner.as_ref().map(|j| j.to_string()).as_deref(),
                    Some(new_owner_jid)
                );
                assert_eq!(sub_group_suggestions.len(), 2);
                assert_eq!(sub_group_suggestions[0].to_string(), sg_a);
                assert_eq!(sub_group_suggestions[1].to_string(), sg_b);
            }
            other => panic!("expected ChangeNumber, got {:?}", other),
        }
    }

    /// Missing `jid` attribute yields `new_owner: None` instead of dropping
    /// the entire action.
    #[test]
    fn test_parse_change_number_missing_jid_is_tolerant() {
        let node = make_notification(vec![NodeBuilder::new("change_number").build()]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::ChangeNumber {
                new_owner,
                sub_group_suggestions,
            } => {
                assert!(new_owner.is_none());
                assert!(sub_group_suggestions.is_empty());
            }
            other => panic!("expected ChangeNumber, got {:?}", other),
        }
    }

    /// `<participant>` children inside `<change_number>` must NOT leak into
    /// `sub_group_suggestions`; only `<sub_group_suggestion>` is read.
    #[test]
    fn test_parse_change_number_ignores_participant_children() {
        let node = make_notification(vec![
            NodeBuilder::new("change_number")
                .attr("jid", "5511888888888@s.whatsapp.net")
                .children(vec![
                    NodeBuilder::new("participant")
                        .attr("jid", user_jid())
                        .build(),
                ])
                .build(),
        ]);
        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::ChangeNumber {
                sub_group_suggestions,
                ..
            } => {
                assert!(sub_group_suggestions.is_empty());
            }
            other => panic!("expected ChangeNumber, got {:?}", other),
        }
    }

    #[test]
    fn test_parse_unknown_tag() {
        let node = make_notification(vec![NodeBuilder::new("some_future_feature").build()]);

        let notif = GroupNotification::try_from_node_ref(&node.as_node_ref()).unwrap();
        match &notif.actions[0] {
            GroupNotificationAction::Unknown { tag } => {
                assert_eq!(tag, "some_future_feature");
            }
            other => panic!("expected Unknown, got {:?}", other),
        }
    }

    #[test]
    fn test_missing_from_returns_none() {
        let node = NodeBuilder::new("notification")
            .attr("type", "w:gp2")
            .attr("t", "1704067200")
            .build();

        assert!(GroupNotification::try_from_node_ref(&node.as_node_ref()).is_none());
    }

    /// Every variant serializes its JSON `"type"` discriminator using the
    /// exact wire tag the parser dispatches on. This is the regression guard
    /// for the PascalCase discriminator leak that used to ship
    /// `{"type":"Demote", ...}` instead of `{"type":"demote", ...}`.
    #[test]
    fn serialize_discriminator_matches_wire_tag() {
        let dummy_node = NodeBuilder::new("placeholder").build();
        let samples: Vec<GroupNotificationAction> = vec![
            GroupNotificationAction::Add {
                participants: vec![],
                reason: None,
            },
            GroupNotificationAction::Remove {
                participants: vec![],
                reason: Some("r".into()),
            },
            GroupNotificationAction::Promote {
                participants: vec![],
            },
            GroupNotificationAction::Demote {
                participants: vec![],
            },
            GroupNotificationAction::Modify {
                participants: vec![],
            },
            GroupNotificationAction::Subject {
                subject: "s".into(),
                subject_owner: None,
                subject_time: None,
            },
            GroupNotificationAction::Description {
                id: "i".into(),
                description: None,
            },
            GroupNotificationAction::Locked { threshold: None },
            GroupNotificationAction::Unlocked,
            GroupNotificationAction::Announce,
            GroupNotificationAction::NotAnnounce,
            GroupNotificationAction::Ephemeral {
                expiration: 0,
                trigger: None,
            },
            GroupNotificationAction::MembershipApprovalMode { enabled: true },
            GroupNotificationAction::MembershipApprovalRequest {
                request_method: MembershipRequestMethod::InviteLink,
                parent_group_jid: None,
            },
            GroupNotificationAction::CreatedMembershipRequests {
                request_method: MembershipRequestMethod::InviteLink,
                parent_group_jid: None,
                requests: vec![],
            },
            GroupNotificationAction::RevokedMembershipRequests {
                participants: vec![],
            },
            GroupNotificationAction::MemberAddMode { mode: "x".into() },
            GroupNotificationAction::NoFrequentlyForwarded,
            GroupNotificationAction::FrequentlyForwardedOk,
            GroupNotificationAction::Invite { code: "c".into() },
            GroupNotificationAction::RevokeInvite,
            GroupNotificationAction::GrowthLocked {
                expiration: 0,
                lock_type: "x".into(),
            },
            GroupNotificationAction::GrowthUnlocked,
            GroupNotificationAction::Create {
                raw: dummy_node.clone(),
            },
            GroupNotificationAction::Delete { reason: None },
            GroupNotificationAction::Link {
                link_type: "x".into(),
                raw: dummy_node.clone(),
            },
            GroupNotificationAction::Unlink {
                unlink_type: "x".into(),
                unlink_reason: None,
                raw: dummy_node.clone(),
            },
            GroupNotificationAction::LinkedGroupPromote {
                participants: vec![],
            },
            GroupNotificationAction::LinkedGroupDemote {
                participants: vec![],
            },
            GroupNotificationAction::Suspended,
            GroupNotificationAction::Unsuspended,
            GroupNotificationAction::AutoAddDisabled,
            GroupNotificationAction::IsCapiHostedGroup,
            GroupNotificationAction::GroupSafetyCheck,
            GroupNotificationAction::LimitSharingEnabled { trigger: None },
            GroupNotificationAction::AllowAdminReports,
            GroupNotificationAction::NotAllowAdminReports,
            GroupNotificationAction::Reports,
            GroupNotificationAction::AllowNonAdminSubGroupCreation,
            GroupNotificationAction::NotAllowNonAdminSubGroupCreation,
            GroupNotificationAction::CreatedSubGroupSuggestion {
                raw: dummy_node.clone(),
            },
            GroupNotificationAction::RevokedSubGroupSuggestions {
                raw: dummy_node.clone(),
            },
            GroupNotificationAction::ChangeNumber {
                new_owner: None,
                sub_group_suggestions: vec![],
            },
            GroupNotificationAction::Unknown {
                tag: "future_tag".into(),
            },
        ];
        let _ = dummy_node;

        for action in &samples {
            let value = serde_json::to_value(action).expect("serialize");
            let ty = value
                .get("type")
                .and_then(|v| v.as_str())
                .unwrap_or_else(|| panic!("missing type in {value}"));
            assert_eq!(
                ty,
                action.tag_name(),
                "serialized discriminator diverged from wire tag for {action:?}"
            );
        }
    }

    /// Lowercase wire strings round-trip through the parser, matching the
    /// exact JSON discriminators we now emit. If someone renames a variant
    /// and forgets to keep `tag_name()` aligned with the parser's dispatch
    /// table, this test fails.
    #[test]
    fn wire_tags_round_trip_through_parser() {
        type Check = fn(&GroupNotificationAction) -> bool;
        let cases: &[(&str, Check)] = &[
            ("add", |a| matches!(a, GroupNotificationAction::Add { .. })),
            ("demote", |a| {
                matches!(a, GroupNotificationAction::Demote { .. })
            }),
            ("promote", |a| {
                matches!(a, GroupNotificationAction::Promote { .. })
            }),
            ("revoke", |a| {
                matches!(a, GroupNotificationAction::RevokeInvite)
            }),
            ("not_announcement", |a| {
                matches!(a, GroupNotificationAction::NotAnnounce)
            }),
            ("announcement", |a| {
                matches!(a, GroupNotificationAction::Announce)
            }),
        ];

        for (tag, check) in cases {
            let node = make_notification(vec![NodeBuilder::new(tag).build()]);
            let notif = GroupNotification::try_from_node_ref(&node.as_node_ref())
                .unwrap_or_else(|| panic!("parse failed for <{tag}>"));
            let action = &notif.actions[0];
            assert!(
                check(action),
                "tag <{tag}> did not produce expected variant (got {action:?})"
            );
            assert_eq!(action.tag_name(), *tag);
        }
    }
}