local open_floating_window = require"lazygit.window".open_floating_window
local project_root_dir  = require"lazygit.utils".project_root_dir
local get_root  = require"lazygit.utils".get_root
local is_lazygit_available = require"lazygit.utils".is_lazygit_available
local is_symlink = require"lazygit.utils".is_symlink

local fn = vim.fn

LAZYGIT_BUFFER = nil
LAZYGIT_LOADED = false
vim.g.lazygit_opened = 0
local prev_win = -1
local win = -1
local buffer = -1

--- on_exit callback function to delete the open buffer when lazygit exits in a neovim terminal
local function on_exit(job_id, code, event)
  if code ~= 0 then
    return
  end

  LAZYGIT_BUFFER = nil
  LAZYGIT_LOADED = false
  vim.g.lazygit_opened = 0
  vim.cmd('silent! :checktime')

  if vim.api.nvim_win_is_valid(prev_win) then
    vim.api.nvim_win_close(win, true)
    vim.api.nvim_set_current_win(prev_win)
    prev_win = -1
    if vim.api.nvim_buf_is_valid(buffer) and vim.api.nvim_buf_is_loaded(buffer) then
      vim.api.nvim_buf_delete(buffer, { force = true })
    end
    buffer = -1
    win = -1
  end
end

--- Call lazygit
local function exec_lazygit_command(cmd)
  if LAZYGIT_LOADED == false then
    -- ensure that the buffer is closed on exit
    vim.g.lazygit_opened = 1
    vim.fn.termopen(cmd, { on_exit = on_exit })
  end
  vim.cmd 'startinsert'
end

local function lazygitdefaultconfigpath()
  local os_name = vim.loop.os_uname().sysname

  -- TODO: not surer if vim.loop.os_uname() has the same result
  -- check before replacing the following line
  local os = fn.substitute(fn.system('uname'), '\n', '', '')
  if os == 'Darwin' then
    return '~/Library/Application\\ Support/jesseduffield/lazygit/config.yml'
  else
    if string.find(os_name, 'Window') then
        return '%APPDATA%/lazygit/config.yml'
    else
      return '~/.config/lazygit/config.yml'
    end
  end
end

local function lazygitgetconfigpath()
  if vim.g.lazygit_use_custom_config_file_path == 1 then
    if vim.g.lazygit_config_file_path then
      -- if file exists
      if fn.empty(fn.glob(vim.g.lazygit_config_file_path)) == 0 then
        return vim.g.lazygit_config_file_path
      end

      print('lazygit: custom config file path: \'' .. vim.g.lazygit_config_file_path .. '\' could not be found')
    else
      print('lazygit: custom config file path is not set, option: \'lazygit_config_file_path\' is missing')
    end
  end

  -- any issue with the config file we fallback to the default config file path
  return lazygitdefaultconfigpath()
end

--- :LazyGit entry point
local function lazygit(path)
  if is_lazygit_available() ~= true then
    print('Please install lazygit. Check documentation for more information')
    return
  end

  prev_win = vim.api.nvim_get_current_win()

  win, buffer = open_floating_window()

  local cmd = 'lazygit'

  -- set path to the root path
  _ = project_root_dir()

  -- print(lazygitgetconfigpath())

  cmd = cmd .. ' -ucf ' .. lazygitgetconfigpath()

  if path == nil then
    if is_symlink() then
      path = project_root_dir()
    end
  else
      if fn.isdirectory(path) then
        cmd = cmd .. ' -p ' .. path
      end
  end

  exec_lazygit_command(cmd)
end

--- :LazyGitCurrentFile entry point
local function lazygitcurrentfile()
  local current_dir = vim.fn.expand('%:p:h')
  local git_root = get_root(current_dir)
  lazygit(git_root)
end

--- :LazyGitFilter entry point
local function lazygitfilter(path)
  if is_lazygit_available() ~= true then
    print('Please install lazygit. Check documentation for more information')
    return
  end
  if path == nil then
    path = project_root_dir()
  end
  prev_win = vim.api.nvim_get_current_win()
  open_floating_window()
  local cmd = 'lazygit ' .. '-f ' .. path
  exec_lazygit_command(cmd)
end

--- :LazyGitFilterCurrentFile entry point
local function lazygitfiltercurrentfile()
  local current_file = vim.fn.expand('%')
  lazygitfilter(current_file)
end


--- :LazyGitConfig entry point
local function lazygitconfig()
  local config_file = lazygitgetconfigpath()

  if fn.empty(fn.glob(config_file)) == 1 then
    -- file does not exist
    -- check if user wants to create it
    local answer = fn.confirm('File ' .. config_file
                                  .. ' does not exist.\nDo you want to create the file and populate it with the default configuration?',
                              '&Yes\n&No')
    if answer == 2 then
      return nil
    end
    if fn.isdirectory(fn.fnamemodify(config_file, ':h')) == false then
      -- directory does not exist
      fn.mkdir(fn.fnamemodify(config_file, ':h'), 'p')
    end
    vim.cmd('edit ' .. config_file)
    vim.cmd([[execute "silent! 0read !lazygit -c"]])
    vim.cmd([[execute "normal 1G"]])
  else
    vim.cmd('edit ' .. config_file)
  end
end

return {
  lazygit = lazygit,
  lazygitcurrentfile = lazygitcurrentfile,
  lazygitfilter = lazygitfilter,
  lazygitfiltercurrentfile = lazygitfiltercurrentfile,
  lazygitconfig = lazygitconfig,
  project_root_dir = project_root_dir,
}