Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

75.2 KB
Raw Blame
import SwiftUI
import Pow
import UIKit

/// Android WorkspaceMemoDetail shell parity (detailHeader*, detailMeta*, detailEditFab).
struct MemoDetailView: View {
    @Environment(AppEnvironment.self) private var env
    @Environment(\.dismiss) private var dismiss
    @Environment(\.colorScheme) private var colorScheme
    let memoId: String
    var initialShareImage = false
    /// Present editor from the parent `WorkspaceView` (more reliable than cover on a pushed page).
    var onEdit: (String, MemoEditInitialFocus) -> Void = { _, _ in }

    @State private var memo: MemoDetail?
    @State private var showRevisions = false
    @State private var memoSharePayload: MemoSharePayload?
    @State private var imageExportSharePayload: MemoImageExportSharePayload?
    @State private var imageExportPreviewPayload: MemoImageExportPreviewPayload?
    @State private var imageExportDocumentPayload: MemoImageExportDocumentPayload?
    @State private var imageExportMessage: MemoImageExportMessage?
    @State private var imageExporting = false
    @State private var imageFontStatus = "ready"
    @State private var imageFontRecoveryId: String?
    @State private var imageFontsRecovered = false
    @State private var retryImageFonts: (() -> Void)?
    @State private var imageExportRequestId: String?
    @State private var imageExportBuffer = MemoImageExportBuffer()
    @State private var imageShareOptionsOpen = false
    @State private var imageExportIntent: MemoImageExportIntent = .share
    @State private var error: String?
    @State private var conflictItem: OutboxItem?
    @State private var outboxStatus: OutboxStatus?
    @State private var lastOutboxError: String?
    @State private var pinPulse = false
    @State private var searchOpen = false
    @State private var titleCollapsed = false
    @State private var searchQuery = ""
    @State private var searchMatchCount = 0
    @State private var searchMatchIndex = 0
    @State private var showDeleteConfirm = false
    @State private var showMoreMenu = false
    @State private var showNoteIdCopied = false
    @State private var showAiAssistant = false
    @State private var showNotebookPicker = false
    @State private var resourceTarget: ResourceTarget?
    @State private var imagePreview: (source: String, alt: String)?
    /// TipTap EditorBundle is ~4MB; keep native text visible until first setContent finishes.
    @State private var bodyReady = false
    @State private var initialShareImageHandled = false

    var body: some View {
        @Bindable var preferences = env.preferences
        return VStack(spacing: 0) {
            detailHeader
            if syncStatus == .conflict, memo != nil {
                conflictBanner
            } else if syncStatus == .error || syncStatus == .pending, memo != nil {
                syncBanner
            }
            if let memo {
                detailBody(memo)
            } else if let error {
                ContentUnavailableView(
                    env.preferences.t("加载失败", en: "Failed to load", pl: "Nie udało się wczytać"),
                    systemImage: "exclamationmark.triangle",
                    description: Text(error)
                )
            } else {
                // Should almost never flash: load() runs onAppear before next frame when mirror is warm.
                ProgressView()
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
            }
        }
        .background(AppTheme.card)
        // UIKit FAB in overlay — SwiftUI Button over WKWebView often receives zero taps.
        .overlay(alignment: .bottomTrailing) {
            if let memo, !memo.isDeleted, !blocksRichTextEdit(memo) {
                EditFabButton(
                    accessibilityLabel: env.preferences.t("编辑笔记", en: "Edit note", pl: "Edytuj notatkę")
                ) {
                    onEdit(memo.id, .body)
                }
                .frame(width: 56, height: 56)
                .padding(.trailing, 12)
                .padding(.bottom, 12)
            }
        }
        .background(AppTheme.card.ignoresSafeArea())
        .toolbar(.hidden, for: .navigationBar)
        .accessibilityIdentifier(DetailMemoChrome.root)
        .sheet(isPresented: $showRevisions) {
            if let memo {
                RevisionsView(
                    memoId: memo.id,
                    memoTitle: memo.title,
                    isDeleted: memo.isDeleted
                ) {
                    showRevisions = false
                    load()
                }
            }
        }
        .sheet(item: $conflictItem) { item in
            ConflictResolutionView(item: item) {
                conflictItem = nil
                load()
                refreshSyncStatus()
            }
        }
        .sheet(item: $resourceTarget) { target in
            ResourceActionSheet(
                target: target,
                canMutate: memo.map { !$0.isDeleted && !$0.id.hasPrefix("local:") } ?? false,
                onContentChanged: { load() }
            )
            .presentationDetents([.height(360), .medium])
            .presentationDragIndicator(.hidden)
        }
        .sheet(item: $memoSharePayload) { payload in
            ActivityShareView(items: [payload.message, payload.url]) { _, _, error in
                if let error { self.error = error.localizedDescription }
                memoSharePayload = nil
            }
        }
        .sheet(item: $imageExportSharePayload) { payload in
            ActivityShareView(items: [payload.url]) { _, _, shareError in
                if let shareError {
                    imageExportMessage = MemoImageExportMessage(
                        title: env.preferences.t("导出失败", en: "Export failed", pl: "Eksport nie powiódł się"),
                        message: shareError.localizedDescription
                    )
                }
                imageExportSharePayload = nil
            }
        }
        .sheet(item: $imageExportDocumentPayload) { payload in
            MemoImageDocumentExportView(fileURL: payload.url) { result in
                if case let .failure(exportError) = result {
                    imageExportMessage = MemoImageExportMessage(
                        title: env.preferences.t("保存失败", en: "Save failed", pl: "Nie udało się zapisać"),
                        message: exportError.localizedDescription
                    )
                }
                imageExportDocumentPayload = nil
            }
        }
        .sheet(item: $imageExportPreviewPayload, onDismiss: {
            imageFontRecoveryId = nil
            retryImageFonts = nil
            if let requestId = imageExportRequestId { imageExportBuffer.cancel(requestId: requestId) }
            imageExportRequestId = nil
            imageExporting = false
        }) { payload in
            let currentPayload = imageExportPreviewPayload ?? payload
            MemoImageExportPreviewView(
                payload: currentPayload,
                isLoadingFonts: imageExporting,
                onRetryFonts: { retryImageFonts?() },
                isEnglish: env.preferences.isEnglish,
                isPolish: env.preferences.uiLanguage == .polish,
                onCopy: {
                    guard let image = UIImage(contentsOfFile: currentPayload.url.path) else {
                        imageExportMessage = MemoImageExportMessage(
                            title: env.preferences.t("复制失败", en: "Copy failed", pl: "Nie udało się skopiować"),
                            message: env.preferences.t("无法读取生成的图片。", en: "The generated image could not be read.", pl: "Nie udało się odczytać wygenerowanego obrazu.")
                        )
                        return
                    }
                    UIPasteboard.general.image = image
                    imageExportMessage = MemoImageExportMessage(
                        title: env.preferences.t("复制成功", en: "Copied", pl: "Skopiowano"),
                        message: env.preferences.t("图片已复制到剪贴板。", en: "The image is on your clipboard.", pl: "Obraz jest w schowku.")
                    )
                },
                onSave: {
                    imageFontRecoveryId = nil
                    imageExportPreviewPayload = nil
                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) {
                        imageExportDocumentPayload = MemoImageExportDocumentPayload(url: currentPayload.url)
                    }
                },
                onShare: {
                    imageFontRecoveryId = nil
                    imageExportPreviewPayload = nil
                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) {
                        imageExportSharePayload = MemoImageExportSharePayload(url: currentPayload.url)
                    }
                }
            )
        }
        .sheet(isPresented: $imageShareOptionsOpen) {
            NavigationStack {
                Form {
                    Section(env.preferences.t("主题风格", en: "Theme", pl: "Motyw")) {
                        Picker(env.preferences.t("主题风格", en: "Theme", pl: "Motyw"), selection: Binding(
                            get: { preferences.noteImageShare.theme },
                            set: { theme in
                                var share = preferences.noteImageShare
                                share.theme = theme
                                share.fontStyle = "auto"
                                preferences.noteImageShare = share
                            }
                        )) {
                            Text(env.preferences.t("透明", en: "Glass", pl: "Szkło")).tag("glass")
                            Text(env.preferences.t("金句", en: "Quote", pl: "Cytat")).tag("quote")
                            Text(env.preferences.t("书摘", en: "Book excerpt", pl: "Fragment książki")).tag("book")
                            Text(env.preferences.t("备忘录", en: "Memo", pl: "Notatka")).tag("memo")
                            Text(env.preferences.t("便当", en: "Bento", pl: "Bento")).tag("bento")
                            Text(env.preferences.t("黑日", en: "Black Sun", pl: "Czarne słońce")).tag("black-sun")
                            Text(env.preferences.t("框界", en: "Frame", pl: "Ramka")).tag("frame")
                            Text(env.preferences.t("手写", en: "Handwritten", pl: "Pismo odręczne")).tag("handwritten")
                            Text(env.preferences.t("代码", en: "Code", pl: "Kod")).tag("code")
                        }
                        .pickerStyle(.menu)
                    }
                    Section(env.preferences.t("字体风格", en: "Typography", pl: "Typografia")) {
                        NavigationLink {
                            NoteImageFontPickerView()
                        } label: {
                            HStack {
                                Text(env.preferences.t("字体风格", en: "Typography", pl: "Typografia"))
                                Spacer()
                                Text(NoteImageFontPickerOptions.label(preferences))
                                    .foregroundStyle(.secondary)
                                    .multilineTextAlignment(.trailing)
                            }
                        }
                        Text(env.preferences.t(
                            "下载型字体首次使用需联网并缓存;普惠体等推荐字体使用完整文件,首次下载较大。",
                            en: "Downloadable fonts need a connection on first use and are cached. PuHuiTi and other recommended fonts use larger, complete original files.",
                            pl: "Czcionki są pobierane przy pierwszym użyciu i zapisywane lokalnie. PuHuiTi i inne polecane czcionki używają większych, pełnych plików."
                        ))
                        .font(.footnote)
                        .foregroundStyle(.secondary)
                    }
                    Section(env.preferences.t("字号大小", en: "Font size", pl: "Rozmiar czcionki")) {
                        Picker(env.preferences.t("字号大小", en: "Font size", pl: "Rozmiar czcionki"), selection: $preferences.noteImageShare.fontSize) {
                            Text(env.preferences.t("紧凑", en: "Compact", pl: "Kompaktowy")).tag("sm")
                            Text(env.preferences.t("标准", en: "Standard", pl: "Standardowy")).tag("md")
                            Text(env.preferences.t("舒适", en: "Comfortable", pl: "Wygodny")).tag("lg")
                        }
                        .pickerStyle(.segmented)
                    }
                    Section(env.preferences.t("卡片宽度", en: "Card width", pl: "Szerokość karty")) {
                        Picker(env.preferences.t("卡片宽度", en: "Card width", pl: "Szerokość karty"), selection: $preferences.noteImageShare.cardWidth) {
                            Text(env.preferences.t("紧凑", en: "Compact", pl: "Kompaktowy")).tag("compact")
                            Text(env.preferences.t("标准", en: "Standard", pl: "Standardowy")).tag("standard")
                            Text(env.preferences.t("宽屏", en: "Wide", pl: "Szeroka")).tag("wide")
                        }
                        .pickerStyle(.segmented)
                    }
                    Section(env.preferences.t("显示内容", en: "Content elements", pl: "Elementy treści")) {
                        Toggle(env.preferences.t("笔记标题", en: "Note title", pl: "Tytuł notatki"), isOn: $preferences.noteImageShare.showTitle)
                        Toggle(env.preferences.t("笔记本", en: "Notebook", pl: "Notatnik"), isOn: $preferences.noteImageShare.showNotebook)
                        Toggle(env.preferences.t("标签", en: "Tags", pl: "Tagi"), isOn: $preferences.noteImageShare.showTags)
                        Toggle(env.preferences.t("更新时间", en: "Updated time", pl: "Czas aktualizacji"), isOn: $preferences.noteImageShare.showUpdatedAt)
                        Toggle(env.preferences.t("EdgeEver 品牌标识", en: "EdgeEver branding", pl: "Oznaczenie EdgeEver"), isOn: $preferences.noteImageShare.showBranding)
                    }
                    Section(env.preferences.t("图片格式", en: "Image format", pl: "Format obrazu")) {
                        Picker(env.preferences.t("图片格式", en: "Image format", pl: "Format obrazu"), selection: $preferences.noteImageShare.format) {
                            Text(env.preferences.t("PNG · 超清无损", en: "PNG · Best for text", pl: "PNG · Najlepszy do tekstu")).tag("png")
                            Text(env.preferences.t("JPEG · 体积小", en: "JPEG · Smaller file", pl: "JPEG · Mniejszy plik")).tag("jpeg")
                        }
                        .pickerStyle(.segmented)
                    }
                }
                .navigationTitle(env.preferences.t("分享为图片", en: "Share as image", pl: "Udostępnij jako obraz"))
                .navigationBarTitleDisplayMode(.inline)
                .toolbar {
                    ToolbarItem(placement: .cancellationAction) {
                        Button(env.preferences.t("取消", en: "Cancel", pl: "Anuluj")) { imageShareOptionsOpen = false }
                    }
                    ToolbarItem(placement: .confirmationAction) {
                        Button(env.preferences.t("生成预览", en: "Generate Preview", pl: "Generuj podgląd")) {
                            guard let memo else { return }
                            imageShareOptionsOpen = false
                            exportMemoImage(
                                memo,
                                format: env.preferences.noteImageShare.format,
                                theme: env.preferences.noteImageShare.theme,
                                fontStyle: env.preferences.noteImageShare.fontStyle,
                                fontSize: env.preferences.noteImageShare.fontSize,
                                cardWidth: env.preferences.noteImageShare.cardWidth,
                                showTitle: env.preferences.noteImageShare.showTitle,
                                showNotebook: env.preferences.noteImageShare.showNotebook,
                                showTags: env.preferences.noteImageShare.showTags,
                                showUpdatedAt: env.preferences.noteImageShare.showUpdatedAt,
                                showBranding: env.preferences.noteImageShare.showBranding,
                                intent: .preview
                            )
                        }
                        .disabled(imageExporting || !bodyReady || memo == nil)
                    }
                }
            }
        }
        .overlay(alignment: .bottom) {
            if imageExporting && imageExportPreviewPayload == nil {
                ProgressView(imageFontStatus == "loading"
                    ? env.preferences.t("字体加载中…", en: "Loading font…", ja: "フォントを読み込み中…", pl: "Ładowanie czcionki…")
                    : env.preferences.t("正在生成图片…", en: "Generating image…", ja: "画像を生成中…", pl: "Generowanie obrazu…"))
                    .padding().background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12)).padding()
            }
        }
        .alert(item: $imageExportMessage) { message in
            Alert(
                title: Text(message.title),
                message: Text(message.message),
                dismissButton: .default(Text(env.preferences.t("确定", en: "OK", pl: "OK")))
            )
        }
        .sheet(isPresented: $showAiAssistant) {
            if let memo {
                AiAssistantSheet(memo: memo) { draft, mode in
                    try await applyAiDraft(draft, mode: mode, to: memo)
                }
            }
        }
        .sheet(isPresented: $showNotebookPicker) {
            EditNotebookPickerSheet(
                notebooks: availableNotebooks,
                selectedId: memo?.notebookId ?? ""
            ) { notebookId in
                showNotebookPicker = false
                guard let memo else { return }
                Task { await moveMemoToNotebook(memo, notebookId: notebookId) }
            }
            .presentationDetents([.medium, .large])
        }
        .fullScreenCover(isPresented: Binding(
            get: { imagePreview != nil },
            set: { if !$0 { imagePreview = nil } }
        )) {
            if let imagePreview {
                ResourceImagePreviewHost(
                    source: imagePreview.source,
                    alt: imagePreview.alt,
                    baseURL: env.session.session.flatMap { URL(string: $0.baseUrl) },
                    token: env.session.session?.token,
                    onClose: {
                        self.imagePreview = nil
                    },
                    canMutate: memo.map { !$0.isDeleted && !$0.id.hasPrefix("local:") } ?? false,
                    onContentChanged: {
                        load()
                        // Rename/delete may invalidate the blob; close preview after mutation.
                        self.imagePreview = nil
                    }
                )
            }
        }
        .confirmationDialog(
            env.preferences.t("笔记操作", en: "Note actions", pl: "Działania na notatce"),
            isPresented: $showMoreMenu,
            titleVisibility: .visible
        ) {
            if let memo {
                if !blocksRichTextEdit(memo) {
                    Button(env.preferences.t("编辑", en: "Edit", pl: "Edytuj")) { onEdit(memo.id, .body) }
                }
                if !memo.isDeleted && !isTemporaryMemoId(memo.id) && !blocksRichTextEdit(memo) {
                    Button(env.preferences.t("AI 笔记助手", en: "AI note assistant", pl: "Asystent AI notatek")) {
                        showAiAssistant = true
                    }
                }
                Button(
                    memo.isPinned
                        ? env.preferences.t("取消置顶", en: "Unpin", pl: "Odepnij")
                        : env.preferences.t("置顶", en: "Pin", pl: "Przypnij")
                ) {
                    Task {
                        await togglePin(memo)
                        pinPulse.toggle()
                    }
                }
                Button(env.preferences.t("分享链接", en: "Share link", pl: "Udostępnij link")) {
                    Task { await shareMemo(memo) }
                }
                Button(
                    imageExporting
                        ? env.preferences.t("正在导出图片…", en: "Exporting image…", pl: "Eksportowanie obrazu…")
                        : env.preferences.t("分享为图片", en: "Share as image", pl: "Udostępnij jako obraz")
                ) {
                    imageShareOptionsOpen = true
                }
                .disabled(imageExporting || !bodyReady)
                Button(env.preferences.t("高级导出 PNG", en: "Advanced export PNG", pl: "Zaawansowany eksport PNG")) {
                    exportMemoImage(memo, format: "png")
                }
                .disabled(imageExporting || !bodyReady)
                Button(env.preferences.t("导出 JPEG", en: "Export JPEG", pl: "Eksportuj JPEG")) {
                    exportMemoImage(memo, format: "jpeg")
                }
                .disabled(imageExporting || !bodyReady)
                Button(
                    isTemporaryMemoId(memo.id)
                        ? env.preferences.t("同步后可复制笔记 ID", en: "Copy note ID after sync", pl: "Identyfikator notatki można skopiować po synchronizacji")
                        : env.preferences.t("复制笔记 ID", en: "Copy note ID", pl: "Kopiuj identyfikator notatki")
                ) {
                    UIPasteboard.general.string = memo.id
                    showNoteIdCopied = true
                }
                .disabled(isTemporaryMemoId(memo.id))
                Button(env.preferences.t("修订历史", en: "Revisions", pl: "Wersje")) { showRevisions = true }
                Button(env.preferences.t("删除", en: "Delete", pl: "Usuń"), role: .destructive) {
                    showDeleteConfirm = true
                }
            }
        }
        .alert(env.preferences.t("删除笔记", en: "Delete note", pl: "Usuń notatkę"), isPresented: $showDeleteConfirm) {
            Button(env.preferences.t("删除", en: "Delete", pl: "Usuń"), role: .destructive) {
                if let memo { Task { await deleteMemo(memo) } }
            }
            Button(env.preferences.t("取消", en: "Cancel", pl: "Anuluj"), role: .cancel) {}
        } message: {
            Text(env.preferences.t("笔记将移入回收站。", en: "The note will move to trash.", pl: "Notatka zostanie przeniesiona do kosza."))
        }
        .alert(
            env.preferences.t("笔记 ID 已复制", en: "Note ID copied", pl: "Skopiowano identyfikator notatki"),
            isPresented: $showNoteIdCopied
        ) {
            Button(env.preferences.t("好", en: "OK", pl: "OK"), role: .cancel) {}
        } message: {
            Text(memo?.id ?? memoId)
        }
        // Local SQLite mirror is sync and cheap — load before the first blank ProgressView frame.
        .onAppear {
            if memo == nil {
                load()
            }
            refreshSyncStatus()
            TipTapWarmPool.warmIfNeeded()
            SharedTipTapRuntime.viewer.resetReaderScroll()
            openInitialShareImageIfReady()
        }
        .onDisappear {
            if let requestId = imageExportRequestId {
                imageExportBuffer.cancel(requestId: requestId)
            }
            imageExportRequestId = nil
            imageFontRecoveryId = nil
            retryImageFonts = nil
            imageExporting = false
        }
        .onChange(of: bodyReady) { _, _ in
            openInitialShareImageIfReady()
        }
        .task(id: memoId) {
            // Re-load if mirror was empty on first paint (rare race during bootstrap).
            if memo == nil {
                load()
            }
            refreshSyncStatus()
        }
        .onChange(of: env.isSyncing) { _, _ in
            refreshSyncStatus()
        }
        .onChange(of: memoId) { _, _ in
            bodyReady = false
            titleCollapsed = false
            SharedTipTapRuntime.viewer.resetReaderScroll()
            searchQuery = ""
            searchMatchCount = 0
            searchMatchIndex = 0
            showNotebookPicker = false
            load()
            refreshSyncStatus()
        }
        .preferredColorScheme(env.preferences.colorScheme)
    }

    // MARK: - Header

    private var detailHeader: some View {
        HStack(spacing: 0) {
            Button {
                dismiss()
            } label: {
                Image(systemName: "chevron.left")
                    .font(.system(size: 18, weight: .semibold))
                    .foregroundStyle(AppTheme.slate)
                    .frame(width: 32, height: 32)
                    .contentShape(Rectangle())
            }
            .buttonStyle(.plain)
            .accessibilityLabel(env.preferences.t("返回列表", en: "Back to list", pl: "Wróć do listy"))
            .accessibilityIdentifier(DetailMemoChrome.back)

            if titleCollapsed && !searchOpen, let memo {
                collapsedHeaderTitle(memo)
                    .padding(.leading, 8)
                    .frame(maxWidth: .infinity, alignment: .leading)
            } else {
                Spacer(minLength: 8)
            }

            HStack(spacing: 2) {
                Button {
                    handleSyncStatusPress()
                } label: {
                    Text(syncLabel)
                        .font(.system(size: 11, weight: syncStatus == .conflict || syncStatus == .error ? .bold : .medium))
                        .foregroundStyle(syncStatus.foreground)
                        .padding(.horizontal, 8)
                        .padding(.vertical, 4)
                        .background(syncStatus.background)
                        .clipShape(Capsule())
                        .lineLimit(1)
                        .frame(maxWidth: 88)
                }
                .buttonStyle(.plain)
                .disabled(!syncStatus.isInteractive || memo == nil)
                .accessibilityLabel(syncLabel)
                .accessibilityIdentifier(DetailMemoChrome.syncStatus)

                if let memo, !memo.isDeleted {
                    headerIconButton(
                        systemImage: "square.and.arrow.up",
                        label: env.preferences.t("分享笔记", en: "Share note", pl: "Udostępnij notatkę"),
                        id: DetailMemoChrome.share
                    ) {
                        Task { await shareMemo(memo) }
                    }
                    headerIconButton(
                        systemImage: "clock.arrow.circlepath",
                        label: env.preferences.t("版本历史", en: "Version history", pl: "Historia wersji"),
                        id: DetailMemoChrome.history
                    ) {
                        showRevisions = true
                    }
                    headerIconButton(
                        systemImage: "magnifyingglass",
                        label: env.preferences.t("搜索当前笔记", en: "Search in note", pl: "Szukaj w notatce"),
                        id: DetailMemoChrome.search
                    ) {
                        withAnimation(Motion.chip) {
                            if searchOpen {
                                closeSearch()
                            } else {
                                searchOpen = true
                            }
                        }
                    }
                    headerIconButton(
                        systemImage: "ellipsis",
                        label: env.preferences.t("笔记操作", en: "Note actions", pl: "Działania na notatce"),
                        id: DetailMemoChrome.more
                    ) {
                        showMoreMenu = true
                    }
                }
            }
            .accessibilityIdentifier(DetailMemoChrome.header)
        }
        .padding(.horizontal, 12)
        .frame(minHeight: 48)
        .background(AppTheme.card)
        .overlay(alignment: .bottom) {
            Rectangle().fill(AppTheme.cardBorder).frame(height: 1)
        }
        .accessibilityIdentifier(DetailMemoChrome.header)
    }

    private func headerIconButton(
        systemImage: String,
        label: String,
        id: String,
        action: @escaping () -> Void
    ) -> some View {
        Button(action: action) {
            Image(systemName: systemImage)
                .font(.system(size: 16, weight: .semibold))
                .foregroundStyle(AppTheme.slate)
                .frame(width: 32, height: 32)
                .contentShape(Rectangle())
        }
        .buttonStyle(.plain)
        .accessibilityLabel(label)
        .accessibilityIdentifier(id)
    }

    @ViewBuilder
    private func collapsedHeaderTitle(_ memo: MemoDetail) -> some View {
        if memo.isDeleted || blocksRichTextEdit(memo) {
            Text(localizedTitle(for: memo))
                .font(.system(size: 14, weight: .semibold))
                .foregroundStyle(AppTheme.title)
                .lineLimit(1)
        } else {
            Button {
                onEdit(memo.id, .title)
            } label: {
                Text(localizedTitle(for: memo))
                    .font(.system(size: 14, weight: .semibold))
                    .foregroundStyle(AppTheme.title)
                    .lineLimit(1)
            }
            .buttonStyle(.plain)
            .accessibilityLabel(env.preferences.t("编辑笔记标题", en: "Edit note title", pl: "Edytuj tytuł notatki"))
            .accessibilityHint(env.preferences.t("进入编辑并聚焦标题", en: "Opens editing with the title focused", pl: "Otwiera edycję z kursorem w tytule"))
            .accessibilityIdentifier(DetailMemoChrome.title)
        }
    }

    // MARK: - Banners

    private var conflictBanner: some View {
        VStack(alignment: .leading, spacing: 10) {
            Text(env.preferences.t(
                "云端笔记已在其他标签页、设备,或离线期间被更新。可先复制本地草稿,再采用云端版本后继续编辑。",
                en: "This note changed on another device or while offline. Copy the local draft, then adopt the cloud version to continue.",
                pl: "Ta notatka zmieniła się na innym urządzeniu lub w trybie offline. Skopiuj lokalny szkic, a następnie przyjmij wersję z chmury, aby kontynuować."
            ))
            .font(.system(size: 12))
            .foregroundStyle(AppTheme.dangerStrong)
            .fixedSize(horizontal: false, vertical: true)

            if let lastOutboxError, !lastOutboxError.isEmpty {
                Text(lastOutboxError)
                    .font(.system(size: 12))
                    .foregroundStyle(AppTheme.dangerStrong)
            }

            HStack(spacing: 8) {
                Button {
                    if let item = conflictItem {
                        // Open full conflict resolution (Android "更多")
                        conflictItem = item
                    } else {
                        detectConflict()
                    }
                } label: {
                    Text(env.preferences.t("处理冲突", en: "Resolve", pl: "Rozwiąż"))
                        .font(.system(size: 12, weight: .bold))
                        .foregroundStyle(.white)
                        .padding(.horizontal, 10)
                        .padding(.vertical, 8)
                        .background(AppTheme.dangerAction)
                        .clipShape(RoundedRectangle(cornerRadius: 8))
                }
                .buttonStyle(.plain)

                Button {
                    Task { await copyLocalDraft() }
                } label: {
                    Text(env.preferences.t("复制本地草稿", en: "Copy local draft", pl: "Kopiuj lokalny szkic"))
                        .font(.system(size: 12, weight: .semibold))
                        .foregroundStyle(AppTheme.dangerStrong)
                        .padding(.horizontal, 10)
                        .padding(.vertical, 8)
                        .background(AppTheme.card)
                        .overlay(
                            RoundedRectangle(cornerRadius: 8)
                                .stroke(AppTheme.dangerBorder, lineWidth: 1)
                        )
                }
                .buttonStyle(.plain)
            }
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 12)
        .frame(maxWidth: .infinity, alignment: .leading)
        .background(AppTheme.dangerSurface)
        .overlay(alignment: .bottom) {
            Rectangle().fill(AppTheme.dangerBorder).frame(height: 0.5)
        }
    }

    private var syncBanner: some View {
        let isError = syncStatus == .error
        return VStack(alignment: .leading, spacing: 10) {
            Text(
                lastOutboxError?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
                    ?? (isError
                        ? env.preferences.t("本地改动未能上传到云端。内容仍保存在本机,可立即重试。", en: "Local changes could not upload. Content is still on device; retry anytime.", pl: "Nie udało się przesłać lokalnych zmian. Treść nadal jest na urządzeniu – możesz spróbować ponownie w dowolnym momencie.")
                        : env.preferences.t("本地改动待上传。下拉刷新或点此可立即同步。", en: "Local changes pending upload. Pull to refresh or tap to sync now.", pl: "Lokalne zmiany czekają na przesłanie. Przeciągnij w dół, aby odświeżyć, lub dotknij, aby zsynchronizować teraz."))
            )
            .font(.system(size: 12))
            .foregroundStyle(isError ? AppTheme.dangerStrong : AppTheme.infoText)
            .fixedSize(horizontal: false, vertical: true)

            HStack(spacing: 8) {
                Button {
                    Task {
                        // Force: ignore outbox backoff so "Memo not found" retries immediately
                        // and can recover via recreate-on-404 in OutboxFlusher.
                        await env.runSyncCycle(force: true)
                        refreshSyncStatus()
                        load()
                    }
                } label: {
                    Text(env.preferences.t("立即同步", en: "Sync now", pl: "Synchronizuj teraz"))
                        .font(.system(size: 12, weight: .bold))
                        .foregroundStyle(.white)
                        .padding(.horizontal, 10)
                        .padding(.vertical, 8)
                        .background(isError ? AppTheme.dangerAction : AppTheme.infoAction)
                        .clipShape(RoundedRectangle(cornerRadius: 8))
                }
                .buttonStyle(.plain)

                if isError {
                    Button {
                        Task { await copyLocalDraft() }
                    } label: {
                        Text(env.preferences.t("复制本地草稿", en: "Copy local draft", pl: "Kopiuj lokalny szkic"))
                            .font(.system(size: 12, weight: .semibold))
                            .foregroundStyle(AppTheme.dangerStrong)
                            .padding(.horizontal, 10)
                            .padding(.vertical, 8)
                            .background(AppTheme.card)
                            .overlay(
                                RoundedRectangle(cornerRadius: 8)
                                    .stroke(AppTheme.dangerBorder, lineWidth: 1)
                            )
                    }
                    .buttonStyle(.plain)
                }
            }
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 12)
        .frame(maxWidth: .infinity, alignment: .leading)
        .background(isError ? AppTheme.dangerSurface : AppTheme.infoSurface)
        .overlay(alignment: .bottom) {
            Rectangle()
                .fill(isError ? AppTheme.dangerBorder : AppTheme.infoText.opacity(0.55))
                .frame(height: 0.5)
        }
    }

    // MARK: - Body

    private func detailBody(_ memo: MemoDetail) -> some View {
        VStack(alignment: .leading, spacing: 0) {
            VStack(alignment: .leading, spacing: 0) {
                if !titleCollapsed || searchOpen {
                    detailTitleRow(memo)
                        .padding(.top, 8)
                        .edgeEverSuccessShine(trigger: pinPulse)

                    HStack(spacing: 8) {
                        notebookAffiliationControl(memo)

                        HStack(spacing: 8) {
                            Image(systemName: "tag")
                                .font(.system(size: 12, weight: .semibold))
                                .foregroundStyle(AppTheme.secondary)
                            Text(
                                memo.tags.isEmpty
                                    ? env.preferences.t("添加标签,用逗号分隔", en: "Add tags, comma separated", pl: "Dodaj tagi, oddzielone przecinkami")
                                    : memo.tags.joined(separator: ", ")
                            )
                            .font(.system(size: 12))
                            .foregroundStyle(memo.tags.isEmpty ? AppTheme.muted : AppTheme.secondary)
                            .lineLimit(1)
                            .textSelection(.enabled)
                        }
                        .frame(maxWidth: .infinity, alignment: .leading)
                        .accessibilityIdentifier(DetailMemoChrome.tags)
                    }
                    .frame(minHeight: 32)
                    .padding(.top, 6)
                    .accessibilityIdentifier(DetailMemoChrome.metaRow)

                    Text(
                        "\(env.preferences.t("创建于", en: "Created", pl: "Utworzono")) \(MemoDetailDate.format(memo.createdAt, locale: env.preferences.resolvedLocale))"
                        + " · "
                        + "\(env.preferences.t("更新于", en: "Updated", pl: "Zaktualizowano")) \(MemoDetailDate.format(memo.updatedAt, locale: env.preferences.resolvedLocale))"
                    )
                    .font(.system(size: 12))
                    .foregroundStyle(AppTheme.muted)
                    .padding(.top, 4)
                    .textSelection(.enabled)
                }

                if searchOpen {
                    HStack(spacing: 8) {
                        Image(systemName: "magnifyingglass")
                            .font(.system(size: 14, weight: .semibold))
                            .foregroundStyle(AppTheme.secondary)
                        TextField(
                            env.preferences.t("在当前笔记内搜索", en: "Search in this note", pl: "Szukaj w tej notatce"),
                            text: $searchQuery
                        )
                        .font(.system(size: 14))
                        .textFieldStyle(.plain)
                        .onChange(of: searchQuery) { _, query in
                            searchMatchIndex = 0
                            SharedTipTapRuntime.viewer.search(query, index: 0)
                        }
                        Text(searchMatchCount == 0 ? "0/0" : "\(searchMatchIndex + 1)/\(searchMatchCount)")
                            .font(.system(size: 12, weight: .semibold))
                            .foregroundStyle(AppTheme.secondary)
                            .monospacedDigit()
                        Button {
                            guard searchMatchCount > 0 else { return }
                            let next = (searchMatchIndex - 1 + searchMatchCount) % searchMatchCount
                            SharedTipTapRuntime.viewer.search(searchQuery, index: next)
                        } label: {
                            Image(systemName: "chevron.up")
                                .font(.system(size: 12, weight: .bold))
                                .frame(width: 28, height: 28)
                        }
                        .buttonStyle(.plain)
                        .disabled(searchMatchCount == 0)
                        .accessibilityLabel(env.preferences.t("上一个匹配项", en: "Previous match", pl: "Poprzednie dopasowanie"))
                        Button {
                            guard searchMatchCount > 0 else { return }
                            let next = (searchMatchIndex + 1) % searchMatchCount
                            SharedTipTapRuntime.viewer.search(searchQuery, index: next)
                        } label: {
                            Image(systemName: "chevron.down")
                                .font(.system(size: 12, weight: .bold))
                                .frame(width: 28, height: 28)
                        }
                        .buttonStyle(.plain)
                        .disabled(searchMatchCount == 0)
                        .accessibilityLabel(env.preferences.t("下一个匹配项", en: "Next match", pl: "Następne dopasowanie"))
                        Button {
                            closeSearch()
                        } label: {
                            Image(systemName: "xmark")
                                .font(.system(size: 12, weight: .bold))
                                .foregroundStyle(AppTheme.title)
                                .frame(width: 28, height: 28)
                        }
                        .buttonStyle(.plain)
                    }
                    .padding(10)
                    .background(AppTheme.background)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
                    .overlay(
                        RoundedRectangle(cornerRadius: 8)
                            .stroke(AppTheme.border, lineWidth: 1)
                    )
                    .padding(.top, 14)
                }

                Rectangle()
                    .fill(AppTheme.border)
                    .frame(height: 1)
                    .padding(.top, titleCollapsed && !searchOpen ? 0 : 16)
                    .padding(.bottom, 8)
            }
            .padding(.horizontal, 16)

            // Always show TipTap at full opacity. A plain contentText overlay looked like a
            // "broken layout" (one wall of text) when bodyReady failed to flip.
            ZStack {
                TipTapWebView(
                    mode: .viewer,
                    documentJSON: (try? memo.contentJson.jsonString())
                        ?? "{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\"}]}",
                    markdown: memo.contentMarkdown,
                    baseURL: env.session.session.flatMap { URL(string: $0.baseUrl) },
                    token: env.session.session?.token,
                    locale: env.preferences.apiLocale,
                    theme: colorScheme == .dark ? "dark" : "light",
                    placeholder: env.preferences.t("开始输入…", en: "Start writing…", pl: "Zacznij pisać…"),
                    onChange: nil,
                    onResourcePress: { target in
                        resourceTarget = target
                    },
                    onImagePreview: { source, alt in
                        imagePreview = (source, alt)
                    },
                    onDoubleTap: blocksRichTextEdit(memo) ? nil : {
                        onEdit(memo.id, .body)
                    },
                    onPickImage: nil,
                    onSearchResult: { count, index in
                        searchMatchCount = count
                        searchMatchIndex = index
                    },
                    onReaderScroll: { collapsed in
                        titleCollapsed = collapsed
                    },
                    onImageExportEvent: { event in
                        handleImageExportEvent(event)
                    },
                    onBodyReady: {
                        bodyReady = true
                    }
                )

                if !bodyReady {
                    ProgressView()
                        .tint(AppTheme.title)
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                        .background(AppTheme.card.opacity(0.92))
                        .allowsHitTesting(false)
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .accessibilityIdentifier(DetailMemoChrome.body)
            .task(id: memo.id) {
                // Safety net: never leave the spinner forever if a ready callback is missed.
                try? await Task.sleep(nanoseconds: 1_200_000_000)
                if !bodyReady {
                    bodyReady = true
                }
            }
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
    }

    // MARK: - Sync helpers

    private var syncStatus: DetailSyncStatus {
        DetailSyncStatus.derive(outboxStatus: outboxStatus, isGlobalSyncing: env.isSyncing)
    }

    private var syncLabel: String {
        env.preferences.t(syncStatus.labelZH, en: syncStatus.labelEN, pl: syncStatus.labelPL)
    }

    private var availableNotebooks: [Notebook] {
        (try? env.mirror.listNotebooks(scope: env.session.dataScope ?? "")) ?? []
    }

    private func notebookName(for memo: MemoDetail) -> String {
        availableNotebooks.first(where: { $0.id == memo.notebookId })?.name
            ?? env.preferences.t("笔记本", en: "Notebook", pl: "Notatnik")
    }

    private func notebookAffiliationLabel(_ memo: MemoDetail) -> some View {
        HStack(spacing: 4) {
            Text(notebookName(for: memo))
                .font(.system(size: 12))
                .foregroundStyle(AppTheme.secondary)
                .lineLimit(1)
            Image(systemName: "chevron.down")
                .font(.system(size: 11, weight: .semibold))
                .foregroundStyle(AppTheme.muted)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .layoutPriority(0)
    }

    @ViewBuilder
    private func notebookAffiliationControl(_ memo: MemoDetail) -> some View {
        if memo.isDeleted {
            notebookAffiliationLabel(memo)
                .accessibilityIdentifier(DetailMemoChrome.notebook)
        } else {
            Button {
                showNotebookPicker = true
            } label: {
                notebookAffiliationLabel(memo)
            }
            .buttonStyle(.plain)
            .accessibilityLabel(env.preferences.t("所在笔记本", en: "Notebook", pl: "Notatnik"))
            .accessibilityHint(env.preferences.t("更改笔记所属笔记本", en: "Change the notebook for this note", pl: "Zmień notatnik tej notatki"))
            .accessibilityIdentifier(DetailMemoChrome.notebook)
        }
    }

    private func handleSyncStatusPress() {
        switch syncStatus {
        case .conflict:
            detectConflict()
        case .error, .pending:
            Task {
                await env.runSyncCycle(force: true)
                refreshSyncStatus()
                load()
            }
        case .synced, .syncing:
            break
        }
    }

    private func detailTitleRow(_ memo: MemoDetail) -> some View {
        HStack(spacing: 6) {
            if memo.isPinned {
                Text("★")
                    .font(.system(size: 16))
                    .foregroundStyle(AppTheme.secondary)
            }
            Button {
                onEdit(memo.id, .title)
            } label: {
                Text(localizedTitle(for: memo))
                    .font(.system(size: 18, weight: .bold))
                    .foregroundStyle(AppTheme.title)
                    .lineLimit(4)
                    .multilineTextAlignment(.leading)
            }
            .buttonStyle(.plain)
            .disabled(memo.isDeleted || blocksRichTextEdit(memo))
            .accessibilityLabel(isInfographic(memo)
                ? env.preferences.t("信息图标题", en: "Infographic title", pl: "Tytuł infografiki")
                : isStructuredTable(memo)
                ? env.preferences.t("表格标题", en: "Database title", pl: "Tytuł bazy danych")
                : isVisualDiagram(memo)
                ? env.preferences.t("图表标题", en: "Diagram title", pl: "Tytuł diagramu")
                : env.preferences.t("编辑笔记标题", en: "Edit note title", pl: "Edytuj tytuł notatki"))
            .accessibilityHint(memo.contentMarkdown.contains("<!-- edgeever-poster-v1:")
                ? env.preferences.t("海报请在 Web 或桌面端编辑", en: "Edit posters on Web or desktop", pl: "Plakaty edytuj w wersji webowej lub desktopowej")
                : isInfographic(memo)
                ? env.preferences.t("信息图请在 Web 或桌面端编辑", en: "Edit infographics on Web or desktop", pl: "Infografiki edytuj w wersji webowej lub desktopowej")
                : isStructuredTable(memo)
                ? env.preferences.t("多维表格请在 Web 或桌面端编辑", en: "Edit databases on Web or desktop", pl: "Bazy danych edytuj w wersji webowej lub desktopowej")
                : isVisualDiagram(memo)
                ? env.preferences.t("可视化图表请在 Web 或桌面端编辑", en: "Edit visual diagrams on Web or desktop", pl: "Diagramy wizualne edytuj w wersji webowej lub desktopowej")
                : env.preferences.t("进入编辑并聚焦标题", en: "Opens editing with the title focused", pl: "Otwiera edycję z kursorem w tytule"))
            .accessibilityIdentifier(DetailMemoChrome.title)
        }
    }

    private func load() {
        guard let scope = env.session.dataScope else { return }
        do {
            memo = try env.mirror.resolveMemo(scope: scope, id: memoId)
            if memo == nil {
                error = env.preferences.t("本地未找到该笔记,请先同步。", en: "Note not in local cache. Sync first.", pl: "Notatki nie ma w lokalnej pamięci podręcznej. Najpierw zsynchronizuj.")
            }
        } catch {
            self.error = error.localizedDescription
        }
    }

    private func isVisualDiagram(_ memo: MemoDetail) -> Bool {
        memo.contentMarkdown.contains("<!-- edgeever-diagram-v1:")
    }

    private func isStructuredTable(_ memo: MemoDetail) -> Bool {
        memo.contentMarkdown.contains("<!-- edgeever-table-v1:")
    }

    private func isInfographic(_ memo: MemoDetail) -> Bool {
        memo.contentMarkdown.contains("<!-- edgeever-infographic-v1:")
    }

    private func blocksRichTextEdit(_ memo: MemoDetail) -> Bool {
        isVisualDiagram(memo) || isStructuredTable(memo) || isInfographic(memo) || memo.contentMarkdown.contains("<!-- edgeever-poster-v1:")
    }

    private func refreshSyncStatus() {
        guard let scope = env.session.dataScope else {
            outboxStatus = nil
            lastOutboxError = nil
            return
        }
        let items = (try? env.outbox.listItems(scope: scope)) ?? []
        if let item = items.first(where: { $0.memoId == memoId }) {
            outboxStatus = item.status
            lastOutboxError = item.lastError
            if item.status == .conflict {
                conflictItem = item
            }
        } else {
            outboxStatus = nil
            lastOutboxError = nil
        }
    }

    private func detectConflict() {
        guard let scope = env.session.dataScope else { return }
        let items = (try? env.outbox.listItems(scope: scope)) ?? []
        conflictItem = items.first { $0.memoId == memoId && $0.status == .conflict }
        refreshSyncStatus()
    }

    private func copyLocalDraft() async {
        guard let memo else { return }
        let text = [localizedTitle(for: memo), memo.contentMarkdown].filter { !$0.isEmpty }.joined(separator: "\n\n")
        UIPasteboard.general.string = text
    }

    private func isTemporaryMemoId(_ id: String) -> Bool {
        id.hasPrefix("local:") || id.hasPrefix("local_")
    }

    private func closeSearch() {
        searchOpen = false
        searchQuery = ""
        searchMatchCount = 0
        searchMatchIndex = 0
        SharedTipTapRuntime.viewer.search("", index: 0)
    }

    private func localizedTitle(for memo: MemoDetail) -> String {
        let title = memo.title?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
        return title.isEmpty ? env.preferences.t("无标题笔记", en: "Untitled note", pl: "Notatka bez tytułu") : title
    }

    private func moveMemoToNotebook(_ memo: MemoDetail, notebookId: String) async {
        guard !memo.isDeleted else { return }
        guard !notebookId.isEmpty, notebookId != memo.notebookId else { return }
        guard let scope = env.session.dataScope else { return }
        let revision = memo.revision
        let contentHash = memo.contentHash
        var updated = memo
        updated.notebookId = notebookId
        updated.updatedAt = EdgeEverDate.nowString()
        do {
            try env.mirror.upsertMemo(scope: scope, memo: updated)
            self.memo = updated
            try env.outbox.enqueueUpdate(
                scope: scope,
                payload: MemoUpdatePayload(
                    memoId: updated.id,
                    expectedRevision: revision,
                    expectedContentHash: contentHash,
                    title: updated.title ?? "",
                    contentMarkdown: updated.contentMarkdown,
                    contentJson: try? updated.contentJson.jsonString(),
                    notebookId: notebookId,
                    tags: updated.tags
                )
            )
            await env.runSyncCycle()
            load()
            refreshSyncStatus()
        } catch {
            self.error = error.localizedDescription
            load()
        }
    }

    private func togglePin(_ memo: MemoDetail) async {
        guard let scope = env.session.dataScope else { return }
        do {
            let updated = try await env.session.client.updateMemo(
                id: memo.id,
                expectedRevision: nil,
                expectedContentHash: nil,
                editSessionId: nil,
                notebookId: nil,
                title: nil,
                isPinned: !memo.isPinned,
                contentMarkdown: nil,
                tags: nil
            )
            try env.mirror.upsertMemo(scope: scope, memo: updated)
            self.memo = updated
        } catch {
            self.error = error.localizedDescription
        }
    }

    private func applyAiDraft(
        _ draft: String,
        mode: AiDraftApplyMode,
        to sourceMemo: MemoDetail
    ) async throws {
        guard let scope = env.session.dataScope else {
            throw APIError(
                status: -1,
                code: "session_unavailable",
                message: env.preferences.t("登录状态已失效,请重新登录。", en: "Your session has expired. Sign in again.", pl: "Sesja wygasła. Zaloguj się ponownie.")
            )
        }
        let normalizedDraft = draft.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !normalizedDraft.isEmpty else { return }
        let currentContent = sourceMemo.contentMarkdown.trimmingCharacters(in: .whitespacesAndNewlines)
        let contentMarkdown = mode == .append && !currentContent.isEmpty
            ? "\(currentContent)\n\n\(normalizedDraft)"
            : normalizedDraft

        let editSession = try await env.session.client.createMemoEditSession(memoId: sourceMemo.id)
        guard
            editSession.baseRevision == sourceMemo.revision,
            editSession.baseContentHash == sourceMemo.contentHash
        else {
            throw APIError(
                status: 409,
                code: "revision_conflict",
                message: env.preferences.t(
                    "笔记已在其他设备更新,请刷新后重新生成。",
                    en: "This note changed on another device. Refresh it and generate again.",
                    pl: "Ta notatka zmieniła się na innym urządzeniu. Odśwież ją i wygeneruj ponownie."
                )
            )
        }

        let updated = try await env.session.client.updateMemo(
            id: sourceMemo.id,
            expectedRevision: sourceMemo.revision,
            expectedContentHash: sourceMemo.contentHash,
            editSessionId: editSession.id,
            notebookId: nil,
            title: nil,
            isPinned: nil,
            contentMarkdown: contentMarkdown,
            contentJson: nil,
            tags: nil
        )
        try env.mirror.upsertMemo(scope: scope, memo: updated)
        memo = updated
        refreshSyncStatus()
    }

    private func openInitialShareImageIfReady() {
        guard initialShareImage, bodyReady, memo?.isDeleted == false, !initialShareImageHandled else { return }
        initialShareImageHandled = true
        imageShareOptionsOpen = true
    }

    private func shareMemo(_ memo: MemoDetail) async {
        do {
            let share = try await env.session.client.createMemoShare(memoId: memo.id)
            let base = env.session.session?.baseUrl.trimmingCharacters(in: CharacterSet(charactersIn: "/")) ?? ""
            guard let url = URL(string: "\(base)/share/\(share.token)") else { return }
            let title = memo.title?.trimmingCharacters(in: .whitespacesAndNewlines)
            let displayTitle = title?.isEmpty == false
                ? title!
                : env.preferences.t("无标题笔记", en: "Untitled note", pl: "Notatka bez tytułu")
            memoSharePayload = MemoSharePayload(message: "\(displayTitle)\n\(url.absoluteString)", url: url)
        } catch {
            self.error = error.localizedDescription
        }
    }

    private func deleteMemo(_ memo: MemoDetail) async {
        guard let scope = env.session.dataScope else { return }
        do {
            if memo.id.hasPrefix("local:") {
                try env.outbox.cancelMemo(scope: scope, memoId: memo.id)
                try env.mirror.deleteMemo(scope: scope, id: memo.id)
            } else {
                _ = try env.mirror.softDeleteMemo(scope: scope, id: memo.id)
                try await env.session.client.deleteMemo(id: memo.id, permanent: false)
            }
            dismiss()
        } catch {
            self.error = error.localizedDescription
        }
    }

    private func exportMemoImage(
        _ memo: MemoDetail,
        format: String,
        theme: String = "mint",
        fontStyle: String = "auto",
        fontSize: String = "lg",
        cardWidth: String = "wide",
        showTitle: Bool = false,
        showNotebook: Bool = false,
        showTags: Bool = false,
        showUpdatedAt: Bool = true,
        showBranding: Bool = true,
        intent: MemoImageExportIntent = .share
    ) {
        guard !imageExporting, bodyReady else { return }
        let requestId = UUID().uuidString
        imageExportBuffer.start(requestId: requestId)
        imageExportRequestId = requestId
        imageFontRecoveryId = requestId
        imageFontsRecovered = false
        imageFontStatus = "loading"
        retryImageFonts = {
            exportMemoImage(memo, format: format, theme: theme, fontStyle: fontStyle, fontSize: fontSize,
                cardWidth: cardWidth, showTitle: showTitle, showNotebook: showNotebook, showTags: showTags,
                showUpdatedAt: showUpdatedAt, showBranding: showBranding, intent: .preview)
        }
        imageExportIntent = intent
        imageExporting = true
        DispatchQueue.main.asyncAfter(deadline: .now() + 60) {
            guard imageExportRequestId == requestId else { return }
            imageExportBuffer.cancel(requestId: requestId)
            imageExportRequestId = nil
            imageExporting = false
            imageExportMessage = MemoImageExportMessage(
                title: env.preferences.t("导出失败", en: "Export failed", pl: "Eksport nie powiódł się"),
                message: env.preferences.t(
                    "生成图片超时。请调小导出字号,或尝试较短的笔记。",
                    en: "Image generation timed out. Try a smaller font size or a shorter note.",
                    ja: "画像の生成がタイムアウトしました。文字を小さくするか、短いノートでお試しください。",
                    pl: "Generowanie obrazu przekroczyło limit czasu. Spróbuj mniejszej czcionki lub krótszej notatki."
                )
            )
        }
        let title = memo.title?.trimmingCharacters(in: .whitespacesAndNewlines)
        SharedTipTapRuntime.viewer.exportNoteImage(request: [
            "requestId": requestId,
            "format": format,
            "title": title?.isEmpty == false ? title! : env.preferences.t("无标题笔记", en: "Untitled note", pl: "Notatka bez tytułu"),
            "fallbackTitle": env.preferences.t("无标题笔记", en: "Untitled note", pl: "Notatka bez tytułu"),
            "notebook": showNotebook ? notebookName(for: memo) : "",
            "tags": showTags ? memo.tags : [],
            "updatedAt": showUpdatedAt ? formattedImageExportDate(memo.updatedAt) : "",
            "theme": theme,
            "fontStyle": fontStyle,
            "fontSize": fontSize,
            "cardWidth": cardWidth,
            "showTitle": showTitle,
            "showNotebook": showNotebook,
            "showTags": showTags,
            "showUpdatedAt": showUpdatedAt,
            "branding": showBranding,
        ])
    }

    private func formattedImageExportDate(_ rawValue: String) -> String {
        let parsers = [ISO8601DateFormatter.edgeEver, ISO8601DateFormatter.edgeEverFallback]
        guard let date = parsers.lazy.compactMap({ $0.date(from: rawValue) }).first else { return rawValue }
        let formatter = DateFormatter()
        formatter.locale = env.preferences.uiLanguage == .polish
            ? Locale(identifier: "pl_PL")
            : (env.preferences.isEnglish ? Locale(identifier: "en_US") : Locale(identifier: "zh_CN"))
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }

    private func handleImageExportEvent(_ event: [String: Any]) {
        if event["type"] as? String == "imageExportFontsReady" {
            guard event["requestId"] as? String == imageFontRecoveryId else { return }
            imageFontsRecovered = true
            if !imageExporting, imageExportPreviewPayload?.fontFallback == true { retryImageFonts?() }
            return
        }
        if event["type"] as? String == "imageExportFontStatus" {
            guard event["requestId"] as? String == imageExportRequestId else { return }
            imageFontStatus = event["status"] as? String ?? "ready"
            return
        }
        switch imageExportBuffer.accept(event) {
        case .none:
            break
        case let .failure(message):
            imageExportRequestId = nil
            imageExporting = false
            let explanation: String
            switch message {
            case "NOTE_IMAGE_TOO_LONG":
                explanation = env.preferences.t(
                    "笔记太长,无法清晰地导出为单张图片。",
                    en: "This note is too long to export clearly as one image.",
                    ja: "ノートが長すぎるため、1枚の画像として鮮明に書き出せません。",
                    pl: "Notatka jest zbyt długa, aby wyeksportować ją czytelnie jako jeden obraz."
                )
            case "NOTE_IMAGE_RENDER_FAILED":
                explanation = env.preferences.t(
                    "图片生成失败,请稍后重试。",
                    en: "The image could not be generated. Please try again.",
                    ja: "画像を生成できませんでした。もう一度お試しください。",
                    pl: "Nie udało się wygenerować obrazu. Spróbuj ponownie."
                )
            default:
                explanation = message
            }
            imageExportMessage = MemoImageExportMessage(
                title: env.preferences.t("导出失败", en: "Export failed", pl: "Eksport nie powiódł się"),
                message: explanation
            )
        case let .complete(data, filename, metadata):
            imageExportRequestId = nil
            imageExporting = false
            do {
                let directory = FileManager.default.temporaryDirectory.appendingPathComponent("EdgeEverNoteExports", isDirectory: true)
                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
                try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
                let safeFilename = (filename as NSString).lastPathComponent
                let url = directory.appendingPathComponent(safeFilename)
                try data.write(to: url, options: .atomic)
                if imageExportIntent == .preview || metadata.fontFallback {
                    imageExportPreviewPayload = MemoImageExportPreviewPayload(
                        id: imageExportPreviewPayload?.id ?? UUID(),
                        fontFallback: metadata.fontFallback,
                        url: url,
                        width: metadata.width,
                        height: metadata.height,
                        totalImages: metadata.totalImages,
                        failedImages: metadata.failedImages
                    )
                    if metadata.fontFallback, imageFontsRecovered {
                        let recoveryId = imageFontRecoveryId
                        DispatchQueue.main.async {
                            if imageFontRecoveryId == recoveryId, imageExportPreviewPayload != nil { retryImageFonts?() }
                        }
                    }
                } else {
                    imageExportSharePayload = MemoImageExportSharePayload(url: url)
                }
            } catch {
                imageExportMessage = MemoImageExportMessage(
                    title: env.preferences.t("导出失败", en: "Export failed", pl: "Eksport nie powiódł się"),
                    message: error.localizedDescription
                )
            }
        }
    }
}

private struct MemoSharePayload: Identifiable {
    let id = UUID()
    let message: String
    let url: URL
}

private struct MemoImageExportSharePayload: Identifiable {
    let id = UUID()
    let url: URL
}

private struct MemoImageExportPreviewPayload: Identifiable {
    let id: UUID
    let fontFallback: Bool
    let url: URL
    let width: Int
    let height: Int
    let totalImages: Int
    let failedImages: Int
}

private struct MemoImageExportDocumentPayload: Identifiable {
    let id = UUID()
    let url: URL
}

private enum MemoImageExportIntent {
    case preview
    case share
}

private struct MemoImageExportMessage: Identifiable {
    let id = UUID()
    let title: String
    let message: String
}

private struct MemoImageExportPreviewView: View {
    @Environment(\.dismiss) private var dismiss
    let payload: MemoImageExportPreviewPayload
    let isLoadingFonts: Bool
    let onRetryFonts: () -> Void
    let isEnglish: Bool
    var isPolish: Bool = false
    let onCopy: () -> Void
    let onSave: () -> Void
    let onShare: () -> Void

    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                ScrollView {
                    VStack(spacing: 12) {
                        if let image = UIImage(contentsOfFile: payload.url.path) {
                            Image(uiImage: image)
                                .resizable()
                                .scaledToFit()
                                .clipShape(RoundedRectangle(cornerRadius: 14))
                                .shadow(color: .black.opacity(0.16), radius: 12, y: 5)
                        } else {
                            ContentUnavailableView(
                                isPolish ? "Podgląd niedostępny" : (isEnglish ? "Preview unavailable" : "无法预览"),
                                systemImage: "photo.badge.exclamationmark"
                            )
                        }
                        if payload.fontFallback || isLoadingFonts {
                            if isLoadingFonts {
                                ProgressView(isPolish ? "Ładowanie czcionki…" : (isEnglish ? "Loading font…" : "字体加载中…"))
                            } else {
                                warning(isPolish
                                    ? "Tymczasowo używane są czcionki zastępcze. Po załadowaniu oryginalne czcionki zostaną przywrócone automatycznie."
                                    : (isEnglish ? "Temporarily using substitute fonts. The original fonts will be restored automatically when loaded." : "暂时使用替代字体,加载成功后将自动恢复"))
                                Button(isPolish ? "Ponów próbę" : (isEnglish ? "Retry" : "重试"), action: onRetryFonts)
                            }
                        }
                        if payload.failedImages > 0 {
                            warning(
                                isPolish
                                    ? "Nie udało się dołączyć obrazów z notatki: \(payload.failedImages) z \(payload.totalImages)."
                                    : isEnglish
                                    ? "\(payload.failedImages) of \(payload.totalImages) note image(s) could not be included."
                                    : "笔记中的 \(payload.totalImages) 张图片有 \(payload.failedImages) 张未能包含。"
                            )
                        }
                        if payload.height > 12_000 {
                            warning(
                                isPolish
                                    ? "To długi obraz. Niektóre aplikacje społecznościowe mogą obniżyć jego jakość – zachowaj zapisany oryginał."
                                    : isEnglish
                                    ? "This is a long image. Some social apps may reduce its quality; keep the saved original."
                                    : "图片较长,部分社交平台可能会压缩画质;建议保留保存的原图。"
                            )
                        }
                    }
                    .padding(16)
                }
                Divider()
                HStack(spacing: 8) {
                    previewButton(isPolish ? "Kopiuj" : (isEnglish ? "Copy" : "复制图片"), systemImage: "doc.on.doc", action: onCopy)
                    previewButton(isPolish ? "Zapisz" : (isEnglish ? "Save" : "保存图片"), systemImage: "square.and.arrow.down", action: onSave)
                    Button(action: onShare) {
                        Label(isPolish ? "Udostępnij" : (isEnglish ? "Share" : "系统分享"), systemImage: "square.and.arrow.up")
                            .frame(maxWidth: .infinity, minHeight: 44)
                    }
                    .buttonStyle(.borderedProminent)
                    .tint(Color(red: 22 / 255, green: 160 / 255, blue: 110 / 255))
                }
                .font(.system(size: 13, weight: .semibold))
                .padding(12)
            }
            .background(Color(.systemGroupedBackground))
            .navigationTitle(isPolish ? "Podgląd obrazu" : (isEnglish ? "Image Preview" : "图片预览"))
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button(isPolish ? "Zamknij" : (isEnglish ? "Close" : "关闭")) { dismiss() }
                }
            }
        }
    }

    private func warning(_ text: String) -> some View {
        Text(text)
            .font(.system(size: 13))
            .foregroundStyle(Color.orange)
            .frame(maxWidth: .infinity, alignment: .leading)
            .padding(10)
            .background(Color.orange.opacity(0.1), in: RoundedRectangle(cornerRadius: 8))
    }

    private func previewButton(_ title: String, systemImage: String, action: @escaping () -> Void) -> some View {
        Button(action: action) {
            Label(title, systemImage: systemImage)
                .frame(maxWidth: .infinity, minHeight: 44)
        }
        .buttonStyle(.bordered)
    }
}

private struct MemoImageDocumentExportView: UIViewControllerRepresentable {
    let fileURL: URL
    let onFinish: (Result<Bool, Error>) -> Void

    func makeCoordinator() -> Coordinator { Coordinator(onFinish: onFinish) }

    func makeUIViewController(context: Context) -> UIDocumentPickerViewController {
        let picker = UIDocumentPickerViewController(forExporting: [fileURL], asCopy: true)
        picker.delegate = context.coordinator
        picker.shouldShowFileExtensions = true
        return picker
    }

    func updateUIViewController(_ uiViewController: UIDocumentPickerViewController, context: Context) {}

    final class Coordinator: NSObject, UIDocumentPickerDelegate {
        let onFinish: (Result<Bool, Error>) -> Void
        init(onFinish: @escaping (Result<Bool, Error>) -> Void) { self.onFinish = onFinish }
        func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
            onFinish(.success(!urls.isEmpty))
        }
        func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
            onFinish(.success(false))
        }
    }
}

private final class MemoImageExportBuffer {
    struct Metadata {
        let fontFallback: Bool
        let width: Int
        let height: Int
        let totalImages: Int
        let failedImages: Int
    }

    enum Result {
        case none
        case complete(Data, filename: String, metadata: Metadata)
        case failure(String)
    }

    private var requestId: String?
    private var chunks: [String] = []

    func start(requestId: String) {
        self.requestId = requestId
        chunks.removeAll(keepingCapacity: true)
    }

    func cancel(requestId: String) {
        guard self.requestId == requestId else { return }
        self.requestId = nil
        chunks.removeAll(keepingCapacity: false)
    }

    func accept(_ event: [String: Any]) -> Result {
        guard let currentRequestId = requestId,
              event["requestId"] as? String == currentRequestId,
              let type = event["type"] as? String
        else { return .none }

        if type == "imageExportChunk" {
            if let chunk = event["chunk"] as? String { chunks.append(chunk) }
            return .none
        }

        defer {
            requestId = nil
            chunks.removeAll(keepingCapacity: false)
        }
        if type == "imageExportError" {
            return .failure(event["message"] as? String ?? "Image export failed")
        }
        guard type == "imageExportComplete",
              let filename = event["filename"] as? String,
              let data = Data(base64Encoded: chunks.joined())
        else { return .failure("Image export returned invalid data") }
        let metadata = Metadata(
            fontFallback: event["fontFallback"] as? Bool ?? false,
            width: (event["width"] as? NSNumber)?.intValue ?? 0,
            height: (event["height"] as? NSNumber)?.intValue ?? 0,
            totalImages: (event["totalImages"] as? NSNumber)?.intValue ?? 0,
            failedImages: (event["failedImages"] as? NSNumber)?.intValue ?? 0
        )
        return .complete(data, filename: filename, metadata: metadata)
    }
}

// MARK: - String helper

private extension String {
    var nilIfEmpty: String? {
        let t = trimmingCharacters(in: .whitespacesAndNewlines)
        return t.isEmpty ? nil : t
    }
}

// MARK: - Version history (Android RevisionHistoryModal parity)

/// Android `RevisionHistoryModal`: header + selected summary/restore + timeline pills + markdown preview.