// src/tools/background-task/
export const background_output = Tool.define('background_output', {
  description: 'Get output from a background task',
  parameters: z.object({
    task_id: z.string().describe('Task ID to retrieve'),
    wait: z.boolean().optional().describe('Wait for completion if still running'),
    timeout: z.number().optional().default(10_000),
  }),
})

export const background_cancel = Tool.define('background_cancel', {
  description: 'Cancel a running background task',
  parameters: z.object({
    task_id: z.string().describe('Task ID to cancel'),
    reason: z.string().optional(),
  }),
})

// src/tools/delegate-task/
export const delegate_task = Tool.define('delegate_task', {
  description: 'Delegate a task to a specialized agent by category or directly',
  parameters: z.object({
    description: z.string().describe('Short description (3-5 words)'),
    prompt: z.string().describe('The task for the agent'),
    category: z.enum([
      'quick', 'code', 'frontend', 'backend',
      'infra', 'data', 'security', 'quality',
    ]).optional().describe('Task category for routing'),
    agent: z.string().optional().describe('Direct agent name (overrides category)'),
    task_id: z.string().optional().describe('Resume a previous task'),
  }),
  execute: async (params, ctx) => {
    // 1. 解析目标 Agent
    const targetAgent = params.agent
      ?? resolveCategoryAgent(params.category ?? inferCategory(params.prompt))

    // 2. 模型选择
    const model = resolveModelForAgent(targetAgent, ctx.config)

    // 3. 创建子会话
    const session = await ctx.client.session.create({
      parentID: ctx.sessionID,
      title: params.description,
      agent: targetAgent,
      model,
    })

    // 4. 执行
    const result = await session.prompt(params.prompt)

    // 5. 返回结果
    return {
      title: params.description,
      metadata: { sessionId: session.id, agent: targetAgent, model },
      output: formatTaskResult(result),
    }
  },
})

// src/tools/hashline-edit/
export const hashline_edit = Tool.define('hashline_edit', {
  description: 'Edit files using content hashes as anchors (more reliable than line numbers)',

  parameters: z.object({
    filePath: z.string(),
    oldString: z.string().describe('Content to replace'),
    newString: z.string().describe('Replacement content'),
    algorithm: z.enum(['sha256', 'md5']).default('sha256'),
  }),

  execute: async (params, ctx) => {
    // 1. 读取文件
    const content = await readFile(params.filePath)

    // 2. 计算 oldString 的 SHA256 哈希
    const hash = crypto
      .createHash(params.algorithm)
      .update(params.oldString)
      .digest('hex')

    // 3. 找到包含该哈希的行（用于调试输出）
    const lineHash = computeLineHashes(content)
    const matchingLine = lineHash.find(h => h.hash === hash)

    if (!matchingLine) {
      // 4. 降级到普通编辑
      return fallbackToEdit(params, ctx)
    }

    // 5. 执行替换
    const newContent = content.replace(params.oldString, params.newString)

    // 6. 验证新内容
    const newHash = crypto
      .createHash(params.algorithm)
      .update(params.newString)
      .digest('hex')

    // 7. 写入
    await writeFile(params.filePath, newContent)

    return {
      title: `Edited ${path.basename(params.filePath)}`,
      output: `Hashline edit successful.\nAlgorithm: ${params.algorithm}\nOld hash: ${hash}\nNew hash: ${newHash}`,
      metadata: { hash, line: matchingLine.line, algorithm: params.algorithm },
    }
  },
})

// src/tools/ast-grep/

// AST_Grep_Search — AST 模式搜索
export const ast_grep_search = Tool.define('ast_grep_search', {
  description: 'Search code using AST patterns (language-aware, not regex)',
  parameters: z.object({
    pattern: z.string().describe('AST pattern (e.g., "$FUNC call($ARG)")'),
    language: z.enum(['javascript', 'typescript', 'python', 'go', 'rust', 'java']),
    file: z.string().optional().describe('File or directory to search'),
    globals: z.record(z.string()).optional().describe('Pattern variables'),
  }),
  execute: async (params, ctx) => {
    // 使用 @ast-grep/napi
    const sg = await import('@ast-grep/napi')

    const results = await sg.search({
      rule: params.pattern,
      language: params.language,
      paths: [params.file ?? ctx.directory],
      globals: params.globals,
    })

    return {
      title: `AST search: ${params.pattern}`,
      output: formatASTResults(results),
      metadata: { count: results.length },
    }
  },
})

// AST_Grep_Replace — AST 模式替换
export const ast_grep_replace = Tool.define('ast_grep_replace', {
  description: 'Replace code using AST patterns with transformations',
  parameters: z.object({
    pattern: z.string(),
    replacement: z.string().describe('Replacement AST pattern with $NEW syntax'),
    language: z.enum(['javascript', 'typescript', 'python', 'go', 'rust', 'java']),
    file: z.string(),
  }),
})

// src/tools/session-manager/
export const session_list = Tool.define('session_list', {
  description: 'List recent sessions in the project',
  parameters: z.object({
    limit: z.number().default(10),
    filter: z.string().optional(),
  }),
})

export const session_read = Tool.define('session_read', {
  description: 'Read a previous session transcript',
  parameters: z.object({
    session_id: z.string().describe('Session ID to read'),
    offset: z.number().optional(),
    limit: z.number().optional(),
  }),
})

export const session_search = Tool.define('session_search', {
  description: 'Search across all sessions for content',
  parameters: z.object({
    query: z.string(),
    sessions: z.array(z.string()).optional(),
  }),
})

export const session_info = Tool.define('session_info', {
  description: 'Get metadata about a session',
  parameters: z.object({
    session_id: z.string().optional().describe('Default: current session'),
  }),
})