--@diagnostic disable: undefined-global
vim.loader.enable()


vim.g.netrw_banner = 0
vim.g.netrw_liststyle = 3
vim.g.netrw_altv = 0
vim.g.netrw_winsize = 25
vim.g.netrw_browse_split = 4
vim.g.rustfmt_autosave = 1
vim.g.mkdp_auto_start = 1
vim.g.gitgutter_set_sign_backgrounds = 1

vim.opt.nu = true
vim.opt.tabstop = 4
vim.opt.softtabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
vim.opt.smartindent = true
vim.opt.ruler = false
vim.opt.wrap = false
vim.opt.swapfile = false
vim.opt.wildmenu = true
vim.opt.path:append("**")
vim.opt.hlsearch = true
vim.opt.incsearch = true
vim.opt.updatetime = 50
vim.opt.laststatus = 0
vim.opt.signcolumn = "number"
vim.opt.clipboard = "unnamedplus"
vim.opt.fillchars = "eob: "
vim.opt.autoindent = true
vim.opt.lazyredraw = false
vim.opt.updatetime = 300
vim.opt.timeoutlen = 500

vim.api.nvim_create_autocmd("BufWritePre", {
    callback = function()
        local buf = vim.api.nvim_get_current_buf()
        local clients = vim.lsp.get_clients({bufnr = buf})
        for _, client in ipairs(clients) do
            if client.server_capabilities.documentFormattingProvider then
                vim.lsp.buf.format({async = false})
                return
            end
        end
    end
})

local run_on_save = vim.api.nvim_create_augroup("RunPfOnSave", {clear = true})
local formatters = {
    {
        patterns = {"*.js","*.ts","*.jsx","*.json","*.tsx","*.css","*.html","*.yaml","*.md","*.svelte","*.lua"},
        command = function(file) vim.fn.system({"prettier", "--write", file}) end
    },
    {patterns = {"*.tex"}, command = function(file) vim.fn.system({"pdflatex", "--shell-escape", file}) end},
    {patterns = {"*.c","*.h"}, command = function(file) vim.fn.system({"clang-format", "-i", file}) end}
}
for _, fmt in ipairs(formatters) do
    vim.api.nvim_create_autocmd("BufWritePost", {
        group = run_on_save, pattern = fmt.patterns,
        callback = function(args) pcall(fmt.command, args.match or args.file) end
    })
end

vim.api.nvim_create_augroup("AutoDeleteNetrwHiddenBuffers", {clear = true})
vim.api.nvim_create_autocmd("FileType", {
    group = "AutoDeleteNetrwHiddenBuffers", pattern = "netrw",
    callback = function() vim.opt_local.bufhidden = "wipe"; vim.opt_local.buflisted = false end
})

function ToggleVExplorer()
    local expl_buf = vim.t.expl_buf_num
    local expl_win = expl_buf and vim.fn.bufwinnr(expl_buf) or -1
    if expl_win ~= -1 then
        vim.cmd(expl_win .. "wincmd c")
        vim.t.expl_buf_num = nil
    else
        vim.cmd("topleft " .. (vim.g.netrw_winsize or 30) .. "vsplit")
        vim.cmd("Explore")
        vim.t.expl_buf_num = vim.fn.bufnr("%")
    end
end

local autopairs = { ["("]=")", ["["]="]", ["{"]="}", ["<"]=">" }
for open, close in pairs(autopairs) do
    vim.api.nvim_set_keymap("i", open, open..close.."<Left>", {noremap=true, silent=true})
end

function set_highlights()
    local highlights = {
        {"GitGutterAdd",{bg="none"}},{"GitGutterDelete",{bg="none"}},{"GitGutterChange",{bg="none"}},
        {"NonText",{fg="none"}},{"EndOfBuffer",{fg="none",bg="none"}},{"SignColumn",{bg="none"}},
        {"StatusLine",{bg="none",fg="none"}},{"StatusLineNc",{bg="none",fg="none"}},
        {"CursorColumn",{fg="none"}},{"CursorLine",{bg="none"}},{"VertSplit",{bg="none"}},
        {"DiagnosticError",{bg="none"}},{"DiagnosticWarn",{bg="none"}},{"DiagnosticInfo",{bg="none"}},
        {"DiagnosticHint",{bg="none"}},{"Pmenu",{bg="none"}},{"LspFloatWinNormal",{bg="none"}},
        {"NormalFloat",{bg="none"}},{"LineNr",{bg="none"}}
    }
    for _, hl in ipairs(highlights) do vim.api.nvim_set_hl(0, hl[1], hl[2]) end
end

vim.cmd("colorscheme quiet")
vim.o.background = "dark"
function color_mode()
    if vim.o.background == "dark" then
        vim.o.background = "light"
        vim.cmd("colorscheme zellner")
    else
        vim.o.background = "dark"
        vim.cmd("colorscheme quiet")
    end
    set_highlights()
end

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
    vim.fn.system({"git","clone","--filter=blob:none","https://github.com/folke/lazy.nvim.git","--branch=stable",lazypath})
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
    {"ibhagwan/fzf-lua", opts = {}},
    {"airblade/vim-gitgutter"},

    {
        "neovim/nvim-lspconfig",
        config = function()
            local capabilities = require("cmp_nvim_lsp").default_capabilities()
            local function get_root(patterns)
                local root = vim.fs.dirname(vim.fs.find(patterns, { upward = true })[1])
                return root or vim.fn.getcwd()
            end
            local on_attach = function(_, bufnr)
                local opts = {buffer = bufnr, silent = true}
                vim.keymap.set("n", "gd", vim.lsp.buf.definition, opts)
                vim.keymap.set("n", "K", vim.lsp.buf.hover, opts)
                vim.keymap.set("n", "gr", vim.lsp.buf.references, opts)
                vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action, opts)
            end

            vim.lsp.config.clangd = {
                cmd = {"clangd"},
                root_dir = get_root({"compile_commands.json", ".git", "Makefile"}),
                capabilities = capabilities,
                on_attach = on_attach,
            }
            vim.lsp.config.rust_analyzer = {
                cmd = {"rust-analyzer"},
                root_dir = get_root({"Cargo.toml", ".git"}),
                capabilities = capabilities,
                on_attach = on_attach,
            }
            vim.lsp.config.ts_ls = {
                cmd = {"typescript-language-server","--stdio"},
                root_dir = get_root({"package.json", ".git"}),
                capabilities = capabilities,
                on_attach = on_attach,
            }

            vim.api.nvim_create_autocmd("FileType", {
                pattern = {"c","cpp","h","rs","typescript","javascript"},
                callback = function()
                    local ft = vim.bo.filetype
                    if ft == "c" or ft == "cpp" or ft == "h" then
                        vim.lsp.start(vim.lsp.config.clangd)
                    elseif ft == "rust" then
                        vim.lsp.start(vim.lsp.config.rust_analyzer)
                    elseif ft == "typescript" or ft == "javascript" then
                        vim.lsp.start(vim.lsp.config.ts_ls)
                    end
                end
            })
        end
    },

    {
        "hrsh7th/nvim-cmp",
        dependencies = {
            "hrsh7th/cmp-nvim-lsp","hrsh7th/cmp-buffer","hrsh7th/cmp-path",
            "L3MON4D3/LuaSnip","saadparwaiz1/cmp_luasnip","onsails/lspkind.nvim",
            {
                "rafamadriz/friendly-snippets",
                config = function() require("luasnip.loaders.from_vscode").lazy_load() end
            },
        },
        config = function()
            local cmp = require("cmp")
            local luasnip = require("luasnip")
            local lspkind = require("lspkind")
            cmp.setup({
                snippet = {expand = function(args) luasnip.lsp_expand(args.body) end},
                mapping = cmp.mapping.preset.insert({
                    ["<C-Space>"] = cmp.mapping.complete(),
                    ["<CR>"] = cmp.mapping.confirm({select=true}),
                    ["<Tab>"] = cmp.mapping(function(fb)
                        if cmp.visible() then cmp.select_next_item()
                        elseif luasnip.expand_or_jumpable() then luasnip.expand_or_jump()
                        else fb() end
                    end, {"i","s"}),
                    ["<S-Tab>"] = cmp.mapping(function(fb)
                        if cmp.visible() then cmp.select_prev_item()
                        elseif luasnip.jumpable(-1) then luasnip.jump(-1)
                        else fb() end
                    end, {"i","s"}),
                }),
                sources = cmp.config.sources({
                    {name="nvim_lsp", keyword_length = 2},{name="luasnip"},{name="buffer", keyword_length = 3},{name="path"}
                }),
                formatting = {
                    format = lspkind.cmp_format({
                        mode = "symbol_text", maxwidth = 50, ellipsis_char = "..."
                    })
                }
            })
        end
    }
})
vim.g.mapleader = " "
vim.keymap.set("n", "<leader>e", ToggleVExplorer, {desc = "Toggle VExplorer"})
vim.keymap.set("n", "<leader>z", [[:%s/\<<C-r><C-w>\>/<C-r><C-w>/gI<Left><Left><Left>]])
vim.keymap.set("n", "<leader>a", "ggVG")
vim.keymap.set("n", "<leader>y", "cc")
vim.keymap.set("n", "<C-c>", "yy")
vim.keymap.set("n", "<C-v>", "p")
vim.keymap.set("n", "<C-z>", "u")
vim.keymap.set("n", "j", "5j")
vim.keymap.set("n", "k", "5k")
vim.keymap.set("n", "<leader>f", "<cmd>FzfLua files<cr>")
vim.keymap.set("n", "<leader>F", "<cmd>FzfLua live_grep<cr>", {noremap = true, silent = true})
vim.keymap.set("n", "<leader>b", "<cmd>FzfLua buffers<cr>")
vim.keymap.set("n", "<leader>d", vim.lsp.buf.definition, {silent = true})
vim.keymap.set("n", "<leader>df", vim.diagnostic.open_float, {silent = true})
vim.keymap.set("n", "<leader>k", vim.lsp.buf.hover, {silent = true})
vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action, {silent = true})
vim.keymap.set("n", "<leader>r", color_mode, {desc = "Change mode light/dark"})
vim.keymap.set("n", "<leader>t", function()
    vim.cmd("terminal")
    vim.cmd("startinsert")
end, {desc = "Open terminal"})

vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv")
vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
vim.keymap.set("t", "<Esc>", function()
    vim.cmd([[stopinsert]])
    vim.cmd([[b#]])
end, {noremap = true, silent = true})
set_highlights()