local status, config = pcall(require, "null-ls")
if (not status) then return end

config.setup({
  sources = {
    config.builtins.diagnostics.eslint_d.with({
      diagnostics_format = '[eslint] #{m}\n(#{c})'
    })
  }
})

local status, saga = pcall(require, "lspsaga")
if (not status) then return end

saga.init_lsp_saga({
    border_style = "rounded",
    finder_action_keys = {
      open = "<cr>",
      quit = "<esc>",
    },
    code_action_keys = {
      quit = "<esc>"
    },
    definition_action_keys = {
      quit = "<esc>"
    }
})

-- saga.init_lsp_saga {
--   server_filetype_map = {
--     typescript = 'typescript'
--   },
--   finder_action_keys = {
--     open = "<CR>",
--     quit = "<esc>"
--   }
-- }

--vim.lsp.set_log_level("debug")

local status, nvim_lsp = pcall(require, "lspconfig")
if (not status) then return end

local protocol = require('vim.lsp.protocol')

-- Use an on_attach function to only map the following keys
-- after the language server attaches to the current buffer
local on_attach = function(client, bufnr)
  local function buf_set_option(...) vim.api.nvim_buf_set_option(bufnr, ...) end

  --Enable completion triggered by <c-x><c-o>
  buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc')

  -- Mappings.
  local opts = { noremap = true, silent = true }

  -- formatting
  if client.server_capabilities.documentFormattingProvider then
    vim.api.nvim_create_autocmd("BufWritePre", {
      group = vim.api.nvim_create_augroup("Format", { clear = true }),
      buffer = bufnr,
      callback = function() vim.lsp.buf.formatting_seq_sync() end
    })
  end
end

protocol.CompletionItemKind = {
  '', -- Text
  '', -- Method
  '', -- Function
  '', -- Constructor
  '', -- Field
  '', -- Variable
  '', -- Class
  'ﰮ', -- Interface
  '', -- Module
  '', -- Property
  '', -- Unit
  '', -- Value
  '', -- Enum
  '', -- Keyword
  '﬌', -- Snippet
  '', -- Color
  '', -- File
  '', -- Reference
  '', -- Folder
  '', -- EnumMember
  '', -- Constant
  '', -- Struct
  '', -- Event
  'ﬦ', -- Operator
  '', -- TypeParameter
}

-- Set up completion using nvim_cmp with LSP source
local capabilities = require('cmp_nvim_lsp').update_capabilities(
  vim.lsp.protocol.make_client_capabilities()
)

nvim_lsp.tsserver.setup {
  on_attach = on_attach,
  filetypes = { "typescript", "typescriptreact", "typescript.tsx" },
  cmd = { "typescript-language-server", "--stdio" },
  capabilities = capabilities
}

nvim_lsp.sumneko_lua.setup {
  on_attach = on_attach,
  settings = {
    Lua = {
      diagnostics = {
        -- Get the language server to recognize the `vim` global
        globals = { 'vim' },
      },

      workspace = {
        -- Make the server aware of Neovim runtime files
        library = vim.api.nvim_get_runtime_file("", true),
        checkThirdParty = false
      },
    },
  },
}

local util = require "lspconfig/util"

nvim_lsp.gopls.setup {
  cmd = {"gopls", "serve"},
  filetypes = {"go", "gomod"},
  root_dir = util.root_pattern("go.work", "go.mod", ".git"),
  settings
}

require("rust-tools").setup({
  server = {
    on_attach = on_attach,
    capabilities = capabilities
  },
})

nvim_lsp.tailwindcss.setup {}

vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
  vim.lsp.diagnostic.on_publish_diagnostics, {
  underline = true,
  update_in_insert = false,
  virtual_text = { spacing = 4, prefix = "●" },
  severity_sort = true,
}
)

-- Diagnostic symbols in the sign column (gutter)
local signs = { Error = " ", Warn = " ", Hint = " ", Info = " " }
for type, icon in pairs(signs) do
  local hl = "DiagnosticSign" .. type
  vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = "" })
end

vim.diagnostic.config({
  virtual_text = {
    prefix = '●'
  },
  update_in_insert = true,
  float = {
    source = "always", -- Or "if_many"
  },
})

local status, config = pcall(require, "nvim-autopairs")
if(not status) then return end
config.setup({
    disable_filetype = {"TelescopePrompt", "vim"}
})

local status, cmp = pcall(require, "cmp")
if(not status) then return end

local has_words_before = function()
  local line, col = unpack(vim.api.nvim_win_get_cursor(0))
  return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
end
local lspkind = require 'lspkind'
local luasnip = require 'luasnip'

-- lazy load
require("luasnip.loaders.from_vscode").lazy_load()

cmp.setup({
    snippet = {
      expand = function(args)
        luasnip.lsp_expand(args.body)
      end,
    },

    mapping = cmp.mapping.preset.insert({
        ['<C-d>'] = cmp.mapping.scroll_docs(-4),
        ['<C-f>'] = cmp.mapping.scroll_docs(-4),
        ['<C-Space>'] = cmp.mapping.complete(),
        ['<C-e>'] = cmp.mapping.close(),
        ['<CR>'] = cmp.mapping.confirm({
            behaivior = cmp.ConfirmBehavior.Replace,
            select = true
        }),
        ["<Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then
              luasnip.expand_or_jump()
            elseif has_words_before() then
              cmp.complete()
            else
              fallback()
            end
        end, { "i", "s" }),
        ["<S-Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
              luasnip.jump(-1)
            else
              fallback()
            end
        end, { "i", "s" })
    }),
    sources = cmp.config.sources({
        {name = 'nvim_lsp'},
        {name = 'buffer'},
        {name = 'path'},

    }),
    formatting = {
      format = lspkind.cmp_format({mode = 'symbol', maxwidth = 50})
    }
})

local status, config = pcall(require, "lspkind")
if (not status) then return end

config.init({
    mode='symbol',
})

local status, config = pcall(require, "lualine")
if (not status) then return end

config.setup{
  options = {
    theme = 'tokyonight'
  }
}

local status, config = pcall(require, "prettier")
if (not status) then return end

config.setup {
  bin = 'prettierd',
  filetypes = {
    "css",
    "javascript",
    "javascriptreact",
    "typescript",
    "typescriptreact",
    "json",
    "scss",
    "less"
  }
}

local status, config = pcall(require, "telescope")
if (not status) then return end

local actions = require('telescope.actions')

config.setup {
  defaults = {
    mappings = {
      n = {
        ["q"] = actions.close
      },
    },
  },
  extensions = {
    file_browser = {
      theme = "dropdown",
      -- disables netrw and use telescope-file-browser in its place
      hijack_netrw = true,
    },
  },
}

config.load_extension("file_browser")

local status, config = pcall(require, "nvim-treesitter.configs")
if (not status) then return end

config.setup {
  autotag = {
    enable = true
  },
  highlight = {
    enable = true,
    disable = {},
  },
  indent = {
    enable = true,
    disable = {},
  },
  ensure_installed = {
    "tsx",
    "toml",
    "php",
    "json",
    "yaml",
    "css",
    "html",
    "lua",
    "rust"
  },
  autotag = {
    enable = true,
  },
}

local parser_config = require "nvim-treesitter.parsers".get_parser_configs()
parser_config.tsx.filetype_to_parsername = { "javascript", "typescript.tsx" }

local status, config = pcall(require, "which-key")
if(not status) then return end

config.setup{
  spelling = {enabled = true}
}

config.register(
  {
  f = {'<cmd>Telescope find_files<cr>', 'Find files'},
  r = {'<cmd>Telescope live_grep<cr>', 'Grep'},
  h = {'<cmd>Telescope help_tags<cr>', 'Help tags'},
  j = {'<cmd>Migemo<cr>', 'search Japanese text'},
  b = {
    name = 'buffer',
    b = {"<cmd>Telescope buffers<cr>", "Buffer list"},
    p = {"<cmd>bp<cr>", "Prev Buffer"},
    n = {"<cmd>bn<cr>", "Next Buffer"},
    d = {"<cmd>Bdelete<cr>", "Delete buffer"}
  },
  g = {
    name = 'LSP functions',
    g = {'<cmd>Lspsaga lsp_finder<cr>', 'LSP find file'},
    f = {vim.lsp.buf.formatting_seq_sync(), 'LSP format'},
    n = {'<cmd>Lspsaga diagnostic_jump_next<cr>', 'next diagnostic'},
    p = {'<cmd>Lspsaga diagnostic_jump_prev<cr>', 'prev diagnostic'},
    d = {'<cmd>Lspsaga preview_definition<cr>', 'preview definition'},
    D = {vim.lsp.buf.definition(), 'jump to definition'},
    a = {'<cmd>Lspsaga code_action<cr>', 'code action'},
    k = {'<cmd>Lspsaga hover_doc<cr>', 'documentation'},
    K = {'<cmd>Lspsaga signature_help<cr>', 'signature help'},
    i = {vim.lsp.buf.implementation(), 'list implementation'},
    r = {'<cmd>Lspsaga rename<cr>', 'rename'}
  },
  s = {'<cmd>Neogit kind=split<cr>', 'Git'},
  t = {'<cmd>terminal<cr>', 'Open Terminal'},
  e = {'<cmd>e .<cr>', 'edit'}
  },
  {prefix = "<leader>"}
)

vim.g.migemodict='/opt/homebrew/Cellar/cmigemo/20110227/share/migemo/utf-8/migemo-dict'