/**
 * @local/omp-lsp — oh-my-pi style language-server integration for DSH.
 *
 *  - Diagnostics writethrough: after every successful `edit` / `write` (DSH built-ins or
 *    @local/omp-edit), the touched files are synced to their language server and fresh
 *    errors/warnings are appended to the tool result the model sees.
 *  - `lsp` tool: diagnostics, definition, type_definition, implementation, references, hover,
 *    symbols, rename (applied through DSH's fs), code_actions, status, reload, capabilities,
 *    raw request.
 *
 * Servers (typescript-language-server, pyright, gopls, rust-analyzer, clangd, bash, json, yaml,
 * css, html) are auto-detected on PATH, ~/.local/bin and the project's node_modules/.bin; one
 * client per (server, project root), idle clients are stopped after `idleMinutes`.
 */
import fs from 'node:fs'
import path from 'node:path'
import { ServerPool } from './lib/servers.js'
import { fromUri, toUri } from './lib/client.js'
import {
  applyTextEdits, columnOf, formatDiagnostics, formatHover, formatLocations, formatSymbols, normalizeWorkspaceEdit, rel,
} from './lib/format.js'

export const name = 'omp-lsp'
export const inject = ['tools', 'fs', 'systemPrompt']

const ACTIONS = ['diagnostics', 'definition', 'type_definition', 'implementation', 'references', 'hover', 'symbols', 'rename', 'rename_file', 'code_actions', 'status', 'reload', 'capabilities', 'request']
const WRITE_TOOLS = new Set(['edit', 'write'])

export function apply(ctx, config = {}) {
  const cfg = {
    writethrough: true,
    writethroughTools: ['edit', 'write'],
    minSeverity: 2, // 1 error, 2 warning, 3 info, 4 hint
    budgetMs: 4000,
    maxDiagnostics: 25,
    idleMinutes: 10,
    servers: {},
    disabled: [],
    ...config,
  }
  const writeTools = new Set(cfg.writethroughTools ?? [...WRITE_TOOLS])
  const pool = new ServerPool({
    servers: cfg.servers,
    disabled: cfg.disabled,
    idleMs: cfg.idleMinutes * 60_000,
    log: (m) => console.warn(`[omp-lsp] ${m}`),
  })
  ctx.effect(() => () => { pool.stopAll() }, 'omp-lsp: language servers')

  const cwdOf = (exec) => exec?.agent?.session?.header?.cwd
  const absPath = async (p, exec) => {
    const t = await ctx.fs.resolve(String(p).replace(/^\[(.+?)#[0-9A-Fa-f]{4}\]$/, '$1'), { ...(cwdOf(exec) ? { cwd: cwdOf(exec) } : {}), signal: exec?.signal })
    return { target: t, file: ctx.fs.processPath(t) }
  }

  // ---------------------------------------------------------------- writethrough diagnostics

  /** Files a write/edit call touched, from its arguments and (omp-edit) result value. */
  function touchedFiles(exec, result) {
    const a = isObj(exec.arguments) ? exec.arguments : {}
    const files = new Set()
    if (typeof a.file_path === 'string') files.add(a.file_path)
    if (typeof a.path === 'string') files.add(a.path)
    const v = result.value
    if (isObj(v)) {
      if (typeof v.path === 'string') files.add(v.path)
      for (const r of Array.isArray(v.results) ? v.results : []) {
        if (r?.operation === 'delete') continue
        if (typeof r?.movedTo === 'string') files.add(r.movedTo)
        else if (typeof r?.path === 'string') files.add(r.path)
      }
    }
    // omp-edit text payloads: [PATH#TAG] headers / *** Edit File: / *** Update File:
    if (typeof a.input === 'string' && !(isObj(v) && Array.isArray(v.results))) {
      for (const m of a.input.matchAll(/^\[(.+?)#[0-9A-Fa-f]{4}\]\s*$/gm)) files.add(m[1])
      for (const m of a.input.matchAll(/^\*\*\* (?:Edit|Update|Add) File:\s*(.+?)(?:\s+all)?\s*$/gm)) files.add(m[1])
    }
    return [...files]
  }

  async function diagnose(files, exec) {
    const sections = []
    const totals = { error: 0, warning: 0 }
    await Promise.all(files.slice(0, 8).map(async (f) => {
      try {
        const { file } = await absPath(f, exec)
        if (!fs.existsSync(file)) return
        const client = await pool.clientFor(file, { cwd: cwdOf(exec) })
        if (!client) return
        const { items, fresh } = await client.diagnosticsFor(file, { budgetMs: cfg.budgetMs })
        const fmt = formatDiagnostics(file, items, { cwd: cwdOf(exec), minSeverity: cfg.minSeverity, max: cfg.maxDiagnostics })
        totals.error += fmt.counts.error; totals.warning += fmt.counts.warning
        if (fmt.text) sections.push(fmt.text)
        else if (!fresh) sections.push(`${rel(file, cwdOf(exec))}: ${client.id} did not report diagnostics within ${cfg.budgetMs}ms.`)
      } catch (e) {
        sections.push(`${f}: diagnostics unavailable (${e?.message ?? e})`)
      }
    }))
    return { sections, totals }
  }

  if (cfg.writethrough) {
    ctx.on('tools/post-execute', async (exec, result, next) => {
      const decision = await next()
      if (decision.kind !== 'accept' || result.isError || !writeTools.has(exec.name) || exec.parent !== undefined) return decision
      const files = touchedFiles(exec, result)
      if (!files.length) return decision
      const { sections, totals } = await diagnose(files, exec)
      if (!sections.length) return decision
      const head = totals.error || totals.warning
        ? `LSP diagnostics after this ${exec.name} (${totals.error} error${totals.error === 1 ? '' : 's'}, ${totals.warning} warning${totals.warning === 1 ? '' : 's'}):`
        : `LSP diagnostics after this ${exec.name}:`
      const content = [...(decision.content ?? result.content ?? []), { type: 'text', text: `\n${head}\n${sections.join('\n')}` }]
      return { ...decision, content }
    })
  }

  // ---------------------------------------------------------------- lsp tool

  async function positionArgs(args, exec) {
    if (!args.file) throw new Error('file is required for this action')
    const { file } = await absPath(args.file, exec)
    if (!fs.existsSync(file)) throw new Error(`${args.file}: not found`)
    const client = await pool.clientFor(file, { cwd: cwdOf(exec) })
    if (!client) throw new Error(`No language server available for ${path.extname(file) || args.file}. Run lsp action=status to see installed servers.`)
    const { uri } = client.sync(file)
    const line = Math.max(1, Math.floor(args.line ?? 1)) - 1
    const lineStr = fs.readFileSync(file, 'utf8').split(/\r?\n/)[line] ?? ''
    const character = columnOf(lineStr, args.symbol)
    if (character < 0) throw new Error(`symbol ${JSON.stringify(args.symbol)} not found on line ${line + 1}: ${lineStr.trim()}`)
    return { client, file, uri, position: { line, character } }
  }

  async function applyWorkspaceEdit(we, exec) {
    const { files, ops } = normalizeWorkspaceEdit(we)
    const changed = []
    for (const [file, edits] of files) {
      const { target } = await absPath(file, exec)
      const before = await ctx.fs.readText(target, exec?.signal)
      const after = applyTextEdits(before, edits)
      if (after === before) continue
      const outcome = await ctx.fs.writeText(target, after, undefined, exec?.signal, sandboxPolicyFor(exec))
      ctx.emit('fs/observed', target, { kind: 'present', version: outcome.version }, exec)
      changed.push(`${rel(file, cwdOf(exec))} (${edits.length} edit${edits.length === 1 ? '' : 's'})`)
    }
    for (const op of ops) {
      if (op.kind === 'rename') {
        const from = fromUri(op.oldUri); const to = fromUri(op.newUri)
        await fs.promises.mkdir(path.dirname(to), { recursive: true })
        await fs.promises.rename(from, to)
        changed.push(`renamed ${rel(from, cwdOf(exec))} → ${rel(to, cwdOf(exec))}`)
      } else if (op.kind === 'create') {
        await fs.promises.writeFile(fromUri(op.uri), '', { flag: 'wx' }).catch(() => {})
        changed.push(`created ${rel(fromUri(op.uri), cwdOf(exec))}`)
      } else if (op.kind === 'delete') {
        await fs.promises.rm(fromUri(op.uri), { recursive: !!op.options?.recursive, force: true })
        changed.push(`deleted ${rel(fromUri(op.uri), cwdOf(exec))}`)
      }
    }
    return changed
  }

  const sandboxPolicyFor = (exec) => {
    try { return ctx.get('sandboxPolicy')?.resolve({ ...(exec?.agent ? { session: exec.agent.session } : {}) }) } catch { return undefined }
  }

  function describeEdit(we, exec) {
    const { files, ops } = normalizeWorkspaceEdit(we)
    const out = []
    for (const [file, edits] of files) out.push(`${rel(file, cwdOf(exec))}: ${edits.length} edit${edits.length === 1 ? '' : 's'}`)
    for (const op of ops) out.push(`${op.kind} ${fromUri(op.oldUri ?? op.uri)}${op.newUri ? ` → ${fromUri(op.newUri)}` : ''}`)
    return out.join('\n') || '(no changes)'
  }

  async function runLsp(args, exec) {
    const action = args.action
    const timeout = Math.max(5, Math.min(300, args.timeout ?? 20)) * 1000
    const cwd = cwdOf(exec)
    switch (action) {
      case 'status': {
        const s = pool.status()
        return [
          'Servers:',
          ...s.servers.map((x) => `  ${x.installed ? '✓' : '✗'} ${x.id} (${x.command}) ${x.extensions.join(' ')}`),
          s.running.length ? 'Running:' : 'Running: none',
          ...s.running.map((r) => `  ${r.id} ${r.state} root=${r.root} open=${r.openDocuments}`),
          ...(s.broken.length ? ['Failed:', ...s.broken.map((b) => `  ${b.server}: ${b.error}`)] : []),
        ].join('\n')
      }
      case 'reload': {
        await pool.stopAll()
        pool.reaper = setInterval(() => pool.reap(), 60_000); pool.reaper.unref?.()
        pool.broken.clear()
        return 'All language servers stopped; they restart on next use.'
      }
      case 'diagnostics': {
        if (!args.file) throw new Error('file is required (path or glob)')
        const files = await expand(args.file, cwd)
        if (!files.length) return `No files match ${args.file}.`
        const out = []; let errors = 0; let warnings = 0
        for (const f of files.slice(0, 50)) {
          const client = await pool.clientFor(f, { cwd })
          if (!client) continue
          const { items } = await client.diagnosticsFor(f, { budgetMs: Math.min(timeout, 15000) })
          const fmt = formatDiagnostics(f, items, { cwd, minSeverity: 4, max: 100 })
          errors += fmt.counts.error; warnings += fmt.counts.warning
          if (fmt.text) out.push(fmt.text)
        }
        return out.length ? `${errors} error(s), ${warnings} warning(s)\n${out.join('\n')}` : `No diagnostics (${files.length} file${files.length === 1 ? '' : 's'} checked).`
      }
      case 'definition': case 'type_definition': case 'implementation': case 'references': {
        const { client, uri, position } = await positionArgs(args, exec)
        const method = { definition: 'textDocument/definition', type_definition: 'textDocument/typeDefinition', implementation: 'textDocument/implementation', references: 'textDocument/references' }[action]
        const params = { textDocument: { uri }, position, ...(action === 'references' ? { context: { includeDeclaration: true } } : {}) }
        return formatLocations(await client.request(method, params, timeout), { cwd })
      }
      case 'hover': {
        const { client, uri, position } = await positionArgs(args, exec)
        return formatHover(await client.request('textDocument/hover', { textDocument: { uri }, position }, timeout))
      }
      case 'symbols': {
        if (args.file && args.file !== '*') {
          const { file } = await absPath(args.file, exec)
          const client = await pool.clientFor(file, { cwd })
          if (!client) throw new Error(`No language server for ${args.file}`)
          const { uri } = client.sync(file)
          return formatSymbols(await client.request('textDocument/documentSymbol', { textDocument: { uri } }, timeout), { cwd })
        }
        if (!args.query) throw new Error('symbols needs file, or file="*" with query for a workspace search')
        const clients = [...pool.clients.values()].filter((c) => c.state === 'ready')
        if (!clients.length) throw new Error('No running language server; open a file first (e.g. lsp action=symbols file=<path>).')
        const res = (await Promise.all(clients.map((c) => c.request('workspace/symbol', { query: args.query }, timeout).catch(() => [])))).flat()
        return formatSymbols(res, { cwd })
      }
      case 'rename': {
        if (!args.new_name) throw new Error('new_name is required')
        const { client, uri, position } = await positionArgs(args, exec)
        const we = await client.request('textDocument/rename', { textDocument: { uri }, position, newName: args.new_name }, timeout)
        if (!we) return 'Rename not possible at this position.'
        if (args.apply === false) return `Preview (not applied):\n${describeEdit(we, exec)}`
        const changed = await applyWorkspaceEdit(we, exec)
        for (const c of pool.clients.values()) for (const u of c.docs.keys()) c.sync(fromUri(u))
        return `Renamed to ${args.new_name}:\n${changed.join('\n') || '(no changes)'}`
      }
      case 'rename_file': {
        if (!args.file || !args.new_name) throw new Error('file and new_name are required')
        const { file } = await absPath(args.file, exec)
        const dest = path.resolve(path.dirname(file), args.new_name)
        const client = await pool.clientFor(file, { cwd })
        let we = null
        if (client?.capabilities?.workspace?.fileOperations?.willRename) {
          we = await client.request('workspace/willRenameFiles', { files: [{ oldUri: toUri(file), newUri: toUri(dest) }] }, timeout).catch(() => null)
        }
        if (args.apply === false) return `Preview: ${rel(file, cwd)} → ${rel(dest, cwd)}${we ? `\n${describeEdit(we, exec)}` : ''}`
        const changed = we ? await applyWorkspaceEdit(we, exec) : []
        await fs.promises.mkdir(path.dirname(dest), { recursive: true })
        await fs.promises.rename(file, dest)
        client?.notify('workspace/didRenameFiles', { files: [{ oldUri: toUri(file), newUri: toUri(dest) }] })
        return `Moved ${rel(file, cwd)} → ${rel(dest, cwd)}${changed.length ? `\nUpdated references:\n${changed.join('\n')}` : ''}`
      }
      case 'code_actions': {
        const { client, uri, position } = await positionArgs(args, exec)
        const diags = (client.diagnostics.get(uri)?.items || []).filter((d) => d.range.start.line <= position.line && d.range.end.line >= position.line)
        const actions = (await client.request('textDocument/codeAction', { textDocument: { uri }, range: { start: { line: position.line, character: 0 }, end: { line: position.line + 1, character: 0 } }, context: { diagnostics: diags } }, timeout)) || []
        const filtered = args.query ? actions.filter((a) => (a.title || '').toLowerCase().includes(args.query.toLowerCase()) || (a.kind || '').startsWith(args.query)) : actions
        if (args.apply !== true) return filtered.length ? filtered.map((a, i) => `${i + 1}. ${a.title}${a.kind ? ` [${a.kind}]` : ''}`).join('\n') : 'No code actions here.'
        const pickAction = filtered[0]
        if (!pickAction) return 'No matching code action to apply.'
        let act = pickAction
        if (!act.edit && act.data !== undefined && client.capabilities?.codeActionProvider?.resolveProvider) act = await client.request('codeAction/resolve', act, timeout)
        if (act.edit) {
          const changed = await applyWorkspaceEdit(act.edit, exec)
          return `Applied "${act.title}":\n${changed.join('\n')}`
        }
        if (act.command) { await client.request('workspace/executeCommand', act.command.command ? act.command : act, timeout); return `Executed "${act.title}".` }
        return `"${act.title}" has no edit to apply.`
      }
      case 'capabilities': {
        if (!args.file) throw new Error('file is required')
        const { file } = await absPath(args.file, exec)
        const client = await pool.clientFor(file, { cwd })
        if (!client) throw new Error(`No language server for ${args.file}`)
        return JSON.stringify(client.capabilities, null, 1).slice(0, 8000)
      }
      case 'request': {
        if (!args.file || !args.query) throw new Error('request needs file (to pick the server) and query (LSP method)')
        const { client, uri, position } = await positionArgs(args, exec)
        const params = args.payload ? JSON.parse(args.payload) : { textDocument: { uri }, position }
        return JSON.stringify(await client.request(args.query, params, timeout), null, 1).slice(0, 20000)
      }
      default:
        throw new Error(`unknown action ${action}`)
    }
  }

  async function expand(spec, cwd) {
    const base = cwd || process.cwd()
    if (!/[*?[{]/.test(spec)) return [path.resolve(base, spec)].filter((f) => fs.existsSync(f))
    const out = []
    const glob = fs.promises.glob ? fs.promises.glob(spec, { cwd: base, exclude: (p) => /(^|\/)(node_modules|\.git|dist|build)(\/|$)/.test(p) }) : null
    if (glob) for await (const f of glob) { out.push(path.resolve(base, f)); if (out.length >= 200) break }
    return out
  }

  ctx.tools.register({
    name: 'lsp',
    description: 'Query language servers (auto-detected per file type): diagnostics (file path or glob), definition, type_definition, implementation, references, hover (file + 1-based line + symbol text to locate the column; `name#N` picks the Nth occurrence), symbols (file, or file="*" + query for workspace search), rename (new_name; applies through the workspace unless apply=false), rename_file (moves a file and updates imports when supported), code_actions (lists; apply=true applies the first match of query), status, reload, capabilities, request (raw LSP method in query, JSON params in payload). Errors and warnings are also appended automatically after edit/write.',
    parameters: {
      type: 'object',
      additionalProperties: false,
      required: ['action'],
      properties: {
        action: { type: 'string', enum: ACTIONS },
        file: { type: 'string', description: 'File path; a glob for diagnostics; "*" for workspace symbols.' },
        line: { type: 'integer', description: '1-based line for position-based actions (default 1).' },
        symbol: { type: 'string', description: 'Text on that line to locate the column; `name#N` selects the Nth occurrence.' },
        query: { type: 'string', description: 'Workspace-symbol query, code-action filter, or LSP method for action=request.' },
        new_name: { type: 'string', description: 'New name for rename / new path for rename_file.' },
        apply: { type: 'boolean', description: 'rename/rename_file: apply unless false. code_actions: apply only when true.' },
        timeout: { type: 'integer', description: 'Seconds (5-300, default 20).' },
        payload: { type: 'string', description: 'JSON params for action=request.' },
      },
    },
    output: { schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } } }, render: (_a, v) => [{ type: 'text', text: v.text }] },
    timeoutMs: 320_000,
    async execute(args, exec) {
      return { text: await runLsp(args ?? {}, exec) }
    },
  })

  ctx.systemPrompt.section({
    name: 'omp-lsp',
    order: 1650,
    text: 'Language-server diagnostics are appended to edit/write results; fix reported errors you introduced. Use the `lsp` tool for definitions, references, hover, renames and workspace diagnostics instead of grepping when a server is available.',
  })
}

const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)