import type { VaultEvent } from '@@/apis/events/type'
import type { Entry, TreeIcon } from '@@/apis/tree/type'
import type { PluginAPI } from '@@/plugin-api'
import type { SettingsSection } from '@/pinia/stores/settings'
import { cleanupImagesApi, importImageApi, replaceImageApi, uploadFolderImageApi, uploadImageApi } from '@@/apis/assets'
import { connectEventsApi } from '@@/apis/events'
import { createFolderApi, deleteFileApi, getRawFileApi, importNotesApi, moveFileApi, writeFileApi } from '@@/apis/files'
import { restoreTrashApi } from '@@/apis/trash'
import { getTreeApi, setTreeIconApi } from '@@/apis/tree'
import { appearancePaused } from '@@/appearance/appearance'
import { locale, t as translate } from '@@/i18n/runtime'
// Workspace state and operations: tree, tabs, save queue, conflict handling, and live synchronization.
// File operations update the interface optimistically before requesting the server, rolling back on failure for immediate feedback.
import { decodeLinkDestination } from '@@/markdown/links'

import { pluginEditorFailure, refreshPlugins, startPlugins, stopPlugins } from '@@/plugins/host'
import { notePath, pluginEvents, pluginRefresh, pluginsPaused, setPluginEditorHandlers } from '@@/plugins/registry'
import { handleShortcut, registerCommand } from '@@/utils/commands'
import { readNoteFile } from '@@/utils/note-files'
import { toast } from '@@/utils/notifications'
import { basename, dirname, encodePath, isImage, joinPath, NOTE_EXT, resolveAssetUrl } from '@@/utils/paths'

import { imageResourceRoot, prepareResources } from '@@/utils/resource-tickets'
import { typoraKeys } from '@@/utils/typora-keys'
import { trackVisualViewport } from '@@/utils/viewport'
import { Annotation, EditorState, Transaction } from '@codemirror/state'
import { EditorView } from '@codemirror/view'
import { CanceledError, isCancel } from 'axios'
import { nextTick, reactive, watch } from 'vue'
import { ApiError } from '@/http/axios'
import { pinia } from '@/pinia'
import { SettingsAppearanceError, useSettingsStore } from '@/pinia/stores/settings'
import { useUserStore } from '@/pinia/stores/user'
import { drafts } from './drafts'
import { createEditorState, insertImageFiles, languageCompartment, pasteImages, pluginCompartment, pluginEditorExtensions, pluginLanguage, preferencesCompartment, previewCompartment, previewExtensions } from './editor'
import { refreshImages } from './editor/livepreview'
import { editorLocale, localeCompartment } from './editor/locale'
import { editorCommands } from './editor/shortcuts'
import { refreshMetadata } from './metadata'

const { loadSettings, settings, updateSettings } = useSettingsStore(pinia)

export type TabStatus = 'loading' | 'ready' | 'conflict' | 'deleted' | 'error'

export interface Tab {
  path: string
  pinned?: boolean
  // Last revision synchronized with the server.
  rev: string
  status: TabStatus
  // Changes not yet saved successfully.
  dirty: boolean
  saveError?: string
  // Server revision during conflict; an empty string means the file no longer exists there.
  conflictRev?: string
}

const RECENT_KEY = 'rawmark.recent'
// Local interface state outside settings: sidebar collapse and outline panel.
const LAYOUT_KEY = 'rawmark.layout'
const layout = JSON.parse(localStorage.getItem(LAYOUT_KEY) ?? '{}') as { sidebarCollapsed?: boolean, outlineOpen?: boolean }
const RECENT_MAX = 30

export const ws = reactive({
  entries: [] as Entry[],
  tabs: [] as Tab[],
  active: null as string | null,
  // Path currently being renamed inline in the tree.
  renaming: null as string | null,
  // Mobile sidebar drawer.
  sidebarOpen: false,
  // Show search instead of the tree in the sidebar.
  searchOpen: false,
  // Initial quick-switcher/command-palette query; null closes it, and leading > lists commands.
  switcher: null as string | null,
  // Open settings category; null closes it. index is the general entry, showing categories on phones and the first category on desktop.
  settings: (pluginsPaused ? 'plugins' : appearancePaused ? 'appearance' : null) as SettingsSection | 'index' | null,
  // "Move to..." dialog paths for notes or folders.
  moving: null as string | string[] | null,
  // Import destination folder; an empty string denotes the root.
  importing: null as string | null,
  // Image preview and management, independent of note tabs and drafts.
  image: null as string | null,
  images: null as string | null,
  imagesAll: false,
  // Desktop sidebar collapse state.
  sidebarCollapsed: layout.sidebarCollapsed ?? false,
  // Outline panel: persistent on the right on desktop, an overlay on phones.
  outlineOpen: layout.outlineOpen ?? false,
  sourceMode: false,
  focusMode: false,
  view: 'notes' as 'notes' | 'graph' | 'tags',
  // Recently opened notes, newest first.
  recent: JSON.parse(localStorage.getItem(RECENT_KEY) ?? '[]') as string[],
})

const SAVE_DELAY = 500
const RETRY_DELAY = 5000
const MAX_RETRIES = 12

// Keep the following state outside reactive: large immutable EditorState objects gain nothing from Vue proxies.
const editorStates = new Map<string, EditorState>()
// Each open note has a mutable reference through which editor extensions read its current path, updated on rename.
const noteRefs = new Map<string, { path: string }>()

interface SaveSlot {
  timer?: ReturnType<typeof setTimeout>
  inflight?: Promise<void>
  // Change and saved sequence numbers; equality means no pending changes.
  seq: number
  savedSeq: number
  uploads: number
  paused: number
  retries: number
}
const slots = new Map<string, SaveSlot>()

const user = useUserStore(pinia)
let workspaceRunning = false
let workspaceEpoch = 0
let draftPreserved: Promise<void> = Promise.resolve()

let view: EditorView | null = null
// In-flight local file operations; tree events during these operations must not determine whether tabs were deleted.
let opsInFlight = 0

const externalChange = Annotation.define<boolean>()

// Editor content/cursor subscribers, such as the outline, bypass Vue reactivity to avoid component updates on every keystroke.
const editorListeners = new Set<() => void>()
export function onEditorUpdate(fn: () => void): () => void {
  editorListeners.add(fn)
  return () => editorListeners.delete(fn)
}

export function tabOf(path: string | null): Tab | undefined {
  return path === null ? undefined : ws.tabs.find(t => t.path === path)
}

export function activeTab(): Tab | undefined {
  return tabOf(ws.active)
}

function errorText(err: unknown): string {
  return err instanceof ApiError ? err.message : translate('common.network_error_check_your_connection_566064')
}

// ---- Editor state ----

export function attachView(v: EditorView | null) {
  view = v
}

/** Current editor view, accessed directly by controls such as the mobile toolbar. */
export function editorView(): EditorView | null {
  return view
}

export function toggleSourceMode() {
  ws.sourceMode = !ws.sourceMode
  const effects = previewCompartment.reconfigure(previewExtensions(ws.sourceMode))
  for (const [path, state] of editorStates) {
    if (path === ws.active && view) {
      view.dispatch({ effects })
      editorStates.set(path, view.state)
    } else {
      editorStates.set(path, state.update({ effects }).state)
    }
  }
}

/** Choose an image from photos/files and insert it at the cursor. */
export function insertImagesFromPicker() {
  const v = view
  const tab = activeTab()
  if (!v || tab?.status !== 'ready') return
  const input = document.createElement('input')
  input.type = 'file'
  input.accept = 'image/*'
  input.multiple = true
  input.addEventListener('change', () => {
    if (input.files?.length && view === v) insertImageFiles(v, [...input.files])
  })
  input.click()
}

export function editorStateOf(path: string): EditorState | undefined {
  return editorStates.get(path)
}

// Note identity survives rename/move and determines whether the editor still displays the same note.
export function noteRefOf(path: string): { path: string } | undefined {
  return noteRefs.get(path)
}

// Called by the editor pane before tab switches to save view state, including cursor, non-scroll selection state, and undo history.
export function storeViewState(path: string, state: EditorState) {
  if (editorStates.has(path)) editorStates.set(path, state)
}

function buildState(path: string, doc: string): EditorState {
  const version = user.getSessionVersion()
  const ref = { path }
  noteRefs.set(path, ref)
  const isCurrentNote = () => version === user.getSessionVersion() && noteRefs.get(ref.path) === ref
  return createEditorState({
    doc,
    shortcuts: [],
    spellcheck: settings.spellcheck,
    tabSize: settings.tabSize,
    sourceMode: ws.sourceMode,
    openLink: (href) => {
      void openMarkdownLink(ref.path, href)
    },
    resolveImage: (src) => {
      const url = resolveAssetUrl(ref.path, src)
      const entry = ws.entries.find(e => url === `/api/v1/raw/${encodePath(e.path)}`)
      return entry ? imageUrl(entry.path) : url.startsWith('/api/v1/raw/') ? imageResourceRoot() + url.slice('/api/v1/raw/'.length) : url
    },
    onChange: (u) => {
      editorStates.set(ref.path, u.state)
      if (!u.transactions.some(tr => tr.annotation(externalChange))) scheduleSave(ref.path)
    },
    extensions: [
      notePath.of(ref),
      EditorView.updateListener.of((u) => {
        if (u.docChanged || u.selectionSet) editorListeners.forEach(fn => fn())
      }),
      pasteImages({
        canPaste: () => {
          if (!isCurrentNote()) return false
          if (!slot(ref.path).paused) return true
          toast(translate('workspace.this_note_is_moving_finish_d105e5'))
          return false
        },
        upload: (file) => {
          if (!isCurrentNote()) throw new CanceledError(translate('workspace.the_note_receiving_this_paste_a59580'))
          return uploadImageApi({ note: ref.path, file }).then(({ data }) => data.link)
        },
        importImage: (url) => {
          if (!isCurrentNote()) throw new CanceledError(translate('workspace.the_note_receiving_this_paste_a59580'))
          return importImageApi({ note: ref.path, url }).then(({ data }) => data.link)
        },
        update: (change) => {
          if (!isCurrentNote()) return
          const shown = view?.state.facet(notePath) === ref
          const state = shown ? view!.state : editorStates.get(ref.path)
          if (!state) throw new Error(translate('workspace.the_editor_state_for_the_028961'))
          const spec = change(state)
          if (!spec) return
          if (shown) {
            view!.dispatch(spec)
          } else {
            const transaction = state.update(spec)
            editorStates.set(ref.path, transaction.state)
            if (transaction.docChanged) scheduleSave(ref.path)
          }
        },
        onError: (err) => {
          if (isCurrentNote() && !isCancel(err)) toast(translate('workspace.paste_or_image_import_failed_09d4e6', { p0: err instanceof Error ? err.message : errorText(err) }))
        },
        onPending: (d) => {
          if (!isCurrentNote()) return
          if (d === 1 && slot(ref.path).uploads === 0) toast(translate('workspace.processing_paste_or_image_import_023dad'))
          slot(ref.path).uploads += d
        },
      }),
    ],
  })
}

function reconfigurePluginStates() {
  const effects = [languageCompartment.reconfigure(pluginLanguage()), pluginCompartment.reconfigure(pluginEditorExtensions()), pluginRefresh.of(null)]
  // Compute every new state first so the registering party can roll back on failure; background tabs must not retain disabled extensions.
  const updates = [...editorStates].map(([path, state]) => {
    const current = path === ws.active && view ? view.state : state
    return { path, transaction: current.update({ effects }) }
  })
  for (const { path, transaction } of updates) {
    if (path === ws.active && view) view.dispatch(transaction)
    editorStates.set(path, transaction.state)
  }
}

const pluginWrite: PluginAPI['vault']['write'] = async (path, content, options) => {
  const tab = tabOf(path)
  const saved = slots.get(path)
  if ((tab && (tab.dirty || tab.status !== 'ready')) || saved?.inflight || saved?.uploads || saved?.paused || opsInFlight) throw new ApiError(409, translate('workspace.this_note_has_unsaved_changes_f14427'))
  if (!options || (!('create' in options && options.create === true) && !('ifMatch' in options && typeof options.ifMatch === 'string' && options.ifMatch.length > 0))) throw new ApiError(400, translate('workspace.a_write_requires_a_non_b12fd4'))
  const initialRevision = tab?.rev
  const initialSequence = saved?.seq ?? 0
  const rev = (await writeFileApi({ path, content, ifMatch: 'create' in options ? '' : options.ifMatch })).data.rev
  // A later save or newer revision may already exist; late responses must not revert contents or rev.
  if (tab && tabOf(path) === tab && tab.rev === initialRevision && (slots.get(path)?.seq ?? 0) === initialSequence && !tab.dirty && tab.status === 'ready' && !slots.get(path)?.inflight) {
    replaceDoc(path, content); tab.rev = rev
  }
  await refreshTree()
  return { rev }
}

// Replace document contents with server text by changing only the difference between shared prefix/suffix, preserving the cursor where possible and bypassing undo history.
function replaceDoc(path: string, content: string) {
  const state = path === ws.active && view ? view.state : editorStates.get(path)
  if (!state) return
  const old = state.doc.toString()
  if (old === content) return
  let start = 0
  while (start < old.length && start < content.length && old[start] === content[start]) start++
  let endOld = old.length
  let endNew = content.length
  while (endOld > start && endNew > start && old[endOld - 1] === content[endNew - 1]) {
    endOld--
    endNew--
  }
  const spec = {
    changes: { from: start, to: endOld, insert: content.slice(start, endNew) },
    annotations: [externalChange.of(true), Transaction.addToHistory.of(false)],
  }
  if (path === ws.active && view) view.dispatch(spec)
  else editorStates.set(path, state.update(spec).state)
}

function docOf(path: string): string | undefined {
  if (path === ws.active && view && editorStates.has(path)) return view.state.doc.toString()
  return editorStates.get(path)?.doc.toString()
}

// ---- Save queue ----

function slot(path: string): SaveSlot {
  let s = slots.get(path)
  if (!s) slots.set(path, (s = { seq: 0, savedSeq: 0, uploads: 0, paused: 0, retries: 0 }))
  return s
}

function scheduleSave(path: string, delay = SAVE_DELAY) {
  const s = slot(path)
  s.seq++
  const tab = tabOf(path)
  if (tab) tab.dirty = true
  clearTimeout(s.timer)
  s.timer = setTimeout(() => void flush(path), delay)
}

// Immediately save pending changes for one note; keepalive attempts delivery when the page hides or closes.
export async function flush(path: string, keepalive = false): Promise<void> {
  const version = user.getSessionVersion()
  const s = slots.get(path)
  if (!s) return
  clearTimeout(s.timer)
  while (s.inflight) await s.inflight
  if (version !== user.getSessionVersion() || slots.get(path) !== s) return
  const tab = tabOf(path)
  if (!tab || tab.status !== 'ready' || s.seq === s.savedSeq) return
  if (s.paused || s.uploads) {
    // Defer saves during image uploads or file moves to avoid temporary blob: URLs or writes to old paths.
    s.timer = setTimeout(() => void flush(path), SAVE_DELAY)
    return
  }
  const content = docOf(path)
  if (content === undefined) return
  const seq = s.seq
  const baseRev = tab.rev
  s.inflight = (async () => {
    // Run draft persistence and the request in parallel; waiting for IndexedDB first often prevents the request from starting during page close.
    // Drafts are a recovery fallback; draft-write failures do not block saving itself.
    const draftSaved = drafts.put({ path, content, baseRev, updatedAt: Date.now() }).catch(err => console.warn('写入本地草稿失败', err))
    try {
      const rev = (await writeFileApi({ path, content, ifMatch: baseRev, keepalive })).data.rev
      await draftSaved
      user.assertSession(version)
      tab.rev = rev
      tab.saveError = undefined
      s.savedSeq = seq
      s.retries = 0
      if (s.seq === seq) {
        tab.dirty = false
        await drafts.delete(path)
      }
    } catch (err) {
      if (isCancel(err)) return
      if (err instanceof ApiError && err.status === 412) {
        const serverRev = typeof err.data.rev === 'string' ? err.data.rev : ''
        tab.status = serverRev ? 'conflict' : 'deleted'
        tab.conflictRev = serverRev
      } else if (!(err instanceof ApiError) || err.status >= 500) {
        // Network/server failures can be retried; the local draft preserves contents.
        tab.saveError = s.retries < MAX_RETRIES ? translate('workspace.save_failed_retrying_d62793') : translate('workspace.save_failed_check_your_connection_c0913f')
        if (s.retries++ < MAX_RETRIES) s.timer = setTimeout(() => void flush(path), RETRY_DELAY)
      } else {
        tab.saveError = translate('workspace.save_failed_6ba723', { p0: err.message })
      }
    }
  })()
  await s.inflight
  s.inflight = undefined
  if (version !== user.getSessionVersion() || slots.get(path) !== s) return
  if (s.seq !== s.savedSeq && tab.status === 'ready' && !s.timer) scheduleSave(path)
}

export function retrySave(path: string) {
  slot(path).retries = 0
  void flush(path)
}

export async function flushAll(keepalive = false) {
  await Promise.all([...slots.keys()].map(p => flush(p, keepalive)))
}

// Save failures remain in tab state; completion of flushAll does not guarantee a safe refresh.
export function readyToReload(): boolean {
  return opsInFlight === 0 && !ws.tabs.some(t => t.dirty || t.status === 'loading')
    && [...slots.values()].every(s => !s.uploads && !s.paused && !s.inflight)
}

// ---- Conflict handling ----

// Discard local changes and load the server version.
export async function useServerVersion(path: string) {
  const tab = tabOf(path)
  if (!tab) return
  try {
    const { content, rev } = await readNoteFile(path)
    replaceDoc(path, content)
    const s = slot(path)
    s.savedSeq = s.seq
    Object.assign(tab, { rev, status: 'ready', dirty: false, conflictRev: undefined, saveError: undefined })
    await drafts.delete(path)
  } catch (err) {
    if (isCancel(err)) return
    toast(translate('workspace.load_failed_396d55', { p0: errorText(err) }))
  }
}

// Keep local changes and overwrite the server version, recreating the file if deleted there.
export async function keepLocalVersion(path: string) {
  const version = user.getSessionVersion()
  const tab = tabOf(path)
  const content = docOf(path)
  if (!tab || content === undefined) return
  const s = slot(path)
  if (s.inflight || s.uploads || s.paused) {
    toast(translate('workspace.this_note_is_saving_uploading_c23675'))
    return
  }
  const seq = s.seq
  s.inflight = (async () => {
    try {
      const rev = (await writeFileApi({ path, content, ifMatch: tab.conflictRev ?? '' })).data.rev
      s.savedSeq = seq
      Object.assign(tab, { rev, status: 'ready', dirty: s.seq !== seq, conflictRev: undefined, saveError: undefined })
      if (s.seq === seq) await drafts.delete(path)
      if (!ws.entries.some(e => e.path === path)) {
        void refreshTree().catch((err) => {
          if (!isCancel(err)) toast(translate('workspace.could_not_refresh_the_file_b5f68b', { p0: errorText(err) }))
        })
      }
    } catch (err) {
      if (isCancel(err)) return
      if (err instanceof ApiError && err.status === 412) {
        tab.conflictRev = typeof err.data.rev === 'string' ? err.data.rev : ''
        toast(translate('workspace.the_server_version_changed_again_594f7d'))
      } else {
        toast(translate('workspace.save_failed_6ba723', { p0: errorText(err) }))
      }
    }
  })()
  await s.inflight
  s.inflight = undefined
  if (version !== user.getSessionVersion() || slots.get(path) !== s) return
  if (tab.dirty && tab.status === 'ready') void flush(path)
}

// ---- Open and focus (quick switcher and search results) ----

interface RevealTarget {
  path: string
  line: number
  terms: string[]
}
// The note may not be loaded or its editor visible yet; the editor pane performs this after displaying the note.
let pendingReveal: RevealTarget | null = null

/** Open a note and focus the editor; line > 0 targets that 1-based line and selects its first search-term match. */
export async function openAt(path: string, line = 0, terms: string[] = []) {
  pendingReveal = { path, line, terms }
  if (path === ws.active && view && editorStates.has(path)) {
    ws.sidebarOpen = false
    revealPending(view, path)
  } else {
    await openNote(path)
  }
}

/** Called after the editor pane displays the note; true means the requested line was reached, so do not restore the old scroll position. */
export function revealPending(v: EditorView, path: string): boolean {
  const r = pendingReveal
  if (!r || r.path !== path) return false
  pendingReveal = null
  // Focus opens software keyboards on touch devices and covers content; focus only devices with a mouse.
  if (!matchMedia('(pointer: coarse)').matches) v.focus()
  if (r.line === 0) return false
  const line = v.state.doc.line(Math.min(r.line, v.state.doc.lines))
  const text = line.text.toLowerCase()
  let at = -1
  let len = 0
  for (const t of r.terms) {
    const i = text.indexOf(t.toLowerCase())
    if (i >= 0 && (at < 0 || i < at)) [at, len] = [i, t.length]
  }
  const from = line.from + Math.max(at, 0)
  v.dispatch({ selection: { anchor: from, head: from + len }, effects: EditorView.scrollIntoView(from, { y: 'center' }) })
  return true
}

// ---- Tabs ----

export async function openNote(path: string, options?: { background?: boolean }) {
  const version = user.getSessionVersion()
  const epoch = workspaceEpoch
  if (!options?.background) {
    ws.view = 'notes'
    ws.images = null
    ws.sidebarOpen = false
  }
  // New tree notes appear optimistically; wait for actual creation before reading them.
  const pending = creating.get(path)
  if (pending && !(await pending)) return
  user.assertSession(version)
  if (tabOf(path)) {
    if (!options?.background) ws.active = path
    return
  }
  const tab = reactive<Tab>({ path, pinned: settings.pinnedTabs?.includes(path) ?? false, rev: '', status: 'loading', dirty: false })
  ws.tabs.push(tab)
  if (!options?.background) ws.active = path
  try {
    const { content, rev } = await readNoteFile(path)
    user.assertSession(version)
    if (epoch !== workspaceEpoch || tabOf(path) !== tab) return
    editorStates.set(path, buildState(path, content))
    const t = tabOf(path)
    if (t) Object.assign(t, { rev, status: 'ready' })
  } catch (err) {
    if (isCancel(err)) return
    if (epoch !== workspaceEpoch || tabOf(path) !== tab) return
    const t = tabOf(path)
    if (t) t.status = 'error'
    toast(translate('workspace.could_not_open_0ed1e1', { p0: errorText(err) }))
  }
}

async function syncPinnedTabs() {
  if (settings.pinnedTabs === undefined) return
  const pinned = new Set(settings.pinnedTabs)
  for (const tab of ws.tabs) tab.pinned = pinned.has(tab.path)
  // Remote unpins never close tabs or discard local drafts, and remote pins never steal focus.
  const notes = new Set(ws.entries.filter(entry => !entry.dir && entry.path.endsWith(NOTE_EXT)).map(entry => entry.path))
  await Promise.all([...pinned].filter(path => notes.has(path) && !tabOf(path)).map(path => openNote(path, { background: true })))
}

async function syncSettings() {
  await loadSettings()
  await syncPinnedTabs()
}

async function savePinnedTabs(paths: string[]): Promise<boolean> {
  try {
    const saving = updateSettings({ pinnedTabs: paths })
    for (const tab of ws.tabs) tab.pinned = paths.includes(tab.path)
    await saving
    return true
  } catch (err) {
    if (isCancel(err)) return false
    if (err instanceof SettingsAppearanceError) {
      toast(err.message)
      return true
    }
    toast(translate('common.could_not_save_settings_1cdd7f', { p0: err instanceof Error ? err.message : errorText(err) }))
    try {
      await syncSettings()
    } catch (reload) {
      if (!isCancel(reload)) toast(translate('workspace.could_not_synchronize_settings_7e5bb1', { p0: errorText(reload) }))
    }
    return false
  }
}

export async function toggleTabPin(path: string) {
  if (!tabOf(path)) return
  const pinned = settings.pinnedTabs ?? ws.tabs.filter(tab => tab.pinned).map(tab => tab.path)
  await savePinnedTabs(pinned.includes(path) ? pinned.filter(p => p !== path) : [...pinned, path])
}

async function remapPinnedTabs(from: string, to: string) {
  const pinned = settings.pinnedTabs
  if (pinned?.some(path => remapPath(path, from, to) !== null)) {
    await savePinnedTabs(pinned.map(path => remapPath(path, from, to) ?? path))
  }
}

export async function closeTab(path: string): Promise<boolean> {
  const version = user.getSessionVersion()
  const busy = () => Boolean(slots.get(path)?.uploads || slots.get(path)?.paused)
  if (busy()) {
    toast(translate('workspace.this_note_is_uploading_or_349b3d'))
    return false
  }
  await flush(path)
  user.assertSession(version)
  const i = ws.tabs.findIndex(t => t.path === path)
  if (i < 0) return true
  const tab = ws.tabs[i]
  if (busy()) {
    toast(translate('workspace.this_note_is_uploading_or_349b3d'))
    return false
  }
  if (tab.dirty) {
    const seq = slot(path).seq
    const content = docOf(path)
    if (content === undefined) throw new Error(translate('workspace.the_editor_state_for_this_248447'))
    try {
      await drafts.put({ path, content, baseRev: tab.rev, updatedAt: Date.now() })
      user.assertSession(version)
    } catch (err) {
      if (isCancel(err)) return false
      toast(translate('workspace.could_not_save_the_local_cc0e42', { p0: errorText(err) }))
      return false
    }
    if (tabOf(path) !== tab || slot(path).seq !== seq || busy()) return false
    toast(translate('workspace.unsaved_changes_retained_as_a_8cb2ab'))
  }
  if (tab.pinned) {
    const seq = slot(path).seq
    const pinned = settings.pinnedTabs ?? ws.tabs.filter(tab => tab.pinned).map(tab => tab.path)
    if (!(await savePinnedTabs(pinned.filter(p => p !== path)))) return false
    user.assertSession(version)
    if (!ws.tabs.includes(tab)) return true
    // Saving the pin is asynchronous; retain a tab changed by new input or another operation while it was pending.
    if (tab.path !== path || slot(path).seq !== seq || busy()) {
      const current = settings.pinnedTabs ?? ws.tabs.filter(tab => tab.pinned).map(tab => tab.path)
      if (!current.includes(tab.path)) await savePinnedTabs([...current, tab.path])
      return false
    }
  }
  const index = ws.tabs.indexOf(tab)
  if (index < 0) return true
  ws.tabs.splice(index, 1)
  forget(path)
  if (ws.active === path) ws.active = ws.tabs[Math.min(index, ws.tabs.length - 1)]?.path ?? null
  return true
}

function forget(path: string) {
  editorStates.delete(path)
  noteRefs.delete(path)
  const s = slots.get(path)
  if (s) clearTimeout(s.timer)
  slots.delete(path)
}

// Replace path prefixes; moving a folder changes every descendant path together.
function remapPath(p: string, from: string, to: string): string | null {
  if (p === from) return to
  if (p.startsWith(`${from}/`)) return to + p.slice(from.length)
  return null
}

function remapOpenNotes(from: string, to: string) {
  for (const tab of ws.tabs) {
    const next = remapPath(tab.path, from, to)
    if (next === null) continue
    const old = tab.path
    tab.path = next
    if (ws.active === old) ws.active = next
    for (const map of [editorStates, noteRefs, slots] as Map<string, unknown>[]) {
      if (map.has(old)) {
        map.set(next, map.get(old))
        map.delete(old)
      }
    }
    const ref = noteRefs.get(next)
    if (ref) ref.path = next
  }
  reconfigurePluginStates()
}

function remapRecent(from: string, to: string) {
  ws.recent = ws.recent.map(p => remapPath(p, from, to) ?? p)
}

function affected(path: string): string[] {
  return ws.tabs.map(t => t.path).filter(p => p === path || p.startsWith(`${path}/`))
}

// ---- Directory tree ----

// Tree refresh permits one request at a time; discard and refetch if another refresh or local operation makes its result stale.
// Local operations update the tree optimistically; stale results would erase new entries, such as a new note's rename input.
// Waiting callers settle together after the next accepted result or request failure.
let treeTimer: ReturnType<typeof setTimeout> | undefined
let treeFetching = false
let treeAgain = false
let localTreeEdits = 0
const treeWaiters: { resolve: () => void, reject: (reason: unknown) => void }[] = []

export function refreshTree(): Promise<void> {
  return new Promise((resolve, reject) => {
    treeWaiters.push({ resolve, reject })
    scheduleTreeRefresh()
  })
}

function scheduleTreeRefresh() {
  if (treeFetching) {
    treeAgain = true
    return
  }
  clearTimeout(treeTimer)
  treeTimer = setTimeout(() => void fetchTree(), 50)
}

async function fetchTree() {
  const version = user.getSessionVersion()
  treeFetching = true
  treeAgain = false
  const edits = localTreeEdits
  let entries: Entry[]
  try {
    entries = (await getTreeApi()).data.entries
    user.assertSession(version)
  } catch (err) {
    if (isCancel(err)) return
    treeFetching = false
    for (const waiter of treeWaiters.splice(0)) waiter.reject(err)
    return
  }
  treeFetching = false
  if (treeAgain || edits !== localTreeEdits || opsInFlight > 0) {
    // During active operations, withOp reschedules once all operations finish.
    if (opsInFlight === 0) scheduleTreeRefresh()
    return
  }
  const oldImages = new Map(ws.entries.filter(e => !e.dir && isImage(e.path)).map(e => [e.path, e]))
  const nextPaths = new Set(entries.map(e => e.path))
  const imagesChanged = entries.some(e => !e.dir && isImage(e.path) && (e.mtime !== oldImages.get(e.path)?.mtime || e.size !== oldImages.get(e.path)?.size)) || [...oldImages.keys()].some(p => !nextPaths.has(p))
  ws.entries = entries
  if (imagesChanged) view?.dispatch({ effects: refreshImages.of(null) })
  markMissingTabsDeleted()
  for (const waiter of treeWaiters.splice(0)) waiter.resolve()
}

function markMissingTabsDeleted() {
  const exists = new Set(ws.entries.map(e => e.path))
  for (const tab of ws.tabs) {
    if (tab.status === 'ready' && !exists.has(tab.path)) {
      tab.status = 'deleted'
      tab.conflictRev = ''
    }
  }
}

function uniqueName(dir: string, base: string, ext: string): string {
  const taken = new Set(ws.entries.map(e => e.path))
  for (let i = 0; ; i++) {
    const name = base + (i ? ` ${i}` : '') + ext
    if (!taken.has(joinPath(dir, name))) return joinPath(dir, name)
  }
}

async function withOp<T>(fn: () => Promise<T>): Promise<T> {
  const epoch = workspaceEpoch
  opsInFlight++
  localTreeEdits++
  try {
    return await fn()
  } finally {
    if (epoch === workspaceEpoch) {
      localTreeEdits++
      if (--opsInFlight === 0 && treeWaiters.length) scheduleTreeRefresh()
    }
  }
}

export async function saveTreeIcon(path: string, icon: TreeIcon | null) {
  await withOp(() => setTreeIconApi({ path, icon }).then(({ data }) => data))
  try {
    await refreshTree()
  } catch (err) {
    if (isCancel(err)) return
    toast(translate('workspace.icon_saved_but_the_file_72a5c2', { p0: errorText(err) }))
  }
}

export async function createNote(dir: string) {
  const path = uniqueName(dir, translate('workspace.untitled_67bee6'), NOTE_EXT)
  ws.renaming = path
  await createNoteAt(path)
}

// In-flight creation: immediately show the rename input, but wait for actual file creation before renaming.
const creating = new Map<string, Promise<boolean>>()

/** Create and open an empty note at the requested path and report success; the server creates missing parent folders. */
export async function createNoteAt(path: string, content = ''): Promise<boolean> {
  ws.view = 'notes'
  ws.images = null
  const done = createNoteFile(path, content)
  creating.set(path, done)
  try {
    return await done
  } finally {
    if (creating.get(path) === done) creating.delete(path)
  }
}

async function createNoteFile(path: string, content: string): Promise<boolean> {
  const exists = new Set(ws.entries.map(e => e.path))
  const added = [path]
  for (let d = dirname(path); d && !exists.has(d); d = dirname(d)) added.push(d)
  ws.entries.push(...added.map((p, i) => ({ path: p, dir: i > 0, size: 0, mtime: Date.now() })))
  return withOp(async () => {
    try {
      const rev = (await writeFileApi({ path, content, ifMatch: '' })).data.rev
      ws.tabs.push({ path, rev, status: 'ready', dirty: false })
      editorStates.set(path, buildState(path, content))
      ws.active = path
      return true
    } catch (err) {
      if (isCancel(err)) return false
      ws.entries = ws.entries.filter(e => !added.includes(e.path))
      if (ws.renaming === path) ws.renaming = null
      toast(translate('workspace.could_not_create_note_2760ce', { p0: errorText(err) }))
      return false
    }
  })
}

export async function importNotes(dir: string, folder: string, files: File[]) {
  // refreshTree must wait until withOp ends, or it would wait for its own operation count to be released.
  const result = await withOp(() => importNotesApi({ dir, folder, files }).then(({ data }) => data))
  ws.searchOpen = false
  try {
    await refreshTree()
  } catch (err) {
    if (isCancel(err)) throw err
    toast(translate('workspace.import_complete_but_the_file_52460f', { p0: errorText(err) }))
  }
  return result
}

export async function createFolder(dir: string) {
  const path = uniqueName(dir, translate('workspace.new_folder_84244a'), '')
  ws.entries.push({ path, dir: true, size: 0, mtime: Date.now() })
  ws.renaming = path
  await withOp(async () => {
    try {
      await createFolderApi({ path })
    } catch (err) {
      if (isCancel(err)) return
      ws.entries = ws.entries.filter(e => e.path !== path)
      if (ws.renaming === path) ws.renaming = null
      toast(translate('workspace.could_not_create_folder_bc6447', { p0: errorText(err) }))
    }
  })
}

export function renameTarget(path: string, name: string): string | null {
  name = name.trim().replace(/\//g, '')
  if (!name || name.startsWith('.')) return null
  const entry = ws.entries.find(e => e.path === path)
  if (entry && !entry.dir && path.endsWith(NOTE_EXT) && !name.endsWith(NOTE_EXT)) name += NOTE_EXT
  return joinPath(dirname(path), name)
}

export type FileResult = { ok: true } | { ok: false, error: string }
function operationFailed(error: string, owner: 'operation' | 'caller'): FileResult {
  if (owner === 'operation') toast(error)
  return { ok: false, error }
}

export async function move(from: string, to: string, errorOwner: 'operation' | 'caller' = 'operation'): Promise<FileResult> {
  const version = user.getSessionVersion()
  if (from === to) return { ok: true }
  if (creating.has(from) && !(await creating.get(from))) return operationFailed(translate('workspace.this_note_has_not_been_77a7a9'), errorOwner)
  user.assertSession(version)
  if (ws.entries.some(e => e.path === to)) {
    return operationFailed(translate('workspace.already_exists_6af434', { p0: basename(to) }), errorOwner)
  }
  const result = await withOp<FileResult>(async () => {
    // Moves update relative vault links; save all open notes first, retaining revision-conflict protection.
    const impacted = () => ws.tabs.map(t => t.path)
    const busy = () => impacted().some(p => slots.get(p)?.uploads || slots.get(p)?.paused)
    if (busy()) {
      return operationFailed(translate('workspace.this_note_is_processing_a_8c2cce'), errorOwner)
    }
    // Save pending edits first so the latest contents move; pause saving during the move to avoid writing to old paths.
    await Promise.all(impacted().map(p => flush(p)))
    user.assertSession(version)
    // Pasting may start while awaiting saves; check again before acquiring the move lock.
    if (busy()) {
      return operationFailed(translate('workspace.this_note_is_processing_a_8c2cce'), errorOwner)
    }
    if (impacted().some((p) => {
      const tab = tabOf(p); return tab && (tab.dirty || tab.status !== 'ready')
    })) {
      return operationFailed(translate('workspace.save_your_notes_and_resolve_5500d4'), errorOwner)
    }
    const paused = impacted().map(slot)
    paused.forEach(s => s.paused++)
    const snapshot = ws.entries
    let draftsMoved = false
    let remapped = false
    try {
      // Verify persistent drafts can migrate first; on failure, keep original paths on both the server and interface.
      await drafts.move(from, to)
      user.assertSession(version)
      draftsMoved = true
      remapped = true
      ws.entries = ws.entries.map(e => ({ ...e, path: remapPath(e.path, from, to) ?? e.path }))
      remapOpenNotes(from, to)
      remapRecent(from, to)
      if (ws.image) ws.image = remapPath(ws.image, from, to) ?? ws.image
      if (ws.images) ws.images = remapPath(ws.images, from, to) ?? ws.images
      await moveFileApi({ from, to })
    } catch (err) {
      if (isCancel(err)) throw err
      if (remapped) {
        ws.entries = snapshot
        remapOpenNotes(to, from)
        remapRecent(to, from)
        if (ws.image) ws.image = remapPath(ws.image, to, from) ?? ws.image
        if (ws.images) ws.images = remapPath(ws.images, to, from) ?? ws.images
      }
      if (draftsMoved) {
        try {
          await drafts.move(to, from)
        } catch (cause) {
          toast(translate('workspace.could_not_restore_the_draft_e5f464', { p0: cause instanceof Error ? cause.message : errorText(cause) }))
        }
      }
      return operationFailed(translate('workspace.move_failed_04b0a9', { p0: err instanceof Error ? err.message : errorText(err) }), errorOwner)
    } finally {
      paused.forEach(s => s.paused--)
    }
    await remapPinnedTabs(from, to)
    user.assertSession(version)
    // The server rewrites image links when renaming notes, changing their revisions and requiring resynchronization.
    await Promise.all(ws.tabs.map(t => t.path).map(async (p) => {
      const tab = tabOf(p)
      if (!tab) return
      if (tab.dirty) {
        // Input during the move still contains old links; let the user resolve it.
        const { rev } = await readNoteFile(p)
        if (rev !== tab.rev) Object.assign(tab, { status: 'conflict', conflictRev: rev })
      } else {
        await syncOpenTab(tab)
      }
    })).catch((err) => {
      if (isCancel(err)) throw err
      toast(translate('workspace.file_moved_but_note_synchronization_b9ff79', { p0: errorText(err) }))
    })
    return { ok: true }
  })
  void refreshTree().catch((err) => {
    if (!isCancel(err)) toast(translate('workspace.could_not_refresh_the_file_b5f68b', { p0: errorText(err) }))
  })
  return result
}

export async function remove(path: string, errorOwner: 'operation' | 'caller' = 'operation'): Promise<FileResult> {
  const version = user.getSessionVersion()
  const entry = ws.entries.find(e => e.path === path)
  if (!entry) return operationFailed(translate('workspace.file_no_longer_exists_4eb446'), errorOwner)
  return withOp<FileResult>(async () => {
    const paths = affected(path)
    await Promise.all(paths.map(p => flush(p)))
    user.assertSession(version)
    if (paths.some((p) => {
      const tab = tabOf(p); return tab && (tab.dirty || tab.status !== 'ready')
    })) {
      return operationFailed(translate('workspace.save_your_notes_and_resolve_5981a5'), errorOwner)
    }
    const snapshot = ws.entries
    ws.entries = ws.entries.filter(e => remapPath(e.path, path, path) === null) // Remove the item and all descendants.
    for (const p of paths) {
      if (!(await closeTab(p))) {
        ws.entries = snapshot; return operationFailed(translate('workspace.could_not_close_the_note_cd2a80'), errorOwner)
      }
    }
    user.assertSession(version)
    try {
      const item = (await deleteFileApi(path)).data
      if (ws.image && remapPath(ws.image, path, path) !== null) ws.image = null
      toast(translate('workspace.deleted_86a46b', { p0: basename(path).replace(/\.md$/, '') }), {
        get label() {
          return translate('workspace.undo_926a50')
        },
        run: () => void restore(item.id),
      })
      return { ok: true }
    } catch (err) {
      if (isCancel(err)) throw err
      ws.entries = snapshot
      return operationFailed(translate('common.could_not_delete_9619d7', { p0: errorText(err) }), errorOwner)
    }
  })
}

export async function restore(id: string) {
  try {
    const item = (await restoreTrashApi(id)).data
    await refreshTree()
    if (!item.dir && item.path.endsWith(NOTE_EXT)) void openNote(item.path)
    else if (!item.dir && isImage(item.path)) ws.image = item.path
  } catch (err) {
    if (isCancel(err)) return
    toast(translate('workspace.restore_failed_283a6e', { p0: errorText(err) }))
  }
}

// The version refreshes browser images only; relative Markdown paths remain unchanged.
export function imageUrl(path: string): string {
  const entry = ws.entries.find(e => e.path === path)
  return imageResourceRoot() + encodePath(path) + (entry ? `?v=${entry.mtime}-${entry.size}` : '')
}

export async function replaceImage(path: string, file: File) {
  await withOp(() => replaceImageApi({ path, file }).then(({ data }) => data))
  try {
    await refreshTree()
  } catch (err) {
    if (isCancel(err)) return
    toast(translate('workspace.image_replaced_but_the_file_bb4848', { p0: errorText(err) }))
  }
}

// ---- Live synchronization ----

async function syncOpenTab(tab: Tab) {
  const s = slots.get(tab.path)
  if (tab.status !== 'ready' || tab.dirty || s?.inflight) return
  try {
    const { content, rev } = await readNoteFile(tab.path)
    if (rev === tab.rev || tab.dirty) return
    replaceDoc(tab.path, content)
    tab.rev = rev
  } catch (err) {
    if (isCancel(err)) return
    if (err instanceof ApiError && err.status === 404) {
      tab.status = 'deleted'
      tab.conflictRev = ''
    } else {
      throw err
    }
  }
}

async function handleEvents(evs: VaultEvent[]) {
  const version = user.getSessionVersion()
  const epoch = workspaceEpoch
  for (const ev of evs) {
    user.assertSession(version)
    if (ev.type === 'indexed') {
      void refreshMetadata()
    } else if (ev.type === 'settings') {
      await syncSettings().catch((err) => {
        if (!isCancel(err)) toast(translate('workspace.could_not_synchronize_settings_7e5bb1', { p0: errorText(err) }))
      })
      await refreshPlugins()
    } else if (ev.type === 'plugins') {
      await refreshPlugins()
    } else if (ev.type === 'changed') {
      const tab = tabOf(ev.path!)
      // Own-save events match the local rev; do not overwrite local edits, and let the next save detect conflicts.
      if (tab && tab.rev !== ev.rev) await syncOpenTab(tab)
    } else if (ev.type === 'moved') {
      if (ws.image) ws.image = remapPath(ws.image, ev.from!, ev.path!) ?? ws.image
      if (ws.images) ws.images = remapPath(ws.images, ev.from!, ev.path!) ?? ws.images
      const paused = affected(ev.from!).map(slot)
      paused.forEach(s => s.paused++)
      try {
        // In-flight saves may still write the old key; wait for their draft transactions first.
        await Promise.all(paused.map(s => s.inflight))
        user.assertSession(version)
        if (epoch !== workspaceEpoch) return
        try {
          await drafts.move(ev.from!, ev.path!)
        } catch (cause) {
          // The external file already moved, so draft failures must not prevent editor tracking; retain the original record and report failure explicitly.
          toast(translate('workspace.could_not_migrate_the_local_4c513a', { p0: cause instanceof Error ? cause.message : errorText(cause) }))
        }
        user.assertSession(version)
        if (epoch !== workspaceEpoch) return
        if (affected(ev.from!).length && !affected(ev.path!).length) remapOpenNotes(ev.from!, ev.path!)
        remapRecent(ev.from!, ev.path!)
        await remapPinnedTabs(ev.from!, ev.path!)
      } finally {
        paused.forEach(s => s.paused--)
      }
    } else if (ev.type === 'deleted') {
      if (ws.image === ev.path && opsInFlight === 0) ws.image = null
      const tab = tabOf(ev.path!)
      if (tab && tab.status === 'ready' && opsInFlight === 0) {
        tab.status = 'deleted'
        tab.conflictRev = ''
      }
    }
    user.assertSession(version)
    if (epoch !== workspaceEpoch) return
    if (ev.type === 'changed' || ev.type === 'moved' || ev.type === 'deleted') pluginEvents.dispatchEvent(new CustomEvent(ev.type, { detail: ev.type === 'moved' ? { from: ev.from!, path: ev.path! } : ev.type === 'changed' ? { path: ev.path!, rev: ev.rev! } : { path: ev.path! } }))
  }
  if (evs.some(event => event.type === 'tree')) await resync()
}

async function resync() {
  const version = user.getSessionVersion()
  const epoch = workspaceEpoch
  void refreshMetadata()
  await refreshTree()
  user.assertSession(version)
  if (epoch !== workspaceEpoch) return
  await syncSettings().catch((err) => {
    if (!isCancel(err)) toast(translate('workspace.could_not_synchronize_settings_7e5bb1', { p0: errorText(err) }))
  })
  user.assertSession(version)
  if (epoch !== workspaceEpoch) return
  await Promise.all(ws.tabs.map(syncOpenTab))
  user.assertSession(version)
  if (epoch !== workspaceEpoch) return
  pluginEvents.dispatchEvent(new CustomEvent('resync'))
  await refreshPlugins()
}

// ---- Startup ----

const TABS_KEY = 'rawmark.tabs'

function localTabs() {
  return { paths: ws.tabs.map(t => t.path), active: ws.active, ...(settings.pinnedTabs === undefined ? { pinned: ws.tabs.filter(t => t.pinned).map(t => t.path) } : {}) }
}

// Restore unsaved drafts: continue saving if the server revision is unchanged; otherwise enter conflict state for user resolution.
async function recoverDrafts() {
  const version = user.getSessionVersion()
  for (const d of await drafts.all()) {
    user.assertSession(version)
    try {
      const { content, rev } = await readNoteFile(d.path)
      if (content === d.content) {
        await drafts.delete(d.path)
        continue
      }
      if (!tabOf(d.path)) ws.tabs.push({ path: d.path, rev, status: 'ready', dirty: false })
      const tab = tabOf(d.path)!
      editorStates.set(d.path, buildState(d.path, d.content))
      tab.rev = rev
      if (rev === d.baseRev) {
        tab.status = 'ready'
        scheduleSave(d.path)
      } else {
        Object.assign(tab, { status: 'conflict', conflictRev: rev, dirty: true })
      }
    } catch (err) {
      if (isCancel(err)) throw err
      if (!(err instanceof ApiError) || err.status !== 404) throw err
      ws.tabs.push({ path: d.path, rev: '', status: 'deleted', dirty: true, conflictRev: '' })
      editorStates.set(d.path, buildState(d.path, d.content))
    }
  }
}

let disconnect: (() => void) | undefined
let listenersInstalled = false

export async function startWorkspace() {
  const version = user.getSessionVersion()
  await draftPreserved
  user.assertSession(version)
  workspaceRunning = false
  await prepareResources()
  user.assertSession(version)
  // Settings-read failures do not prevent use; retain locally cached values.
  const settingsLoaded = loadSettings().then(() => true).catch((err) => {
    if (!isCancel(err)) toast(translate('workspace.could_not_load_settings_246415', { p0: errorText(err) }))
    return false
  })
  await refreshTree()
  const confirmedSettings = await settingsLoaded
  user.assertSession(version)
  const saved = JSON.parse(localStorage.getItem(TABS_KEY) ?? '{"paths":[],"active":null}') as { paths: string[], active: string | null, pinned?: string[] }
  const exists = new Set(ws.entries.map(e => e.path))
  await Promise.all(saved.paths.filter(p => exists.has(p)).map(path => openNote(path)))
  if (settings.pinnedTabs === undefined) {
    for (const tab of ws.tabs) tab.pinned = saved.pinned?.includes(tab.path) ?? false
    if (confirmedSettings && saved.pinned?.length) await savePinnedTabs(saved.pinned.filter(path => exists.has(path)))
  }
  if (settings.pinnedTabs !== undefined) await syncPinnedTabs()
  try {
    await recoverDrafts()
  } catch (err) {
    if (isCancel(err)) throw err
    toast(translate('workspace.could_not_restore_the_local_a275e8', { p0: errorText(err) }))
  }
  user.assertSession(version)
  ws.active = saved.active && tabOf(saved.active) ? saved.active : (ws.tabs[0]?.path ?? null)
  workspaceRunning = true
  localStorage.setItem(TABS_KEY, JSON.stringify(localTabs()))
  let eventQueue = Promise.resolve()
  let stopped = false
  const enqueue = (work: () => Promise<void>) => {
    // Synchronization reads are asynchronous; later batches must not overtake earlier moves or content updates.
    eventQueue = eventQueue.then(() => {
      if (!stopped) return work()
    }).catch((err) => {
      if (!stopped && version === user.getSessionVersion() && !isCancel(err)) toast(translate('workspace.synchronization_failed_c6eeea', { p0: errorText(err) }))
    })
  }
  const stopEvents = connectEventsApi({ onEvents: events => enqueue(() => handleEvents(events)), onResync: () => enqueue(resync) })
  disconnect = () => {
    stopped = true; stopEvents()
  }
  setPluginEditorHandlers(reconfigurePluginStates, pluginEditorFailure)
  startPlugins({
    notice: toast,
    openNote,
    writeNote: pluginWrite,
    getActiveNote: () => {
      const tab = activeTab()
      if (!tab) return null
      const state = view && ws.active === tab.path ? view.state : editorStates.get(tab.path)
      if (!state) return null
      return { path: tab.path, content: state.doc.toString(), rev: tab.rev, dirty: tab.dirty }
    },
  })
  // The workspace starts again after signing in; register the following global listeners only once.
  if (listenersInstalled) return
  listenersInstalled = true
  watch(
    localTabs,
    (tabs) => {
      if (workspaceRunning) localStorage.setItem(TABS_KEY, JSON.stringify(tabs))
    },
  )
  watch(
    () => ws.active,
    (p) => {
      if (p) ws.recent = [p, ...ws.recent.filter(r => r !== p)].slice(0, RECENT_MAX)
    },
    { immediate: true },
  )
  watch(
    () => ws.recent,
    r => localStorage.setItem(RECENT_KEY, JSON.stringify(r)),
  )
  watch(
    () => ({ sidebarCollapsed: ws.sidebarCollapsed, outlineOpen: ws.outlineOpen, focusMode: ws.focusMode }),
    (l) => {
      localStorage.setItem(LAYOUT_KEY, JSON.stringify(l))
      // Editor width changed; request remeasurement.
      requestAnimationFrame(() => view?.requestMeasure())
    },
  )
  watch(locale, (value) => {
    const effects = localeCompartment.reconfigure(editorLocale.of(value))
    for (const [path, state] of editorStates) {
      if (path === ws.active && view) {
        view.dispatch({ effects })
        editorStates.set(path, view.state)
      } else {
        editorStates.set(path, state.update({ effects }).state)
      }
    }
  })
  // Font-size and text-width changes affect line heights; request editor remeasurement.
  watch(
    () => [settings.uiFont, settings.uiFontSize, settings.fontSize, settings.contentWidth, settings.sidebarWidth, settings.textFont, settings.codeFont, settings.lineHeight],
    () => view?.requestMeasure(),
  )
  watch(
    () => [settings.spellcheck, settings.tabSize],
    () => {
      const effects = preferencesCompartment.reconfigure([
        EditorState.tabSize.of(settings.tabSize),
        EditorView.contentAttributes.of({ spellcheck: String(settings.spellcheck) }),
      ])
      for (const [path, state] of editorStates) {
        if (path === ws.active && view) {
          view.dispatch({ effects })
          editorStates.set(path, view.state)
        } else {
          editorStates.set(path, state.update({ effects }).state)
        }
      }
    },
  )
  window.addEventListener('rawmark-appearance', () => requestAnimationFrame(() => view?.requestMeasure()))
  window.addEventListener('rawmark-plugin-notice', event => toast((event as CustomEvent<string>).detail))
  // Attempt to send pending saves before page hide/close; some browsers fire only pagehide on tab close.
  document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'hidden') void flushAll(true)
  })
  window.addEventListener('pagehide', () => void flushAll(true))
  window.addEventListener('beforeunload', (event) => {
    if (!readyToReload()) event.preventDefault()
  })
  window.addEventListener('keydown', (event) => {
    if (workspaceRunning) handleShortcut(event)
  }, true)
  // Keep the cursor visible when the software keyboard reduces editor height.
  trackVisualViewport(() => {
    if (view?.hasFocus) view.dispatch({ effects: EditorView.scrollIntoView(view.state.selection.main.head, { y: 'nearest', yMargin: 24 }) })
  })
}

// Built-in commands do not depend on workspace state; register at module load before component commands such as sign-out.
registerBuiltinCommands()

function registerBuiltinCommands() {
  for (const command of editorCommands) {
    registerCommand({ ...command, get title() {
      return command.title
    }, when: () => ws.view === 'notes' && ws.settings === null && ws.images === null && ws.active !== null && !!view, run: () => {
      if (view) {
        command.run(view); view.focus()
      }
    } })
  }
  const hasNote = () => ws.active !== null
  const toggleSwitcher = (initial: string) => {
    ws.switcher = ws.switcher === null ? initial : null
  }
  for (const cmd of [
    { id: 'app.quickOpen', get title() {
      return translate('workspace.quick_open_note_0d376f')
    }, run: () => toggleSwitcher('') },
    { id: 'app.commandPalette', get title() {
      return translate('workspace.command_palette_4b495d')
    }, run: () => toggleSwitcher('>') },
    { id: 'app.search', get title() {
      return translate('workspace.full_text_search_a6c47a')
    }, run: openSearch },
    { id: 'note.new', get title() {
      return translate('workspace.new_note_d3d2d9')
    }, run: () => withSidebar(() => createNote('')) },
    { id: 'folder.new', get title() {
      return translate('workspace.new_folder_84244a')
    }, run: () => withSidebar(() => createFolder('')) },
    { id: 'note.save', get title() {
      return translate('workspace.save_current_note_5a7e29')
    }, when: hasNote, run: () => void flush(ws.active!) },
    { id: 'note.rename', get title() {
      return translate('workspace.rename_current_note_de288b')
    }, when: hasNote, run: () => withSidebar(() => (ws.renaming = ws.active)) },
    { id: 'note.move', get title() {
      return translate('workspace.move_current_note_to_f1fc16')
    }, when: hasNote, run: () => (ws.moving = ws.active) },
    { id: 'note.delete', get title() {
      return translate('workspace.delete_current_note_657a00')
    }, when: hasNote, run: () => void remove(ws.active!) },
    { id: 'note.insertImage', get title() {
      return translate('workspace.insert_image_52c554')
    }, when: hasNote, run: insertImagesFromPicker },
    { id: 'tab.close', get title() {
      return translate('workspace.close_current_tab_cc8a4e')
    }, when: hasNote, run: () => void closeTab(ws.active!) },
    { id: 'app.settings', get title() {
      return translate('common.settings_df3d58')
    }, run: () => (ws.settings = 'index') },
    { id: 'view.sidebar', get title() {
      return translate('workspace.show_hide_sidebar_96b1a4')
    }, run: toggleSidebar },
    { id: 'view.outline', get title() {
      return translate('workspace.show_hide_outline_1da8d2')
    }, when: hasNote, run: () => (ws.outlineOpen = !ws.outlineOpen) },
    { id: 'view.source', get title() {
      return translate('workspace.toggle_source_editing_602b33')
    }, when: hasNote, run: toggleSourceMode },
    { id: 'view.focus', get title() {
      return translate('workspace.toggle_focus_mode_b52fb6')
    }, when: hasNote, run: () => (ws.focusMode = !ws.focusMode) },
    { id: 'app.trash', get title() {
      return translate('workspace.open_trash_8a939d')
    }, run: () => (ws.settings = 'trash') },
    { id: 'app.images', get title() {
      return translate('workspace.manage_root_folder_images_fed368')
    }, run: () => {
      ws.imagesAll = false; ws.images = ''
    } },
    { id: 'app.tokens', get title() {
      return translate('common.api_tokens_79db53')
    }, run: () => (ws.settings = 'account') },
  ]) {
    registerCommand({ ...cmd, get title() {
      return cmd.title
    }, keys: typoraKeys(cmd.id) })
  }
}

// The sidebar is a drawer on phones and collapsible on desktop.
function toggleSidebar() {
  if (matchMedia('(max-width: 768px)').matches) ws.sidebarOpen = !ws.sidebarOpen
  else ws.sidebarCollapsed = !ws.sidebarCollapsed
}

// For tree operations, switch back to the tree and open the sidebar on mobile.
function withSidebar(fn: () => unknown) {
  ws.searchOpen = false
  ws.sidebarOpen = true
  ws.sidebarCollapsed = false
  void fn()
}

export function openSearch() {
  ws.searchOpen = true
  ws.sidebarOpen = true
  ws.sidebarCollapsed = false
  // If already open, refocus and select all so users can immediately enter a new query.
  void nextTick(() => {
    const input = document.querySelector<HTMLInputElement>('.rm-search-input')
    input?.focus()
    input?.select()
  })
}

export function stopWorkspace() {
  workspaceRunning = false
  workspaceEpoch++
  const dirty = ws.tabs.filter(tab => tab.dirty).map((tab) => {
    const content = docOf(tab.path)
    return content === undefined ? Promise.resolve() : drafts.put({ path: tab.path, content, baseRev: tab.rev, updatedAt: Date.now() })
  })
  draftPreserved = Promise.all(dirty).then(() => {}).catch((error) => {
    console.error('保留本地草稿失败', error); toast(translate('workspace.could_not_save_the_local_4b21e1'))
  })
  for (const slot of slots.values()) clearTimeout(slot.timer)
  clearTimeout(treeTimer)
  for (const waiter of treeWaiters.splice(0)) waiter.reject(new CanceledError(translate('workspace.workspace_closed_221ea3')))
  treeFetching = false
  treeAgain = false
  opsInFlight = 0
  localTreeEdits++
  creating.clear()
  slots.clear()
  editorStates.clear()
  noteRefs.clear()
  view = null
  ws.tabs = []
  ws.active = null
  ws.entries = []
  ws.switcher = null
  ws.settings = null
  ws.moving = null
  ws.importing = null
  ws.renaming = null
  ws.image = null
  ws.images = null
  stopPlugins()
  disconnect?.()
  disconnect = undefined
}

async function openMarkdownLink(note: string, href: string) {
  const decoded = decodeLinkDestination(href)
  let url: URL
  try {
    url = new URL(decoded, `https://rawmark.local/${encodePath(note)}`)
  } catch {
    toast(translate('workspace.invalid_link_format_651be5')); return
  }
  if (url.origin !== 'https://rawmark.local') {
    if (['http:', 'https:', 'mailto:', 'tel:'].includes(url.protocol)) window.open(url.href, '_blank', 'noopener')
    else toast(translate('workspace.unsupported_link_protocol_cf426f'))
    return
  }
  let target: string
  try {
    target = decodeURIComponent(url.pathname.slice(1)); decodeURIComponent(url.hash.slice(1))
  } catch {
    toast(translate('workspace.invalid_link_encoding_2c6a7e')); return
  }
  if (!ws.entries.some(e => e.path === target && !e.dir)) {
    toast(translate('workspace.link_target_does_not_exist_2503d1', { p0: target })); return
  }
  if (!target.endsWith('.md')) {
    const response = await getRawFileApi(target)
    const url = URL.createObjectURL(response.data)
    const link = Object.assign(document.createElement('a'), { href: url, download: basename(target) }); link.click(); setTimeout(() => URL.revokeObjectURL(url), 1000)
    return
  }
  await openNote(target)
  if (url.hash) {
    requestAnimationFrame(() => {
      const state = editorStateOf(target); const v = editorView()
      if (!state || !v || ws.active !== target) return
      const heading = decodeURIComponent(url.hash.slice(1)).toLocaleLowerCase()
      for (let i = 1; i <= state.doc.lines; i++) {
        const line = state.doc.line(i)
        const title = line.text.replace(/^#{1,6}\s+/, '').trim().toLocaleLowerCase()
        if (/^#{1,6}\s/.test(line.text) && (title === heading || title.replace(/\s+/g, '-') === heading)) {
          v.dispatch({ selection: { anchor: line.from }, effects: EditorView.scrollIntoView(line.from, { y: 'start' }) }); break
        }
      }
    })
  }
}

export async function openReference(path: string, line: number) {
  await openNote(path)
  requestAnimationFrame(() => {
    const v = editorView()
    if (!v || ws.active !== path) return
    const pos = v.state.doc.line(Math.min(line, v.state.doc.lines)).from
    v.dispatch({ selection: { anchor: pos }, effects: EditorView.scrollIntoView(pos, { y: 'center' }) })
    v.focus()
  })
}

export async function uploadFolderImages(folder: string, files: File[]) {
  const version = user.getSessionVersion()
  const failures: string[] = []
  let uploaded = 0
  await withOp(async () => {
    for (const file of files) {
      try {
        user.assertSession(version)
        await uploadFolderImageApi({ folder, file }); uploaded++
      } catch (error) {
        if (isCancel(error)) throw error
        failures.push(`${file.name}：${errorText(error)}`)
      }
    }
  })
  await refreshTree()
  return { uploaded, failures }
}

export async function cleanupImages(paths: string[]) {
  const version = user.getSessionVersion()
  await flushAll()
  user.assertSession(version)
  if (!readyToReload()) throw new Error(translate('workspace.finish_saving_pasting_uploading_or_e67d3d'))
  const result = await withOp(() => cleanupImagesApi({ paths }).then(({ data }) => data))
  await refreshTree()
  await refreshMetadata()
  return result
}