softchat/

chat.rs

//! Typed Softchat chat-event views, canonical writers, and pure projections.

use std::collections::BTreeSet;

use serde::{Deserialize, Serialize};
use url::Url;

use crate::event::{RumorEvent, SignedEvent};
use crate::{
    AttachmentMetadata, LocalIdentity, NostrEventDraft, NostrEventId, NostrEventKind,
    NostrPublicKey, NostrRumor, NostrTag, SignedNostrEvent, SoftchatError,
};

/// Maximum participant count in one Softchat rumor.
pub const MAX_CHAT_PARTICIPANTS: usize = 256;
/// Maximum typed extension tags accepted from a writer.
pub const MAX_CHAT_EXTENSION_TAGS: usize = 256;
/// Maximum custom emoji definitions on one event.
pub const MAX_CHAT_EMOJI_TAGS: usize = 128;
/// Maximum inline attachments on one canonical chat message.
pub const MAX_CHAT_ATTACHMENTS: usize = 32;

/// Relation semantics exposed by a kind-14 message view.
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Enum))]
pub enum ChatRelationKind {
    /// No reply or forward.
    None,
    /// Canonical marked NIP-10 reply.
    Reply,
    /// Released-Android unmarked `e` compatibility reply.
    LegacyReply,
    /// Softchat `q`-tag forward.
    Forward,
}

/// One validated message relation.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ChatRelation {
    /// No relation.
    None,
    /// Reply to another event.
    Reply {
        /// Parent event ID.
        event_id: NostrEventId,
        /// Optional validated relay hint.
        relay_hint: Option<String>,
        /// Whether the reader recovered the released-Android unmarked shape.
        legacy_unmarked: bool,
    },
    /// Forward another event.
    Forward {
        /// Forwarded event ID.
        event_id: NostrEventId,
        /// Optional validated relay hint.
        relay_hint: Option<String>,
        /// Original event author.
        original_author: NostrPublicKey,
    },
}

/// Flat relation input for generated native bindings.
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct ChatRelationInput {
    /// Relation type. Writers reject `LegacyReply`.
    pub kind: ChatRelationKind,
    /// Related event ID, empty only for `None`.
    pub event_id: String,
    /// Optional relay hint represented by an empty string when absent.
    pub relay_hint: String,
    /// Forwarded event author, empty except for `Forward`.
    pub original_author: String,
}

impl ChatRelationInput {
    /// Validate this binding-friendly value as a canonical writer relation.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::SoftchatEventCreationFailed`] for incomplete
    /// values, invalid IDs, invalid relay hints, or receive-only legacy input.
    pub fn into_relation(self) -> Result<ChatRelation, SoftchatError> {
        let relay_hint = optional_relay_hint(&self.relay_hint)?;
        match self.kind {
            ChatRelationKind::None
                if self.event_id.is_empty()
                    && self.relay_hint.is_empty()
                    && self.original_author.is_empty() =>
            {
                Ok(ChatRelation::None)
            }
            ChatRelationKind::Reply if self.original_author.is_empty() => Ok(ChatRelation::Reply {
                event_id: NostrEventId::from_hex(&self.event_id)
                    .map_err(|_| SoftchatError::SoftchatEventCreationFailed)?,
                relay_hint,
                legacy_unmarked: false,
            }),
            ChatRelationKind::Forward => Ok(ChatRelation::Forward {
                event_id: NostrEventId::from_hex(&self.event_id)
                    .map_err(|_| SoftchatError::SoftchatEventCreationFailed)?,
                relay_hint,
                original_author: NostrPublicKey::from_hex(&self.original_author)
                    .map_err(|_| SoftchatError::SoftchatEventCreationFailed)?,
            }),
            _ => Err(SoftchatError::SoftchatEventCreationFailed),
        }
    }
}

/// Canonical complete kind-14 message writer input.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ChatMessageDraft {
    /// Explicit application timestamp.
    pub created_at: u64,
    /// Every conversation participant except the author.
    pub participants: Vec<NostrPublicKey>,
    /// Text content; may be empty only when at least one attachment is present.
    pub content: String,
    /// At most one reply or forward.
    pub relation: ChatRelation,
    /// Canonical inline attachments.
    pub attachments: Vec<AttachmentMetadata>,
    /// Exact canonical `emoji` tags.
    pub emoji_tags: Vec<NostrTag>,
    /// Caller-owned future tags retained after known tags.
    pub extension_tags: Vec<NostrTag>,
}

/// Flat complete kind-14 message view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct ChatMessageView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Sorted unique participant public keys, excluding the author.
    pub participants: Vec<String>,
    /// Parsed relation type.
    pub relation_kind: ChatRelationKind,
    /// Related event ID, or empty.
    pub related_event_id: String,
    /// Valid relay hint, or empty.
    pub relay_hint: String,
    /// Forwarded author, or empty.
    pub original_author: String,
    /// Parsed attachment metadata.
    pub attachments: Vec<AttachmentMetadata>,
    /// Exact custom-emoji tags.
    pub emoji_tags: Vec<Vec<String>>,
    /// Unknown or compatibility tags retained exactly.
    pub extension_tags: Vec<Vec<String>>,
}

/// Canonical group-subject writer input.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SubjectDraft {
    /// Explicit application timestamp.
    pub created_at: u64,
    /// Every conversation participant except the author.
    pub participants: Vec<NostrPublicKey>,
    /// Subject text; empty explicitly clears text.
    pub subject: String,
    /// Exact custom-emoji tags referenced by the subject.
    pub emoji_tags: Vec<NostrTag>,
    /// Optional icon metadata. Its URL and dimensions are mirrored to `image`.
    pub icon: Option<AttachmentMetadata>,
    /// Caller-owned future tags.
    pub extension_tags: Vec<NostrTag>,
}

/// Typed group-subject view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct SubjectView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Sorted unique participants.
    pub participants: Vec<String>,
    /// Subject text, including an explicit empty clear.
    pub subject: String,
    /// Icon URL, or empty when unchanged.
    pub icon_url: String,
    /// Icon dimensions, or empty.
    pub icon_dimensions: String,
    /// Exact emoji tags.
    pub emoji_tags: Vec<Vec<String>>,
    /// Unknown tags retained exactly.
    pub extension_tags: Vec<Vec<String>>,
}

/// Canonical private-reaction writer input.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ReactionDraft {
    /// Every conversation participant except the author.
    pub participants: Vec<NostrPublicKey>,
    /// Referenced event ID.
    pub parent_id: NostrEventId,
    /// Referenced event author.
    pub parent_author: NostrPublicKey,
    /// Referenced event kind.
    pub parent_kind: NostrEventKind,
    /// Unicode reaction or `:shortcode:`.
    pub reaction: String,
    /// HTTPS custom-emoji URL when `reaction` is a shortcode.
    pub custom_emoji_url: Option<String>,
    /// Explicit application timestamp.
    pub created_at: u64,
}

/// Typed NIP-25 reaction view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct ReactionView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Referenced event ID.
    pub event_id: String,
    /// Referenced participant/author `p` tags retained in canonical order.
    pub event_authors: Vec<String>,
    /// Referenced event kind.
    pub event_kind: i32,
    /// Unicode reaction or `:shortcode:`.
    pub reaction: String,
    /// Custom emoji URL, or empty.
    pub custom_emoji_url: String,
}

/// Typed NIP-09 deletion view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct DeletionView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Referenced event IDs.
    pub event_ids: Vec<String>,
    /// Optional reason.
    pub reason: String,
}

/// Typed Softchat kind-1010 edit view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct EditView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Original message ID.
    pub original_event_id: String,
    /// Sorted conversation participants.
    pub participants: Vec<String>,
    /// Complete replacement text.
    pub content: String,
    /// Replacement custom-emoji tags.
    pub emoji_tags: Vec<Vec<String>>,
    /// Ignored released-client compatibility tags.
    pub compatibility_tags: Vec<Vec<String>>,
}

/// Typed ephemeral typing view.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct TypingView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Sorted conversation participants.
    pub participants: Vec<String>,
}

/// Validated receive-only NIP-18 generic repost.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct GenericRepostView {
    /// Complete exact repost event.
    pub repost: SignedEvent,
    /// Complete verified embedded event.
    pub embedded_event: SignedEvent,
}

/// Pure text/deletion projection over one original and its event history.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct MessageProjection {
    /// Original event ID.
    pub original_event_id: String,
    /// Whether a valid deletion of the original dominates the result.
    pub deleted: bool,
    /// Effective text, empty when deleted.
    pub content: String,
    /// Effective emoji tags.
    pub emoji_tags: Vec<Vec<String>>,
    /// Winning edit ID, or empty when the original wins.
    pub applied_edit_id: String,
}

impl LocalIdentity {
    /// Create a canonical one-to-one or group kind-14 message rumor.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::SoftchatEventCreationFailed`] for invalid
    /// participants, relations, attachment metadata, or extension tags.
    pub fn create_chat_message(
        &self,
        draft: ChatMessageDraft,
    ) -> Result<ChatMessageView, SoftchatError> {
        let draft = prepare_chat_message_draft(self.public_key(), draft)?;
        let rumor = self
            .create_rumor(draft)
            .map_err(|_| SoftchatError::SoftchatEventCreationFailed)?;
        parse_chat_message(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }

    /// Create a canonical subject update with dual Android/iOS icon tags.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::SoftchatEventCreationFailed`] for invalid input.
    pub fn create_subject(&self, draft: SubjectDraft) -> Result<SubjectView, SoftchatError> {
        let participants = canonical_participants(self.public_key(), draft.participants)?;
        validate_writer_tags(&draft.emoji_tags, "emoji", MAX_CHAT_EMOJI_TAGS)?;
        validate_extension_tags(&draft.extension_tags)?;
        let mut tags = participant_tags(&participants)?;
        tags.push(NostrTag::new(vec!["subject".to_owned(), draft.subject])?);
        tags.extend(draft.emoji_tags);
        if let Some(icon) = draft.icon {
            let icon_tag = icon.to_tag()?;
            let dimensions = icon.dimensions.unwrap_or_default();
            tags.push(icon_tag);
            tags.push(NostrTag::new(vec![
                "image".to_owned(),
                icon.url,
                dimensions,
            ])?);
        }
        tags.extend(draft.extension_tags);
        let rumor = self
            .create_rumor(NostrEventDraft::new(
                draft.created_at,
                NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                tags,
                "",
            )?)
            .map_err(|_| SoftchatError::SoftchatEventCreationFailed)?;
        parse_subject(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }

    /// Create a canonical private reaction rumor.
    ///
    /// # Errors
    ///
    /// Returns a stable creation failure for malformed references or reaction.
    pub fn create_reaction(&self, draft: ReactionDraft) -> Result<ReactionView, SoftchatError> {
        let author = self.public_key();
        let parent_is_author = draft.parent_author == author;
        let participants = canonical_participants(author, draft.participants)?;
        if !parent_is_author && !participants.contains(&draft.parent_author) {
            return Err(SoftchatError::SoftchatEventCreationFailed);
        }
        if draft.reaction.is_empty() || draft.reaction.chars().count() > 64 {
            return Err(SoftchatError::SoftchatEventCreationFailed);
        }
        let mut tags = participant_tags(&participants)?;
        tags.extend([
            NostrTag::new(vec!["e".to_owned(), draft.parent_id.to_hex()])?,
            NostrTag::new(vec!["k".to_owned(), draft.parent_kind.as_u16().to_string()])?,
        ]);
        if let Some(url) = draft.custom_emoji_url {
            let shortcode = draft
                .reaction
                .strip_prefix(':')
                .and_then(|value| value.strip_suffix(':'))
                .filter(|value| !value.is_empty())
                .ok_or(SoftchatError::SoftchatEventCreationFailed)?;
            validate_https(&url)?;
            tags.push(NostrTag::new(vec!["emoji", shortcode, &url])?);
        }
        let rumor = self.create_rumor(NostrEventDraft::new(
            draft.created_at,
            NostrEventKind::REACTION,
            tags,
            draft.reaction,
        )?)?;
        parse_reaction(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }

    /// Create a canonical private deletion request.
    ///
    /// # Errors
    ///
    /// Returns a stable creation failure for empty, duplicate, or oversized IDs.
    pub fn create_deletion(
        &self,
        participants: Vec<NostrPublicKey>,
        event_ids: Vec<NostrEventId>,
        reason: String,
        created_at: u64,
    ) -> Result<DeletionView, SoftchatError> {
        let participants = canonical_participants(self.public_key(), participants)?;
        if event_ids.is_empty() || event_ids.len() > 256 {
            return Err(SoftchatError::SoftchatEventCreationFailed);
        }
        let mut unique_ids = BTreeSet::new();
        if event_ids
            .iter()
            .any(|event_id| !unique_ids.insert(*event_id))
        {
            return Err(SoftchatError::SoftchatEventCreationFailed);
        }
        let mut tags = participant_tags(&participants)?;
        for event_id in event_ids {
            tags.push(NostrTag::new(vec!["e".to_owned(), event_id.to_hex()])?);
        }
        let rumor = self.create_rumor(NostrEventDraft::new(
            created_at,
            NostrEventKind::EVENT_DELETION_REQUEST,
            tags,
            reason,
        )?)?;
        parse_deletion(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }

    /// Create a canonical text-and-emoji-only kind-1010 edit.
    ///
    /// # Errors
    ///
    /// Returns a stable creation failure for invalid participants or emoji tags.
    pub fn create_edit(
        &self,
        participants: Vec<NostrPublicKey>,
        original_event_id: NostrEventId,
        content: String,
        emoji_tags: Vec<NostrTag>,
        created_at: u64,
    ) -> Result<EditView, SoftchatError> {
        let participants = canonical_participants(self.public_key(), participants)?;
        validate_writer_tags(&emoji_tags, "emoji", MAX_CHAT_EMOJI_TAGS)?;
        let mut tags = participant_tags(&participants)?;
        tags.push(NostrTag::new(vec![
            "e".to_owned(),
            original_event_id.to_hex(),
        ])?);
        tags.extend(emoji_tags);
        let rumor = self.create_rumor(NostrEventDraft::new(
            created_at,
            NostrEventKind::UPDATED_CONTENT,
            tags,
            content,
        )?)?;
        parse_edit(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }

    /// Create one ephemeral kind-21234 typing rumor.
    ///
    /// # Errors
    ///
    /// Returns a stable creation failure for an invalid participant set.
    pub fn create_typing(
        &self,
        participants: Vec<NostrPublicKey>,
        created_at: u64,
    ) -> Result<TypingView, SoftchatError> {
        let participants = canonical_participants(self.public_key(), participants)?;
        let rumor = self.create_rumor(NostrEventDraft::new(
            created_at,
            NostrEventKind::TYPING,
            participant_tags(&participants)?,
            "",
        )?)?;
        parse_typing(&rumor).map_err(|_| SoftchatError::SoftchatEventCreationFailed)
    }
}

/// Validate a binding-owned rumor as a complete kind-14 message.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_chat_message(rumor: RumorEvent) -> Result<ChatMessageView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_chat_message(&rumor)
}

/// Validate a binding-owned rumor as a subject update.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_subject(rumor: RumorEvent) -> Result<SubjectView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_subject(&rumor)
}

/// Return the complete icon metadata explicitly authored by one valid subject update.
///
/// Absence is distinct from clearing: profile version 1 inherits the previous
/// icon when neither `imeta` nor `image` is present.
#[cfg(feature = "sqlite-storage")]
pub(crate) fn subject_icon_metadata(
    rumor: &RumorEvent,
) -> Result<Option<AttachmentMetadata>, SoftchatError> {
    let parsed = classify_subject(rumor.clone())?;
    subject_icon_metadata_from_validated(rumor, &parsed)
}

#[cfg(feature = "sqlite-storage")]
pub(crate) fn subject_icon_metadata_from_validated(
    rumor: &RumorEvent,
    parsed: &SubjectView,
) -> Result<Option<AttachmentMetadata>, SoftchatError> {
    if let Some(tag) = rumor
        .tags
        .iter()
        .find(|tag| tag.first().map(String::as_str) == Some("imeta"))
    {
        return AttachmentMetadata::from_tag(tag).map(Some);
    }
    Ok((!parsed.icon_url.is_empty()).then(|| AttachmentMetadata {
        url: parsed.icon_url.clone(),
        dimensions: (!parsed.icon_dimensions.is_empty()).then(|| parsed.icon_dimensions.clone()),
        ..AttachmentMetadata::default()
    }))
}

/// Validate a binding-owned rumor as a reaction.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_reaction(rumor: RumorEvent) -> Result<ReactionView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_reaction(&rumor)
}

/// Validate a binding-owned rumor as a deletion request.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_deletion(rumor: RumorEvent) -> Result<DeletionView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_deletion(&rumor)
}

/// Validate a binding-owned rumor as a kind-1010 edit.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_edit(rumor: RumorEvent) -> Result<EditView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_edit(&rumor)
}

/// Validate a binding-owned rumor as a typing event.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_typing(rumor: RumorEvent) -> Result<TypingView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_typing(&rumor)
}

/// Validate a signed receive-only NIP-18 generic repost.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_generic_repost(repost: SignedEvent) -> Result<GenericRepostView, SoftchatError> {
    let repost =
        SignedNostrEvent::try_from(repost).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    parse_generic_repost(&repost)
}

/// Apply authorized edit and deletion history without owning persistence.
///
/// # Errors
///
/// Returns [`SoftchatError::InvalidSoftchatProjection`] when any supplied
/// history event is malformed, targets another original, or has an
/// unauthorized author.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn project_chat_message(
    original: RumorEvent,
    edits: Vec<RumorEvent>,
    deletions: Vec<RumorEvent>,
) -> Result<MessageProjection, SoftchatError> {
    let original =
        NostrRumor::try_from(original).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
    let original_view =
        parse_chat_message(&original).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
    let original_id = original.id();
    let author = original.public_key();

    let mut deleted_ids = BTreeSet::new();
    for deletion in deletions {
        let deletion =
            NostrRumor::try_from(deletion).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
        if deletion.public_key() != author {
            return Err(SoftchatError::InvalidSoftchatProjection);
        }
        let view =
            parse_deletion(&deletion).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
        for event_id in view.event_ids {
            deleted_ids.insert(
                NostrEventId::from_hex(&event_id)
                    .map_err(|_| SoftchatError::InvalidSoftchatProjection)?,
            );
        }
    }

    if deleted_ids.contains(&original_id) {
        return Ok(MessageProjection {
            original_event_id: original_id.to_hex(),
            deleted: true,
            content: String::new(),
            emoji_tags: Vec::new(),
            applied_edit_id: String::new(),
        });
    }

    let mut eligible = Vec::new();
    for edit in edits {
        let edit =
            NostrRumor::try_from(edit).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
        if edit.public_key() != author {
            return Err(SoftchatError::InvalidSoftchatProjection);
        }
        let view = parse_edit(&edit).map_err(|_| SoftchatError::InvalidSoftchatProjection)?;
        if view.original_event_id != original_id.to_hex() {
            return Err(SoftchatError::InvalidSoftchatProjection);
        }
        if !deleted_ids.contains(&edit.id()) {
            eligible.push((edit.created_at(), edit.id(), view));
        }
    }
    let latest = eligible
        .into_iter()
        .max_by(|left, right| crate::replacement::compare(&left.0, &left.1, &right.0, &right.1));
    if let Some((_, event_id, edit)) = latest {
        Ok(MessageProjection {
            original_event_id: original_id.to_hex(),
            deleted: false,
            content: edit.content,
            emoji_tags: edit.emoji_tags,
            applied_edit_id: event_id.to_hex(),
        })
    } else {
        Ok(MessageProjection {
            original_event_id: original_id.to_hex(),
            deleted: false,
            content: original.content().to_owned(),
            emoji_tags: original_view.emoji_tags,
            applied_edit_id: String::new(),
        })
    }
}

fn parse_chat_message(rumor: &NostrRumor) -> Result<ChatMessageView, SoftchatError> {
    if rumor.kind() != NostrEventKind::PRIVATE_DIRECT_MESSAGE {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut participant_count = 0;
    let mut attachment_count = 0;
    let mut emoji_count = 0;
    let mut extension_count = 0;
    let mut unmarked_reply_count = 0;
    let mut marked_reply_count = 0;
    let mut forward_count = 0;
    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => bounded_read_count(&mut participant_count, MAX_CHAT_PARTICIPANTS)?,
            Some("imeta") => bounded_read_count(&mut attachment_count, MAX_CHAT_ATTACHMENTS)?,
            Some("emoji") => bounded_read_count(&mut emoji_count, MAX_CHAT_EMOJI_TAGS)?,
            Some("e") if tag.get(3).map(String::as_str) == Some("reply") => {
                bounded_read_count(&mut marked_reply_count, 1)?;
            }
            Some("e") => bounded_read_count(&mut unmarked_reply_count, 1)?,
            Some("q") => bounded_read_count(&mut forward_count, 1)?,
            _ => bounded_read_count(&mut extension_count, MAX_CHAT_EXTENSION_TAGS)?,
        }
    }
    if participant_count == 0
        || extension_count.saturating_add(unmarked_reply_count) > MAX_CHAT_EXTENSION_TAGS
    {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }

    let mut participants = Vec::with_capacity(participant_count);
    let mut relation = ChatRelation::None;
    let mut legacy_unmarked_e = None;
    let mut attachments = Vec::with_capacity(attachment_count);
    let mut emoji_tags = Vec::with_capacity(emoji_count);
    let mut extension_tags =
        Vec::with_capacity(extension_count.saturating_add(unmarked_reply_count));
    let mut has_subject = false;

    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => participants.push(parse_participant(tag, rumor.public_key())?),
            Some("subject") => {
                has_subject = true;
                extension_tags.push(tag.to_vec());
            }
            Some("e") if tag.len() >= 2 && tag.get(3).map(String::as_str) == Some("reply") => {
                if !matches!(relation, ChatRelation::None) {
                    return Err(SoftchatError::InvalidSoftchatEvent);
                }
                relation = ChatRelation::Reply {
                    event_id: NostrEventId::from_hex(&tag[1])
                        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?,
                    relay_hint: tag
                        .get(2)
                        .and_then(|value| optional_relay_hint(value).ok().flatten()),
                    legacy_unmarked: false,
                };
            }
            Some("e") if tag.len() >= 2 && tag.len() <= 3 => {
                if legacy_unmarked_e.is_some() {
                    return Err(SoftchatError::InvalidSoftchatEvent);
                }
                legacy_unmarked_e = Some((
                    NostrEventId::from_hex(&tag[1])
                        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?,
                    tag.get(2)
                        .and_then(|value| optional_relay_hint(value).ok().flatten()),
                    tag.to_vec(),
                ));
            }
            Some("q") if tag.len() >= 4 => {
                if !matches!(relation, ChatRelation::None) {
                    return Err(SoftchatError::InvalidSoftchatEvent);
                }
                relation = ChatRelation::Forward {
                    event_id: NostrEventId::from_hex(&tag[1])
                        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?,
                    relay_hint: optional_relay_hint(&tag[2]).ok().flatten(),
                    original_author: NostrPublicKey::from_hex(&tag[3])
                        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?,
                };
            }
            Some("imeta") => attachments.push(AttachmentMetadata::from_tag(tag)?),
            Some("emoji") => {
                validate_emoji_tag(tag)?;
                emoji_tags.push(tag.to_vec());
            }
            _ => extension_tags.push(tag.to_vec()),
        }
    }
    participants = validate_read_participants(participants)?;
    if has_subject || (rumor.content().is_empty() && attachments.is_empty()) {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    if matches!(relation, ChatRelation::Forward { .. }) {
        if let Some((legacy_id, _, raw)) = legacy_unmarked_e {
            let forward_id = match &relation {
                ChatRelation::Forward { event_id, .. } => event_id,
                _ => return Err(SoftchatError::InvalidSoftchatEvent),
            };
            if &legacy_id != forward_id {
                return Err(SoftchatError::InvalidSoftchatEvent);
            }
            extension_tags.push(raw);
        }
    } else if let Some((event_id, relay_hint, _)) = legacy_unmarked_e {
        if !matches!(relation, ChatRelation::None) {
            return Err(SoftchatError::InvalidSoftchatEvent);
        }
        relation = ChatRelation::Reply {
            event_id,
            relay_hint,
            legacy_unmarked: true,
        };
    }

    let (relation_kind, related_event_id, relay_hint, original_author) =
        flatten_relation(&relation);
    Ok(ChatMessageView {
        rumor: RumorEvent::from(rumor),
        participants: participants
            .into_iter()
            .map(|public_key| public_key.to_hex())
            .collect(),
        relation_kind,
        related_event_id,
        relay_hint,
        original_author,
        attachments,
        emoji_tags,
        extension_tags,
    })
}

fn parse_subject(rumor: &NostrRumor) -> Result<SubjectView, SoftchatError> {
    if rumor.kind() != NostrEventKind::PRIVATE_DIRECT_MESSAGE || !rumor.content().is_empty() {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut participant_count = 0;
    let mut subject_count = 0;
    let mut emoji_count = 0;
    let mut imeta_count = 0;
    let mut image_count = 0;
    let mut extension_count = 0;
    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => bounded_read_count(&mut participant_count, MAX_CHAT_PARTICIPANTS)?,
            Some("subject") => bounded_read_count(&mut subject_count, 1)?,
            Some("emoji") => bounded_read_count(&mut emoji_count, MAX_CHAT_EMOJI_TAGS)?,
            Some("imeta") => bounded_read_count(&mut imeta_count, 1)?,
            Some("image") => bounded_read_count(&mut image_count, 1)?,
            _ => bounded_read_count(&mut extension_count, MAX_CHAT_EXTENSION_TAGS)?,
        }
    }
    if participant_count == 0 || subject_count != 1 {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }

    let mut participants = Vec::with_capacity(participant_count);
    let mut subject = None;
    let mut emoji_tags = Vec::with_capacity(emoji_count);
    let mut imeta_icon = None;
    let mut image_icon = None;
    let mut extension_tags = Vec::with_capacity(extension_count);
    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => participants.push(parse_participant(tag, rumor.public_key())?),
            Some("subject") if tag.len() == 2 && subject.is_none() => {
                subject = Some(tag[1].clone());
            }
            Some("subject") => return Err(SoftchatError::InvalidSoftchatEvent),
            Some("emoji") => {
                validate_emoji_tag(tag)?;
                emoji_tags.push(tag.to_vec());
            }
            Some("imeta") if imeta_icon.is_none() => {
                let metadata = AttachmentMetadata::from_tag(tag)?;
                imeta_icon = Some((metadata.url, metadata.dimensions.unwrap_or_default()));
            }
            Some("image") if image_icon.is_none() && (tag.len() == 2 || tag.len() == 3) => {
                validate_https(&tag[1])?;
                let dimensions = tag.get(2).cloned().unwrap_or_default();
                if !dimensions.is_empty() {
                    validate_dimensions(&dimensions)?;
                }
                image_icon = Some((tag[1].clone(), dimensions));
            }
            Some("image" | "imeta") => return Err(SoftchatError::InvalidSoftchatEvent),
            _ => extension_tags.push(tag.to_vec()),
        }
    }
    let participants = validate_read_participants(participants)?;
    let subject = subject.ok_or(SoftchatError::InvalidSoftchatEvent)?;
    if imeta_icon.is_some() && image_icon.is_some() && imeta_icon != image_icon {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let (icon_url, icon_dimensions) = imeta_icon.or(image_icon).unwrap_or_default();
    Ok(SubjectView {
        rumor: RumorEvent::from(rumor),
        participants: participants
            .into_iter()
            .map(|public_key| public_key.to_hex())
            .collect(),
        subject,
        icon_url,
        icon_dimensions,
        emoji_tags,
        extension_tags,
    })
}

fn parse_reaction(rumor: &NostrRumor) -> Result<ReactionView, SoftchatError> {
    if rumor.kind() != NostrEventKind::REACTION
        || rumor.content().is_empty()
        || rumor.content().chars().count() > 64
    {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let participant_count = rumor
        .tags()
        .filter(|tag| tag.first().map(String::as_str) == Some("p"))
        .count();
    let emoji_count = rumor
        .tags()
        .filter(|tag| tag.first().map(String::as_str) == Some("emoji"))
        .count();
    if participant_count == 0 || participant_count > MAX_CHAT_PARTICIPANTS || emoji_count > 1 {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let event_id = exactly_one_tag_value(rumor, "e")?;
    let mut event_authors = rumor
        .tags()
        .filter(|tag| tag.first().map(String::as_str) == Some("p"))
        .map(|tag| {
            NostrPublicKey::from_hex(tag.get(1).ok_or(SoftchatError::InvalidSoftchatEvent)?)
                .map(|key| key.to_hex())
                .map_err(|_| SoftchatError::InvalidSoftchatEvent)
        })
        .collect::<Result<Vec<_>, _>>()?;
    event_authors.sort();
    event_authors.dedup();
    if event_authors.is_empty() {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let event_kind = exactly_one_tag_value(rumor, "k")?;
    NostrEventId::from_hex(&event_id).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    let event_kind = event_kind
        .parse::<u32>()
        .ok()
        .and_then(|kind| NostrEventKind::try_from_u32(kind).ok())
        .ok_or(SoftchatError::InvalidSoftchatEvent)?;
    let emoji_tags = rumor
        .tags()
        .filter(|tag| tag.first().map(String::as_str) == Some("emoji"))
        .collect::<Vec<_>>();
    let custom_emoji_url = match emoji_tags.as_slice() {
        [] => String::new(),
        [tag] => {
            validate_emoji_tag(tag)?;
            let expected = format!(":{}:", tag[1]);
            if rumor.content() != expected {
                return Err(SoftchatError::InvalidSoftchatEvent);
            }
            tag[2].clone()
        }
        _ => return Err(SoftchatError::InvalidSoftchatEvent),
    };
    Ok(ReactionView {
        rumor: RumorEvent::from(rumor),
        event_id,
        event_authors,
        event_kind: i32::from(event_kind.as_u16()),
        reaction: rumor.content().to_owned(),
        custom_emoji_url,
    })
}

fn parse_deletion(rumor: &NostrRumor) -> Result<DeletionView, SoftchatError> {
    if rumor.kind() != NostrEventKind::EVENT_DELETION_REQUEST {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let event_id_count = rumor
        .tags()
        .filter(|tag| tag.first().map(String::as_str) == Some("e"))
        .count();
    if event_id_count == 0 || event_id_count > 256 {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut ids = Vec::with_capacity(event_id_count);
    let mut unique = BTreeSet::new();
    for tag in rumor.tags() {
        if tag.first().map(String::as_str) == Some("e") {
            let value = tag.get(1).ok_or(SoftchatError::InvalidSoftchatEvent)?;
            let id =
                NostrEventId::from_hex(value).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
            if !unique.insert(id) {
                return Err(SoftchatError::InvalidSoftchatEvent);
            }
            ids.push(id.to_hex());
        }
    }
    Ok(DeletionView {
        rumor: RumorEvent::from(rumor),
        event_ids: ids,
        reason: rumor.content().to_owned(),
    })
}

fn parse_edit(rumor: &NostrRumor) -> Result<EditView, SoftchatError> {
    if rumor.kind() != NostrEventKind::UPDATED_CONTENT {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut participant_count = 0;
    let mut original_count = 0;
    let mut emoji_count = 0;
    let mut compatibility_count = 0;
    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => bounded_read_count(&mut participant_count, MAX_CHAT_PARTICIPANTS)?,
            Some("e") => bounded_read_count(&mut original_count, 1)?,
            Some("emoji") => bounded_read_count(&mut emoji_count, MAX_CHAT_EMOJI_TAGS)?,
            _ => bounded_read_count(&mut compatibility_count, MAX_CHAT_EXTENSION_TAGS)?,
        }
    }
    if original_count != 1 {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut participants = Vec::with_capacity(participant_count);
    let mut original_event_id = None;
    let mut emoji_tags = Vec::with_capacity(emoji_count);
    let mut compatibility_tags = Vec::with_capacity(compatibility_count);
    for tag in rumor.tags() {
        match tag.first().map(String::as_str) {
            Some("p") => participants.push(parse_participant(tag, rumor.public_key())?),
            Some("e") if original_event_id.is_none() => {
                original_event_id = Some(
                    NostrEventId::from_hex(tag.get(1).ok_or(SoftchatError::InvalidSoftchatEvent)?)
                        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?,
                );
            }
            Some("e") => return Err(SoftchatError::InvalidSoftchatEvent),
            Some("emoji") => {
                validate_emoji_tag(tag)?;
                emoji_tags.push(tag.to_vec());
            }
            _ => compatibility_tags.push(tag.to_vec()),
        }
    }
    let participants = if participants.is_empty() {
        Vec::new()
    } else {
        validate_read_participants(participants)?
    };
    Ok(EditView {
        rumor: RumorEvent::from(rumor),
        original_event_id: original_event_id
            .ok_or(SoftchatError::InvalidSoftchatEvent)?
            .to_hex(),
        participants: participants
            .into_iter()
            .map(|public_key| public_key.to_hex())
            .collect(),
        content: rumor.content().to_owned(),
        emoji_tags,
        compatibility_tags,
    })
}

fn parse_typing(rumor: &NostrRumor) -> Result<TypingView, SoftchatError> {
    if rumor.kind() != NostrEventKind::TYPING || !rumor.content().is_empty() {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let participant_count = rumor.tags().len();
    if participant_count == 0 || participant_count > MAX_CHAT_PARTICIPANTS {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let mut participants = Vec::with_capacity(participant_count);
    for tag in rumor.tags() {
        if tag.first().map(String::as_str) != Some("p") {
            return Err(SoftchatError::InvalidSoftchatEvent);
        }
        participants.push(parse_participant(tag, rumor.public_key())?);
    }
    Ok(TypingView {
        rumor: RumorEvent::from(rumor),
        participants: validate_read_participants(participants)?
            .into_iter()
            .map(|public_key| public_key.to_hex())
            .collect(),
    })
}

fn parse_generic_repost(repost: &SignedNostrEvent) -> Result<GenericRepostView, SoftchatError> {
    if repost.kind() != NostrEventKind::GENERIC_REPOST || repost.content().is_empty() {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    let embedded = SignedNostrEvent::from_json(repost.content())
        .map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    let event_id = exactly_one_signed_tag_value(repost, "e")?;
    let author = exactly_one_signed_tag_value(repost, "p")?;
    let kind = exactly_one_signed_tag_value(repost, "k")?;
    if event_id != embedded.id().to_hex()
        || author != embedded.public_key().to_hex()
        || kind != embedded.kind().as_u16().to_string()
    {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(GenericRepostView {
        repost: SignedEvent::from(repost),
        embedded_event: SignedEvent::from(&embedded),
    })
}

pub(crate) fn prepare_chat_message_draft(
    author: NostrPublicKey,
    draft: ChatMessageDraft,
) -> Result<NostrEventDraft, SoftchatError> {
    let participants = canonical_participants(author, draft.participants)?;
    validate_writer_tags(&draft.emoji_tags, "emoji", MAX_CHAT_EMOJI_TAGS)?;
    validate_extension_tags(&draft.extension_tags)?;
    if draft.attachments.len() > MAX_CHAT_ATTACHMENTS
        || (draft.content.is_empty() && draft.attachments.is_empty())
    {
        return Err(SoftchatError::SoftchatEventCreationFailed);
    }

    let mut tags = participant_tags(&participants)?;
    match draft.relation {
        ChatRelation::None => {}
        ChatRelation::Reply {
            event_id,
            relay_hint,
            legacy_unmarked,
        } => {
            if legacy_unmarked {
                return Err(SoftchatError::SoftchatEventCreationFailed);
            }
            tags.push(NostrTag::new(vec![
                "e".to_owned(),
                event_id.to_hex(),
                relay_hint.unwrap_or_default(),
                "reply".to_owned(),
            ])?);
        }
        ChatRelation::Forward {
            event_id,
            relay_hint,
            original_author,
        } => tags.push(NostrTag::new(vec![
            "q".to_owned(),
            event_id.to_hex(),
            relay_hint.unwrap_or_default(),
            original_author.to_hex(),
        ])?),
    }
    for attachment in draft.attachments {
        tags.push(attachment.to_tag()?);
    }
    tags.extend(draft.emoji_tags);
    tags.extend(draft.extension_tags);
    NostrEventDraft::new(
        draft.created_at,
        NostrEventKind::PRIVATE_DIRECT_MESSAGE,
        tags,
        draft.content,
    )
    .map_err(|_| SoftchatError::SoftchatEventCreationFailed)
}

fn canonical_participants(
    author: NostrPublicKey,
    participants: Vec<NostrPublicKey>,
) -> Result<Vec<NostrPublicKey>, SoftchatError> {
    if participants.is_empty() || participants.len() > MAX_CHAT_PARTICIPANTS {
        return Err(SoftchatError::SoftchatEventCreationFailed);
    }
    let mut participants = participants
        .into_iter()
        .filter(|participant| participant != &author)
        .collect::<Vec<_>>();
    participants.sort_by_key(NostrPublicKey::to_hex);
    let original_len = participants.len();
    participants.dedup();
    if participants.is_empty() || participants.len() != original_len {
        return Err(SoftchatError::SoftchatEventCreationFailed);
    }
    Ok(participants)
}

fn validate_read_participants(
    mut participants: Vec<NostrPublicKey>,
) -> Result<Vec<NostrPublicKey>, SoftchatError> {
    if participants.is_empty() || participants.len() > MAX_CHAT_PARTICIPANTS {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    participants.sort_by_key(NostrPublicKey::to_hex);
    let original_len = participants.len();
    participants.dedup();
    if participants.len() != original_len {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(participants)
}

fn bounded_read_count(count: &mut usize, maximum: usize) -> Result<(), SoftchatError> {
    *count = count
        .checked_add(1)
        .filter(|value| *value <= maximum)
        .ok_or(SoftchatError::InvalidSoftchatEvent)?;
    Ok(())
}

fn participant_tags(participants: &[NostrPublicKey]) -> Result<Vec<NostrTag>, SoftchatError> {
    participants
        .iter()
        .map(|participant| NostrTag::new(vec!["p".to_owned(), participant.to_hex()]))
        .collect()
}

fn parse_participant(
    tag: &[String],
    author: NostrPublicKey,
) -> Result<NostrPublicKey, SoftchatError> {
    let public_key =
        NostrPublicKey::from_hex(tag.get(1).ok_or(SoftchatError::InvalidSoftchatEvent)?)
            .map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    if public_key == author {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(public_key)
}

fn flatten_relation(relation: &ChatRelation) -> (ChatRelationKind, String, String, String) {
    match relation {
        ChatRelation::None => (
            ChatRelationKind::None,
            String::new(),
            String::new(),
            String::new(),
        ),
        ChatRelation::Reply {
            event_id,
            relay_hint,
            legacy_unmarked,
        } => (
            if *legacy_unmarked {
                ChatRelationKind::LegacyReply
            } else {
                ChatRelationKind::Reply
            },
            event_id.to_hex(),
            relay_hint.clone().unwrap_or_default(),
            String::new(),
        ),
        ChatRelation::Forward {
            event_id,
            relay_hint,
            original_author,
        } => (
            ChatRelationKind::Forward,
            event_id.to_hex(),
            relay_hint.clone().unwrap_or_default(),
            original_author.to_hex(),
        ),
    }
}

fn optional_relay_hint(value: &str) -> Result<Option<String>, SoftchatError> {
    if value.is_empty() {
        return Ok(None);
    }
    let url = Url::parse(value).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    if !matches!(url.scheme(), "ws" | "wss") || url.host_str().is_none() || url.fragment().is_some()
    {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(Some(value.to_owned()))
}

fn validate_writer_tags(
    tags: &[NostrTag],
    expected_name: &str,
    maximum: usize,
) -> Result<(), SoftchatError> {
    if tags.len() > maximum
        || tags
            .iter()
            .any(|tag| tag.values().first().map(String::as_str) != Some(expected_name))
    {
        return Err(SoftchatError::SoftchatEventCreationFailed);
    }
    if expected_name == "emoji" {
        for tag in tags {
            validate_emoji_tag(tag.values())?;
        }
    }
    Ok(())
}

fn validate_extension_tags(tags: &[NostrTag]) -> Result<(), SoftchatError> {
    if tags.len() > MAX_CHAT_EXTENSION_TAGS
        || tags.iter().any(|tag| {
            matches!(
                tag.values().first().map(String::as_str),
                Some("p" | "e" | "q" | "subject" | "imeta" | "image" | "emoji")
            )
        })
    {
        return Err(SoftchatError::SoftchatEventCreationFailed);
    }
    Ok(())
}

fn validate_emoji_tag(tag: &[String]) -> Result<(), SoftchatError> {
    if tag.len() != 3 || tag[1].is_empty() || tag[1].contains(':') {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    validate_https(&tag[2])
}

fn validate_https(value: &str) -> Result<(), SoftchatError> {
    let url = Url::parse(value).map_err(|_| SoftchatError::InvalidSoftchatEvent)?;
    if url.scheme() != "https" || url.host_str().is_none() || url.fragment().is_some() {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(())
}

fn validate_dimensions(value: &str) -> Result<(), SoftchatError> {
    let (width, height) = value
        .split_once('x')
        .ok_or(SoftchatError::InvalidSoftchatEvent)?;
    if width
        .parse::<u32>()
        .ok()
        .filter(|value| *value > 0)
        .is_none()
        || height
            .parse::<u32>()
            .ok()
            .filter(|value| *value > 0)
            .is_none()
    {
        return Err(SoftchatError::InvalidSoftchatEvent);
    }
    Ok(())
}

fn exactly_one_tag_value(rumor: &NostrRumor, name: &str) -> Result<String, SoftchatError> {
    exactly_one_value(rumor.tags(), name)
}

fn exactly_one_signed_tag_value(
    event: &SignedNostrEvent,
    name: &str,
) -> Result<String, SoftchatError> {
    exactly_one_value(event.tags(), name)
}

fn exactly_one_value<'a>(
    tags: impl Iterator<Item = &'a [String]>,
    name: &str,
) -> Result<String, SoftchatError> {
    let values = tags
        .filter(|tag| tag.first().map(String::as_str) == Some(name))
        .map(|tag| {
            tag.get(1)
                .cloned()
                .ok_or(SoftchatError::InvalidSoftchatEvent)
        })
        .collect::<Result<Vec<_>, _>>()?;
    match values.as_slice() {
        [value] => Ok(value.clone()),
        _ => Err(SoftchatError::InvalidSoftchatEvent),
    }
}

#[cfg(test)]
mod tests {
    use std::collections::BTreeMap;

    use serde::Deserialize;

    use super::*;

    const ALICE_SECRET: &str = "5c0c523f52a5b6fad39ed2403092df8cebc36318b39383bca6c00808626fab3a";
    const BOB_SECRET: &str = "4b22aa260e4acb7021e32f38a6cdf4b673c6a277755bfce287e370c924dc936d";
    const ANDROID_SHAPES: &str =
        include_str!("../../../fixtures/softchat/released/android-event-shapes.json");
    const IOS_SHAPES: &str =
        include_str!("../../../fixtures/softchat/released/ios-event-shapes.json");

    #[derive(Deserialize)]
    struct Shape {
        kind: u16,
        content: String,
        tags: Vec<Vec<String>>,
    }

    #[derive(Deserialize)]
    struct ReleasedShapes {
        author: String,
        shapes: BTreeMap<String, Shape>,
    }

    fn identity_pair() -> Result<(LocalIdentity, LocalIdentity), SoftchatError> {
        Ok((
            LocalIdentity::from_secret_hex(ALICE_SECRET)?,
            LocalIdentity::from_secret_hex(BOB_SECRET)?,
        ))
    }

    fn rumor_from_shape(
        fixture: &str,
        name: &str,
    ) -> Result<NostrRumor, Box<dyn std::error::Error>> {
        let fixture: ReleasedShapes = serde_json::from_str(fixture)?;
        let shape = fixture
            .shapes
            .get(name)
            .ok_or(SoftchatError::InvalidSoftchatEvent)?;
        let (alice, bob) = identity_pair()?;
        let carol = LocalIdentity::from_secret_hex(
            "8f40e50a84a7462e2b8d24c28898ef1f23359fff50d8c509e6fb7ce06e142f9c",
        )?;
        let replacements = BTreeMap::from([
            (fixture.author.clone(), alice.public_key().to_hex()),
            (
                "2886780f7349afc1344047524540ee716f7bdc1b64191699855662330bf235d8".to_owned(),
                bob.public_key().to_hex(),
            ),
            (
                "918e2da906df4ccd12c8ac672d8335add131a4cf9d27ce42b3bb3625755f0788".to_owned(),
                carol.public_key().to_hex(),
            ),
        ]);
        let tags = shape
            .tags
            .iter()
            .cloned()
            .map(|tag| {
                tag.into_iter()
                    .map(|value| replacements.get(&value).cloned().unwrap_or(value))
                    .collect::<Vec<_>>()
            })
            .map(NostrTag::new)
            .collect::<Result<Vec<_>, _>>()?;
        Ok(NostrRumor::new(
            alice.public_key(),
            NostrEventDraft::new(
                1_700_000_000,
                NostrEventKind::from_u16(shape.kind),
                tags,
                shape.content.clone(),
            )?,
        )?)
    }

    #[test]
    fn creates_group_reply_and_sender_copy_inputs_in_canonical_order() -> Result<(), SoftchatError>
    {
        let (alice, bob) = identity_pair()?;
        let carol = LocalIdentity::from_secret_hex(
            "8f40e50a84a7462e2b8d24c28898ef1f23359fff50d8c509e6fb7ce06e142f9c",
        )?;
        let parent = NostrEventId::from_hex(
            "44900586091b284416a0c001f677f9c49f7639a55c3f1e2ec130a8e1a7998e1b",
        )?;
        let view = alice.create_chat_message(ChatMessageDraft {
            created_at: 1,
            participants: vec![carol.public_key(), bob.public_key()],
            content: "reply".to_owned(),
            relation: ChatRelation::Reply {
                event_id: parent,
                relay_hint: Some("wss://relay.example".to_owned()),
                legacy_unmarked: false,
            },
            attachments: Vec::new(),
            emoji_tags: Vec::new(),
            extension_tags: Vec::new(),
        })?;
        assert_eq!(view.participants.len(), 2);
        assert_eq!(view.relation_kind, ChatRelationKind::Reply);
        assert_eq!(view.rumor.tags[2][3], "reply");
        Ok(())
    }

    #[test]
    fn reads_released_android_and_ios_subject_reply_forward_and_edit_shapes()
    -> Result<(), Box<dyn std::error::Error>> {
        let android_subject = parse_subject(&rumor_from_shape(ANDROID_SHAPES, "subject")?)?;
        let ios_subject = parse_subject(&rumor_from_shape(IOS_SHAPES, "subject")?)?;
        assert_eq!(android_subject.subject, ios_subject.subject);
        assert_eq!(android_subject.icon_url, ios_subject.icon_url);

        let android_reply = parse_chat_message(&rumor_from_shape(ANDROID_SHAPES, "reply")?)?;
        let ios_reply = parse_chat_message(&rumor_from_shape(IOS_SHAPES, "reply")?)?;
        assert_eq!(android_reply.relation_kind, ChatRelationKind::LegacyReply);
        assert_eq!(ios_reply.relation_kind, ChatRelationKind::Reply);
        assert_eq!(android_reply.related_event_id, ios_reply.related_event_id);

        let android_forward = parse_chat_message(&rumor_from_shape(ANDROID_SHAPES, "forward")?)?;
        let ios_forward = parse_chat_message(&rumor_from_shape(IOS_SHAPES, "forward")?)?;
        assert_eq!(android_forward.relation_kind, ChatRelationKind::Forward);
        assert_eq!(
            android_forward.related_event_id,
            ios_forward.related_event_id
        );
        assert_eq!(android_forward.original_author, ios_forward.original_author);

        let android_edit = parse_edit(&rumor_from_shape(ANDROID_SHAPES, "edit")?)?;
        let ios_edit = parse_edit(&rumor_from_shape(IOS_SHAPES, "edit")?)?;
        assert_eq!(android_edit.content, ios_edit.content);
        assert!(!android_edit.compatibility_tags.is_empty());
        assert!(ios_edit.compatibility_tags.is_empty());
        Ok(())
    }

    #[test]
    fn reaction_deletion_typing_and_projection_enforce_authorization() -> Result<(), SoftchatError>
    {
        let (alice, bob) = identity_pair()?;
        let original = alice.create_chat_message(ChatMessageDraft {
            created_at: 1,
            participants: vec![bob.public_key()],
            content: "before".to_owned(),
            relation: ChatRelation::None,
            attachments: Vec::new(),
            emoji_tags: Vec::new(),
            extension_tags: Vec::new(),
        })?;
        let original_id = NostrEventId::from_hex(&original.rumor.id)?;
        let edit = alice.create_edit(
            vec![bob.public_key()],
            original_id,
            "after".to_owned(),
            Vec::new(),
            2,
        )?;
        let projected =
            project_chat_message(original.rumor.clone(), vec![edit.rumor.clone()], Vec::new())?;
        assert_eq!(projected.content, "after");
        assert!(!projected.applied_edit_id.is_empty());

        let tied_first = alice.create_edit(
            vec![bob.public_key()],
            original_id,
            "tied alpha".to_owned(),
            Vec::new(),
            5,
        )?;
        let tied_second = alice.create_edit(
            vec![bob.public_key()],
            original_id,
            "tied beta".to_owned(),
            Vec::new(),
            5,
        )?;
        let expected_id = std::cmp::min(tied_first.rumor.id.clone(), tied_second.rumor.id.clone());
        for order in [
            vec![tied_first.rumor.clone(), tied_second.rumor.clone()],
            vec![tied_second.rumor.clone(), tied_first.rumor.clone()],
        ] {
            assert_eq!(
                project_chat_message(original.rumor.clone(), order, Vec::new())?.applied_edit_id,
                expected_id
            );
        }

        let delete =
            alice.create_deletion(vec![bob.public_key()], vec![original_id], String::new(), 3)?;
        assert!(
            project_chat_message(original.rumor, vec![edit.rumor], vec![delete.rumor])?.deleted
        );

        let reaction = bob.create_reaction(ReactionDraft {
            participants: vec![alice.public_key()],
            parent_id: original_id,
            parent_author: alice.public_key(),
            parent_kind: NostrEventKind::PRIVATE_DIRECT_MESSAGE,
            reaction: "👍".to_owned(),
            custom_emoji_url: None,
            created_at: 2,
        })?;
        assert_eq!(reaction.reaction, "👍");
        let own_message_reaction = alice.create_reaction(ReactionDraft {
            participants: vec![bob.public_key()],
            parent_id: original_id,
            parent_author: alice.public_key(),
            parent_kind: NostrEventKind::PRIVATE_DIRECT_MESSAGE,
            reaction: "❤️".to_owned(),
            custom_emoji_url: None,
            created_at: 3,
        })?;
        assert_eq!(own_message_reaction.reaction, "❤️");
        let outsider = LocalIdentity::from_secret_hex(
            "8f40e50a84a7462e2b8d24c28898ef1f23359fff50d8c509e6fb7ce06e142f9c",
        )?;
        assert_eq!(
            alice.create_reaction(ReactionDraft {
                participants: vec![bob.public_key()],
                parent_id: original_id,
                parent_author: outsider.public_key(),
                parent_kind: NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                reaction: "👎".to_owned(),
                custom_emoji_url: None,
                created_at: 3,
            }),
            Err(SoftchatError::SoftchatEventCreationFailed)
        );
        assert_eq!(
            alice.create_typing(vec![bob.public_key()], 4)?.participants,
            vec![bob.public_key().to_hex()]
        );
        Ok(())
    }

    #[test]
    fn generic_repost_requires_verified_matching_embedded_event() -> Result<(), SoftchatError> {
        let (alice, _) = identity_pair()?;
        let embedded = alice.sign_event(NostrEventDraft::new(
            1,
            NostrEventKind::SHORT_TEXT_NOTE,
            Vec::new(),
            "embedded",
        )?)?;
        let repost = alice.sign_event(NostrEventDraft::new(
            2,
            NostrEventKind::GENERIC_REPOST,
            vec![
                NostrTag::new(vec!["e".to_owned(), embedded.id().to_hex()])?,
                NostrTag::new(vec!["p".to_owned(), embedded.public_key().to_hex()])?,
                NostrTag::new(vec!["k".to_owned(), embedded.kind().as_u16().to_string()])?,
            ],
            embedded.to_json()?,
        )?)?;
        assert_eq!(
            parse_generic_repost(&repost)?.embedded_event.id,
            embedded.id().to_hex()
        );
        Ok(())
    }

    #[test]
    fn readers_reject_collections_above_canonical_writer_caps() -> Result<(), SoftchatError> {
        let (alice, bob) = identity_pair()?;
        let participant = NostrTag::new(vec!["p", &bob.public_key().to_hex()])?;
        let rumor = |kind, tags: Vec<NostrTag>, content: &str| {
            alice.create_rumor(NostrEventDraft::new(1, kind, tags, content)?)
        };

        let mut attachment_tags = vec![participant.clone()];
        attachment_tags.extend(
            (0..=MAX_CHAT_ATTACHMENTS)
                .map(|index| {
                    NostrTag::new(vec![
                        "imeta".to_owned(),
                        format!("url https://media.example/{index}"),
                    ])
                })
                .collect::<Result<Vec<_>, _>>()?,
        );
        assert!(matches!(
            parse_chat_message(&rumor(
                NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                attachment_tags,
                "attachments",
            )?),
            Err(SoftchatError::InvalidSoftchatEvent)
        ));

        let mut emoji_tags = vec![participant.clone()];
        emoji_tags.extend(
            (0..=MAX_CHAT_EMOJI_TAGS)
                .map(|index| {
                    NostrTag::new(vec![
                        "emoji".to_owned(),
                        format!("emoji{index}"),
                        format!("https://emoji.example/{index}.png"),
                    ])
                })
                .collect::<Result<Vec<_>, _>>()?,
        );
        assert!(matches!(
            parse_chat_message(&rumor(
                NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                emoji_tags,
                "emoji",
            )?),
            Err(SoftchatError::InvalidSoftchatEvent)
        ));

        let mut extension_tags = vec![participant.clone()];
        extension_tags.extend(
            (0..=MAX_CHAT_EXTENSION_TAGS)
                .map(|index| NostrTag::new(vec![format!("x{index}")]))
                .collect::<Result<Vec<_>, _>>()?,
        );
        assert!(matches!(
            parse_chat_message(&rumor(
                NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                extension_tags,
                "extensions",
            )?),
            Err(SoftchatError::InvalidSoftchatEvent)
        ));

        let mut subject_tags = vec![
            participant.clone(),
            NostrTag::new(vec!["subject", "bounded"])?,
        ];
        subject_tags.extend(
            (0..=MAX_CHAT_EXTENSION_TAGS)
                .map(|index| NostrTag::new(vec![format!("subject-x{index}")]))
                .collect::<Result<Vec<_>, _>>()?,
        );
        assert!(matches!(
            parse_subject(&rumor(
                NostrEventKind::PRIVATE_DIRECT_MESSAGE,
                subject_tags,
                "",
            )?),
            Err(SoftchatError::InvalidSoftchatEvent)
        ));

        let original_id = "00".repeat(32);
        let mut edit_tags = vec![participant, NostrTag::new(vec!["e", &original_id])?];
        edit_tags.extend(
            (0..=MAX_CHAT_EMOJI_TAGS)
                .map(|index| {
                    NostrTag::new(vec![
                        "emoji".to_owned(),
                        format!("edit{index}"),
                        format!("https://emoji.example/edit-{index}.png"),
                    ])
                })
                .collect::<Result<Vec<_>, _>>()?,
        );
        assert!(matches!(
            parse_edit(&rumor(NostrEventKind::UPDATED_CONTENT, edit_tags, "edit")?),
            Err(SoftchatError::InvalidSoftchatEvent)
        ));
        Ok(())
    }
}