ComposeViewModel.swift

import Foundation
import Observation
import CoreGraphics
import SwiftUI
import PhotosUI

@Observable
@MainActor
final class ComposeViewModel {
    let keypair: Keypair
    /// The account that will sign and publish the post. Defaults to `keypair`
    /// but can be changed mid-compose without affecting the globally active account.
    var signingKeypair: Keypair
    /// Mode is mutable because loading a draft can switch a `.new` composer into
    /// a `.reply` based on the draft's reconstructed `e`/`p` tags.
    var mode: ComposeMode

    // MARK: - Editable state

    var content: String = ""
    var galleryMode: Bool = false
    var explicit: Bool = false
    var powEnabled: Bool = PowPreferences.snapshot().noteEnabled
    /// True when the user has toggled "Private" in a reply composer. Routes
    /// publish through `PrivateReplyPublisher` (NIP-17 gift wrap) instead of
    /// the public kind-1 pipeline. Only meaningful in `.reply` mode — the
    /// view hides the toggle in `.new` / `.quote`.
    var isPrivate: Bool = false
    /// True when the parent of a reply is itself private — the toggle is then
    /// pre-set to ON and the user can't toggle it off (turning the chain
    /// public mid-thread would leak the rumor id into a public kind-1).
    var isPrivateLocked: Bool = false

    var attachments: [ComposeAttachment] = []
    var mentions: [InsertedMention] = []
    var hashtags: [String] = []

    // MARK: - Poll state (NIP-88 / NIP-69)

    var pollEnabled: Bool = false
    var pollOptions: [String] = ["", ""]
    var pollType: Nip88.PollType = .singlechoice
    var isZapPoll: Bool = false
    var zapPollMinSats: Int? = nil
    var zapPollMaxSats: Int? = nil
    var pollEndsAt: Int? = nil

    // MARK: - Autocomplete state

    var mentionQuery: String?
    var mentionCandidates: [MentionCandidate] = []
    /// True while the NIP-50 relay lookup is in flight after the local
    /// search has returned (no follows match). The view surfaces a
    /// "Searching…" row so the user can tell the popup is working on
    /// something rather than assuming the autocomplete is broken — relay
    /// queries take 1-3 s vs the instant follows search.
    var isMentionSearchingRemote: Bool = false
    var emojiQuery: String?
    var emojiCandidates: [CustomEmoji] = []

    // MARK: - Publish lifecycle

    var isPublishing: Bool = false
    var isMining: Bool = false
    var miningAttempts: Int = 0
    var uploadProgress: String?
    var countdownSeconds: Int?
    var countdownTotalSeconds: Int = 10
    var countdownStartedAt: Date?
    var lastError: String?
    var publishedEventId: String?

    // MARK: - Drafts & scheduling

    /// Set when the composer is opened from an existing draft. Reused on
    /// subsequent saves so the same `d` tag updates the same draft.
    var currentDraftId: String?
    /// When non-nil, publish goes to the scheduler relay with this `created_at`.
    var scheduleAt: Date?
    /// Set after a successful `saveDraft()` — UI uses this to dismiss.
    var draftSaved: Bool = false
    /// True once the user has explicitly chosen to discard via the Cancel dialog.
    /// Suppresses the auto-save-on-disappear path.
    var explicitlyDiscarded: Bool = false

    var scheduleEnabled: Bool { scheduleAt != nil }
    /// True when there is text/content the user might lose if the sheet is dismissed.
    /// Counts uploaded attachments too — picking an image and swipe-dismissing should
    /// still autosave the draft even if the user hasn't typed anything yet.
    var hasUnsavedContent: Bool {
        if !content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { return true }
        return attachments.contains { $0.url != nil }
    }

    // MARK: - Private

    @ObservationIgnored private var blossomServers: [String] = [BlossomServerList.defaultServer]
    @ObservationIgnored private var blossomLoaded = false
    @ObservationIgnored private var countdownTask: Task<Void, Never>?
    @ObservationIgnored private var publishContinuation: CheckedContinuation<Void, Never>?
    @ObservationIgnored private var mineTask: Task<Void, Never>?
    /// Debounce handle for social-preview cache warming. Cancelled and
    /// recreated on each content change so a URL typed character by
    /// character doesn't fan out a fetch for every partial fragment.
    @ObservationIgnored private var socialPreviewPrefetchTask: Task<Void, Never>?
    @ObservationIgnored private var autosaveTask: Task<Void, Never>?
    private var powDifficulty: Int { PowPreferences.shared.noteDifficulty }

    /// Track mention triggers via a sentinel index into the content string. When the
    /// `@` signal is active this is the UTF-16 offset of the `@` character.
    @ObservationIgnored private var mentionStartUtf16: Int?
    @ObservationIgnored private var mentionEndUtf16: Int?
    @ObservationIgnored private var emojiStartUtf16: Int?
    @ObservationIgnored private var mentionRemoteTask: Task<Void, Never>?

    // MARK: - Init

    init(keypair: Keypair, mode: ComposeMode = .new, initialText: String = "") {
        self.keypair = keypair
        self.signingKeypair = keypair
        self.mode = mode
        // If we're composing a reply to a rumor the user already has marked
        // private, force the privacy toggle on and lock it. This keeps the
        // whole chain encrypted — a public reply mid-chain would leak the
        // rumor id into a publicly indexed kind-1 event.
        if case .reply(let parent, _) = mode,
           PrivateInteractionStore.shared.contains(parent.id) {
            isPrivate = true
            isPrivateLocked = true
        }
        // Reply / quote drafts are keyed per-parent so closing a half-typed reply
        // and reopening the same parent restores the body. The quote URI is still
        // spliced at publish time, and reply context still lives in tags — only
        // the editor body is restored.
        loadLocalAutosave()
        if !initialText.isEmpty { content = initialText }
    }

    // MARK: - Local autosave (instant restore on reopen)

    /// Per-pubkey, per-mode UserDefaults bucket. Reply and quote drafts are keyed
    /// by the parent / quoted event id so each conversation has its own slot.
    private var autosaveKey: String {
        // Local autosave is a "I closed the composer by accident, give
        // me back my text" recovery mechanism — it belongs to the
        // human at the device (the logged-in `keypair`), not to the
        // temporary signing identity. Switching the per-compose signer
        // doesn't move the draft. The NIP-37 published draft variant
        // below DOES use `signingKeypair` because that draft represents
        // a relay-side artifact attributable to whoever will sign the
        // final post.
        switch mode {
        case .new:
            return "compose_autosave_new_\(keypair.pubkey)"
        case .reply(let parent, _):
            return "compose_autosave_reply_\(keypair.pubkey)_\(parent.id)"
        case .quote(let event):
            return "compose_autosave_quote_\(keypair.pubkey)_\(event.id)"
        }
    }

    func writeLocalAutosave() {
        // Don't autosave when editing a saved draft — the draft is the source of truth
        // and writes go through `saveDraft()`. Otherwise opening a draft would clobber
        // the composer's autosave with the draft's content.
        guard currentDraftId == nil else { return }
        // Private replies never persist a local draft. The buffer disappears on
        // sheet dismissal — sending a private reply later means retyping. The
        // alternative (a UserDefaults bucket holding the intended-private body)
        // would survive cleartext on disk, which violates the privacy intent.
        if isPrivate { return }
        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
        let uploaded = attachments.filter { $0.url != nil }
        guard !trimmed.isEmpty || !uploaded.isEmpty else {
            UserDefaults.standard.removeObject(forKey: autosaveKey)
            return
        }
        var payload: [String: Any] = [
            "content": content,
            "explicit": explicit,
            "powEnabled": powEnabled
        ]
        if let ts = scheduleAt?.timeIntervalSince1970 {
            payload["scheduleAt"] = ts
        }
        let mentionDicts: [[String: String]] = mentions.map { ["displayName": $0.displayName, "pubkey": $0.pubkey] }
        if !mentionDicts.isEmpty {
            payload["mentions"] = mentionDicts
        }
        let attachmentDicts: [[String: Any]] = uploaded.map { a in
            var d: [String: Any] = [
                "url": a.url ?? "",
                "mime": a.mime,
                "dimW": a.dim.width,
                "dimH": a.dim.height
            ]
            if let h = a.sha256Hex { d["sha256"] = h }
            if let s = a.durationSec { d["duration"] = s }
            return d
        }
        if !attachmentDicts.isEmpty {
            payload["attachments"] = attachmentDicts
        }
        UserDefaults.standard.set(payload, forKey: autosaveKey)
    }

    /// Debounced entry point for the per-keystroke autosave triggers. The
    /// compose `TextEditor` binds through a custom `Binding`; running the
    /// `UserDefaults` serialization synchronously inside the keystroke commit
    /// transaction destabilises the editor and leaves a phantom caret on the
    /// previously typed word. Coalescing the write off the keystroke avoids it.
    func scheduleLocalAutosave() {
        autosaveTask?.cancel()
        autosaveTask = Task { @MainActor [weak self] in
            try? await Task.sleep(for: .milliseconds(400))
            guard !Task.isCancelled else { return }
            self?.writeLocalAutosave()
        }
    }

    /// Cancel any pending debounced write and persist immediately. Called from
    /// the view's `onDisappear` so a swipe-dismiss right after the last
    /// keystroke still flushes the autosave bucket for the reopen path.
    func flushLocalAutosave() {
        autosaveTask?.cancel()
        autosaveTask = nil
        writeLocalAutosave()
    }

    func clearLocalAutosave() {
        autosaveTask?.cancel()
        autosaveTask = nil
        UserDefaults.standard.removeObject(forKey: autosaveKey)
    }

    private func loadLocalAutosave() {
        guard let payload = UserDefaults.standard.dictionary(forKey: autosaveKey) else { return }
        let saved = payload["content"] as? String ?? ""
        let restored: [ComposeAttachment] = (payload["attachments"] as? [[String: Any]] ?? []).compactMap { d in
            guard let url = d["url"] as? String, !url.isEmpty else { return nil }
            let mime = d["mime"] as? String ?? "image/jpeg"
            let w = d["dimW"] as? Double ?? 0
            let h = d["dimH"] as? Double ?? 0
            return ComposeAttachment(
                id: UUID(),
                url: url,
                mime: mime,
                dim: CGSize(width: w, height: h),
                durationSec: d["duration"] as? Int,
                sha256Hex: d["sha256"] as? String,
                localBytes: nil
            )
        }
        let restoredMentions: [InsertedMention] = (payload["mentions"] as? [[String: String]] ?? []).compactMap { d in
            guard let dn = d["displayName"], let pk = d["pubkey"] else { return nil }
            return InsertedMention(displayName: dn, pubkey: pk)
        }
        guard !saved.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || !restored.isEmpty else { return }
        content = saved
        attachments = restored
        mentions = restoredMentions
        explicit = payload["explicit"] as? Bool ?? false
        powEnabled = payload["powEnabled"] as? Bool ?? powEnabled
        if let ts = payload["scheduleAt"] as? TimeInterval {
            scheduleAt = Date(timeIntervalSince1970: ts)
        }
    }

    // MARK: - Account selection

    /// All saved accounts that can sign (excludes watch-only).
    var availableSigningAccounts: [Keypair] {
        NostrKey.accounts()
            .filter { !NostrKey.isWatchOnly(pubkey: $0) }
            .compactMap { NostrKey.loadAccount(pubkey: $0) }
    }

    /// Switch the signing identity for this compose session without affecting
    /// the globally active account. Blossom server list is refreshed for the
    /// new account; current editor text is preserved.
    func switchSigningAccount(_ newKeypair: Keypair) {
        signingKeypair = newKeypair
        blossomServers = BlossomServerList.cached(for: newKeypair.pubkey)
        Task { [pubkey = newKeypair.pubkey] in
            let fresh = await BlossomServerList.refresh(for: pubkey)
            await MainActor.run { self.blossomServers = fresh }
        }
        // Profiles for secondary accounts may not be in the in-memory
        // cache yet — kick a fetch so the header avatar / display name
        // resolve instead of falling back to person.fill + short-npub.
        Task { [pubkey = newKeypair.pubkey] in
            _ = await ProfileRepository.shared.ensure([pubkey])
        }
    }

    // MARK: - Lifecycle

    func start() async {
        if !blossomLoaded {
            blossomServers = BlossomServerList.cached(for: signingKeypair.pubkey)
            blossomLoaded = true
            // Refresh in the background; first composer open after install hits the network.
            Task { [pubkey = signingKeypair.pubkey] in
                let fresh = await BlossomServerList.refresh(for: pubkey)
                await MainActor.run { self.blossomServers = fresh }
            }
        }
        Task { await EmojiRepository.shared.refresh(for: keypair.pubkey) }
        // Pre-warm follow profiles so @-mention search can match by name
        // even for follows whose kind-0 hasn't been pulled in by the feed
        // path yet. Without this, MentionSearch falls through to the npub
        // fallback for unloaded follows and can't match user-typed names.
        let follows = FollowsCache.shared.follows(for: keypair.pubkey)
        if !follows.isEmpty {
            Task { _ = await ProfileRepository.shared.ensure(follows) }
        }
        // Pre-warm profiles for every signable account so the composer
        // avatar (and the account-picker menu) show the right name +
        // picture from the moment the composer opens — instead of
        // falling through to the npub placeholder for accounts whose
        // kind-0 hasn't landed in this install yet.
        let signers = availableSigningAccounts.map(\.pubkey)
        if !signers.isEmpty {
            Task { _ = await ProfileRepository.shared.ensure(signers) }
        }
        // Default mention popup state: empty until the user types `@`.
    }

    // MARK: - Toggles

    func toggleGallery() {
        guard mode.allowsGalleryToggle else { return }
        galleryMode.toggle()
        if galleryMode { pollEnabled = false }
    }

    func toggleNsfw() { explicit.toggle() }
    func togglePow() { powEnabled.toggle() }
    /// Toggle the "Private" reply state. No-op when locked (replying to a
    /// rumor that's already private) — the chain stays encrypted end-to-end.
    func togglePrivate() {
        guard !isPrivateLocked else { return }
        isPrivate.toggle()
    }

    // MARK: - Poll mutation

    func togglePoll() {
        guard mode.allowsPollToggle else { return }
        pollEnabled.toggle()
        if pollEnabled { galleryMode = false }
    }

    func updatePollOption(at index: Int, _ text: String) {
        guard pollOptions.indices.contains(index) else { return }
        pollOptions[index] = text
    }

    func addPollOption() {
        guard pollOptions.count < 10 else { return }
        pollOptions.append("")
    }

    func removePollOption(at index: Int) {
        guard pollOptions.count > 2, pollOptions.indices.contains(index) else { return }
        pollOptions.remove(at: index)
    }

    func togglePollType() {
        pollType = (pollType == .singlechoice) ? .multiplechoice : .singlechoice
    }

    func toggleZapPoll() {
        isZapPoll.toggle()
        // Zap polls are always single-choice (Android forces this).
        if isZapPoll { pollType = .singlechoice }
    }

    func setPollEndsAt(_ ts: Int?) {
        pollEndsAt = ts
    }

    // MARK: - Content mutation

    /// Called from the SwiftUI text-field binding. Re-derives mention/emoji/hashtag state.
    func updateContent(_ new: String) {
        // Auto-prefix bare bech32 (`nevent1...`, `note1...`, `nprofile1...`, `npub1...`) with `nostr:`.
        let prefixed = autoPrefixBareBech32(new)
        if prefixed != content {
            content = prefixed
        } else {
            content = new
        }
        // Rehydrate `nostr:nprofile1...` / `nostr:npub1...` pastes into the
        // `@displayName + mentions[]` form so they render as pills. Cheap
        // guard avoids the regex on every keystroke; only runs when a paste
        // actually introduces the URI form.
        if content.contains("nostr:") {
            rehydrateMentionsFromContent()
        }
        recomputeHashtags()
    }

    /// Insert text at the cursor (delegated by the view via a coordinator that knows the
    /// caret). For simplicity v1 appends at end if cursor unknown.
    func append(_ text: String) {
        content += text
        recomputeHashtags()
    }

    // MARK: - Mentions

    /// Caller (the view) reports the substring after `@` and the offset of the `@` itself.
    /// Pass `nil` to dismiss the popup.
    func updateMentionTrigger(query: String?, atOffsetUtf16: Int?, endUtf16: Int? = nil) {
        mentionStartUtf16 = atOffsetUtf16
        mentionEndUtf16 = endUtf16
        mentionQuery = query
        mentionRemoteTask?.cancel()
        guard let query else {
            mentionCandidates = []
            isMentionSearchingRemote = false
            return
        }
        mentionCandidates = MentionSearch.search(query: query, currentUserPubkey: keypair.pubkey)
        // Only fire the relay fallback when the query is long enough to
        // disambiguate and not yet served locally. `searchRemote` itself
        // gates on `.count >= 2`, but checking here too avoids spinning
        // up the loading spinner for `@s` only to clear it instantly.
        let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
        guard trimmed.count >= 2 else {
            isMentionSearchingRemote = false
            return
        }
        // Surface a "Searching…" row so the user can tell the popup is
        // working on something — relay queries take 1-3 s vs the instant
        // follows search and look broken without an affordance.
        isMentionSearchingRemote = true
        // The local pass is follows-only and only sees cached kind-0s, so an
        // account the author doesn't follow yet (e.g. a fresh handle typed
        // from memory) never appears. Fall back to a NIP-50 relay lookup,
        // debounced so we don't fire a query per keystroke and guarded
        // against staleness so a slow reply can't replace a newer query's
        // results. 200 ms gives a typical typist time to add one more
        // letter without firing two relay queries.
        let pubkey = keypair.pubkey
        mentionRemoteTask = Task { @MainActor [weak self] in
            try? await Task.sleep(for: .milliseconds(200))
            guard !Task.isCancelled, let self, self.mentionQuery == query else { return }
            let existing = Set(self.mentionCandidates.map(\.pubkey))
            let remote = await MentionSearch.searchRemote(
                query: query,
                currentUserPubkey: pubkey,
                excluding: existing
            )
            guard !Task.isCancelled, self.mentionQuery == query else { return }
            self.isMentionSearchingRemote = false
            guard !remote.isEmpty else { return }
            let known = Set(self.mentionCandidates.map(\.pubkey))
            self.mentionCandidates.append(contentsOf: remote.filter { !known.contains($0.pubkey) })
        }
    }

    func selectMention(_ candidate: MentionCandidate) {
        guard let startOffset = mentionStartUtf16 else { return }
        let displayName = sanitizeDisplayName(candidate.name)
        let view = content.utf16
        guard startOffset >= 0, startOffset <= view.count else { return }
        let startIdx = view.index(view.startIndex, offsetBy: startOffset)
        // Replace from `@` to end of current word (we use end-of-string as the cursor proxy
        // when the view doesn't tell us otherwise — close enough for v1).
        let replacement = "@\(displayName) "
        let prefix = String(view[..<startIdx])!
        let _ = replacement
        let _ = prefix
        // Actual replacement: replace from `startIdx` to end of the buffer back to where
        // the user's cursor is. We approximate by replacing up to the next whitespace
        // or end of string.
        let s = content
        guard let stringStart = s.utf16.index(s.utf16.startIndex, offsetBy: startOffset, limitedBy: s.utf16.endIndex),
              let stringStartIdx = String.Index(stringStart, within: s) else { return }
        // Use the stored cursor position as the replacement end when available
        // (handles multi-word queries with spaces). Fall back to forward-scanning
        // for callers that don't supply endUtf16.
        var end: String.Index
        if let endOffset = mentionEndUtf16,
           let endUtf16Idx = s.utf16.index(s.utf16.startIndex, offsetBy: endOffset, limitedBy: s.utf16.endIndex),
           let endIdx = String.Index(endUtf16Idx, within: s),
           endIdx >= stringStartIdx {
            end = endIdx
        } else {
            end = stringStartIdx
            while end < s.endIndex, !s[end].isMentionTokenBreak { end = s.index(after: end) }
        }
        var newContent = s
        newContent.replaceSubrange(stringStartIdx..<end, with: "@\(displayName) ")
        content = newContent
        mentions.append(InsertedMention(displayName: displayName, pubkey: candidate.pubkey))
        mentionRemoteTask?.cancel()
        mentionQuery = nil
        mentionCandidates = []
        isMentionSearchingRemote = false
        mentionStartUtf16 = nil
        mentionEndUtf16 = nil
        recomputeHashtags()
    }

    // MARK: - Emoji

    func updateEmojiTrigger(query: String?, atOffsetUtf16: Int?) {
        emojiStartUtf16 = atOffsetUtf16
        emojiQuery = query
        if let query {
            emojiCandidates = EmojiRepository.shared.search(query: query)
        } else {
            emojiCandidates = []
        }
    }

    func selectEmoji(_ emoji: CustomEmoji) {
        guard let startOffset = emojiStartUtf16 else { return }
        content = EmojiShortcode.insert(emoji.shortcode, into: content, atUtf16: startOffset)
        emojiQuery = nil
        emojiCandidates = []
        emojiStartUtf16 = nil
        recomputeHashtags()
    }

    // MARK: - Media

    /// Pick from `PhotosPickerItem` inputs, decode, compress, and upload to Blossom.
    /// Updates `attachments` and `uploadProgress` as work proceeds.
    func addMedia(items: [PhotosPickerItem]) async {
        guard !items.isEmpty else { return }
        uploadProgress = items.count > 1 ? "Loading \(items.count) items…" : "Loading…"
        defer { if uploadProgress != nil { uploadProgress = nil } }
        let pickResults = await MediaPicker.loadAll(items)
        await uploadPickedMedia(pickResults)
    }

    /// Pick from `NSItemProvider` inputs delivered by `PHPickerViewController`.
    /// Same end-to-end pipeline as `addMedia(items:)`; the only difference is
    /// the loader path. Used by the UIKit `PhotosPickerPresenter` bridge that
    /// avoids SwiftUI's sheet-cascade dismissal bug on compose.
    func addMediaProviders(_ providers: [NSItemProvider]) async {
        guard !providers.isEmpty else { return }
        uploadProgress = providers.count > 1 ? "Loading \(providers.count) items…" : "Loading…"
        defer { if uploadProgress != nil { uploadProgress = nil } }
        let pickResults = await MediaPicker.loadAll(providers: providers)
        await uploadPickedMedia(pickResults)
    }

    private func uploadPickedMedia(_ pickResults: [PickedMedia]) async {
        guard !pickResults.isEmpty else { return }
        let total = pickResults.count
        var uploaded = 0
        for picked in pickResults {
            let pendingId = UUID()
            let pendingMime = picked.mime
            let pendingDim = picked.dim
            var pendingDuration = picked.durationSec
            // For videos `picked.data` is a poster JPEG, not the full clip.
            let thumbBytes: Data? = picked.isVideo ? (picked.data.isEmpty ? nil : picked.data) : picked.data

            let pending = ComposeAttachment(
                id: pendingId,
                url: nil,
                mime: pendingMime,
                dim: pendingDim,
                durationSec: pendingDuration,
                sha256Hex: nil,
                localBytes: thumbBytes
            )
            attachments.append(pending)

            do {
                let prepared: (Data, String, CGSize)
                if picked.isVideo {
                    guard let sourceURL = picked.sourceURL else {
                        attachments.removeAll { $0.id == pendingId }
                        lastError = "Couldn't read picked video."
                        continue
                    }
                    uploadProgress = total > 1
                        ? "Compressing video \(uploaded + 1)/\(total)…"
                        : "Compressing video…"
                    do {
                        let r = try await MediaCompressor.compressVideo(sourceURL: sourceURL)
                        prepared = (r.data, r.mime, r.dim != .zero ? r.dim : pendingDim)
                        if let d = r.durationSec { pendingDuration = d }
                    } catch {
                        attachments.removeAll { $0.id == pendingId }
                        lastError = "Video compression failed: \(error)"
                        continue
                    }
                    uploadProgress = total > 1 ? "Uploading \(uploaded + 1)/\(total)…" : "Uploading…"
                } else {
                    uploadProgress = total > 1 ? "Uploading \(uploaded + 1)/\(total)…" : "Uploading…"
                    let r = MediaCompressor.compressImage(data: picked.data, mime: pendingMime)
                    prepared = (r.data, r.mime, r.dim)
                }
                let result = try await BlossomClient.upload(
                    bytes: prepared.0,
                    mime: prepared.1,
                    servers: blossomServers,
                    keypair: signingKeypair
                )
                if let idx = attachments.firstIndex(where: { $0.id == pendingId }) {
                    attachments[idx] = ComposeAttachment(
                        id: pendingId,
                        url: result.url,
                        mime: prepared.1,
                        dim: prepared.2,
                        durationSec: pendingDuration,
                        sha256Hex: result.sha256Hex,
                        localBytes: nil
                    )
                }
                uploaded += 1
            } catch {
                attachments.removeAll { $0.id == pendingId }
                lastError = "Upload failed: \(error)"
            }
        }
        uploadProgress = nil
    }

    func removeMedia(at offsets: IndexSet) {
        attachments.remove(atOffsets: offsets)
    }

    func removeMedia(id: UUID) {
        attachments.removeAll { $0.id == id }
    }

    /// Handle images from a SwiftUI `.onPasteCommand([UTType.image])` callback.
    /// Each provider is loaded to bytes, compressed, and uploaded to Blossom — same
    /// pipeline as the photo picker. In non-gallery mode the resulting URL is also
    /// appended to the post body so it shows up in the live preview alongside the
    /// attachment thumbnail.
    func addPastedImages(_ providers: [NSItemProvider]) async {
        guard !providers.isEmpty else { return }
        uploadProgress = providers.count > 1 ? "Loading \(providers.count) images…" : "Loading…"
        defer { if uploadProgress != nil { uploadProgress = nil } }

        var loaded: [(data: Data, mime: String)] = []
        for provider in providers {
            if let result = await loadPastedImageData(from: provider) {
                loaded.append(result)
            }
        }
        guard !loaded.isEmpty else { return }

        let total = loaded.count
        for (i, item) in loaded.enumerated() {
            await uploadImageBytes(data: item.data, mime: item.mime, progressIndex: i, total: total)
        }
        uploadProgress = nil
    }

    /// Preference order matters: Safari's "Copy Image" on an animated GIF
    /// publishes BOTH `com.compuserve.gif` and `public.png` representations,
    /// and we have to read the GIF first or the PNG (frame zero) wins and
    /// the animation is gone before bytes ever reach the compressor.
    /// Animated formats first, then static.
    private static let pasteImageTypes: [(typeId: String, mime: String)] = [
        ("com.compuserve.gif", "image/gif"),
        ("org.webmproject.webp", "image/webp"),
        ("public.png", "image/png"),
        ("public.jpeg", "image/jpeg"),
        ("public.heic", "image/heic")
    ]

    private func loadPastedImageData(from provider: NSItemProvider) async -> (data: Data, mime: String)? {
        // Source URL preserves animation when the inline bytes do not.
        // Most browsers rasterize images on "Copy Image" — Chromium for
        // example only writes `public.png` (frame zero of the source GIF)
        // even when the source was animated. Fetching the original URL
        // sidesteps that and gets the bytes the server actually serves.
        let sourceUrl = await pasteboardSourceImageUrl(from: provider)
        var inline: (data: Data, mime: String)?
        for entry in Self.pasteImageTypes where provider.hasItemConformingToTypeIdentifier(entry.typeId) {
            if let data = await loadDataRepresentation(from: provider, typeIdentifier: entry.typeId) {
                inline = (data, entry.mime)
                break
            }
        }
        // Inline bytes already animated → no need to hit the network.
        if let inline, MediaCompressor.isAnimated(inline.data) {
            return inline
        }
        // Try the source URL when the inline bytes are static (or absent)
        // and the URL looks like it might be image-flavoured. We trust the
        // fetched bytes when they're animated; otherwise stick with whatever
        // the clipboard provided so we don't pay a network round-trip for a
        // worse result.
        if let sourceUrl, let fetched = await fetchUrlImageBytes(sourceUrl) {
            if MediaCompressor.isAnimated(fetched.data) {
                return fetched
            }
            if inline == nil {
                return fetched
            }
        }
        if let inline { return inline }
        // Fallback for type-id-less providers (rare): re-encode anything decodable as JPEG.
        if let data = await loadDataRepresentation(from: provider, typeIdentifier: "public.image"),
           let img = UIImage(data: data),
           let jpeg = img.jpegData(compressionQuality: 0.92) {
            return (jpeg, "image/jpeg")
        }
        return nil
    }

    /// UTIs that browsers / share extensions use to carry the source URL of
    /// a copied image. Checked in order; first hit wins.
    private static let pasteSourceUrlTypeIds: [String] = [
        "org.chromium.source-url",
        "public.url",
        "public.utf8-plain-text"
    ]

    private func pasteboardSourceImageUrl(from provider: NSItemProvider) async -> URL? {
        for typeId in Self.pasteSourceUrlTypeIds where provider.hasItemConformingToTypeIdentifier(typeId) {
            guard let data = await loadDataRepresentation(from: provider, typeIdentifier: typeId) else { continue }
            guard let string = String(data: data, encoding: .utf8)?
                .trimmingCharacters(in: .whitespacesAndNewlines),
                  !string.isEmpty else { continue }
            guard let url = URL(string: string), let scheme = url.scheme?.lowercased(),
                  scheme == "https" || scheme == "http" else { continue }
            return url
        }
        return nil
    }

    private func fetchUrlImageBytes(_ url: URL) async -> (data: Data, mime: String)? {
        var req = URLRequest(url: url)
        req.setValue("image/*", forHTTPHeaderField: "Accept")
        req.timeoutInterval = 10
        do {
            let (data, response) = try await URLSession.shared.data(for: req)
            guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else { return nil }
            // Trust the server's Content-Type only when it's an image MIME;
            // otherwise sniff the bytes so a `text/html` redirect page doesn't
            // get uploaded as an image.
            let serverMime = (http.value(forHTTPHeaderField: "Content-Type") ?? "")
                .split(separator: ";").first.map { String($0).trimmingCharacters(in: .whitespaces) } ?? ""
            let mime: String
            if serverMime.hasPrefix("image/") {
                mime = serverMime
            } else if let sniffed = sniffImageMime(data) {
                mime = sniffed
            } else {
                return nil
            }
            return (data, mime)
        } catch {
            return nil
        }
    }

    /// Magic-byte sniff for the formats our compressor handles. Used when the
    /// server doesn't send a useful `Content-Type` header (e.g. CDNs that
    /// return `application/octet-stream`).
    private func sniffImageMime(_ data: Data) -> String? {
        guard data.count >= 12 else { return nil }
        let p = data.prefix(12)
        if p.starts(with: [0x47, 0x49, 0x46]) { return "image/gif" }
        if p.starts(with: [0x89, 0x50, 0x4E, 0x47]) { return "image/png" }
        if p.starts(with: [0xFF, 0xD8, 0xFF]) { return "image/jpeg" }
        if p.starts(with: [0x52, 0x49, 0x46, 0x46]) && p.dropFirst(8).starts(with: [0x57, 0x45, 0x42, 0x50]) {
            return "image/webp"
        }
        return nil
    }

    private func loadDataRepresentation(from provider: NSItemProvider, typeIdentifier: String) async -> Data? {
        await withCheckedContinuation { cont in
            provider.loadDataRepresentation(forTypeIdentifier: typeIdentifier) { data, _ in
                cont.resume(returning: data)
            }
        }
    }

    private func uploadImageBytes(data: Data, mime: String, progressIndex: Int, total: Int) async {
        let pendingId = UUID()
        let compressed = MediaCompressor.compressImage(data: data, mime: mime)
        let pending = ComposeAttachment(
            id: pendingId,
            url: nil,
            mime: compressed.mime,
            dim: compressed.dim,
            durationSec: nil,
            sha256Hex: nil,
            localBytes: data
        )
        attachments.append(pending)
        uploadProgress = total > 1 ? "Uploading \(progressIndex + 1)/\(total)…" : "Uploading…"
        do {
            let result = try await BlossomClient.upload(
                bytes: compressed.data,
                mime: compressed.mime,
                servers: blossomServers,
                keypair: signingKeypair
            )
            if let idx = attachments.firstIndex(where: { $0.id == pendingId }) {
                attachments[idx] = ComposeAttachment(
                    id: pendingId,
                    url: result.url,
                    mime: compressed.mime,
                    dim: compressed.dim,
                    durationSec: nil,
                    sha256Hex: result.sha256Hex,
                    localBytes: nil
                )
            }
        } catch {
            attachments.removeAll { $0.id == pendingId }
            lastError = "Upload failed: \(error)"
        }
    }

    /// Re-host a GIF picked from Giphy on the user's Blossom servers, then
    /// append the resulting URL to the post body. Falls back to the original
    /// Giphy URL if the rehost fails so the user always gets a working link.
    func attachGifFromGiphy(_ giphyURL: String) async {
        uploadProgress = "Uploading GIF…"
        defer { uploadProgress = nil }
        let outcome = await GifBlossomUploader.rehost(
            giphyURL: giphyURL,
            keypair: signingKeypair,
            servers: blossomServers
        )
        if !content.isEmpty, !content.hasSuffix("\n") { content += "\n" }
        content += outcome.url
        content += "\n"
        if !outcome.didRehost {
            lastError = "Couldn't re-host GIF on your Blossom server — using the Giphy link instead."
        }
    }

    // MARK: - Publish

    /// Begin the 10-second undo countdown. Caller must keep the view alive — the
    /// publish fires after the timer elapses unless `cancelPublish()` is called.
    /// When `scheduleAt` is set, the countdown is skipped (no rush — the
    /// scheduler relay holds the post until the chosen time).
    func publish() {
        guard countdownSeconds == nil, !isPublishing else { return }
        if let validation = validate() {
            lastError = validation
            return
        }
        lastError = nil
        if scheduleEnabled {
            // Flip `isPublishing` synchronously so the button shows the
            // spinner the moment the user taps. The pipeline's own
            // `isPublishing = true` becomes a no-op; the `defer` still
            // resets it on completion.
            isPublishing = true
            Task { await runPublishPipeline() }
            return
        }
        // Resolve the user's undo-timer preference. Replies opt out by
        // default — the default user wants confirmation on top-level posts
        // but expects replies to send immediately like a chat.
        let settings = AppSettings.shared
        let isReply: Bool = { if case .reply = mode { return true } else { return false } }()
        let useTimer = settings.postUndoTimerEnabled && (!isReply || settings.postUndoTimerForReplies)
        guard useTimer, settings.postUndoTimerSeconds > 0 else {
            isPublishing = true
            Task { await runPublishPipeline() }
            return
        }
        let totalSeconds = settings.postUndoTimerSeconds
        // Show the countdown UI synchronously — without this the button
        // stays on "Publish" until the Task scheduled below first runs,
        // which on a busy main actor reads as a 1–2 s no-op.
        countdownSeconds = totalSeconds
        countdownTotalSeconds = totalSeconds
        countdownStartedAt = Date()
        countdownTask = Task { @MainActor [weak self] in
            guard let self else { return }
            for n in stride(from: totalSeconds - 1, through: 1, by: -1) {
                do {
                    try await Task.sleep(for: .seconds(1))
                } catch {
                    return
                }
                self.countdownSeconds = n
            }
            do {
                try await Task.sleep(for: .seconds(1))
            } catch {
                return
            }
            self.countdownSeconds = nil
            self.countdownStartedAt = nil
            await self.runPublishPipeline()
        }
    }

    func publishNow() {
        countdownTask?.cancel()
        countdownTask = nil
        countdownSeconds = nil
        countdownStartedAt = nil
        Task { await runPublishPipeline() }
    }

    func cancelPublish() {
        countdownTask?.cancel()
        countdownTask = nil
        countdownSeconds = nil
        countdownStartedAt = nil
        mineTask?.cancel()
        mineTask = nil
        isPublishing = false
        isMining = false
        miningAttempts = 0
    }

    // MARK: - Drafts

    /// Hydrate the composer from a previously saved draft. Reply context is
    /// reconstructed from the draft's `e` and `p` tags — when the parent event
    /// isn't in cache we synthesize a stub `NostrEvent` with id+pubkey only,
    /// matching the Android client's behavior.
    func loadDraft(_ draft: Nip37.Draft) {
        currentDraftId = draft.dTag
        // Restore the composer mode from the draft's inner kind. Kind 20
        // (NIP-68 picture) and 21 / 22 (NIP-71 short-form video) round-trip
        // as gallery posts; kind 1 stays in text mode. Without this, a
        // gallery draft would silently reopen in text mode and republish
        // as a kind-1 note with the URLs spliced into the body.
        let isGalleryKind = (draft.innerKind == Nip68.kindPicture
                             || draft.innerKind == Nip71.kindVideoHorizontal
                             || draft.innerKind == Nip71.kindVideoVertical)
        if isGalleryKind && mode.allowsGalleryToggle {
            galleryMode = true
        }
        let imetaAttachments = Self.parseImetaAttachments(tags: draft.tags)
        if !imetaAttachments.isEmpty {
            // Imeta tags carry full attachment metadata (mime, dim, hash), so the
            // round-trip is exact; the body stays as the user typed it.
            content = draft.content
            attachments = imetaAttachments
        } else {
            // Legacy drafts (saved before the imeta round-trip landed, or by other
            // clients) put the URLs at the end of the body — peel them back off.
            let (body, restoredAttachments) = Self.splitDraftBody(draft.content)
            content = body
            attachments = restoredAttachments
        }
        recomputeHashtags()

        // Mentions persist in the body as `nostr:nprofile1...` URIs. Convert
        // each back to `@displayName` and seed `mentions` so the rich editor
        // can render them as pills — without this, drafts come back as raw
        // bech32 strings even though the on-disk format is identical to what
        // `materializeMentions` produces for a fresh post. `materializeMentions`
        // at publish time will turn them back into URIs, so this is a pure
        // display rehydrate.
        rehydrateMentionsFromContent()

        // Reconstruct reply context from draft tags (Android: Navigation.kt:989).
        let replyTag = draft.tags.first(where: {
            $0.count >= 4 && $0[0] == "e" && $0[3] == "reply"
        })
        let rootTag = draft.tags.first(where: {
            $0.count >= 4 && $0[0] == "e" && $0[3] == "root"
        })
        let parentTag = replyTag ?? rootTag ?? draft.tags.first(where: {
            $0.count >= 2 && $0[0] == "e"
        })
        if let parentTag, parentTag.count >= 2 {
            let parentId = parentTag[1]
            let parentAuthor = draft.tags.first(where: { $0.count >= 2 && $0[0] == "p" })?[1] ?? ""
            let parentStub = NostrEvent(
                id: parentId, pubkey: parentAuthor, kind: 1,
                createdAt: 0, tags: [], content: "", sig: ""
            )
            let rootStub: NostrEvent? = {
                guard let rootTag, rootTag.count >= 2, rootTag[1] != parentId else { return nil }
                return NostrEvent(
                    id: rootTag[1], pubkey: parentAuthor, kind: 1,
                    createdAt: 0, tags: [], content: "", sig: ""
                )
            }()
            mode = .reply(parent: parentStub, root: rootStub)
        } else if let quoteTag = draft.tags.first(where: { $0.count >= 2 && $0[0] == "q" }) {
            let quotedId = quoteTag[1]
            let quotedAuthor = draft.tags.first(where: { $0.count >= 2 && $0[0] == "p" })?[1] ?? ""
            let stub = NostrEvent(
                id: quotedId, pubkey: quotedAuthor, kind: 1,
                createdAt: 0, tags: [], content: "", sig: ""
            )
            mode = .quote(stub)
        }
    }

    /// Save the current buffer as a NIP-37 draft. Idempotent for a given
    /// `currentDraftId` — calling repeatedly updates the same `d` tag.
    /// Sets `draftSaved = true` on success so the view can dismiss.
    /// Returns the persisted `Nip37.Draft` on success, or nil when nothing was
    /// saved (empty buffer) or a relay error occurred. Callers use the returned
    /// draft to wire a "Draft saved → tap to reopen" toast.
    @discardableResult
    func saveDraft() async -> Nip37.Draft? {
        // Drafts publish a kind 31234 NIP-37 wrapper to the user's relays. A
        // private reply explicitly opted out of that — refuse to save a draft
        // whose intent was to never touch public infrastructure.
        if isPrivate { return nil }
        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
        let uploaded = attachments.filter { $0.url != nil }
        guard !trimmed.isEmpty || !uploaded.isEmpty else { return nil }

        let dTag = currentDraftId ?? Nip37.newDraftId()
        currentDraftId = dTag

        let materialized = materializeMentions(content)
        // Inner kind matches the post the draft will publish as: 1 for a
        // text post, 20 (NIP-68 picture) or 21 / 22 (NIP-71 horizontal /
        // vertical short-form video) for a gallery post. The wrapper's
        // `["k", ...]` tag preserves it across the round-trip so
        // `loadDraft` can restore the correct composer mode (text vs
        // gallery) instead of silently dropping the gallery state.
        // **Android counterpart needed**: Android's draft save currently
        // hard-codes kind-1; needs the same treatment to keep gallery
        // drafts round-trippable across clients.
        let innerKind = determineKind()
        var innerTags: [[String]] = buildBaseTags(kind: innerKind, materializedContent: materialized)
        // Strip `client` and the publish-time `imeta`; we rebuild `imeta` below from the
        // composer's `attachments` so reopening the draft restores the thumbnail row.
        innerTags = innerTags.filter { tag in
            guard let key = tag.first else { return false }
            return key != "client" && key != "imeta"
        }
        for attachment in uploaded {
            guard let url = attachment.url else { continue }
            var imeta: [String] = ["imeta", "url \(url)"]
            imeta.append("m \(attachment.mime)")
            if attachment.dim != .zero {
                imeta.append("dim \(Int(attachment.dim.width))x\(Int(attachment.dim.height))")
            }
            if let hash = attachment.sha256Hex { imeta.append("x \(hash)") }
            if let d = attachment.durationSec { imeta.append("duration \(d)") }
            innerTags.append(imeta)
        }

        let now = NostrClock.now()
        let innerJSON = Nip37.serializeInner(
            pubkeyHex: signingKeypair.pubkey, innerKind: innerKind,
            content: materialized, tags: innerTags, createdAt: now
        )
        // NIP-37 encrypts the inner event to the user's own pubkey. For a
        // remote-signer account this is a NIP-44 round-trip to the signer;
        // for a local key it computes the conversation key in-process.
        let cipher: String
        do {
            cipher = try await Signer.nip44Encrypt(
                keypair: signingKeypair,
                peerPubkey: signingKeypair.pubkey,
                plaintext: innerJSON
            )
        } catch {
            lastError = "Failed to encrypt draft."
            return nil
        }
        let wrapperTags = Nip37.wrapperTags(dTag: dTag, innerKind: innerKind)
        let wrapper: NostrEvent
        do {
            wrapper = try await Signer.sign(
                keypair: signingKeypair,
                kind: Nip37.kindDraft,
                tags: wrapperTags,
                content: cipher,
                createdAt: now
            )
        } catch {
            lastError = "Failed to sign draft."
            return nil
        }

        let relays = topWriteRelays()
        let succeeded = await RelayPool.publish(event: wrapper, to: relays, timeout: 8)
        guard !succeeded.isEmpty else {
            lastError = "Couldn't reach a relay to save the draft."
            return nil
        }
        draftSaved = true
        return Nip37.Draft(
            dTag: dTag,
            innerKind: innerKind,
            content: materialized,
            tags: innerTags,
            createdAt: now,
            wrapperEventId: wrapper.id
        )
    }

    /// Mark the active draft as deleted by publishing an empty-content NIP-37
    /// replacement under the same `d` tag. Called after a successful publish
    /// of the underlying note so the draft doesn't linger.
    private func clearDraftOnPublish() async {
        guard let dTag = currentDraftId else { return }
        currentDraftId = nil
        let now = NostrClock.now()
        let innerJSON = Nip37.serializeInner(
            pubkeyHex: signingKeypair.pubkey, innerKind: 1, content: "", tags: [], createdAt: now
        )
        guard let cipher = try? await Signer.nip44Encrypt(
            keypair: signingKeypair,
            peerPubkey: signingKeypair.pubkey,
            plaintext: innerJSON
        ) else { return }
        guard let wrapper = try? await Signer.sign(
            keypair: signingKeypair,
            kind: Nip37.kindDraft,
            tags: Nip37.wrapperTags(dTag: dTag, innerKind: 1),
            content: cipher,
            createdAt: now
        ) else { return }
        _ = await RelayPool.publish(event: wrapper, to: topWriteRelays(), timeout: 6)
    }

    // MARK: - Scheduling

    func setSchedule(_ date: Date?) {
        scheduleAt = date
    }

    /// True when the composer has enough content to publish. Drives the
    /// Publish button's enabled state — the user shouldn't be able to
    /// tap a button that will immediately error out with "Type something
    /// first." Mirrors the success conditions in `validate()`, minus the
    /// transitional "Wait for uploads to finish" case: a partial upload
    /// counts as content (the user clearly intends to post something);
    /// the validator catches the not-ready-yet state on tap.
    var canPublish: Bool {
        if pollEnabled {
            let nonBlank = pollOptions
                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
                .filter { !$0.isEmpty }
            if nonBlank.count < 2 { return false }
            if content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { return false }
            return true
        }
        if galleryMode {
            return !attachments.isEmpty
        }
        let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
        return !trimmed.isEmpty || !attachments.isEmpty
    }

    // MARK: - Internals

    private func validate() -> String? {
        if pollEnabled {
            let nonBlank = pollOptions
                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
                .filter { !$0.isEmpty }
            if nonBlank.count < 2 { return "Add at least 2 poll options." }
            if nonBlank.count > 10 { return "Maximum 10 poll options." }
            let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
            if trimmed.isEmpty { return "Add a poll question." }
            return nil
        }
        if galleryMode {
            if attachments.isEmpty || attachments.contains(where: { $0.url == nil }) {
                return "Add at least one image or video."
            }
        } else {
            let trimmed = content.trimmingCharacters(in: .whitespacesAndNewlines)
            if attachments.contains(where: { $0.url == nil }) { return "Wait for uploads to finish." }
            if trimmed.isEmpty && attachments.isEmpty { return "Type something first." }
        }
        return nil
    }

    private func runPublishPipeline() async {
        isPublishing = true
        defer { isPublishing = false }

        // Private-reply branch: skip the public kind-1 pipeline entirely. We
        // also skip PoW (gift wraps don't benefit from spam mining the same
        // way), scheduling (no scheduler relay accepts kind-1059 wraps), and
        // attachment URL splicing (the rumor body == typed content, with any
        // URLs already inline via the composer).
        if case .reply(let parent, let root) = mode, isPrivate {
            await runPrivateReplyPipeline(parent: parent, root: root)
            return
        }

        let kind = determineKind()
        let materialized = materializeMentions(content)
        let tags = buildBaseTags(kind: kind, materializedContent: materialized)
        let postContent = bodyForPublish(kind: kind, materialized: materialized)

        // Scheduled posts route through the scheduler relay synchronously — the
        // sheet stays open until the relay ack returns. PoW + scheduling don't
        // mix (mining mutates `created_at`), so PoW is silently skipped here.
        if let scheduleTimestamp = scheduleAt.map({ Int($0.timeIntervalSince1970) }) {
            await runScheduledPublish(
                kind: kind, tags: tags, content: postContent, createdAt: scheduleTimestamp
            )
            return
        }

        // Normal post: hand off to PostPublisher so the sheet can dismiss
        // immediately while mining + broadcasting run in the background.
        let createdAt = NostrClock.now()
        let draft = PreparedDraft(
            kind: kind,
            tags: tags,
            createdAt: createdAt,
            content: postContent,
            signingKeypair: signingKeypair,
            powEnabled: powEnabled,
            powDifficulty: powDifficulty,
            relays: topWriteRelays(),
            autosaveKeyToClear: autosaveKey,
            draftIdToClear: currentDraftId
        )
        currentDraftId = nil
        // Stand up the optimistic feed row before handing off — the sheet
        // dismisses immediately after this call, so the row needs to be in
        // the store by the time the home feed re-renders. The row dissolves
        // when the real published event arrives via `.nostrEventPublished`,
        // or flips to a failed state if PostPublisher reports an error.
        PendingPostStore.shared.start(
            content: postContent,
            tags: tags,
            pubkey: signingKeypair.pubkey,
            kind: kind
        )
        PostPublisher.shared.submit(draft)
        Haptics.shared.pulse()
        // Any non-nil id triggers the sheet's dismiss observer. The actual event
        // id isn't known yet (PoW + signing happen in the publisher), and the
        // existing observers that key off `publishedEventId` don't read it.
        publishedEventId = "handed-off"
    }

    private func runScheduledPublish(kind: Int, tags: [[String]], content: String, createdAt: Int) async {
        let event: NostrEvent
        do {
            event = try await Signer.sign(
                keypair: signingKeypair,
                kind: kind,
                tags: tags,
                content: content,
                createdAt: createdAt
            )
        } catch {
            lastError = "Signing failed: \(error)"
            return
        }
        let relay = DraftsViewModel.schedulerRelay
        await GroupRelayPool.shared.ensureRelay(relay, keypair: signingKeypair)
        let result = await GroupRelayPool.shared.publishWithAuthRetry(event, to: relay)
        switch result {
        case .ok, .duplicate:
            publishedEventId = event.id
            clearLocalAutosave()
            await clearDraftOnPublish()
            Haptics.shared.pulse()
        default:
            lastError = "Scheduler relay rejected the post."
        }
    }

    /// Send a private reply via NIP-17 gift wrap. Bypasses the public kind-1
    /// publish path entirely — the synthetic rumor event is delivered to the
    /// recipient's + sender's DM relays only. The local thread / notification
    /// surfaces pick up the rumor via `PrivateInteractionRouter` (on echo) and
    /// via the `.nostrEventPublished` broadcast the publisher emits.
    private func runPrivateReplyPipeline(parent: NostrEvent, root: NostrEvent?) async {
        let materialized = materializeMentions(content)
        let body = appendQuoteUri(to: appendAttachmentUrls(to: materialized))

        // Build the rumor's extra tag set: mentions, pubkey refs from inline
        // nostr URIs, hashtags, and the client tag. NIP-10 e/p tags are added
        // inside the publisher via `Nip10.buildReplyTags` — passing them here
        // would just be deduplicated against the canonical set.
        var extras: [[String]] = []
        var existingP = Set<String>()
        for tag in Nip10.buildReplyTags(replyTo: parent, relayHint: "") where tag.count >= 2 && tag[0] == "p" {
            existingP.insert(tag[1])
        }
        for mention in mentions where !existingP.contains(mention.pubkey) {
            extras.append(["p", mention.pubkey])
            existingP.insert(mention.pubkey)
        }
        for pk in extractProfilePubkeys(materialized) where !existingP.contains(pk) {
            extras.append(["p", pk])
            existingP.insert(pk)
        }
        for tag in hashtags { extras.append(["t", tag]) }
        extras.append(contentsOf: EmojiShortcode.emojiTags(in: body))
        if let clientTag = NostrEvent.clientTagIfEnabled() { extras.append(clientTag) }

        do {
            let synthetic = try await PrivateReplyPublisher.send(
                keypair: keypair,
                parent: parent,
                root: root,
                content: body,
                extraTags: extras
            )
            clearLocalAutosave()
            // Drafts and private replies don't mix — but if a user toggled
            // private on top of a draft-restored composer, surface the same
            // post-publish cleanup so the draft entry doesn't linger.
            await clearDraftOnPublish()
            publishedEventId = synthetic.id
            Haptics.shared.pulse()
        } catch PrivateReplyPublisher.SendError.noRecipientRelays {
            lastError = "Recipient has no DM relays."
        } catch PrivateReplyPublisher.SendError.noOwnRelays {
            lastError = "Add a DM relay in settings to send private replies."
        } catch PrivateReplyPublisher.SendError.wrapFailed {
            lastError = "Failed to encrypt the private reply."
        } catch let PrivateReplyPublisher.SendError.publishFailed(recipientTried, ownTried) {
            lastError = "No relay accepted the private reply (tried \(recipientTried) recipient relays, \(ownTried) own relays). Check the Xcode console for per-relay rejection reasons."
        } catch {
            lastError = "Failed to send private reply: \(error)"
        }
    }

    private func determineKind() -> Int {
        if pollEnabled {
            return isZapPoll ? Nip69.kindZapPoll : Nip88.kindPoll
        }
        guard galleryMode else { return 1 }
        if attachments.contains(where: { $0.isVideo }) {
            // Pick orientation from the first video.
            if let video = attachments.first(where: { $0.isVideo }) {
                return Nip71.kindFor(width: Int(video.dim.width), height: Int(video.dim.height))
            }
            return Nip71.kindVideoVertical
        }
        return Nip68.kindPicture
    }

    /// For regular notes the body is the materialized content with attachment URLs
    /// spliced onto the end (in `attachments` order). For gallery events the body
    /// is just the caption — upload URLs ride in `imeta` tags instead.
    private func bodyForPublish(kind: Int, materialized: String) -> String {
        switch kind {
        case Nip68.kindPicture, Nip71.kindVideoHorizontal, Nip71.kindVideoVertical:
            return materialized
        default:
            return appendQuoteUri(to: appendAttachmentUrls(to: materialized))
        }
    }

    private func appendAttachmentUrls(to body: String) -> String {
        appendUrls(to: body, urls: attachments.compactMap { $0.url })
    }

    private func appendUrls(to body: String, urls: [String]) -> String {
        guard !urls.isEmpty else { return body }
        var out = body
        for url in urls {
            if !out.isEmpty, !out.hasSuffix("\n") { out += "\n" }
            out += url
        }
        return out
    }

    /// Parse `imeta` tags from a draft into `ComposeAttachment` entries. Mirror of the
    /// imeta builder in `saveDraft`: each tag's `url`, `m`, `dim`, `x`, `duration`
    /// sub-entries become attachment fields.
    static func parseImetaAttachments(tags: [[String]]) -> [ComposeAttachment] {
        tags.compactMap { tag in
            guard tag.first == "imeta", tag.count > 1 else { return nil }
            var url: String? = nil
            var mime: String? = nil
            var dim: CGSize = .zero
            var hash: String? = nil
            var durationSec: Int? = nil
            for entry in tag.dropFirst() {
                if let value = entry.split(separator: " ", maxSplits: 1).last.map(String.init) {
                    if entry.hasPrefix("url ") { url = value }
                    else if entry.hasPrefix("m ") { mime = value }
                    else if entry.hasPrefix("dim ") {
                        let parts = value.split(separator: "x")
                        if parts.count == 2, let w = Double(parts[0]), let h = Double(parts[1]) {
                            dim = CGSize(width: w, height: h)
                        }
                    }
                    else if entry.hasPrefix("x ") { hash = value }
                    else if entry.hasPrefix("duration ") { durationSec = Int(value) }
                }
            }
            guard let url else { return nil }
            return ComposeAttachment(
                id: UUID(),
                url: url,
                mime: mime ?? "image/jpeg",
                dim: dim,
                durationSec: durationSec,
                sha256Hex: hash,
                localBytes: nil
            )
        }
    }

    /// Inverse of `appendUrls` for legacy drafts whose attachments were spliced into
    /// the body as trailing URLs. Drafts written by the current code path use imeta
    /// tags instead, but this fallback keeps older drafts (and any cross-client
    /// drafts that put media URLs at the end of the body) loading correctly.
    static func splitDraftBody(_ source: String) -> (body: String, attachments: [ComposeAttachment]) {
        let imageExts: Set<String> = ["jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "avif", "svg"]
        let videoExts: Set<String> = ["mp4", "mov", "webm", "m3u8"]
        var lines = source.components(separatedBy: "\n")
        var trailing: [(url: String, isVideo: Bool)] = []
        while let last = lines.last {
            let trimmed = last.trimmingCharacters(in: .whitespaces)
            guard let url = URL(string: trimmed),
                  let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" else {
                break
            }
            let ext = url.pathExtension.lowercased()
            if imageExts.contains(ext) {
                trailing.insert((trimmed, false), at: 0)
                lines.removeLast()
            } else if videoExts.contains(ext) {
                trailing.insert((trimmed, true), at: 0)
                lines.removeLast()
            } else {
                break
            }
        }
        let attachments: [ComposeAttachment] = trailing.map { entry in
            ComposeAttachment(
                id: UUID(),
                url: entry.url,
                mime: entry.isVideo ? "video/mp4" : "image/jpeg",
                dim: .zero,
                durationSec: nil,
                sha256Hex: nil,
                localBytes: nil
            )
        }
        // Drop trailing blank lines left behind once URLs are removed.
        while lines.last?.trimmingCharacters(in: .whitespaces).isEmpty == true {
            lines.removeLast()
        }
        return (lines.joined(separator: "\n"), attachments)
    }

    /// In `.quote` mode the embedded `nostr:nevent…` reference is hidden from the
    /// editor and spliced onto the end of the body at publish time, so the user
    /// types their commentary in an empty composer instead of around a 60-char URI.
    private func appendQuoteUri(to body: String) -> String {
        guard case .quote(let event) = mode else { return body }
        return Nip18.appendNoteUri(
            content: body,
            eventIdHex: event.id,
            relayHints: [],
            authorHex: event.pubkey
        )
    }

    /// Content as it would appear in the published note, including any spliced
    /// attachment URLs and `nostr:` mention URIs. Used by the live preview card
    /// so pasted/uploaded images render inline (even though the URLs no longer
    /// live in `content`) and tagged usernames render as pills rather than raw
    /// `@displayName` text.
    var previewContent: String {
        bodyForPublish(kind: determineKind(), materialized: materializeMentions(content))
    }

    /// Warm `LinkPreviewService`'s cache for every standalone link in the
    /// post being written. The composer preview panel renders links as
    /// plain text (`showLinkPreviews: false`), but once the note is
    /// published it shows full preview cards in the feed/thread — doing
    /// the OG fetch while the user is still composing means those cards
    /// paint from cache on first render instead of flashing a spinner.
    /// Debounced ~800ms so mid-typing URL fragments don't trigger wasted
    /// fetches; the service itself dedupes the rest.
    func prefetchSocialPreviews() {
        socialPreviewPrefetchTask?.cancel()
        let body = previewContent
        socialPreviewPrefetchTask = Task {
            try? await Task.sleep(for: .milliseconds(800))
            guard !Task.isCancelled else { return }
            let segments = ContentParser.parse(content: body, tags: [])
            for case .link(let url) in segments {
                LinkPreviewService.shared.prefetch(url)
            }
        }
    }

    /// Replace each `@displayName` token with `nostr:nprofile1...` (per stored mentions).
    private func materializeMentions(_ source: String) -> String {
        var out = source
        for mention in mentions {
            guard let bytes = Hex.decode(mention.pubkey) else { continue }
            guard let nprofile = Nip19.nprofileEncode(pubkey32: Array(bytes)) else { continue }
            let needle = "@\(mention.displayName)"
            // Replace *every* occurrence, not just the first — a user can
            // copy a pill within the composer and end up with multiple
            // `@displayName` tokens for the same mention. Each one should
            // materialize to its own `nostr:nprofile1...` URI so the
            // preview / final event sees the same `.nostrProfile` segment
            // count, and so subsequent pastes don't degrade to plain text
            // on publish.
            out = out.replacingOccurrences(of: needle, with: "nostr:\(nprofile)")
        }
        // Separator pass: two pills typed back-to-back (or pasted next to
        // each other) produce `nostr:Y1nostr:Y2` in the materialized text.
        // `ContentParser`'s greedy `[a-z0-9]+` then consumes the second
        // URI's `nostr` prefix into the first match, decoding fails, and
        // the second mention falls through to plain text in the preview /
        // published event. Insert a space between adjacent URIs so the
        // parser can find the boundary cleanly. Non-greedy `+?` + a
        // lookahead is the minimum bech32 run that satisfies "followed by
        // another nostr:" — i.e. the full first URI.
        if let regex = try? NSRegularExpression(
            pattern: "(nostr:(?:note1|nevent1|npub1|nprofile1|naddr1)[a-z0-9]+?)(?=nostr:)",
            options: []
        ) {
            let ns = out as NSString
            out = regex.stringByReplacingMatches(
                in: out,
                range: NSRange(location: 0, length: ns.length),
                withTemplate: "$1 "
            )
        }
        // Separator pass. `ContentParser`'s greedy `[a-z0-9]+` after the
        // bech32 prefix runs past the end of a `nostr:nprofile1...` URI
        // and eats any contiguous lowercase letters / digits that follow
        // — e.g. user backspaces the trailing space after a pill and
        // types `tag!`, producing `nostr:Ytag!`. The decode then fails
        // on the bech32 mismatch and the whole token renders as plain
        // text in the published event. Insert a space between the URI
        // and any such blender character. We iterate the known
        // materialized URIs (exact lengths are known here) so we don't
        // have to fight the parser's greedy regex.
        for mention in mentions {
            guard let bytes = Hex.decode(mention.pubkey) else { continue }
            guard let nprofile = Nip19.nprofileEncode(pubkey32: Array(bytes)) else { continue }
            let uri = "nostr:\(nprofile)"
            var cursor = out.startIndex
            while let r = out.range(of: uri, range: cursor..<out.endIndex) {
                let nextIdx = r.upperBound
                if nextIdx < out.endIndex {
                    let c = out[nextIdx]
                    if (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || (c >= "0" && c <= "9") {
                        out.insert(" ", at: nextIdx)
                        cursor = out.index(after: nextIdx)
                        continue
                    }
                }
                cursor = nextIdx
            }
        }
        return out
    }

    private func buildBaseTags(kind: Int, materializedContent: String) -> [[String]] {
        var tags: [[String]] = []

        // Reply / quote contextual tags.
        switch mode {
        case .new:
            break
        case .reply(let parent, let root):
            if let root {
                tags.append(["e", root.id, "", "root"])
                if root.id != parent.id {
                    tags.append(["e", parent.id, "", "reply"])
                }
            } else {
                tags.append(["e", parent.id, "", "reply"])
            }
            // Re-emit every distinct `p` tag carried in the parent so everyone
            // already in the thread stays notified, then the parent author.
            // (Mirrors the private-reply path.) Without the carry-forward we'd
            // only tag the direct parent author, so a reply to a note that
            // itself p-tagged others silently drops them — e.g. A↔B then B
            // replying to B's own note would lose A.
            tags.append(contentsOf: Nip10.participantTags(replyingTo: parent))
        case .quote(let q):
            tags.append(contentsOf: Nip18.buildQuoteTags(event: q))
        }

        // Mentioned `p` tags from inline mentions, not already present.
        var existingP = Set(tags.compactMap { $0.count >= 2 && $0[0] == "p" ? $0[1] : nil })
        for mention in mentions where !existingP.contains(mention.pubkey) {
            tags.append(["p", mention.pubkey])
            existingP.insert(mention.pubkey)
        }

        // Pre-existing nostr URIs in content -> p tags for profile refs.
        for pubkey in extractProfilePubkeys(materializedContent) where !existingP.contains(pubkey) {
            tags.append(["p", pubkey])
            existingP.insert(pubkey)
        }

        // Hashtags.
        for tag in hashtags {
            tags.append(["t", tag])
        }

        // Poll tags: NIP-88 (kind 1068) or NIP-69 zap poll (kind 6969).
        if pollEnabled {
            let nonBlank = pollOptions
                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
                .filter { !$0.isEmpty }
            let pollRelays = topWriteRelays()
            if isZapPoll {
                let opts = nonBlank.enumerated().map { Nip69.ZapPollOption(index: $0.offset, label: $0.element) }
                tags.append(contentsOf: Nip69.buildZapPollTags(
                    options: opts,
                    valueMinimum: zapPollMinSats,
                    valueMaximum: zapPollMaxSats,
                    consensusThreshold: nil,
                    closedAt: pollEndsAt,
                    relayUrls: pollRelays
                ))
            } else {
                let opts = nonBlank.map { Nip88.PollOption(id: Nip88.generateOptionId(), label: $0) }
                tags.append(contentsOf: Nip88.buildPollTags(
                    options: opts,
                    pollType: pollType,
                    endsAt: pollEndsAt,
                    relayUrls: pollRelays
                ))
            }
            if explicit { tags.append(["content-warning", ""]) }
            tags.append(contentsOf: EmojiShortcode.emojiTags(in: materializedContent))
            if let clientTag = NostrEvent.clientTagIfEnabled() { tags.append(clientTag) }
            return tags
        }

        // Kind-specific: imeta for gallery, content-warning for NSFW.
        if galleryMode {
            switch kind {
            case Nip68.kindPicture:
                let imeta: [Nip68.ImetaEntry] = attachments.compactMap { a in
                    guard let url = a.url else { return nil }
                    let dim = a.dim != .zero ? "\(Int(a.dim.width))x\(Int(a.dim.height))" : nil
                    return Nip68.ImetaEntry(url: url, mimeType: a.mime, dim: dim, hash: a.sha256Hex)
                }
                let extra = Nip68.buildPictureTags(
                    title: nil,
                    media: imeta,
                    hashtags: [],
                    contentWarning: explicit ? "" : nil
                )
                tags.append(contentsOf: extra)
            case Nip71.kindVideoHorizontal, Nip71.kindVideoVertical:
                let videos: [Nip71.VideoMeta] = attachments.compactMap { a in
                    guard let url = a.url else { return nil }
                    let dim = a.dim != .zero ? "\(Int(a.dim.width))x\(Int(a.dim.height))" : nil
                    return Nip71.VideoMeta(url: url, mimeType: a.mime, dim: dim, duration: a.durationSec, hash: a.sha256Hex)
                }
                let extra = Nip71.buildVideoTags(
                    title: nil,
                    media: videos,
                    hashtags: [],
                    contentWarning: explicit ? "" : nil
                )
                tags.append(contentsOf: extra)
            default:
                break
            }
        } else if explicit {
            tags.append(["content-warning", ""])
        }

        tags.append(contentsOf: EmojiShortcode.emojiTags(in: materializedContent))

        if let clientTag = NostrEvent.clientTagIfEnabled() { tags.append(clientTag) }

        return tags
    }

    private func recomputeHashtags() {
        let regex = try? NSRegularExpression(pattern: "(?<![\\w])#([\\p{L}\\p{N}_]{1,64})", options: [])
        guard let regex else { hashtags = []; return }
        let range = NSRange(content.startIndex..<content.endIndex, in: content)
        var seen = Set<String>()
        var out: [String] = []
        regex.enumerateMatches(in: content, range: range) { match, _, _ in
            guard let m = match, m.numberOfRanges >= 2,
                  let r = Range(m.range(at: 1), in: content) else { return }
            let tag = String(content[r]).lowercased()
            if seen.insert(tag).inserted { out.append(tag) }
        }
        hashtags = out
    }

    private func autoPrefixBareBech32(_ s: String) -> String {
        let pattern = "(?<![a-z0-9:./])(?<!nostr:)(nevent1|note1|nprofile1|naddr1|npub1)([a-z0-9]{20,})"
        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return s }
        let nsRange = NSRange(s.startIndex..<s.endIndex, in: s)
        let matches = regex.matches(in: s, range: nsRange)
        if matches.isEmpty { return s }
        // Skip tokens that appear inside a URL (e.g. ?npub=npub1... query params).
        var urlRanges: [NSRange] = []
        if let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue) {
            urlRanges = detector.matches(in: s, range: nsRange).map(\.range)
        }
        var out = s
        for m in matches.reversed() {
            let insideURL = urlRanges.contains { NSIntersectionRange($0, m.range).length > 0 }
            guard !insideURL else { continue }
            guard let r = Range(m.range, in: out) else { continue }
            let token = String(out[r])
            if Nip19.decodeNostrUri(token) != nil {
                out.replaceSubrange(r, with: "nostr:\(token)")
            }
        }
        return out
    }

    private func extractProfilePubkeys(_ s: String) -> [String] {
        let pattern = "nostr:(npub1[a-z0-9]+|nprofile1[a-z0-9]+)"
        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return [] }
        let range = NSRange(s.startIndex..<s.endIndex, in: s)
        var out: [String] = []
        regex.enumerateMatches(in: s, range: range) { match, _, _ in
            guard let m = match, let r = Range(m.range, in: s) else { return }
            let token = String(s[r])
            if case .profileRef(let pk, _)? = Nip19.decodeNostrUri(token) {
                out.append(pk)
            }
        }
        return out
    }

    /// Walk `content` for `nostr:nprofile1...` and `nostr:npub1...` tokens
    /// (the materialized form used in drafts and finalized event bodies),
    /// replace each with `@displayName`, and add the corresponding
    /// `InsertedMention` so the rich editor pill-styles them. Idempotent
    /// when no nostr tokens are present.
    private func rehydrateMentionsFromContent() {
        let pattern = #"nostr:(npub1[acdefghjklmnpqrstuvwxyz023456789]+|nprofile1[acdefghjklmnpqrstuvwxyz023456789]+)"#
        guard let regex = try? NSRegularExpression(pattern: pattern, options: [.caseInsensitive]) else { return }
        let ns = content as NSString
        let fullRange = NSRange(location: 0, length: ns.length)
        let matches = regex.matches(in: content, range: fullRange)
        guard !matches.isEmpty else { return }
        // Skip nostr: tokens that are embedded inside a URL (e.g. a relay URL
        // whose path or query string happens to contain a bech32 identifier).
        var urlRanges: [NSRange] = []
        if let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue) {
            urlRanges = detector.matches(in: content, range: fullRange).map(\.range)
        }
        var rewritten = ""
        var lastEnd = 0
        var added: [String: String] = [:]   // pubkey → displayName
        for match in matches {
            rewritten += ns.substring(with: NSRange(location: lastEnd, length: match.range.location - lastEnd))
            let token = ns.substring(with: match.range)
            let insideURL = urlRanges.contains { NSIntersectionRange($0, match.range).length > 0 }
            if !insideURL, let decoded = Nip19.decodeNostrUri(token), case .profileRef(let pubkey, _) = decoded {
                let displayName: String
                if let existing = added[pubkey] {
                    displayName = existing
                } else {
                    let profile = ProfileRepository.shared.get(pubkey)
                    let raw = profile?.displayString ?? Nip19.shortNpub(hex: pubkey)
                    displayName = sanitizeDisplayName(raw)
                    added[pubkey] = displayName
                    mentions.append(InsertedMention(displayName: displayName, pubkey: pubkey))
                }
                rewritten += "@\(displayName)"
            } else {
                rewritten += token
            }
            lastEnd = match.range.upperBound
        }
        rewritten += ns.substring(from: lastEnd)
        content = rewritten
    }

    private func sanitizeDisplayName(_ name: String) -> String {
        // Replace plain spaces with non-breaking spaces so a multi-word display
        // name reads visually as a space in the editor while staying a single
        // contiguous token for the @-trigger parser. Mention-aware whitespace
        // checks (`isMentionTokenBreak`) ignore U+00A0.
        let cleaned = name.replacingOccurrences(of: " ", with: "\u{00A0}")
            .replacingOccurrences(of: "@", with: "")
        return cleaned.isEmpty ? "user" : cleaned
    }

    private func topWriteRelays() -> [String] {
        RelayRouting.topWriteRelays(for: signingKeypair.pubkey)
    }
}

extension Character {
    /// Whitespace check used by the mention / emoji trigger parser. Identical to
    /// `isWhitespace` except non-breaking space (U+00A0) is treated as part of
    /// the token, so multi-word display names that `sanitizeDisplayName` joined
    /// with NBSP stay a single `@displayName` token.
    var isMentionTokenBreak: Bool {
        if self == "\u{00A0}" { return false }
        return isWhitespace
    }
}