-- Basic Keymaps
-- See `:help vim.keymap.set()`

local helpers = require 'helpers'

-- Swap : and ; around
vim.keymap.set({ 'n', 'v' }, ':', ';')
vim.keymap.set({ 'n', 'v' }, ';', ':')

-- Clear highlights on search when pressing <Esc> in normal mode
--  See `:help hlsearch`
vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>')

-- Diagnostic keymaps
vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' })

vim.keymap.set({ 'n', 'v' }, 'c', '"zc', { desc = 'Change without copying to clipboard' })
vim.keymap.set({ 'n', 'v' }, 'x', '"zx', { desc = 'Cut without copying to clipboard' })
vim.keymap.set('v', 'p', '"zdP', { desc = 'Paste over selection without yanking replaced text' })

-- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier
-- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which
-- is not what someone will guess without a bit more experience.
--
-- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping
-- or just use <C-\><C-n> to exit terminal mode
vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })

vim.keymap.set('n', '<Leader>z', function()
    vim.treesitter.inspect_tree()
end, { desc = 'Treesitter' })

vim.keymap.set('n', '<C-S-D>', function()
    local node = vim.treesitter.get_node {}
    local range = { vim.treesitter.get_node_range(node) }
    vim.api.nvim_win_set_cursor(0, { range[3] + 1, range[4] - 1 })
    vim.fn.setpos("'x", { 0, range[1] + 1, range[2] + 1, 0 })
    vim.cmd.normal 'v`x'
end, { desc = 'Select surrounding treesitter node' })

vim.keymap.set('v', '<C-S-D>', function()
    local start = vim.api.nvim_win_get_cursor(0)
    local start_row, start_column
    if start[2] == 0 then
        start_row = start[1] - 1
        start_column = 0
    else
        start_row = start[1]
        start_column = start[2] - 1
    end
    vim.api.nvim_win_set_cursor(0, { start_row, start_column })
    local node = vim.treesitter.get_node {}
    local range = { vim.treesitter.get_node_range(node) }
    vim.api.nvim_win_set_cursor(0, { range[3] + 1, range[4] - 1 })
    vim.fn.setpos("'x", { 0, range[1] + 1, range[2] + 1, 0 })
    vim.cmd.normal 'i'
    vim.cmd.normal 'v`x'
end, { desc = 'Select surrounding treesitter node' })

local swappable_nodes = { 'argument', 'array_element_initializer', 'simple_parameter', 'string', 'integer', 'member_call_expression', 'method_declaration' }

local function closest_swappable_node(node)
    while node and not vim.list_contains(swappable_nodes, node:type()) and (not node:next_named_sibling() or not node:prev_named_sibling()) do
        node = node:parent()
    end
    return node
end

vim.keymap.set({ 'n' }, '<C-S-h>', function()
    local node = closest_swappable_node(vim.treesitter.get_node())
    if not node then
        return
    end
    local prev_node = node:prev_named_sibling()
    while prev_node and not vim.list_contains(swappable_nodes, prev_node:type()) do
        prev_node = prev_node:prev_named_sibling()
    end
    if prev_node == nil then
        return
    end
    require('nvim-treesitter.ts_utils').swap_nodes(node, prev_node, 0, true)
end, { desc = 'Swap with node to the left' })
vim.keymap.set({ 'n' }, '<C-S-l>', function()
    local node = closest_swappable_node(vim.treesitter.get_node())
    if not node then
        return
    end
    local next_node = node:next_named_sibling()
    while next_node and not vim.list_contains(swappable_nodes, next_node:type()) do
        next_node = next_node:next_named_sibling()
    end
    if next_node == nil then
        return
    end
    require('nvim-treesitter.ts_utils').swap_nodes(node, next_node, 0, true)
end, { desc = 'Swap with node to the right' })
vim.keymap.set('n', '<C-S-j>', 'ddp', { desc = 'Move line down' })
vim.keymap.set('n', '<C-S-k>', 'ddkP', { desc = 'Move line up' })
vim.keymap.set('v', '<C-S-j>', 'do<Esc>p`[v`]', { desc = 'Move selection down' })
vim.keymap.set('v', '<C-S-k>', 'dkO<Esc>p`[v`]', { desc = 'Move selection up' })

-- Keybinds to make split navigation easier.
--  Use CTRL+<hjkl> to switch between windows
--
--  See `:help wincmd` for a list of all window commands
local function win_or_treesj(dir_cmd, desc)
    return function()
        local cur = vim.api.nvim_get_current_win()
        vim.cmd('wincmd ' .. dir_cmd)
        if vim.api.nvim_get_current_win() == cur then
            local ok, treesj = pcall(require, 'treesj')
            if ok and type(treesj.toggle) == 'function' then
                treesj.toggle()
            end
        end
    end, { desc = desc }
end

vim.keymap.set('n', '<C-h>', '<C-w><C-h>', { desc = 'Move focus to the left window' })
vim.keymap.set('n', '<C-l>', '<C-w><C-l>', { desc = 'Move focus to the right window' })
vim.keymap.set('n', '<C-j>', (win_or_treesj)('j', 'Move focus to the lower window or treesj.toggle()'))
vim.keymap.set('n', '<C-k>', (win_or_treesj)('k', 'Move focus to the upper window or treesj.toggle()'))

vim.keymap.set('t', '<C-h>', '<C-\\><C-n><C-w>h', { desc = 'Move focus to the left window' })
vim.keymap.set('t', '<C-l>', '<C-\\><C-n><C-w>l', { desc = 'Move focus to the right window' })
vim.keymap.set('t', '<C-j>', '<C-\\><C-n><C-w>j', { desc = 'Move focus to the lower window' })
vim.keymap.set('t', '<C-k>', '<C-\\><C-n><C-w>k', { desc = 'Move focus to the upper window' })

vim.keymap.set({ 'i' }, '<C-J>', function()
    local ls = require 'luasnip'
    if ls.choice_active() then
        ls.change_choice(1)
    end
end, { desc = 'Toggle snippet choice', silent = true })
vim.keymap.set({ 'i' }, '<C-k>', function()
    local ls = require 'luasnip'
    if ls.choice_active() then
        ls.change_choice(-1)
    end
end, { desc = 'Toggle snippet choice', silent = true })
vim.keymap.set({ 'i', 's' }, '<C-L>', function()
    local ls = require 'luasnip'
    if ls.expandable() then
        ls.expand()
    elseif ls.in_snippet() then
        ls.jump(1)
    end
end, { desc = 'Expand snippet', silent = true })
vim.keymap.set({ 'i', 's' }, '<C-H>', function()
    local ls = require 'luasnip'
    if ls.in_snippet() then
        ls.jump(-1)
    end
end, { desc = 'Go back a snippet slot', silent = true })

vim.keymap.set('n', '<Leader>.', '<Cmd>tabnext<CR>', { desc = 'Next tab' })
vim.keymap.set('n', '<Leader>,', '<Cmd>tabprevious<CR>', { desc = 'Previous tab' })

-- Overriding CTRL mappings because some of them are stupid
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-B>', '<CMD>Git blame<CR>', { desc = 'Git blame' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Q>', '<CMD>Telescope lsp_document_symbols<CR>', { desc = 'Show symbols in current document' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Q>', '<CMD>Telescope lsp_workspace_symbols<CR>', { desc = 'Show symbols in workspace' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-E>', '<CMD>Telescope oldfiles<CR>', { desc = 'Show recently opened files' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-P>', function()
    require('telescope.builtin').find_files {
        show_untracked = true,
        no_ignore = false,
        hidden = true,
    }
end, { desc = 'Find all files' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-P>', function()
    require('telescope.builtin').find_files {
        show_untracked = true,
        no_ignore = true,
        hidden = true,
    }
end, { desc = 'Find all files' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-f>', function()
    require('telescope.builtin').live_grep {
        hidden = true,
    }
end, { desc = 'Search within the whole project' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-Y>', '<CMD>Telescope quickfix<CR>', { desc = 'Show quickfix list' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-Y>', '<CMD>Telescope quickfixhistory<CR>', { desc = 'Show quickfix history' })
vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-A>', function()
    local ai_tools = { 'codex', 'agy', 'opencode' }
    local ai_win_opts = {
        width = math.floor(vim.o.columns / 3),
        vertical = true,
        split = 'right',
    }

    local term_bufnr = -1
    for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
        if vim.bo[bufnr].buftype == 'terminal' then
            local name = vim.api.nvim_buf_get_name(bufnr)

            for _, tool in ipairs(ai_tools) do
                if name:match(':' .. tool .. '$') or name:match('/' .. tool .. '$') then
                    term_bufnr = bufnr
                end
            end
        end
    end

    if term_bufnr ~= -1 then
        local term_winid = vim.fn.bufwinid(term_bufnr)
        if term_winid ~= -1 then
            vim.api.nvim_win_hide(term_winid)
            return
        end

        vim.api.nvim_open_win(term_bufnr, true, ai_win_opts)
        vim.cmd.startinsert()
        return
    end
    for _, tool in ipairs(ai_tools) do
        if vim.fn.executable(tool) == 1 then
            helpers.open_term {
                cmd = tool,
                win_opts = ai_win_opts,
                buf_opts = {
                    bufhidden = 'hide',
                    modifiable = false,
                },
            }
            return
        end
    end
    vim.api.nvim_echo({ { 'No AI tool found. Please install one of the following: codex, agy, opencode', 'WarningMsg' } }, false, {})
end, { desc = 'Toggle AI tool' })
-- vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-A>', '<CMD>vsplit term://codex<CR>i', { desc = 'Open AI tool' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S>', function()
    require('snacks').scratch()
end, { desc = 'Open scratchpad' })
vim.keymap.set({ 'n', 'v', 'c', 'i' }, '<C-S-S>', function()
    require('snacks').scratch.select()
end, { desc = 'Open scratchpad buffers' })
vim.keymap.set({ 'n', 'v', 'c', 'i', 't' }, '<C-T>', function()
    require('snacks').terminal.toggle()
end, { desc = 'Toggle terminal' })

-- Editing helpers
vim.keymap.set('i', '<C-O>', '<Esc>o', { desc = 'Add line below' })
vim.keymap.set('i', '<C-S-O>', '<Esc>O', { desc = 'Add line above' })
local esc_keys = { 'jj', 'jk', 'kk' }
for _, key in ipairs(esc_keys) do
    vim.keymap.set('i', key, '<Esc>', { desc = 'Exit insert mode' })
end
vim.keymap.set('i', '<C-D>', '<Esc>ddi', { desc = 'Delete line' })
vim.keymap.set('i', '<Leader>;', '<Esc>mzA;<Esc>`za', { desc = 'Append a semicolon' })
vim.keymap.set('n', '<Leader>;', 'mzA;<Esc>`za', { desc = 'Append a semicolon' })
vim.keymap.set('n', '<Leader>{', 'mzF[`a<CR><Esc>``%i<CR><Esc>`z', { desc = 'Indent an array' })
vim.keymap.set('n', '<Leader>}', 'mzF[`a<CR><Esc>``%i<CR><Esc>`zvi[:s/,\\s*/,\\r/g<CR>vi[=<Esc>`z:nohlsearch<CR>', { desc = 'Indent an array some other way?' })

-- Git mappings
vim.keymap.set('n', '<Leader>gb', '<CMD>Git blame<CR>', { desc = 'Git blame' })
vim.keymap.set('n', '<Leader>gd', '<CMD>Git diff<CR>', { desc = 'Git diff' })
vim.keymap.set('n', '<Leader>gdc', '<CMD>Git diff --cached<CR>', { desc = 'Git diff' })
vim.keymap.set('n', '<Leader>G', function()
    helpers.open_term { cmd = 'lazygit' }
end, { desc = 'Git' })

-- Add keymaps for diff mode
vim.api.nvim_create_autocmd('BufEnter', {
    callback = function()
        if vim.wo.diff then
            -- Keymaps for navigating hunks
            vim.api.nvim_buf_set_keymap(0, 'n', '<Tab>', ']c', { noremap = true, silent = true, desc = 'Next hunk in diff mode' })
            vim.api.nvim_buf_set_keymap(0, 'n', '<S-Tab>', '[c', { noremap = true, silent = true, desc = 'Previous hunk in diff mode' })

            -- Keymaps for resolving conflicts
            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dl', ':diffget LOCAL<CR>', { noremap = true, silent = true, desc = 'Get LOCAL changes' })
            vim.api.nvim_buf_set_keymap(0, 'n', '<leader>dr', ':diffget REMOTE<CR>', { noremap = true, silent = true, desc = 'Get REMOTE changes' })
        end
    end,
})

-- AI mappings
-- vim.keymap.set('v', '<Leader>ae', '<CMD>CodeCompanion<CR>', { desc = 'Edit selection with AI' })
-- vim.keymap.set('n', '<Leader>ac', '<CMD>CodeCompanionCmd<CR>', { desc = 'Run Neovim commands with AI' })
vim.api.nvim_create_autocmd('FileType', {
    pattern = 'codecompanion',
    callback = function()
        vim.keymap.set('i', '<Enter>', function()
            require('codecompanion').last_chat():submit()
        end, { buffer = true, desc = 'Use enter to send the message' })
        vim.keymap.set('i', '<S-Enter>', '<Enter>', { buffer = true, desc = 'Use shift enter to start a new line' })
        vim.keymap.set('n', '<Enter>', 'G', { buffer = true, desc = 'Use enter in normal mode to go to the end of the chat' })

        local models = { vim.env.DEFAULT_AI_MODEL, vim.env.REASONING_MODEL, vim.env.FAST_MODEL }
        -- Loop through models and create keymaps for each
        for i, model in ipairs(models) do
            vim.keymap.set('n', '<C-' .. i .. '>', 'mzggj0W"_C' .. model .. '<Esc>`z', { desc = 'Switch to ' .. model })
            vim.keymap.set('i', '<C-' .. i .. '>', '<Esc>mzggj0W"_C' .. model .. '<Esc>`za', { desc = 'Switch to ' .. model })
        end
    end,
})

-- Search mappings
vim.keymap.set('n', '<Leader>sGb', '<CMD>Telescope git_branches<CR>', { desc = 'Search git branches' })
vim.keymap.set('n', '<Leader>sGc', '<CMD>Telescope git_commits<CR>', { desc = 'Search git history' })
vim.keymap.set('n', '<Leader>sGh', '<CMD>Telescope git_bcommits<CR>', { desc = 'Search git history within current buffer/selection' })
vim.keymap.set('n', '<Leader>sGs', '<CMD>Telescope git_status<CR>', { desc = 'Search git status' })
vim.keymap.set('n', '<Leader>sGS', '<CMD>Telescope git_stash<CR>', { desc = 'Search git stash' })

-- Misc
vim.keymap.set('n', '<Leader>]', '<CMD>cnext<CR>', { desc = 'Next item in quickfix list' })
vim.keymap.set('n', '<Leader>[', '<CMD>cprevious<CR>', { desc = 'Previous item in quickfix list' })
vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' })
vim.keymap.set('n', '<Leader>r', function()
    for _, c in ipairs(vim.lsp.get_clients { bufnr = 0 }) do
        if c.name == 'phpantom_lsp' then
            c:stop(true)
        end
    end
    vim.cmd 'edit'
end, { desc = 'Reload buffer' })

local function open_test()
    require('neotest').summary.open()
    require('neotest').output_panel.open()
end
-- Testing
local test_maps = {
    {
        keys = { '<Leader>tc' },
        action = function()
            require('neotest').summary.close()
            require('neotest').output_panel.close()
        end,
        desc = 'Close [T]est panels',
    },
    {
        keys = { '<Leader>tn' },
        action = function()
            require('neotest').run.run()
            open_test()
        end,
        desc = 'Run nearest [T]est',
    },
    {
        keys = { '<Leader>ta' },
        action = function()
            require('neotest').run.run { suite = true }
            open_test()
        end,
        desc = 'Run all [T]ests in the project',
    },
    {
        keys = { '<Leader>tp' },
        action = function()
            require('neotest').run.run_last()
            open_test()
        end,
        desc = 'Run previous [T]est again',
    },
    {
        keys = { '<Leader>td' },
        action = function()
            local dap = require 'dap'
            if dap.session() == nil then
                dap.continue()
            end
            require('dapui').open()
            local neotest = require 'neotest'
            local bufnr = vim.api.nvim_get_current_buf()
            local row = vim.api.nvim_win_get_cursor(0)[1] - 1

            local adapters = neotest.state.adapter_ids()
            local found = false

            vim.g.neotest_debug = true
            for _, adapter_id in ipairs(adapters) do
                local tree = neotest.state.positions(adapter_id, { buffer = bufnr })
                if tree then
                    local nearest = require('neotest.lib.positions').nearest(tree, row)
                    if nearest and nearest:data().type ~= 'file' then
                        neotest.run.run()
                        found = true
                        break
                    end
                end
            end

            if not found then
                neotest.run.run_last()
            end
            vim.g.neotest_debug = nil
        end,
        desc = 'Run last [T]est with debugger',
    },
}

for _, map_info in ipairs(test_maps) do
    for _, key in ipairs(map_info.keys) do
        vim.keymap.set('n', key, map_info.action, { desc = map_info.desc })
    end
end
vim.keymap.set('n', '<Leader>tf', function()
    require('neotest').run.run(vim.fn.expand '%')
    open_test()
end, { desc = 'Run all tests in the current file' })
vim.keymap.set('n', '<Leader>tc', function()
    require('neotest').summary.close()
    require('neotest').output_panel.close()
end, { desc = 'Close test panels' })

vim.keymap.set('i', '<Tab>', function()
    if ls.jumpable(1) then
        vim.api.nvim_echo({ { 'Jumping in snippet' } }, false, {})
        ls.jump()
    else
        vim.api.nvim_echo({ { 'Inserting tab' } }, false, {})
        vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<Tab>', true, true, true), 'n', true)
    end
end, { desc = 'Luasnip accept copilot or jump forward' })

-- Leaving this commented out, I will try the format command instead
-- "A command to properly indent json code
-- command! FormatJSON %!python -m json.tool

-- Edit the snippet file for the current buffer filetype or the snippets
-- directory if the file does not exist
vim.keymap.set('n', '<Leader>es', function()
    local ft = vim.bo.filetype
    if ft == 'vue' then
        ft = 'javascript'
    end
    local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
    local snippets_file = snippets_dir .. '/' .. ft .. '.lua'
    vim.cmd('tabedit ' .. snippets_file)
end, { desc = 'Edit snippets file' })

vim.keymap.set('n', '<Leader>cz', function()
    require('utils/cheatsheets').open 'zsh'
end, { desc = 'Open zsh cheat sheet' })
vim.keymap.set('n', '<Leader>cb', function()
    require('utils/cheatsheets').open 'bash'
end, { desc = 'Open bash cheat sheet' })
vim.keymap.set('n', '<Leader>cr', function()
    require('utils/cheatsheets').open 'regex'
end, { desc = 'Open RegExp cheat sheet' })

require('helpers').edit_cf('k', '/lua/keymap.lua')