local parser = require 'symbols-outline.parser'
local providers = require 'symbols-outline.providers.init'
local ui = require 'symbols-outline.ui'
local writer = require 'symbols-outline.writer'
local cfg = require 'symbols-outline.config'
local utils = require 'symbols-outline.utils.init'
local View = require 'symbols-outline.view'
local folding = require 'symbols-outline.folding'

local M = {}

local function setup_global_autocmd()
  if
    cfg.o.outline_items.highlight_hovered_item or cfg.o.symbol_folding.auto_unfold_hover
  then
    vim.api.nvim_create_autocmd('CursorHold', {
      pattern = '*',
      callback = function()
        M._highlight_current_item(nil)
      end,
    })
  end

  vim.api.nvim_create_autocmd({
    'InsertLeave',
    'WinEnter',
    'BufEnter',
    'BufWinEnter',
    'TabEnter',
    'BufWritePost',
  }, {
    pattern = '*',
    callback = M._refresh,
  })

  vim.api.nvim_create_autocmd('WinEnter', {
    pattern = '*',
    callback = require('symbols-outline.preview').close,
  })
end

-------------------------
-- STATE
-------------------------
M.state = {
  outline_items = {},
  flattened_outline_items = {},
  code_win = 0,
}

local function wipe_state()
  M.state = { outline_items = {}, flattened_outline_items = {}, code_win = 0, opts = {} }
end

local function _update_lines()
  M.state.flattened_outline_items = parser.flatten(M.state.outline_items)
  writer.parse_and_write(M.view.bufnr, M.state.flattened_outline_items)
end

local function _merge_items(items)
  utils.merge_items_rec(
    { children = items },
    { children = M.state.outline_items }
  )
end

local function __refresh()
  local current_buffer_is_outline = M.view.bufnr
    == vim.api.nvim_get_current_buf()
  if M.view:is_open() and current_buffer_is_outline then
    local function refresh_handler(response)
      if response == nil or type(response) ~= 'table' then
        return
      end

      local items = parser.parse(response)
      _merge_items(items)

      M.state.code_win = vim.api.nvim_get_current_win()

      _update_lines()
    end

    providers.request_symbols(refresh_handler)
  end
end

M._refresh = utils.debounce(__refresh, 100)

function M._current_node()
  local current_line = vim.api.nvim_win_get_cursor(M.view.winnr)[1]
  return M.state.flattened_outline_items[current_line]
end

function M.__goto_location(change_focus)
  local node = M._current_node()
  vim.api.nvim_win_set_cursor(
    M.state.code_win,
    { node.line + 1, node.character }
  )
  utils.flash_highlight(M.state.code_win, node.line + 1, true)
  if change_focus then
    vim.fn.win_gotoid(M.state.code_win)
  end
end

-- Wraps __goto_location and handles auto_close
function M._goto_location(change_focus)
  M.__goto_location(change_focus)
  if change_focus and cfg.o.outline_window.auto_close then
    M.close_outline()
  end
end

function M._move_and_goto(direction)
  local move = direction == 'down' and 1 or -1
  local cur = vim.api.nvim_win_get_cursor(0)
  cur[1] = cur[1] + move
  pcall(vim.api.nvim_win_set_cursor, 0, cur)
  M.__goto_location(false)
end

function M._toggle_fold(move_cursor, node_index)
  local node = M.state.flattened_outline_items[node_index] or M._current_node()
  local is_folded = folding.is_folded(node)

  if folding.is_foldable(node) then
    M._set_folded(not is_folded, move_cursor, node_index)
  end
end

local function setup_buffer_autocmd()
  if cfg.o.preview_window.auto_preview then
    vim.api.nvim_create_autocmd('CursorMoved', {
      buffer = 0,
      callback = require('symbols-outline.preview').show,
    })
  else
    vim.api.nvim_create_autocmd('CursorMoved', {
      buffer = 0,
      callback = require('symbols-outline.preview').close,
    })
  end
  if cfg.o.outline_window.auto_goto then
    vim.api.nvim_create_autocmd('CursorMoved', {
      buffer = 0,
      callback = function()
        -- Don't use _goto_location because we don't want to auto-close
        M.__goto_location(false)
      end
    })
  end
end

function M._set_folded(folded, move_cursor, node_index)
  local node = M.state.flattened_outline_items[node_index] or M._current_node()
  local changed = (folded ~= folding.is_folded(node))

  if folding.is_foldable(node) and changed then
    node.folded = folded

    if move_cursor then
      vim.api.nvim_win_set_cursor(M.view.winnr, { node_index, 0 })
    end

    _update_lines()
  elseif node.parent then
    local parent_node =
      M.state.flattened_outline_items[node.parent.line_in_outline]

    if parent_node then
      M._set_folded(
        folded,
        not parent_node.folded and folded,
        parent_node.line_in_outline
      )
    end
  end
end

function M._toggle_all_fold(nodes)
  nodes = nodes or M.state.outline_items
  local folded = true

  for _, node in ipairs(nodes) do
    if folding.is_foldable(node) and not folding.is_folded(node) then
      folded = false
      break
    end
  end

  M._set_all_folded(not folded, nodes)
end

function M._set_all_folded(folded, nodes)
  local stack = { nodes or M.state.outline_items }

  while #stack > 0 do
    local current_nodes = table.remove(stack, #stack)
    for _, node in ipairs(current_nodes) do
      node.folded = folded
      if node.children then
        stack[#stack + 1] = node.children
      end
    end
  end

  _update_lines()
end

function M._highlight_current_item(winnr)
  local has_provider = M.has_provider()
  local has_outline_open = M.view:is_open()
  local current_buffer_is_outline = M.view.bufnr
    == vim.api.nvim_get_current_buf()

  if not has_provider then
    return
  end

  if
    not has_outline_open   -- Outline not open
    -- Not currently on outline window, but no code window is given.
    or (not winnr and not current_buffer_is_outline)
  then
    return
  end

  local win = winnr or vim.api.nvim_get_current_win()
  local hovered_line = vim.api.nvim_win_get_cursor(win)[1] - 1
  local leaf_node = nil

  local cb = function(value)
    value.hovered = nil

    if
      value.line == hovered_line
      or (hovered_line > value.range_start and hovered_line < value.range_end)
    then
      value.hovered = true
      leaf_node = value
    end
  end

  utils.items_dfs(cb, M.state.outline_items)

  _update_lines()

  if leaf_node then
    for index, node in ipairs(M.state.flattened_outline_items) do
      if node == leaf_node then
        vim.api.nvim_win_set_cursor(M.view.winnr, { index, 1 })
        break
      end
    end
  end
end

local function setup_keymaps(bufnr)
  local map = function(...)
    utils.nmap(bufnr, ...)
  end
  -- goto_location of symbol and focus that window
  map(cfg.o.keymaps.goto_location, function()
    M._goto_location(true)
  end)
  -- goto_location of symbol but stay in outline
  map(cfg.o.keymaps.peek_location, function()
    M._goto_location(false)
  end)
  -- Navigate to corresponding outline location for current code location
  map(cfg.o.keymaps.restore_location, function()
    M._map_follow_cursor()
  end)
  -- Move down/up in outline and peek that location in code
  map(cfg.o.keymaps.down_and_goto, function()
    M._move_and_goto('down')
  end)
  -- Move down/up in outline and peek that location in code
  map(cfg.o.keymaps.up_and_goto, function()
    M._move_and_goto('up')
  end)
  -- hover symbol
  map(
    cfg.o.keymaps.hover_symbol,
    require('symbols-outline.hover').show_hover
  )
  -- preview symbol
  map(
    cfg.o.keymaps.toggle_preview,
    require('symbols-outline.preview').toggle
  )
  -- rename symbol
  map(
    cfg.o.keymaps.rename_symbol,
    require('symbols-outline.rename').rename
  )
  -- code actions
  map(
    cfg.o.keymaps.code_actions,
    require('symbols-outline.code_action').show_code_actions
  )
  -- show help
  map(
    cfg.o.keymaps.show_help,
    require('symbols-outline.config').show_help
  )
  -- close outline
  map(cfg.o.keymaps.close, function()
    M.view:close()
  end)
  -- toggle fold selection
  map(cfg.o.keymaps.fold_toggle, M._toggle_fold)
  -- fold selection
  map(cfg.o.keymaps.fold, function()
    M._set_folded(true)
  end)
  -- unfold selection
  map(cfg.o.keymaps.unfold, function()
    M._set_folded(false)
  end)
  -- toggle fold all
  map(cfg.o.keymaps.fold_toggle_all, M._toggle_all_fold)
  -- fold all
  map(cfg.o.keymaps.fold_all, function()
    M._set_all_folded(true)
  end)
  -- unfold all
  map(cfg.o.keymaps.unfold_all, function()
    M._set_all_folded(false)
  end)
  -- fold reset
  map(cfg.o.keymaps.fold_reset, function()
    M._set_all_folded(nil)
  end)
end

local function handler(response, opts)
  if response == nil or type(response) ~= 'table' or M.view:is_open() then
    return
  end

  M.state.code_win = vim.api.nvim_get_current_win()

  M.view:setup_view()
  -- clear state when buffer is closed
  vim.api.nvim_buf_attach(M.view.bufnr, false, {
    on_detach = function(_, _)
      wipe_state()
    end,
  })

  setup_keymaps(M.view.bufnr)
  setup_buffer_autocmd()

  local items = parser.parse(response)

  M.state.outline_items = items
  M.state.flattened_outline_items = parser.flatten(items)

  writer.parse_and_write(M.view.bufnr, M.state.flattened_outline_items)

  M._highlight_current_item(M.state.code_win)

  if not cfg.o.outline_window.focus_on_open or (opts and not opts.focus_outline) then
    vim.fn.win_gotoid(M.state.code_win)
  end
end

---Set position of outline window to match cursor position in code, return
---whether the window is just newly opened (previously not open).
---@param opts table? Field `focus_outline` = `false` or `nil` means don't focus on outline window after following cursor. If opts is not provided, focus will be on outline window after following cursor.
---@return boolean ok Whether it was successful. If ok=false, either the outline window is not open or the code window cannot be found.
function M.follow_cursor(opts)
  if not M.view:is_open() then
    return false
  end

  if require('symbols-outline.preview').has_code_win() then
    M._highlight_current_item(M.state.code_win)
  else
    return false
  end

  if not opts then
    opts = { focus_outline = true }
  end
  if opts.focus_outline then
    M.focus_outline()
  end

  return true
end

local function _cmd_follow_cursor(opts)
  local fnopts = { focus_outline = true }
  if opts.bang then
    fnopts.focus_outline = false
  end
  M.follow_cursor(fnopts)
end

function M._map_follow_cursor()
  if not M.follow_cursor({ focus_outline = true }) then
    vim.notify(
      "Code window no longer active. Try closing and reopening the outline.",
      vim.log.levels.ERROR
    )
  end
end

---Toggle the outline window, and return whether the outline window is open
---after this operation.
---@param opts table? Table of options, @see open_outline
---@return boolean is_open Whether outline window is open
function M.toggle_outline(opts)
  if M.view:is_open() then
    M.close_outline()
    return false
  else
    M.open_outline(opts)
    return true
  end
end

-- Used for SymbolsOutline user command
local function _cmd_toggle_outline(opts)
  if opts.bang then
    M.toggle_outline({ focus_outline = false })
  else
    M.toggle_outline({ focus_outline = true })
  end
end

---Open the outline window.
---@param opts table? Field focus_outline=false means don't focus on outline window after opening. If opts is not provided, focus will be on outline window after opening.
function M.open_outline(opts)
  if not opts then
    opts = { focus_outline = true }
  end
  if not M.view:is_open() then
    local found = providers.request_symbols(handler, opts)
    if not found then
      vim.notify("[symbols-outline]: No providers found for current buffer", vim.log.levels.WARN)
    -- else
    --   print("Using provider ".._G._symbols_outline_current_provider.name.."...")
    end
  end
end

local function _cmd_open_outline(opts)
  if opts.bang then
    M.open_outline({ focus_outline = false })
  else
    M.open_outline({ focus_outline = true })
  end
end

---Close the outline window.
function M.close_outline()
  M.view:close()
end

---Set cursor to focus on the outline window, return whether the window is currently open..
---@return boolean is_open Whether the window is open
function M.focus_outline()
  if M.view:is_open() then
    vim.fn.win_gotoid(M.view.winnr)
    return true
  end
  return false
end

---Set cursor to focus on the code window, return whether this operation was successful.
---@return boolean ok Whether it was successful. If unsuccessful, it might mean that the attached code window has been closed or is no longer valid.
function M.focus_code()
  if require('symbols-outline.preview').has_code_win() then
    vim.fn.win_gotoid(M.state.code_win)
    return true
  end
  return false
end

---Toggle focus between outline and code window, returns whether it was successful.
---@return boolean ok Whether it was successful. If `ok=false`, either the outline window is not open or the code window is no longer valid.
function M.focus_toggle()
  if M.view:is_open() and require('symbols-outline.preview').has_code_win() then
    local winid = vim.fn.win_getid()
    if winid == M.state.code_win then
      vim.fn.win_gotoid(M.view.winnr)
    else
      vim.fn.win_gotoid(M.state.code_win)
    end
    return true
  end
  return false
end

---Whether the outline window is currently open.
---@return boolean is_open
function M.is_open()
  return M.view:is_open()
end

---Display outline window status in the message area.
function M.show_status()
  if M.has_provider() then
    print("Current provider:")
    print('  ' .. _G._symbols_outline_current_provider.name)
    if M.view:is_open() then
      print("Outline window is open.")
    else
      print("Outline window is not open.")
    end
    if require('symbols-outline.preview').has_code_win() then
      print("Code window is active.")
    else
      print("Warning: code window is either closed or invalid. Please close and reopen the outline window.")
    end
  else
    print("No providers")
  end
end

---Whether there is currently an available provider.
---@return boolean has_provider
function M.has_provider()
  local winid = vim.fn.win_getid()
  if M.view:is_open() and winid == M.view.winnr then
    return _G._symbols_outline_current_provider ~= nil
  end
  return providers.has_provider() and _G._symbols_outline_current_provider
end

local function setup_commands()
  local cmd = function(n, c, o)
    vim.api.nvim_create_user_command('SymbolsOutline'..n, c, o)
  end

  cmd('', _cmd_toggle_outline, {
    desc = "Toggle the outline window. \
With bang, keep focus on initial window after opening.",
    nargs = 0,
    bang = true,
  })
  cmd('Open', _cmd_open_outline, {
    desc = "With bang, keep focus on initial window after opening.",
    nargs = 0,
    bang = true,
  })
  cmd('Close', M.close_outline, { nargs = 0 })
  cmd('FocusOutline', M.focus_outline, { nargs = 0 })
  cmd('FocusCode', M.focus_code, { nargs = 0 })
  cmd('Focus', M.focus_toggle, { nargs = 0 })
  cmd('Status', M.show_status, {
    desc = "Show a message about the current status of the outline window.",
    nargs = 0,
  })
  cmd('Follow', _cmd_follow_cursor, {
    desc = "Update position of outline with position of cursor. \
With bang, don't switch cursor focus to outline window.",
    nargs = 0,
    bang = true,
  })
end

---Set up configuration options for symbols-outline.
function M.setup(opts)
  cfg.setup(opts)
  ui.setup_highlights()

  M.view = View:new()
  setup_global_autocmd()
  setup_commands()
end

return M