llm-in-text/src/composables/useFileSystem.js

import { computed, ref } from 'vue'

const DB_NAME = 'llm-in-text-docs'
const DB_VERSION = 1
const STORE_NAME = 'nodes'
const MAX_FILE_SIZE = 1024 * 1024 * 1024
const MAX_TEXT_SIZE = 8 * 1024 * 1024
const PREVIEW_TEXT_SIZE = 2 * 1024 * 1024
const MAX_NODES = 5000

let dbPromise = null

function generateId() {
  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`
}

function openDatabase() {
  if (dbPromise) return dbPromise
  dbPromise = new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION)
    request.onupgradeneeded = () => {
      const db = request.result
      if (!db.objectStoreNames.contains(STORE_NAME)) {
        db.createObjectStore(STORE_NAME, { keyPath: 'id' })
      }
    }
    request.onsuccess = () => resolve(request.result)
    request.onerror = () => reject(request.error || new Error('打开本地数据库失败'))
  })
  return dbPromise
}

async function withStore(mode, handler) {
  const db = await openDatabase()
  return new Promise((resolve, reject) => {
    const transaction = db.transaction(STORE_NAME, mode)
    const store = transaction.objectStore(STORE_NAME)
    let request
    try {
      request = handler(store)
    } catch (error) {
      reject(error)
      return
    }
    if (request && typeof request.onsuccess === 'function') {
      request.onsuccess = () => resolve(request.result)
      request.onerror = () => reject(request.error || new Error('本地数据库操作失败'))
    } else {
      transaction.oncomplete = () => resolve(request)
      transaction.onerror = () => reject(transaction.error || new Error('本地数据库操作失败'))
    }
    transaction.onabort = () => reject(transaction.error || new Error('本地数据库操作已取消'))
  })
}

function cloneRecord(record) {
  if (!record) return record
  return {
    ...record,
    children: undefined
  }
}

function getExtension(name = '') {
  const parts = String(name).split('.')
  return parts.length > 1 ? parts.pop().toLowerCase() : ''
}

function isTextExtension(ext) {
  const textExtensions = [
    'md', 'markdown', 'txt', 'json', 'js', 'jsx', 'ts', 'tsx',
    'css', 'scss', 'less', 'html', 'htm', 'py', 'vue', 'xml',
    'yaml', 'yml', 'csv', 'log', 'sql', 'toml', 'ini', 'cfg',
    'conf', 'sh', 'bat', 'ps1', 'java', 'c', 'cpp', 'h', 'hpp',
    'go', 'rs', 'swift', 'kt', 'rb', 'php', 'pl', 'r', 'scala',
    'gradle', 'properties', 'env', 'gitignore', 'dockerfile'
  ]
  return textExtensions.includes(ext)
}

function isBinaryExtension(ext) {
  const binaryExtensions = [
    'exe', 'dll', 'so', 'dylib', 'bin', 'dat', 'obj', 'o', 'a',
    'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp',
    'pdf', 'zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz',
    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'svg',
    'mp3', 'mp4', 'wav', 'avi', 'mov', 'mkv', 'flv', 'wmv',
    'ttf', 'otf', 'woff', 'woff2', 'eot',
    'class', 'pyc', 'pyo', 'jar', 'war', 'ear',
    'db', 'sqlite', 'mdb', 'accdb',
    'pem', 'key', 'crt', 'cer', 'p12', 'pfx', 'jks',
    'msg', 'eml', 'pst', 'ost',
    'dwg', 'dxf', 'step', 'stl', 'obj', 'fbx', '3ds', 'blend'
  ]
  return binaryExtensions.includes(ext.toLowerCase())
}

function inferMimeType(name, fallback = '') {
  const ext = getExtension(name)
  const map = {
    avi: 'video/x-msvideo',
    md: 'text/markdown',
    markdown: 'text/markdown',
    mkv: 'video/x-matroska',
    mov: 'video/quicktime',
    mp4: 'video/mp4',
    txt: 'text/plain',
    json: 'application/json',
    js: 'text/javascript',
    jsx: 'text/javascript',
    ts: 'text/typescript',
    tsx: 'text/typescript',
    css: 'text/css',
    html: 'text/html',
    htm: 'text/html',
    py: 'text/x-python',
    vue: 'text/plain',
    xml: 'application/xml',
    yaml: 'text/yaml',
    yml: 'text/yaml',
    csv: 'text/csv',
    log: 'text/plain',
    sql: 'text/plain',
    toml: 'text/plain',
    ini: 'text/plain',
    cfg: 'text/plain',
    conf: 'text/plain',
    sh: 'text/plain',
    bat: 'text/plain',
    ps1: 'text/plain',
    jpg: 'image/jpeg',
    jpeg: 'image/jpeg',
    flv: 'video/x-flv',
    m4v: 'video/x-m4v',
    png: 'image/png',
    gif: 'image/gif',
    webp: 'image/webp',
    svg: 'image/svg+xml',
    pdf: 'application/pdf',
    ogg: 'video/ogg',
    ogv: 'video/ogg',
    webm: 'video/webm',
    wmv: 'video/x-ms-wmv'
  }
  return fallback || map[ext] || 'application/octet-stream'
}

function isTextFile(record) {
  const ext = getExtension(record?.name)
  // 二进制文件不提供预览
  if (isBinaryExtension(ext)) return false
  const mime = String(record?.mimeType || '')
  return isTextExtension(ext) || mime.startsWith('text/') || mime.includes('json') || mime.includes('xml')
}

function buildTree(records) {
  const map = new Map()
  const roots = []
  for (const record of records) {
    map.set(record.id, {
      ...record,
      children: record.type === 'folder' ? [] : undefined
    })
  }
  for (const record of records) {
    const current = map.get(record.id)
    if (!record.parentId) {
      roots.push(current)
      continue
    }
    const parent = map.get(record.parentId)
    if (parent?.type === 'folder') {
      parent.children.push(current)
    } else {
      roots.push(current)
    }
  }
  const sorter = (a, b) => {
    if (a.type !== b.type) return a.type === 'folder' ? -1 : 1
    return a.name.localeCompare(b.name, 'zh-CN', { sensitivity: 'base' })
  }
  const sortChildren = (nodes) => {
    nodes.sort(sorter)
    for (const node of nodes) {
      if (node.type === 'folder' && Array.isArray(node.children)) {
        sortChildren(node.children)
      }
    }
  }
  sortChildren(roots)
  return roots
}

function findNode(nodes, id) {
  for (const node of nodes) {
    if (node.id === id) return node
    if (node.type === 'folder') {
      const found = findNode(node.children || [], id)
      if (found) return found
    }
  }
  return null
}

function getPath(nodes, id, path = []) {
  for (const node of nodes) {
    if (node.id === id) return [...path, node]
    if (node.type === 'folder') {
      const found = getPath(node.children || [], id, [...path, node])
      if (found) return found
    }
  }
  return null
}

function estimateRecordSize(record) {
  if (typeof record?.size === 'number') return record.size
  if (typeof record?.content === 'string') return new Blob([record.content]).size
  if (typeof record?.previewText === 'string') return new Blob([record.previewText]).size
  return 0
}

async function readFilePayload(file) {
  const mimeType = inferMimeType(file.name, file.type)
  const ext = getExtension(file.name)
  const textFile = isTextExtension(ext) || mimeType.startsWith('text/') || mimeType.includes('json') || mimeType.includes('xml')

  if (!textFile) {
    return {
      mimeType,
      size: file.size,
      storageKind: 'blob',
      blob: file
    }
  }

  // 二进制扩展名文件不尝试读取内容，避免长时间等待
  if (isBinaryExtension(ext)) {
    return {
      mimeType,
      size: file.size,
      storageKind: 'blob',
      blob: file
    }
  }

  if (file.size <= MAX_TEXT_SIZE) {
    const content = await file.text()
    return {
      mimeType,
      size: file.size,
      storageKind: 'text',
      content,
      previewText: content,
      isTruncatedPreview: false
    }
  }
  const previewText = await file.slice(0, PREVIEW_TEXT_SIZE).text()
  return {
    mimeType,
    size: file.size,
    storageKind: 'blob',
    blob: file,
    previewText,
    isTruncatedPreview: true
  }
}

function createWelcomeRecords() {
  const folderId = generateId()
  const fileId = generateId()
  const now = Date.now()
  return [
    {
      id: folderId,
      name: '示例文件夹',
      type: 'folder',
      parentId: null,
      createdAt: now,
      updatedAt: now
    },
    {
      id: fileId,
      name: '欢迎使用.md',
      type: 'file',
      parentId: null,
      createdAt: now,
      updatedAt: now,
      mimeType: 'text/markdown',
      storageKind: 'text',
      size: 258,
      content: [
        '# 欢迎使用文档模式',
        '',
        '这里已经切换为更接近 GitHub 的文件浏览体验。',
        '',
        '## 现在支持',
        '',
        '- 左侧文件树与快速上传',
        '- 浏览器本地持久化存储',
        '- 文本、Markdown、图片、PDF 预览',
        '- 大文件保留原始文件并显示截断预览'
      ].join('\n'),
      previewText: '',
      isTruncatedPreview: false
    }
  ]
}

export function useFileSystem() {
  const records = ref([])
  const selectedId = ref(null)
  const expandedIds = ref(new Set())
  const clipboard = ref(null)
  const contextMenu = ref(null)
  const error = ref(null)
  const loading = ref(false)

  const tree = computed(() => buildTree(records.value))
  const stats = computed(() => {
    let fileCount = 0
    let folderCount = 0
    let usedBytes = 0
    for (const record of records.value) {
      if (record.type === 'folder') folderCount += 1
      else fileCount += 1
      usedBytes += estimateRecordSize(record)
    }
    return { fileCount, folderCount, usedBytes }
  })

  async function load() {
    loading.value = true
    try {
      const nextRecords = await withStore('readonly', (store) => store.getAll())
      if (!Array.isArray(nextRecords) || nextRecords.length === 0) {
        const seed = createWelcomeRecords()
        await Promise.all(seed.map((record) => persistRecord(record)))
        records.value = seed
      } else {
        records.value = nextRecords
      }
      error.value = null
    } catch {
      error.value = '读取本地文件失败，请刷新页面后重试'
      records.value = []
    } finally {
      loading.value = false
    }
  }

  async function persistRecord(record) {
    return withStore('readwrite', (store) => store.put(cloneRecord(record)))
  }

  async function deleteRecord(id) {
    return withStore('readwrite', (store) => store.delete(id))
  }

  function touchParent(parentId) {
    if (!parentId) return
    const parent = records.value.find((item) => item.id === parentId)
    if (!parent) return
    parent.updatedAt = Date.now()
    persistRecord(parent).catch(() => {
      error.value = '更新目录时间失败'
    })
  }

  function createFile(parentId, name, content = '', options = {}) {
    if (records.value.length >= MAX_NODES) {
      error.value = `文件数量不能超过 ${MAX_NODES} 个`
      return false
    }
    const size = typeof options.size === 'number' ? options.size : new Blob([content]).size
    if (size > MAX_FILE_SIZE) {
      error.value = '单个文件不能超过 1GB'
      return false
    }
    const now = Date.now()
    const file = {
      id: generateId(),
      name,
      type: 'file',
      parentId: parentId || null,
      createdAt: now,
      updatedAt: now,
      mimeType: inferMimeType(name, options.mimeType),
      storageKind: options.storageKind || 'text',
      size,
      content: options.content ?? content,
      previewText: options.previewText ?? '',
      isTruncatedPreview: Boolean(options.isTruncatedPreview),
      blob: options.blob || null
    }
    records.value = [...records.value, file]
    if (parentId) {
      const next = new Set(expandedIds.value)
      next.add(parentId)
      expandedIds.value = next
    }
    selectedId.value = file.id
    error.value = null
    persistRecord(file).catch(() => {
      error.value = '保存文件失败，可能是浏览器存储空间不足'
    })
    touchParent(parentId)
    return true
  }

  function updateFile(id, nextValue, options = {}) {
    const file = records.value.find((item) => item.id === id && item.type === 'file')
    if (!file) return false

    const nextName = options.name || file.name
    const isBlobValue = nextValue instanceof Blob
    const nextContent = isBlobValue ? (options.content ?? '') : String(options.content ?? nextValue ?? '')
    const nextSize = typeof options.size === 'number'
      ? options.size
      : isBlobValue
        ? nextValue.size
        : new Blob([nextContent]).size

    if (nextSize > MAX_FILE_SIZE) {
      error.value = '单个文件不能超过 1GB'
      return false
    }

    file.name = nextName
    file.updatedAt = Date.now()
    file.mimeType = inferMimeType(nextName, options.mimeType || (isBlobValue ? nextValue.type : file.mimeType))
    file.size = nextSize
    file.storageKind = options.storageKind || (isBlobValue ? 'blob' : 'text')
    file.content = nextContent
    file.previewText = options.previewText ?? (file.storageKind === 'text' ? nextContent : '')
    file.isTruncatedPreview = Boolean(options.isTruncatedPreview)
    file.blob = isBlobValue ? nextValue : null
    records.value = [...records.value]
    error.value = null

    persistRecord(file).catch(() => {
      error.value = '保存文件失败，可能是浏览器存储空间不足'
    })
    touchParent(file.parentId)
    return true
  }

  function createFolder(parentId, name) {
    if (records.value.length >= MAX_NODES) {
      error.value = `目录项数量不能超过 ${MAX_NODES} 个`
      return false
    }
    const now = Date.now()
    const folder = {
      id: generateId(),
      name,
      type: 'folder',
      parentId: parentId || null,
      createdAt: now,
      updatedAt: now
    }
    records.value = [...records.value, folder]
    if (parentId) {
      const next = new Set(expandedIds.value)
      next.add(parentId)
      expandedIds.value = next
    }
    selectedId.value = folder.id
    error.value = null
    persistRecord(folder).catch(() => {
      error.value = '保存文件夹失败'
    })
    touchParent(parentId)
    return true
  }

  function rename(id, newName) {
    const node = records.value.find((item) => item.id === id)
    if (!node) return false
    node.name = newName
    node.updatedAt = Date.now()
    error.value = null
    persistRecord(node).catch(() => {
      error.value = '重命名失败'
    })
    return true
  }

  function collectDescendantIds(id) {
    const ids = new Set([id])
    let changed = true
    while (changed) {
      changed = false
      for (const record of records.value) {
        if (record.parentId && ids.has(record.parentId) && !ids.has(record.id)) {
          ids.add(record.id)
          changed = true
        }
      }
    }
    return [...ids]
  }

  function remove(id) {
    const ids = new Set(collectDescendantIds(id))
    const deletingSelected = selectedId.value && ids.has(selectedId.value)
    records.value = records.value.filter((item) => !ids.has(item.id))
    if (deletingSelected) selectedId.value = null
    if (clipboard.value?.nodeId && ids.has(clipboard.value.nodeId)) {
      clipboard.value = null
    }
    if (clipboard.value?.node?.id && ids.has(clipboard.value.node.id)) {
      clipboard.value = null
    }
    error.value = null
    ids.forEach((currentId) => {
      deleteRecord(currentId).catch(() => {
        error.value = '删除文件失败'
      })
    })
  }

  function select(id) {
    selectedId.value = id
  }

  function toggleFolder(id) {
    const node = records.value.find((item) => item.id === id)
    if (!node || node.type !== 'folder') return
    const next = new Set(expandedIds.value)
    if (next.has(id)) next.delete(id)
    else next.add(id)
    expandedIds.value = next
  }

  function copy(id) {
    const node = findNode(tree.value, id)
    if (!node) return
    clipboard.value = {
      mode: 'copy',
      node: JSON.parse(JSON.stringify(node))
    }
  }

  function cut(id) {
    const node = records.value.find((item) => item.id === id)
    if (!node) return
    clipboard.value = {
      mode: 'cut',
      nodeId: node.id
    }
  }

  function isDescendantOf(sourceId, targetParentId) {
    let current = records.value.find((item) => item.id === targetParentId)
    while (current) {
      if (current.parentId === sourceId) return true
      current = current.parentId ? records.value.find((item) => item.id === current.parentId) : null
    }
    return false
  }

  function duplicateNode(node, targetParentId) {
    const now = Date.now()
    const clonedId = generateId()
    const record = {
      ...cloneRecord(node),
      id: clonedId,
      parentId: targetParentId,
      createdAt: now,
      updatedAt: now
    }
    records.value = [...records.value, record]
    persistRecord(record).catch(() => {
      error.value = '复制文件失败'
    })
    if (node.type === 'folder') {
      for (const child of node.children || []) {
        duplicateNode(child, clonedId)
      }
    }
  }

  function paste(targetParentId) {
    if (!clipboard.value) return
    if (clipboard.value.mode === 'cut') {
      const node = records.value.find((item) => item.id === clipboard.value.nodeId)
      if (!node) {
        clipboard.value = null
        return
      }
      if (node.id === targetParentId || (targetParentId && isDescendantOf(node.id, targetParentId))) {
        error.value = '不能移动到自身或子目录中'
        return
      }
      node.parentId = targetParentId || null
      node.updatedAt = Date.now()
      persistRecord(node).catch(() => {
        error.value = '移动文件失败'
      })
      touchParent(targetParentId)
      clipboard.value = null
      error.value = null
      return
    }
    const source = clipboard.value.node
    if (!source) return
    if (records.value.length >= MAX_NODES) {
      error.value = `目录项数量不能超过 ${MAX_NODES} 个`
      return
    }
    duplicateNode(source, targetParentId || null)
    touchParent(targetParentId)
    error.value = null
  }

  function canPaste() {
    return clipboard.value !== null
  }

  function clearClipboard() {
    clipboard.value = null
  }

  function getSelectedNode() {
    return selectedId.value ? findNode(tree.value, selectedId.value) : null
  }

  function getBreadcrumbPath(id) {
    return getPath(tree.value, id) || []
  }

  function showContextMenu(x, y, node) {
    contextMenu.value = { x, y, node }
  }

  function hideContextMenu() {
    contextMenu.value = null
  }

  function getFileIcon(name) {
    const ext = getExtension(name)
    const iconMap = {
      avi: 'video',
      md: 'markdown',
      markdown: 'markdown',
      mkv: 'video',
      mov: 'video',
      mp4: 'video',
      txt: 'text',
      json: 'json',
      js: 'javascript',
      jsx: 'javascript',
      ts: 'typescript',
      tsx: 'typescript',
      css: 'css',
      html: 'html',
      htm: 'html',
      py: 'python',
      vue: 'vue',
      xml: 'xml',
      yaml: 'yaml',
      yml: 'yaml',
      csv: 'csv',
      log: 'log',
      sql: 'sql',
      jpg: 'image',
      jpeg: 'image',
      png: 'image',
      gif: 'image',
      flv: 'video',
      m4v: 'video',
      webp: 'image',
      svg: 'image',
      ogg: 'video',
      ogv: 'video',
      pdf: 'pdf',
      doc: 'word',
      docx: 'word',
      ppt: 'ppt',
      pptx: 'ppt',
      webm: 'video',
      wmv: 'video',
      xls: 'excel',
      xlsx: 'excel',
      zip: 'zip'
    }
    return iconMap[ext] || 'file'
  }

  async function uploadFiles(files, parentId = null) {
    const source = Array.from(files || [])
    if (source.length === 0) return { success: 0, failed: [] }
    const failed = []
    let success = 0
    for (const file of source) {
      if (file.size > MAX_FILE_SIZE) {
        failed.push({ name: file.name, reason: '单个文件不能超过 1GB' })
        continue
      }
      try {
        const payload = await readFilePayload(file)
        const created = createFile(parentId, file.name, payload.content || '', payload)
        if (created) success += 1
        else failed.push({ name: file.name, reason: error.value || '创建文件失败' })
      } catch {
        failed.push({ name: file.name, reason: '读取文件失败' })
      }
    }
    if (success > 0 && parentId) {
      const next = new Set(expandedIds.value)
      next.add(parentId)
      expandedIds.value = next
    }
    return { success, failed }
  }

  function getFileBlob(node) {
    if (!node || node.type !== 'file') return null
    if (node.blob instanceof Blob) return node.blob
    if (typeof node.content === 'string') {
      return new Blob([node.content], { type: inferMimeType(node.name, node.mimeType) })
    }
    if (typeof node.previewText === 'string' && node.previewText) {
      return new Blob([node.previewText], { type: inferMimeType(node.name, node.mimeType) })
    }
    return null
  }

  return {
    tree,
    selectedId,
    expandedIds,
    clipboard,
    contextMenu,
    error,
    loading,
    stats,
    load,
    createFile,
    updateFile,
    createFolder,
    rename,
    remove,
    select,
    toggleFolder,
    copy,
    cut,
    paste,
    canPaste,
    clearClipboard,
    getSelectedNode,
    getBreadcrumbPath,
    showContextMenu,
    hideContextMenu,
    getFileIcon,
    getExtension,
    getFileBlob,
    isTextFile,
    uploadFiles,
    MAX_FILE_SIZE,
    MAX_NODES
  }
}