/**
 * 文件操作逻辑封装
 *
 * @module composables/useFileOperations
 * @description 封装所有文件操作逻辑，提供统一的错误处理和状态管理
 */

import { ref, watch } from 'vue'
import { Message, Modal } from '@arco-design/web-vue'
import {
  listDir,
  readFile as readFileApi,
  writeFile as writeFileApi,
  deletePath as deletePathApi,
} from '@/api'

/**
 * LocalStorage 键名
 */
const STORAGE_KEY_LAST_PATH = 'app-filesystem-last-path'

/**
 * 文件操作 composable
 * @param {Object} [options] - 配置选项
 * @param {Function} [options.onSuccess] - 操作成功回调
 * @param {Function} [options.onError] - 操作失败回调
 * @returns {UseFileOperationsReturn} 文件操作API
 *
 * @example
 * const {
 *   filePath,
 *   fileContent,
 *   fileList,
 *   fileLoading,
 *   listDirectory,
 *   readFile,
 *   writeFile,
 *   deleteFile
 * } = useFileOperations({
 *   onSuccess: (operation, data) => console.log(operation, data),
 *   onError: (operation, error) => console.error(operation, error)
 * })
 */
export function useFileOperations(options = {}) {
  const { onSuccess = () => {}, onError = () => {} } = options

  // ========== 响应式状态 ==========

  /**
   * 当前文件/目录路径
   * @type {Ref<string>}
   */
  // 从 localStorage 恢复上次路径
  const savedPath = localStorage.getItem(STORAGE_KEY_LAST_PATH)
  const filePath = ref(savedPath || '')

  /**
   * 文件内容
   * @type {Ref<string>}
   */
  const fileContent = ref('')

  /**
   * 文件列表
   * @type {Ref<Array>}
   */
  const fileList = ref([])

  /**
   * 加载状态
   * @type {Ref<boolean>}
   */
  const fileLoading = ref(false)

  /**
   * 正在删除状态（防止并发删除）
   * @type {Ref<boolean>}
   */
  const isDeleting = ref(false)

  // ========== 文件操作方法 ==========

  /**
   * 列出目录内容
   * @param {string} [path] - 目录路径，不传则使用当前路径
   * @returns {Promise<boolean>} 是否成功
   */
  const listDirectory = async (path) => {
    const targetPath = path || filePath.value

    if (!targetPath) {
      Message.error('请输入目录路径')
      return false
    }

    fileLoading.value = true
    try {
      const result = await listDir(targetPath)
      fileList.value = result

      if (!path) {
        // 如果没有传参，更新当前路径
        filePath.value = targetPath
      }

      onSuccess('listDirectory', { path: targetPath, count: result.length })
      return true
    } catch (error) {
      onError('listDirectory', error)
      const errorMsg = error.message || error || '未知错误'
      Message.error(`列出目录失败 [${targetPath}]: ${errorMsg}`)
      return false
    } finally {
      fileLoading.value = false
    }
  }

  /**
   * 读取文件内容
   * @param {string} [path] - 文件路径，不传则使用当前路径
   * @returns {Promise<boolean>} 是否成功
   */
  const readFile = async (path) => {
    const targetPath = path || filePath.value

    if (!targetPath) {
      Message.error('请输入文件路径')
      return false
    }

    fileLoading.value = true
    try {
      const content = await readFileApi(targetPath)
      fileContent.value = content

      if (!path) {
        filePath.value = targetPath
      }

      onSuccess('readFile', { path: targetPath })
      // 文件读取成功，静默无提示
      return true
    } catch (error) {
      onError('readFile', error)
      Message.error(`读取文件失败: ${error.message || error}`)
      return false
    } finally {
      fileLoading.value = false
    }
  }

  /**
   * 写入文件内容
   * @param {string} [content] - 要写入的内容，不传则使用当前内容
   * @param {string} [path] - 文件路径，不传则使用当前路径
   * @param {string} [fileName] - 文件名，用于成功提示显示
   * @param {boolean} [isShortcut=false] - 是否是快捷键触发（快捷键不显示提示）
   * @returns {Promise<boolean>} 是否成功
   */
  const writeFile = async (content, path, fileName, isShortcut = false) => {
    // 忽略事件对象（当点击按钮时 Vue 会传递事件对象）
    const targetContent = (content !== undefined && typeof content === 'string') ? content : fileContent.value
    const targetPath = (path !== undefined && typeof path === 'string') ? path : filePath.value

    if (!targetPath) {
      Message.error('请输入文件路径')
      return false
    }

    fileLoading.value = true
    try {
      await writeFileApi(targetPath, targetContent)

      if (content !== undefined) {
        fileContent.value = targetContent
      }
      if (path) {
        filePath.value = path
      }

      onSuccess('writeFile', { path: targetPath })

      // 差异化反馈：快捷键不显示提示，按钮点击显示轻提示
      if (!isShortcut) {
        // 按钮点击保存：显示轻量 Toast 提示
        if (fileName && typeof fileName === 'string') {
          Message.success({
            content: `✓ ${fileName} 已保存`,
            duration: 1500, // 1.5秒后自动消失
            position: 'bottom' // 底部显示，不打断操作
          })
        } else {
          Message.success({
            content: '文件已保存',
            duration: 1500,
            position: 'bottom'
          })
        }
      }
      // 快捷键保存：无提示（静默成功）

      return true
    } catch (error) {
      onError('writeFile', error)
      // 保存失败：总是显示醒目错误提示（需手动关闭）
      Message.error({
        content: `文件保存失败: ${error.message || error}`,
        duration: 5000, // 错误提示显示更久
        closable: true // 允许手动关闭
      })
      return false
    } finally {
      fileLoading.value = false
    }
  }

  /**
   * 删除文件或目录
   * 🔒 安全修复：移除 confirm 参数，始终需要用户确认，防止绕过
   * 🔒 安全修复：添加并发删除检查，防止批量删除攻击
   * @param {string} [path] - 文件路径，不传则使用当前路径
   * @returns {Promise<boolean>} 用户是否确认及操作是否成功
   */
  const deleteFile = async (path) => {
    const targetPath = path || filePath.value

    if (!targetPath) {
      Message.error('请输入文件路径')
      return false
    }

    // 🔒 安全修复：添加调用频率限制（防止批量删除攻击）
    if (isDeleting.value) {
      Message.warning('正在删除中，请稍候...')
      return false
    }

    const executeDelete = async () => {
      isDeleting.value = true
      fileLoading.value = true
      try {
        await deletePathApi(targetPath)

        // 清空状态
        filePath.value = ''
        fileContent.value = ''
        fileList.value = []

        onSuccess('deleteFile', { path: targetPath })
        Message.success('删除成功')
        return true
      } catch (error) {
        onError('deleteFile', error)
        Message.error(`删除失败: ${error.message || error}`)
        return false
      } finally {
        fileLoading.value = false
        isDeleting.value = false
      }
    }

    // 🔒 安全修复：始终显示确认对话框，无法绕过
    return new Promise((resolve) => {
      Modal.confirm({
        title: '⚠️ 确认删除',
        content: `确定要删除 ${targetPath} 吗？此操作不可恢复！`,
        okText: '确定删除',
        cancelText: '取消',
        okButtonProps: { status: 'danger' }, // 红色按钮提醒危险
        onOk: async () => {
          const result = await executeDelete()
          resolve(result)
        },
        onCancel: () => {
          resolve(false)
        },
      })
    })
  }

  /**
   * 选择文件（智能判断是文件还是目录）
   * @param {string} path - 文件/目录路径
   * @param {Array} fileListData - 文件列表数据
   * @returns {Promise<boolean>} 是否成功
   */
  const selectFile = async (path, fileListData) => {
    if (!path) return false

    filePath.value = path

    // 从文件列表中查找该项
    const item = fileListData.find(f => f.path === path)

    if (!item) {
      // 如果列表中找不到，尝试根据路径判断
      // 简单判断：路径以 / 或 \ 结尾可能是目录
      const isDir = path.endsWith('/') || path.endsWith('\\')
      if (isDir) {
        return await listDirectory(path)
      } else {
        return await readFile(path)
      }
    }

    if (item.is_dir) {
      // 是目录，列出内容
      return await listDirectory(path)
    } else {
      // 是文件，读取内容
      return await readFile(path)
    }
  }

  /**
   * 清空所有状态
   */
  const clearAll = () => {
    filePath.value = ''
    fileContent.value = ''
    fileList.value = []
  }

  // ========== 持久化 ==========

  /**
   * 监听路径变化，自动保存到 localStorage
   * 用于下次启动时恢复上次访问的路径
   */
  watch(filePath, (newPath) => {
    try {
      if (newPath) {
        localStorage.setItem(STORAGE_KEY_LAST_PATH, newPath)
      } else {
        localStorage.removeItem(STORAGE_KEY_LAST_PATH)
      }
    } catch (e) {
      console.warn('[useFileOperations] 保存路径失败:', e)
    }
  })

  // ========== 返回公共API ==========

  return {
    // 状态
    filePath,
    fileContent,
    fileList,
    fileLoading,

    // 方法
    listDirectory,
    readFile,
    writeFile,
    deleteFile,
    selectFile,
    clearAll,
  }
}

/**
 * @typedef {Object} UseFileOperationsReturn
 * @property {Ref<string>} filePath - 当前文件路径
 * @property {Ref<string>} fileContent - 文件内容
 * @property {Ref<Array>} fileList - 文件列表
 * @property {Ref<boolean>} fileLoading - 加载状态
 * @property {Function} listDirectory - 列出目录
 * @property {Function} readFile - 读取文件
 * @property {Function} writeFile - 写入文件
 * @property {Function} deleteFile - 删除文件
 * @property {Function} selectFile - 智能选择文件
 * @property {Function} clearAll - 清空所有状态
 */
