-- Commands module for nvim-claude
local M = {}

-- Reference to main module
local claude = nil

-- Setup commands
function M.setup(claude_module)
  claude = claude_module
  
  -- ClaudeChat command
  vim.api.nvim_create_user_command('ClaudeChat', function()
    M.claude_chat()
  end, {
    desc = 'Open Claude in a tmux pane'
  })
  
  -- ClaudeSendBuffer command
  vim.api.nvim_create_user_command('ClaudeSendBuffer', function()
    M.send_buffer()
  end, {
    desc = 'Send current buffer to Claude'
  })
  
  -- ClaudeSendSelection command (visual mode)
  vim.api.nvim_create_user_command('ClaudeSendSelection', function(opts)
    M.send_selection(opts.line1, opts.line2)
  end, {
    desc = 'Send selected text to Claude',
    range = true
  })
  
  -- ClaudeSendHunk command
  vim.api.nvim_create_user_command('ClaudeSendHunk', function()
    M.send_hunk()
  end, {
    desc = 'Send git hunk under cursor to Claude'
  })
  
  -- ClaudeBg command
  vim.api.nvim_create_user_command('ClaudeBg', function(opts)
    M.claude_bg(opts.args)
  end, {
    desc = 'Start a background Claude agent',
    nargs = '+',
    complete = function() return {} end
  })
  
  -- ClaudeAgents command
  vim.api.nvim_create_user_command('ClaudeAgents', function()
    M.list_agents()
  end, {
    desc = 'List all Claude agents'
  })
  
  -- ClaudeKill command
  vim.api.nvim_create_user_command('ClaudeKill', function(opts)
    M.kill_agent(opts.args)
  end, {
    desc = 'Kill a Claude agent',
    nargs = '?',
    complete = function()
      local agents = claude.registry.get_project_agents()
      local completions = {}
      for id, agent in pairs(agents) do
        if agent.status == 'active' then
          table.insert(completions, id)
        end
      end
      return completions
    end
  })
  
  -- ClaudeClean command
  vim.api.nvim_create_user_command('ClaudeClean', function()
    M.clean_agents()
  end, {
    desc = 'Clean up old Claude agents'
  })
  
  -- ClaudeDebug command
  vim.api.nvim_create_user_command('ClaudeDebug', function()
    M.debug_panes()
  end, {
    desc = 'Debug Claude pane detection'
  })
end

-- Open Claude chat
function M.claude_chat()
  if not claude.tmux.validate() then
    return
  end
  
  local pane_id = claude.tmux.create_pane('claude')
  if pane_id then
    vim.notify('Claude chat opened in pane ' .. pane_id, vim.log.levels.INFO)
  else
    vim.notify('Failed to create Claude pane', vim.log.levels.ERROR)
  end
end

-- Send current buffer to Claude
function M.send_buffer()
  if not claude.tmux.validate() then
    return
  end
  
  local pane_id = claude.tmux.find_claude_pane()
  if not pane_id then
    pane_id = claude.tmux.create_pane('claude')
  end
  
  if not pane_id then
    vim.notify('Failed to find or create Claude pane', vim.log.levels.ERROR)
    return
  end
  
  -- Get buffer info
  local filename = vim.fn.expand('%:t')
  local filetype = vim.bo.filetype
  local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
  
  -- Build complete message as one string
  local message_parts = {
    string.format('Here is `%s` (%s):', filename, filetype),
    '```' .. (filetype ~= '' and filetype or ''),
  }
  
  -- Add all lines
  for _, line in ipairs(lines) do
    table.insert(message_parts, line)
  end
  
  table.insert(message_parts, '```')
  
  -- Send as one batched message
  local full_message = table.concat(message_parts, '\n')
  claude.tmux.send_text_to_pane(pane_id, full_message)
  
  vim.notify('Buffer sent to Claude', vim.log.levels.INFO)
end

-- Send selection to Claude
function M.send_selection(line1, line2)
  if not claude.tmux.validate() then
    return
  end
  
  local pane_id = claude.tmux.find_claude_pane()
  if not pane_id then
    pane_id = claude.tmux.create_pane('claude')
  end
  
  if not pane_id then
    vim.notify('Failed to find or create Claude pane', vim.log.levels.ERROR)
    return
  end
  
  -- Get selected lines
  local lines = vim.api.nvim_buf_get_lines(0, line1 - 1, line2, false)
  
  -- Build complete message as one string
  local filename = vim.fn.expand('%:t')
  local filetype = vim.bo.filetype
  local message_parts = {
    string.format('Selection from `%s` (lines %d-%d):', filename, line1, line2),
    '```' .. (filetype ~= '' and filetype or ''),
  }
  
  -- Add all lines
  for _, line in ipairs(lines) do
    table.insert(message_parts, line)
  end
  
  table.insert(message_parts, '```')
  
  -- Send as one batched message
  local full_message = table.concat(message_parts, '\n')
  claude.tmux.send_text_to_pane(pane_id, full_message)
  
  vim.notify('Selection sent to Claude', vim.log.levels.INFO)
end

-- Send git hunk under cursor to Claude
function M.send_hunk()
  if not claude.tmux.validate() then
    return
  end
  
  local pane_id = claude.tmux.find_claude_pane()
  if not pane_id then
    pane_id = claude.tmux.create_pane('claude')
  end
  
  if not pane_id then
    vim.notify('Failed to find or create Claude pane', vim.log.levels.ERROR)
    return
  end
  
  -- Get current cursor position
  local cursor_pos = vim.api.nvim_win_get_cursor(0)
  local current_line = cursor_pos[1]
  
  -- Get git diff to find hunks
  local filename = vim.fn.expand('%:p')
  local relative_filename = vim.fn.expand('%')
  
  if not filename or filename == '' then
    vim.notify('No file to get hunk from', vim.log.levels.ERROR)
    return
  end
  
  -- Get git diff for this file
  local cmd = string.format('git diff HEAD -- "%s"', filename)
  local diff_output = claude.utils.exec(cmd)
  
  if not diff_output or diff_output == '' then
    vim.notify('No git changes found in current file', vim.log.levels.INFO)
    return
  end
  
  -- Parse diff to find hunk containing current line
  local hunk_lines = {}
  local hunk_start = nil
  local hunk_end = nil
  local found_hunk = false
  
  for line in diff_output:gmatch('[^\n]+') do
    if line:match('^@@') then
      -- Parse hunk header: @@ -oldstart,oldcount +newstart,newcount @@
      local newstart, newcount = line:match('^@@ %-%d+,%d+ %+(%d+),(%d+) @@')
      if newstart and newcount then
        newstart = tonumber(newstart)
        newcount = tonumber(newcount)
        
        if current_line >= newstart and current_line < newstart + newcount then
          found_hunk = true
          hunk_start = newstart
          hunk_end = newstart + newcount - 1
          table.insert(hunk_lines, line) -- Include the @@ line
        else
          found_hunk = false
          hunk_lines = {}
        end
      end
    elseif found_hunk then
      table.insert(hunk_lines, line)
    end
  end
  
  if #hunk_lines == 0 then
    vim.notify('No git hunk found at cursor position', vim.log.levels.INFO)
    return
  end
  
  -- Build message
  local message_parts = {
    string.format('Git hunk from `%s` (around line %d):', relative_filename, current_line),
    '```diff'
  }
  
  -- Add hunk lines
  for _, line in ipairs(hunk_lines) do
    table.insert(message_parts, line)
  end
  
  table.insert(message_parts, '```')
  
  -- Send as one batched message
  local full_message = table.concat(message_parts, '\n')
  claude.tmux.send_text_to_pane(pane_id, full_message)
  
  vim.notify('Git hunk sent to Claude', vim.log.levels.INFO)
end

-- Start background agent
function M.claude_bg(task)
  if not claude.tmux.validate() then
    return
  end
  
  if not task or task == '' then
    vim.notify('Please provide a task description', vim.log.levels.ERROR)
    return
  end
  
  -- Create agent work directory
  local project_root = claude.utils.get_project_root()
  local work_dir = project_root .. '/' .. claude.config.agents.work_dir
  local agent_dir = work_dir .. '/' .. claude.utils.agent_dirname(task)
  
  -- Ensure work directory exists
  if not claude.utils.ensure_dir(work_dir) then
    vim.notify('Failed to create work directory', vim.log.levels.ERROR)
    return
  end
  
  -- Add to gitignore if needed
  if claude.config.agents.auto_gitignore then
    claude.git.add_to_gitignore(claude.config.agents.work_dir .. '/')
  end
  
  -- Create agent directory
  if not claude.utils.ensure_dir(agent_dir) then
    vim.notify('Failed to create agent directory', vim.log.levels.ERROR)
    return
  end
  
  -- Create worktree or clone
  local success, result
  if claude.config.agents.use_worktrees and claude.git.supports_worktrees() then
    local branch = claude.git.current_branch() or 'main'
    success, result = claude.git.create_worktree(agent_dir, branch)
    if not success then
      vim.notify('Failed to create worktree: ' .. tostring(result), vim.log.levels.ERROR)
      return
    end
  else
    -- Fallback to copy (simplified for now)
    local cmd = string.format('cp -r "%s"/* "%s"/', project_root, agent_dir)
    local _, err = claude.utils.exec(cmd)
    if err then
      vim.notify('Failed to copy project: ' .. err, vim.log.levels.ERROR)
      return
    end
  end
  
  -- Create mission log
  local log_content = string.format(
    "Agent Mission Log\n================\n\nTask: %s\nStarted: %s\nStatus: Active\n\n",
    task,
    os.date('%Y-%m-%d %H:%M:%S')
  )
  claude.utils.write_file(agent_dir .. '/mission.log', log_content)
  
  -- Check agent limit
  local active_count = claude.registry.get_active_count()
  if active_count >= claude.config.agents.max_agents then
    vim.notify(string.format(
      'Agent limit reached (%d/%d). Complete or kill existing agents first.',
      active_count,
      claude.config.agents.max_agents
    ), vim.log.levels.ERROR)
    return
  end
  
  -- Create tmux window for agent
  local window_name = 'claude-' .. claude.utils.timestamp()
  local window_id = claude.tmux.create_agent_window(window_name, agent_dir)
  
  if window_id then
    -- Register agent
    local agent_id = claude.registry.register(task, agent_dir, window_id, window_name)
    
    -- Update mission log with agent ID
    local log_content = claude.utils.read_file(agent_dir .. '/mission.log')
    log_content = log_content .. string.format("\nAgent ID: %s\n", agent_id)
    claude.utils.write_file(agent_dir .. '/mission.log', log_content)
    
    -- In first pane (0) open Neovim
    claude.tmux.send_to_window(window_id, 'nvim .')

    -- Split right side 40% and open Claude
    local pane_claude = claude.tmux.split_window(window_id, 'h', 40)
    if pane_claude then
      claude.tmux.send_to_pane(pane_claude, 'claude --dangerously-skip-permissions')
      
      -- Send initial task description to Claude
      vim.wait(1000) -- Wait for Claude to start
      local task_msg = string.format(
        "I'm an autonomous agent working on the following task:\n\n%s\n\n" ..
        "My workspace is: %s\n" ..
        "I should work independently to complete this task.",
        task, agent_dir
      )
      claude.tmux.send_text_to_pane(pane_claude, task_msg)
    end

    vim.notify(string.format(
      'Background agent started\nID: %s\nTask: %s\nWorkspace: %s\nWindow: %s',
      agent_id,
      task,
      agent_dir,
      window_name
    ), vim.log.levels.INFO)
  else
    vim.notify('Failed to create agent window', vim.log.levels.ERROR)
  end
end

-- List all agents
function M.list_agents()
  -- Validate agents first
  claude.registry.validate_agents()
  
  local agents = claude.registry.get_project_agents()
  if vim.tbl_isempty(agents) then
    vim.notify('No agents found for this project', vim.log.levels.INFO)
    return
  end
  
  -- Create a simple list view
  local lines = { 'Claude Agents:', '' }
  
  -- Sort agents by start time
  local sorted_agents = {}
  for id, agent in pairs(agents) do
    agent.id = id
    table.insert(sorted_agents, agent)
  end
  table.sort(sorted_agents, function(a, b) return a.start_time > b.start_time end)
  
  for _, agent in ipairs(sorted_agents) do
    table.insert(lines, claude.registry.format_agent(agent))
    table.insert(lines, '  ID: ' .. agent.id)
    table.insert(lines, '  Window: ' .. (agent.window_name or 'unknown'))
    table.insert(lines, '')
  end
  
  -- Display in a floating window
  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
  vim.api.nvim_buf_set_option(buf, 'modifiable', false)
  
  local width = 60
  local height = math.min(#lines, 20)
  local opts = {
    relative = 'editor',
    width = width,
    height = height,
    col = (vim.o.columns - width) / 2,
    row = (vim.o.lines - height) / 2,
    style = 'minimal',
    border = 'rounded',
  }
  
  local win = vim.api.nvim_open_win(buf, true, opts)
  vim.api.nvim_win_set_option(win, 'winhl', 'Normal:Normal,FloatBorder:Comment')
  
  -- Close on q or Esc
  vim.api.nvim_buf_set_keymap(buf, 'n', 'q', ':close<CR>', { silent = true })
  vim.api.nvim_buf_set_keymap(buf, 'n', '<Esc>', ':close<CR>', { silent = true })
end

-- Kill an agent
function M.kill_agent(agent_id)
  if not agent_id or agent_id == '' then
    -- Show selection UI for agent killing
    M.show_kill_agent_ui()
    return
  end
  
  local agent = claude.registry.get(agent_id)
  if not agent then
    vim.notify('Agent not found: ' .. agent_id, vim.log.levels.ERROR)
    return
  end
  
  -- Kill tmux window
  if agent.window_id then
    local cmd = 'tmux kill-window -t ' .. agent.window_id
    claude.utils.exec(cmd)
  end
  
  -- Update registry
  claude.registry.update_status(agent_id, 'killed')
  
  vim.notify(string.format('Agent killed: %s (%s)', agent_id, agent.task), vim.log.levels.INFO)
end

-- Show agent kill selection UI
function M.show_kill_agent_ui()
  -- Validate agents first
  claude.registry.validate_agents()
  
  local agents = claude.registry.get_project_agents()
  local active_agents = {}
  
  for id, agent in pairs(agents) do
    if agent.status == 'active' then
      agent.id = id
      table.insert(active_agents, agent)
    end
  end
  
  if #active_agents == 0 then
    vim.notify('No active agents to kill', vim.log.levels.INFO)
    return
  end
  
  -- Sort agents by start time
  table.sort(active_agents, function(a, b) return a.start_time > b.start_time end)
  
  -- Track selection state
  local selected = {}
  for i = 1, #active_agents do
    selected[i] = false
  end
  
  -- Create buffer
  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_option(buf, 'bufhidden', 'wipe')
  
  -- Create window
  local width = 80
  local height = math.min(#active_agents * 4 + 4, 25)
  local opts = {
    relative = 'editor',
    width = width,
    height = height,
    col = (vim.o.columns - width) / 2,
    row = (vim.o.lines - height) / 2,
    style = 'minimal',
    border = 'rounded',
    title = ' Kill Claude Agents ',
    title_pos = 'center',
  }
  
  local win = vim.api.nvim_open_win(buf, true, opts)
  vim.api.nvim_win_set_option(win, 'winhl', 'Normal:Normal,FloatBorder:Comment')
  
  -- Function to update display
  local function update_display()
    local lines = { 'Kill Claude Agents (Space: toggle, Y: confirm kill, q: quit):', '' }
    
    for i, agent in ipairs(active_agents) do
      local icon = selected[i] and '●' or '○'
      local formatted = claude.registry.format_agent(agent)
      table.insert(lines, string.format('%s %s', icon, formatted))
      table.insert(lines, '    ID: ' .. agent.id)
      table.insert(lines, '    Window: ' .. (agent.window_name or 'unknown'))
      table.insert(lines, '')
    end
    
    -- Get current cursor position
    local cursor_line = 1
    if win and vim.api.nvim_win_is_valid(win) then
      cursor_line = vim.api.nvim_win_get_cursor(win)[1]
    end
    
    -- Update buffer content
    vim.api.nvim_buf_set_option(buf, 'modifiable', true)
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
    vim.api.nvim_buf_set_option(buf, 'modifiable', false)
    
    -- Restore cursor position
    if win and vim.api.nvim_win_is_valid(win) then
      vim.api.nvim_win_set_cursor(win, {math.min(cursor_line, #lines), 0})
    end
  end
  
  -- Initial display
  update_display()
  
  -- Set up keybindings
  local function close_window()
    if vim.api.nvim_win_is_valid(win) then
      vim.api.nvim_win_close(win, true)
    end
  end
  
  local function get_agent_from_line(line)
    if line <= 2 then return nil end -- Header lines
    local agent_index = math.ceil((line - 2) / 4)
    return agent_index <= #active_agents and agent_index or nil
  end
  
  local function toggle_selection()
    local line = vim.api.nvim_win_get_cursor(win)[1]
    local agent_index = get_agent_from_line(line)
    
    if agent_index then
      selected[agent_index] = not selected[agent_index]
      update_display()
    end
  end
  
  local function confirm_kill()
    local selected_agents = {}
    for i, is_selected in ipairs(selected) do
      if is_selected then
        table.insert(selected_agents, active_agents[i])
      end
    end
    
    if #selected_agents == 0 then
      vim.notify('No agents selected', vim.log.levels.INFO)
      return
    end
    
    close_window()
    
    -- Confirm before killing
    local task_list = {}
    for _, agent in ipairs(selected_agents) do
      table.insert(task_list, '• ' .. agent.task:sub(1, 50))
    end
    
    vim.ui.select(
      {'Yes', 'No'},
      {
        prompt = string.format('Kill %d agent(s)?', #selected_agents),
        format_item = function(item)
          if item == 'Yes' then
            return 'Yes - Kill selected agents:\n' .. table.concat(task_list, '\n')
          else
            return 'No - Cancel'
          end
        end
      },
      function(choice)
        if choice == 'Yes' then
          for _, agent in ipairs(selected_agents) do
            M.kill_agent(agent.id)
          end
        end
      end
    )
  end
  
  -- Close on q or Esc
  vim.api.nvim_buf_set_keymap(buf, 'n', 'q', '', {
    callback = close_window,
    silent = true,
    noremap = true,
  })
  vim.api.nvim_buf_set_keymap(buf, 'n', '<Esc>', '', {
    callback = close_window,
    silent = true,
    noremap = true,
  })
  
  -- Space to toggle selection
  vim.api.nvim_buf_set_keymap(buf, 'n', '<Space>', '', {
    callback = toggle_selection,
    silent = true,
    noremap = true,
  })
  
  -- Y to confirm kill
  vim.api.nvim_buf_set_keymap(buf, 'n', 'Y', '', {
    callback = confirm_kill,
    silent = true,
    noremap = true,
  })
  vim.api.nvim_buf_set_keymap(buf, 'n', 'y', '', {
    callback = confirm_kill,
    silent = true,
    noremap = true,
  })
end

-- Clean up old agents
function M.clean_agents()
  local removed = claude.registry.cleanup(claude.config.agents.cleanup_days)
  
  if removed > 0 then
    vim.notify(string.format('Cleaned up %d old agent(s)', removed), vim.log.levels.INFO)
  else
    vim.notify('No old agents to clean up', vim.log.levels.INFO)
  end
end

-- Debug pane detection
function M.debug_panes()
  local utils = require('nvim-claude.utils')
  
  -- Get all panes with details
  local cmd = "tmux list-panes -F '#{pane_id}:#{pane_pid}:#{pane_title}:#{pane_current_command}'"
  local result = utils.exec(cmd)
  
  local lines = { 'Claude Pane Debug Info:', '' }
  
  if result and result ~= '' then
    table.insert(lines, 'All panes:')
    for line in result:gmatch('[^\n]+') do
      local pane_id, pane_pid, pane_title, pane_cmd = line:match('^([^:]+):([^:]+):([^:]*):(.*)$')
      if pane_id and pane_pid then
        table.insert(lines, string.format('  %s: pid=%s, title="%s", cmd="%s"', 
          pane_id, pane_pid, pane_title or '', pane_cmd or ''))
      end
    end
  else
    table.insert(lines, 'No panes found')
  end
  
  table.insert(lines, '')
  
  -- Show detected Claude pane
  local detected_pane = claude.tmux.find_claude_pane()
  if detected_pane then
    table.insert(lines, 'Detected Claude pane: ' .. detected_pane)
  else
    table.insert(lines, 'No Claude pane detected')
  end
  
  -- Display in floating window
  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
  vim.api.nvim_buf_set_option(buf, 'modifiable', false)
  
  local width = 80
  local height = math.min(#lines + 2, 25)
  local opts = {
    relative = 'editor',
    width = width,
    height = height,
    col = (vim.o.columns - width) / 2,
    row = (vim.o.lines - height) / 2,
    style = 'minimal',
    border = 'rounded',
  }
  
  local win = vim.api.nvim_open_win(buf, true, opts)
  vim.api.nvim_win_set_option(win, 'winhl', 'Normal:Normal,FloatBorder:Comment')
  
  -- Close on q or Esc
  vim.api.nvim_buf_set_keymap(buf, 'n', 'q', ':close<CR>', { silent = true })
  vim.api.nvim_buf_set_keymap(buf, 'n', '<Esc>', ':close<CR>', { silent = true })
end

return M