--[[---------------------------------------------
- Description - Vilyaem's Neovim Configuration
- Author - Vilyaem
- -------------------------------------------]]

vim.g.mapleader = " "


--Vilyaem's Settings
vim.opt.autoindent = true
vim.opt.backspace = { 'indent', 'eol', 'start' }
vim.opt.encoding = 'utf-8'
vim.opt.expandtab = true
vim.opt.lazyredraw = true
vim.opt.list = true
vim.opt.listchars = { tab = '>.' }
vim.opt.mouse = 'a'
vim.opt.swapfile = false
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.spelllang = 'en_gb'
vim.opt.shiftwidth = 2
vim.opt.viminfo = ''
vim.opt.history = 1000

--Colouring
vim.cmd("highlight Comment guifg=NONE ")
vim.cmd("highlight @comment guifg=NONE ")
vim.api.nvim_set_hl(0,"Normal",{bg = "none"})
vim.api.nvim_set_hl(0,"NormalFloat",{bg = "none"})

--Enable King's English Spell Checking
vim.opt.spelllang = 'en_gb'
vim.opt.spell = true

-- Easy search and replace
vim.api.nvim_set_keymap('n', 'S', ':%s///g<Left><Left><Left>', { noremap = true })
vim.api.nvim_set_keymap('v', 'S', ':s///g<Left><Left><Left>', { noremap = true })

-- Easy save
vim.api.nvim_set_keymap('n', 'W', ':w<CR>', { noremap = true })

-- Function or File heading
function FileHeading()
    local line = vim.fn.line(".")
    vim.fn.setline(line, "/*********************************************")
    vim.fn.append(line, "* Description - ")
    vim.fn.append(line + 1, "* Author - Vilyaem")
    vim.fn.append(line + 2, "* *******************************************/")
end
vim.api.nvim_set_keymap('i', '<F4>', '<Esc>:lua FileHeading()<CR>g;kkA', { noremap = true })

-- Section
vim.api.nvim_set_keymap('i', '<F3>', '<Esc>I/*----------!----------*/<Esc>/!<CR>?<CR>xi', { noremap = true })

--F6 talk to the soybot
vim.api.nvim_set_keymap("n","<F6>","<Esc>:Gen<CR>",{noremap = true, silent = true})

-- Set the key mappings for the GDB commands
vim.keymap.set("n", "<leader>db", "<cmd>GdbStart<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>dc", "<cmd>GdbContinue<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>dn", "<cmd>GdbNext<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>ds", "<cmd>GdbStep<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>di", "<cmd>GdbStepInto<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>do", "<cmd>GdbStepOut<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>db", "<cmd>GdbBreakpoint<cr>", { noremap = true, silent = true })
vim.keymap.set("n", "<leader>dw", "<cmd>GdbWatch<cr>", { noremap = true, silent = true })

--Calculate expression plugin
vim.api.nvim_create_user_command("Calculate", "lua require(\"calculator\").calculate()",
    { ["range"] = 1, ["nargs"] = 0 })

--Setup packer
-- Install packer.nvim for plugin management
local function bootstrap_packer()
  local fn = vim.fn
  local install_path = fn.stdpath('data')..'/site/pack/packer/start/packer.nvim'
  if fn.empty(fn.glob(install_path)) > 0 then
    fn.system({'git', 'clone', '--depth', '1', 'https://github.com/wbthomason/packer.nvim', install_path})
    vim.cmd('packadd packer.nvim')
    return true
  end
  return false
end

local packer_bootstrap = bootstrap_packer()

-- Use packer to manage plugins
require('packer').startup(function(use)
  use 'wbthomason/packer.nvim'  -- Package manager

  use{"L3MON4D3/LuaSnip"}
  use{"vzze/calculator.nvim"}
  use{"hrsh7th/nvim-cmp"}
  use{"hrsh7th/cmp-buffer"}
  use{"hrsh7th/cmp-nvim-lsp"}
  use{"hrsh7th/cmp-nvim-lua"}
  use{"hrsh7th/cmp-path"}
  use{"saadparwaiz1/cmp_luasnip"}
  use{"stevearc/conform.nvim"}
  use{"rafamadriz/friendly-snippets"}
  use{"David-Kunz/gen.nvim"}
  use{"lewis6991/gitsigns.nvim"}
  use{"lukas-reineke/indent-blankline.nvim"}
  use{"williamboman/mason.nvim"}
  use{"williamboman/mason-lspconfig.nvim"}
  use{"windwp/nvim-autopairs"}
  use{"sakhnik/nvim-gdb"}
  use{"neovim/nvim-lspconfig"}
  use{"nvim-tree/nvim-tree.lua"}
  use{"nvim-treesitter/nvim-treesitter"}
  use{"nvim-lua/plenary.nvim"}
  use{"nvim-telescope/telescope.nvim"}
  use{"ThePrimeagen/vim-be-good"}
  use{"folke/which-key.nvim"}

  if packer_bootstrap then
    require('packer').sync()
  end
end)


-- Setup installed packages
require("nvim-tree").setup()
require("mason").setup()
require("telescope").setup{}


-- LSP
vim.api.nvim_create_autocmd('LspAttach', {
  desc = 'LSP actions',
  callback = function(event)
    local opts = {buffer = event.buf}
    -- these will be buffer-local keybindings
    -- because they only work if you have an active language server
    vim.keymap.set('n', 'K', '<cmd>lua vim.lsp.buf.hover()<cr>', opts)
    vim.keymap.set('n', 'gd', '<cmd>lua vim.lsp.buf.definition()<cr>', opts)
    vim.keymap.set('n', 'gD', '<cmd>lua vim.lsp.buf.declaration()<cr>', opts)
    vim.keymap.set('n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<cr>', opts)
    vim.keymap.set('n', 'go', '<cmd>lua vim.lsp.buf.type_definition()<cr>', opts)
    vim.keymap.set('n', 'gr', '<cmd>lua vim.lsp.buf.references()<cr>', opts)
    vim.keymap.set('n', 'gs', '<cmd>lua vim.lsp.buf.signature_help()<cr>', opts)
    vim.keymap.set('n', '<F2>', '<cmd>lua vim.lsp.buf.rename()<cr>', opts)
    vim.keymap.set({'n', 'x'}, '<F3>', '<cmd>lua vim.lsp.buf.format({async = true})<cr>', opts)
    vim.keymap.set('n', '<F4>', '<cmd>lua vim.lsp.buf.code_action()<cr>', opts)
  end
})

local lsp_capabilities = require('cmp_nvim_lsp').default_capabilities()

require('mason').setup({})
require('mason-lspconfig').setup({
  ensure_installed = {},
  handlers = {
    function(clangd)
      require('lspconfig').clangd.setup({
        capabilities = lsp_capabilities,
      })
    end,
  },
})

local cmp = require('cmp')

cmp.setup({
  sources = {
    {name = 'nvim_lsp'},
  },
  mapping = cmp.mapping.preset.insert({
    -- Enter key confirms completion item
    ['<CR>'] = cmp.mapping.confirm({select = false}),
    -- Ctrl + space triggers completion menu
    ['<C-Space>'] = cmp.mapping.complete(),
  }),
  snippet = {
    expand = function(args)
      require('luasnip').lsp_expand(args.body)
    end,
  },
})

-- Set package keybindings

local map = vim.keymap.set
map("i", "<C-b>", "<ESC>^i", { desc = "move beginning of line" })
map("i", "<C-e>", "<End>", { desc = "move end of line" })
map("i", "<C-h>", "<Left>", { desc = "move left" })
map("i", "<C-l>", "<Right>", { desc = "move right" })
map("i", "<C-j>", "<Down>", { desc = "move down" })
map("i", "<C-k>", "<Up>", { desc = "move up" })
map("n", "<C-h>", "<C-w>h", { desc = "switch window left" })
map("n", "<C-l>", "<C-w>l", { desc = "switch window right" })
map("n", "<C-j>", "<C-w>j", { desc = "switch window down" })
map("n", "<C-k>", "<C-w>k", { desc = "switch window up" })
map("n", "<Esc>", "<cmd>noh<CR>", { desc = "general clear highlights" })
map("n", "<C-s>", "<cmd>w<CR>", { desc = "general save file" })
map("n", "<C-c>", "<cmd>%y+<CR>", { desc = "general copy whole file" })

-- Key mappings for tab navigation
vim.api.nvim_set_keymap('n', '<Tab>', ':tabnext<CR>', { noremap = true, silent = true })
vim.api.nvim_set_keymap('n', '<S-Tab>', ':tabprevious<CR>', { noremap = true, silent = true })

-- Key mappings for closing and creating tabs
vim.api.nvim_set_keymap('n', '<leader>x', ':tabclose<CR>', { noremap = true, silent = true })
vim.api.nvim_set_keymap('n', '<leader>b', ':tabnew<CR>', { noremap = true, silent = true })

-- Ensure new files opened from Nvim Tree open in new tabs
vim.api.nvim_create_autocmd("BufEnter", {
  pattern = "*",
  callback = function()
    if vim.fn.winnr('$') == 1 and vim.bo.filetype == 'NvimTree' then
      vim.cmd('tabnew')
    end
  end
})

-- Comment
map("n", "<leader>/", "gcc", { desc = "toggle comment", remap = true })
map("v", "<leader>/", "gc", { desc = "toggle comment", remap = true })

-- nvimtree
map("n", "<C-n>", "<cmd>NvimTreeToggle<CR>", { desc = "nvimtree toggle window" })
map("n", "<leader>e", "<cmd>NvimTreeFocus<CR>", { desc = "nvimtree focus window" })

-- telescope
map("n", "<leader>fw", "<cmd>Telescope live_grep<CR>", { desc = "telescope live grep" })
map("n", "<leader>fb", "<cmd>Telescope buffers<CR>", { desc = "telescope find buffers" })
map("n", "<leader>fh", "<cmd>Telescope help_tags<CR>", { desc = "telescope help page" })
map("n", "<leader>ma", "<cmd>Telescope marks<CR>", { desc = "telescope find marks" })
map("n", "<leader>fo", "<cmd>Telescope oldfiles<CR>", { desc = "telescope find oldfiles" })
map("n", "<leader>fz", "<cmd>Telescope current_buffer_fuzzy_find<CR>", { desc = "telescope find in current buffer" })
map("n", "<leader>cm", "<cmd>Telescope git_commits<CR>", { desc = "telescope git commits" })
map("n", "<leader>gt", "<cmd>Telescope git_status<CR>", { desc = "telescope git status" })
map("n", "<leader>pt", "<cmd>Telescope terms<CR>", { desc = "telescope pick hidden term" })


map("n", "<leader>ff", "<cmd>Telescope find_files<cr>", { desc = "telescope find files" })
map(
  "n",
  "<leader>fa",
  "<cmd>Telescope find_files follow=true no_ignore=true hidden=true<CR>",
  { desc = "telescope find all files" }
)