local M = {}
local f = require("funcs")
local icons = require("config.icons")

local maps = f.empty_map_table()

M.sections = {
	p = { desc = icons.Package .. " Packages" },
	b = { desc = icons.Buffer .. " Buffers" },
	bs = { desc = "Sort Buffers" },
	d = { desc = icons.Bug .. " Debugger" },
	g = { desc = icons.Git .. " Git" },
	f = { desc = icons.Search .. " Find" },
	l = { desc = icons.Code .. " LSP" },
	t = { desc = icons.Console .. " Terminal" },
	u = { desc = icons.Gear .. " Utility" },
	n = { desc = icons.Note .. " Notes" },
	e = { desc = icons.FileTree .. " File Manager" },
}

-- Standard --
maps.n["j"] = { "v:count == 0 ? 'gj' : 'j'", expr = true, desc = "Move cursor down" }
maps.n["k"] = { "v:count == 0 ? 'gk' : 'k'", expr = true, desc = "Move cursor up" }
maps.n["<Leader>w"] = { "<Cmd>w<CR>", desc = "Write buffer" }
maps.n["<Leader>c"] = { "<Cmd>conf q<CR>", desc = "Quit" }
maps.n["<Leader>C"] = { "<Cmd>conf qa<CR>", desc = "Quit all" }
maps.n["<Leader>n"] = { "<Cmd>ene<CR>", desc = "New buffer" }
maps.n["<Leader>h"] = { "<Cmd>noh<CR>", desc = "Clear highlight" }
maps.n["<C-s>"] = { "<Cmd>w!<cr>", desc = "Force write buffer" }
maps.n["<C-q>"] = { "<Cmd>qa!<cr>", desc = "Force quit all" }
maps.n["<Leader>|"] = { "<Cmd>vsplit<cr>", desc = "Vertical split" }
maps.n["<Leader>\\"] = { "<Cmd>split<cr>", desc = "Horizontal split" }
maps.v["<"] = { "<gv", desc = "Unindent line" }
maps.v[">"] = { ">gv", desc = "Indent line" }
maps.n["<Leader>q"] = { f.buf_close, desc = "Close buffer" }
maps.n["<C-b>"] = { "<C-a>" }
maps.n["<C-f>"] = { "<Nop>" }
maps.i["<C-h>"] = { "<C-W>" }

-- Utility --
if f.is_available("nvim-colorizer.lua") then
	maps.n["<Leader>u"] = M.sections.u
	maps.n["<Leader>uc"] = { "<Cmd>ColorizerToggle<CR>", desc = "Toggle colorizer" }
end

-- Notes --
if f.is_available("zk-nvim") then
	maps.n["<Leader>n"] = M.sections.n
	maps.v["<Leader>n"] = maps.n["<Leader>n"]
	maps.n["<Leader>nn"] = {
		function()
			require("zk").new({ notebook_path = vim.g.wikidir, title = vim.fn.input("Title: ") })
		end,
		desc = "New Note",
	}
	maps.v["<Leader>nnt"] = {
		":ZkNewFromTitleSelection { notebook_path = vim.g.wikidir }<CR>",
		desc = "New Note (Selection as title)",
	}
	maps.v["<Leader>nnc"] = {
		":ZkNewFromContentSelection { notebook_path = vim.g.wikidir, title = vim.fn.input('Title: ') }<CR>",
		desc = "New Note (Selection as content)",
	}
	maps.n["<Leader>no"] = {
		function()
			require("zk").edit({ notebook_path = vim.g.wikidir })
		end,
		desc = "Open Note",
	}
	maps.n["<Leader>ni"] = {
		function()
			require("zk").index({ notebook_path = vim.g.wikidir })
		end,
		desc = "Index Notes",
	}
end

-- Window Navigation --
maps.n["<C-h>"] = { "<C-w>h", desc = "Move to left split" }
maps.n["<C-j>"] = { "<C-w>j", desc = "Move to below split" }
maps.n["<C-k>"] = { "<C-w>k", desc = "Move to above split" }
maps.n["<C-l>"] = { "<C-w>l", desc = "Move to right split" }
maps.n["<C-Up>"] = { "<Cmd>resize -2<CR>", desc = "Resize split up" }
maps.n["<C-Down>"] = { "<Cmd>resize +2<CR>", desc = "Resize split down" }
maps.n["<C-Left>"] = { "<Cmd>vertical resize -2<CR>", desc = "Resize split left" }
maps.n["<C-Right>"] = { "<Cmd>vertical resize +2<CR>", desc = "Resize split right" }
maps.t["<C-h>"] = { "<Cmd>wincmd h<cr>", desc = "Terminal left window navigation" }
maps.t["<C-j>"] = { "<Cmd>wincmd j<cr>", desc = "Terminal down window navigation" }
maps.t["<C-k>"] = { "<Cmd>wincmd k<cr>", desc = "Terminal up window navigation" }
maps.t["<C-l>"] = { "<Cmd>wincmd l<cr>", desc = "Terminal right window navigation" }

-- Plugin Manager --
maps.n["<Leader>p"] = M.sections.p
maps.n["<Leader>ph"] = {
	function()
		require("lazy").home()
	end,
	desc = "Home",
}
maps.n["<Leader>pi"] = {
	function()
		require("lazy").install()
	end,
	desc = "Install",
}
maps.n["<Leader>pu"] = {
	function()
		require("lazy").update()
	end,
	desc = "Update",
}
maps.n["<Leader>ps"] = {
	function()
		require("lazy").sync()
	end,
	desc = "Sync",
}
maps.n["<Leader>px"] = {
	function()
		require("lazy").clean()
	end,
	desc = "Clean",
}
maps.n["<Leader>pc"] = {
	function()
		require("lazy").check()
	end,
	desc = "Check",
}
maps.n["<Leader>pl"] = {
	function()
		require("lazy").log()
	end,
	desc = "Log",
}
maps.n["<Leader>pr"] = {
	function()
		require("lazy").restore()
	end,
	desc = "Restore",
}
maps.n["<Leader>pp"] = {
	function()
		require("lazy").profile()
	end,
	desc = "Profile",
}
maps.n["<Leader>pd"] = {
	function()
		require("lazy").debug()
	end,
	desc = "Debug",
}
maps.n["<Leader>p?"] = {
	function()
		require("lazy").help()
	end,
	desc = "Help",
}

if f.is_available("bufferline.nvim") then
	maps.n["<S-l>"] = {
		function()
			require("bufferline").cycle(1)
		end,
		desc = "Switch to next buffer",
	}
	maps.n["<S-h>"] = {
		function()
			require("bufferline").cycle(-1)
		end,
		desc = "Switch to previous buffer",
	}
	maps.n["<A-l>"] = {
		function()
			require("bufferline").move(1)
		end,
		desc = "Move buffer to next",
	}
	maps.n["<A-h>"] = {
		function()
			require("bufferline").move(-1)
		end,
		desc = "Move buffer to previous",
	}
	maps.n["<Leader>b"] = M.sections.b
	maps.n["<Leader>bc"] = {
		function()
			require("bufferline").close_others()
		end,
		desc = "Close other buffers",
	}
	maps.n["<Leader>bl"] = {
		function()
			require("bufferline").close_in_direction("left")
		end,
		desc = "Close lefthand buffers",
	}
	maps.n["<Leader>br"] = {
		function()
			require("bufferline").close_in_direction("right")
		end,
		desc = "Close righthand buffers",
	}
	maps.n["<Leader>bs"] = M.sections.bs
	maps.n["<Leader>bse"] = {
		function()
			require("bufferline").sort_by("extension")
		end,
		desc = "By extension",
	}
	maps.n["<Leader>bsd"] = {
		function()
			require("bufferline").sort_by("directory")
		end,
		desc = "By directory",
	}
	maps.n["<Leader>bsr"] = {
		function()
			require("bufferline").sort_by("relative_directory")
		end,
		desc = "By relative directory",
	}
	maps.n["<Leader>bst"] = {
		function()
			require("bufferline").sort_by("tabs")
		end,
		desc = "By tabs",
	}
end

if f.is_available("Comment.nvim") then
	maps.n["<Leader>/"] = {
		function()
			require("Comment.api").toggle.linewise.count(vim.v.count > 0 and vim.v.count or 1)
		end,
		desc = "Toggle comment line",
	}
	maps.v["<Leader>/"] = {
		"<esc><Cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<cr>",
		desc = "Toggle comment for selection",
	}
end

if f.is_available("gitsigns.nvim") then
	maps.n["<Leader>g"] = M.sections.g
	maps.n["]g"] = {
		function()
			require("gitsigns").next_hunk()
		end,
		desc = "Next Git hunk",
	}
	maps.n["[g"] = {
		function()
			require("gitsigns").prev_hunk()
		end,
		desc = "Previous Git hunk",
	}
	maps.n["<Leader>gl"] = {
		function()
			require("gitsigns").blame_line()
		end,
		desc = "View Git blame",
	}
	maps.n["<Leader>gL"] = {
		function()
			require("gitsigns").blame_line({ full = true })
		end,
		desc = "View full Git blame",
	}
	maps.n["<Leader>gp"] = {
		function()
			require("gitsigns").preview_hunk()
		end,
		desc = "Preview Git hunk",
	}
	maps.n["<Leader>gh"] = {
		function()
			require("gitsigns").reset_hunk()
		end,
		desc = "Reset Git hunk",
	}
	maps.n["<Leader>gr"] = {
		function()
			require("gitsigns").reset_buffer()
		end,
		desc = "Reset Git buffer",
	}
	maps.n["<Leader>gs"] = {
		function()
			require("gitsigns").stage_hunk()
		end,
		desc = "Stage Git hunk",
	}
	maps.n["<Leader>gS"] = {
		function()
			require("gitsigns").stage_buffer()
		end,
		desc = "Stage Git buffer",
	}
	maps.n["<Leader>gu"] = {
		function()
			require("gitsigns").undo_stage_hunk()
		end,
		desc = "Unstage Git hunk",
	}
	maps.n["<Leader>gd"] = {
		function()
			require("gitsigns").diffthis()
		end,
		desc = "View Git diff",
	}
end

if f.is_available("taolf") then
	maps.n["<Leader>e"] = M.sections.e
	maps.n["E"] = {
		function()
			require("taolf").start({ dir = "fd" })
		end,
		desc = "File manager",
	}
	maps.n["gE"] = { "<Noop>" }
	maps.n["<Leader>ee"] = {
		function()
			require("taolf").start()
		end,
		desc = "File manager",
	}
	maps.n["<Leader>eg"] = {
		function()
			require("taolf").start({ dir = "gwd" })
		end,
		desc = "File manager in git working directory",
	}
	maps.n["<Leader>ef"] = {
		function()
			require("taolf").start({ dir = "fd" })
		end,
		desc = "File manager in open file's working directory",
	}
end

if f.is_available("mason.nvim") then
	maps.n["<Leader>pm"] = { "<Cmd>Mason<cr>", desc = "Mason" }
end

if f.is_available("aerial.nvim") then
	maps.n["<leader>l"] = M.sections.l
	maps.n["<leader>lS"] = {
		function()
			require("aerial").toggle()
		end,
		desc = "Symbols outline",
	}
end

if f.is_available("telescope.nvim") then
	maps.n["<Leader>f"] = M.sections.f
	maps.n["<Leader>g"] = M.sections.g
	maps.n["<Leader>gb"] = {
		function()
			require("telescope.builtin").git_branches({ use_file_path = true })
		end,
		desc = "Git branches",
	}
	maps.n["<Leader>gc"] = {
		function()
			require("telescope.builtin").git_commits({ use_file_path = true })
		end,
		desc = "Git commits (repository)",
	}
	maps.n["<Leader>gC"] = {
		function()
			require("telescope.builtin").git_bcommits({ use_file_path = true })
		end,
		desc = "Git commits (current file)",
	}
	maps.n["<Leader>gt"] = {
		function()
			require("telescope.builtin").git_status({ use_file_path = true })
		end,
		desc = "Git status",
	}
	maps.n["<Leader>f<CR>"] = {
		function()
			require("telescope.builtin").resume()
		end,
		desc = "Resume previous search",
	}
	maps.n["<Leader>f'"] = {
		function()
			require("telescope.builtin").marks()
		end,
		desc = "Find marks",
	}
	maps.n["<Leader>f/"] = {
		function()
			require("telescope.builtin").current_buffer_fuzzy_find()
		end,
		desc = "Find words in current buffer",
	}
	maps.n["<Leader>fc"] = {
		function()
			require("telescope.builtin").grep_string()
		end,
		desc = "Find word under cursor",
	}
	maps.n["<Leader>fC"] = {
		function()
			require("telescope.builtin").commands()
		end,
		desc = "Find commands",
	}
	maps.n["<Leader>ff"] = {
		function()
			require("telescope.builtin").find_files()
		end,
		desc = "Find files",
	}
	maps.n["<Leader>fF"] = {
		function()
			require("telescope.builtin").find_files({ hidden = true, no_ignore = true })
		end,
		desc = "Find all files",
	}
	maps.n["<Leader>fh"] = {
		function()
			require("telescope.builtin").help_tags()
		end,
		desc = "Find help",
	}
	maps.n["<Leader>fk"] = {
		function()
			require("telescope.builtin").keymaps()
		end,
		desc = "Find keymaps",
	}
	maps.n["<Leader>fm"] = {
		function()
			require("telescope.builtin").man_pages()
		end,
		desc = "Find man",
	}
	maps.n["<Leader>fo"] = {
		function()
			require("telescope.builtin").oldfiles()
		end,
		desc = "Find history",
	}
	maps.n["<Leader>fr"] = {
		function()
			require("telescope.builtin").registers()
		end,
		desc = "Find registers",
	}
	maps.n["<Leader>fw"] = {
		function()
			require("telescope.builtin").live_grep()
		end,
		desc = "Find words",
	}
	-- maps.n["<Leader>fb"] = { function() require("telescope.builtin").buffers() end, desc = "Find buffers" }
	maps.n["<Leader>ft"] = {
		function()
			require("telescope").extensions["todo-comments"].todo()
		end,
		desc = "Find buffers",
	}
	maps.n["<Leader>fW"] = {
		function()
			require("telescope.builtin").live_grep({
				additional_args = function(args)
					return vim.list_extend(args, { "--hidden", "--no-ignore" })
				end,
			})
		end,
		desc = "Find words in all files",
	}
	maps.n["<Leader>l"] = M.sections.l
	maps.n["<Leader>ls"] = {
		function()
			local aerial_avail, _ = pcall(require, "aerial")
			if aerial_avail then
				require("telescope").extensions.aerial.aerial()
			else
				require("telescope.builtin").lsp_document_symbols()
			end
		end,
		desc = "Search symbols",
	}
end

if f.is_available("toggleterm.nvim") then
	maps.n["<leader>t"] = M.sections.t
	if vim.fn.executable("lazygit") == 1 then
		maps.n["<leader>g"] = M.sections.g
		maps.n["<leader>gg"] = {
			function()
				local worktree = f.file_worktree()
				local flags = worktree and (" --work-tree=%s --git-dir=%s"):format(worktree.toplevel, worktree.gitdir)
					or ""
				f.toggle_term_cmd("lazygit " .. flags)
			end,
			desc = "ToggleTerm lazygit",
		}
		maps.n["<leader>tl"] = maps.n["<leader>gg"]
	end
	if vim.fn.executable("node") == 1 then
		maps.n["<leader>tn"] = {
			function()
				f.toggle_term_cmd("node")
			end,
			desc = "ToggleTerm node",
		}
	end
	if vim.fn.executable("gdu") == 1 then
		maps.n["<leader>tu"] = {
			function()
				f.toggle_term_cmd("gdu")
			end,
			desc = "ToggleTerm gdu",
		}
	end
	if vim.fn.executable("btm") == 1 then
		maps.n["<leader>tt"] = {
			function()
				f.toggle_term_cmd("btm")
			end,
			desc = "ToggleTerm btm",
		}
	end
	local python = vim.fn.executable("python") == 1 and "python" or vim.fn.executable("python3") == 1 and "python3"
	if python then
		maps.n["<leader>tp"] = {
			function()
				f.toggle_term_cmd(python)
			end,
			desc = "ToggleTerm python",
		}
	end
	maps.n["<leader>tf"] = { "<Cmd>ToggleTerm direction=float<cr>", desc = "ToggleTerm float" }
	maps.n["<leader>th"] = { "<Cmd>ToggleTerm direction=horizontal<cr>", desc = "ToggleTerm horizontal split" }
	maps.n["<C-z>"] = { "<Cmd>ToggleTerm<cr>", desc = "Toggle terminal" }
	maps.t["<C-z>"] = maps.n["<F7>"]
end

if f.is_available("nvim-dap") then
	local conditional_breakpoint = function()
		vim.ui.input({ prompt = "Condition: " }, function(condition)
			if condition then
				require("dap").set_breakpoint(condition)
			end
		end)
	end
	maps.n["<leader>d"] = M.sections.d
	maps.v["<leader>d"] = M.sections.d
	maps.n["<F5>"] = {
		function()
			require("dap").continue()
		end,
		desc = "Debugger: Start",
	}
	maps.n["<S-F5>"] = {
		function()
			require("dap").terminate()
		end,
		desc = "Debugger: Stop",
	}
	maps.n["<S-F9>"] = { conditional_breakpoint, desc = "Debugger: Conditional Breakpoint" }
	maps.n["<C-F5>"] = {
		function()
			require("dap").restart_frame()
		end,
		desc = "Debugger: Restart",
	}
	maps.n["<F6>"] = {
		function()
			require("dap").pause()
		end,
		desc = "Debugger: Pause",
	}
	maps.n["<F9>"] = {
		function()
			require("dap").toggle_breakpoint()
		end,
		desc = "Debugger: Toggle Breakpoint",
	}
	maps.n["<F10>"] = {
		function()
			require("dap").step_over()
		end,
		desc = "Debugger: Step Over",
	}
	maps.n["<F11>"] = {
		function()
			require("dap").step_into()
		end,
		desc = "Debugger: Step Into",
	}
	maps.n["<S-F11>"] = {
		function()
			require("dap").step_out()
		end,
		desc = "Debugger: Step Out",
	}
	maps.n["<leader>db"] = {
		function()
			require("dap").toggle_breakpoint()
		end,
		desc = "Toggle Breakpoint (F9)",
	}
	maps.n["<leader>dB"] = {
		function()
			require("dap").clear_breakpoints()
		end,
		desc = "Clear Breakpoints",
	}
	maps.n["<leader>dc"] = {
		function()
			require("dap").continue()
		end,
		desc = "Start/Continue (F5)",
	}
	maps.n["<leader>dC"] = { conditional_breakpoint, desc = "Conditional Breakpoint (S-F9)" }
	maps.n["<leader>di"] = {
		function()
			require("dap").step_into()
		end,
		desc = "Step Into (F11)",
	}
	maps.n["<leader>do"] = {
		function()
			require("dap").step_over()
		end,
		desc = "Step Over (F10)",
	}
	maps.n["<leader>dO"] = {
		function()
			require("dap").step_out()
		end,
		desc = "Step Out (S-F11)",
	}
	maps.n["<leader>dq"] = {
		function()
			require("dap").close()
		end,
		desc = "Close Session",
	}
	maps.n["<leader>dQ"] = {
		function()
			require("dap").terminate()
		end,
		desc = "Terminate Session (S-F5)",
	}
	maps.n["<leader>dp"] = {
		function()
			require("dap").pause()
		end,
		desc = "Pause (F6)",
	}
	maps.n["<leader>dr"] = {
		function()
			require("dap").restart_frame()
		end,
		desc = "Restart (C-F5)",
	}
	maps.n["<leader>dR"] = {
		function()
			require("dap").repl.toggle()
		end,
		desc = "Toggle REPL",
	}
	maps.n["<leader>ds"] = {
		function()
			require("dap").run_to_cursor()
		end,
		desc = "Run To Cursor",
	}

	if f.is_available("nvim-dap-ui") then
		maps.n["<leader>dE"] = {
			function()
				vim.ui.input({ prompt = "Expression: " }, function(expr)
					if expr then
						require("dapui").eval(expr, { enter = true })
					end
				end)
			end,
			desc = "Evaluate Input",
		}
		maps.v["<leader>dE"] = {
			function()
				require("dapui").eval()
			end,
			desc = "Evaluate Input",
		}
		maps.n["<leader>du"] = {
			function()
				require("dapui").toggle()
			end,
			desc = "Toggle Debugger UI",
		}
		maps.n["<leader>dh"] = {
			function()
				require("dap.ui.widgets").hover()
			end,
			desc = "Debugger Hover",
		}
	end
end

if f.is_available("nvim-ufo") then
	maps.n["zR"] = {
		function()
			require("ufo").openAllFolds()
		end,
		desc = "Open all folds",
	}
	maps.n["zM"] = {
		function()
			require("ufo").closeAllFolds()
		end,
		desc = "Close all folds",
	}
	maps.n["zr"] = {
		function()
			require("ufo").openFoldsExceptKinds()
		end,
		desc = "Fold less",
	}
	maps.n["zm"] = {
		function()
			require("ufo").closeFoldsWith()
		end,
		desc = "Fold more",
	}
	maps.n["zp"] = {
		function()
			require("ufo").peekFoldedLinesUnderCursor()
		end,
		desc = "Peek fold",
	}
end

M.maps = maps

return M