#ifndef CONFIG_H
#define CONFIG_H

#include "lsp/lsp.h"
#include "pch.h"
#include "ts/decl.h"

static const std::unordered_map<uint8_t, LSP> kLsps = {
    {1,
     {"clangd",
      {
          "clangd",
          "--background-index",
          "--clang-tidy",
          "--completion-style=detailed",
          "--header-insertion=never",
          "--pch-storage=memory",
          "--limit-results=50",
          "--log=error",
          nullptr,
      }}},
    {2,
     {"ruby-lsp",
      {
          "ruby-lsp",
          nullptr,
      }}},
    {3,
     {"solargraph",
      {
          "solargraph",
          "stdio",
          nullptr,
      }}},
    {4,
     {"bash-language-server",
      {
          "bash-language-server",
          "start",
          nullptr,
      }}},
    {5,
     {"vscode-css-language-server",
      {
          "vscode-css-language-server",
          "--stdio",
          nullptr,
      }}},
    {6,
     {"vscode-json-language-server",
      {
          "vscode-json-language-server",
          "--stdio",
          nullptr,
      }}},
    {7,
     {"fish-lsp",
      {
          "fish-lsp",
          "start",
          nullptr,
      }}},
    {8,
     {"gopls",
      {
          "gopls",
          "serve",
          nullptr,
      }}},
    {9,
     {"haskell-language-server",
      {
          "haskell-language-server",
          "lsp",
          nullptr,
      }}},
    {10,
     {"emmet-ls",
      {
          "emmet-ls",
          "--stdio",
          nullptr,
      }}},
    {11,
     {"typescript-language-server",
      {
          "typescript-language-server",
          "--stdio",
          nullptr,
      }}},
    {12,
     {"lua-language-server",
      {
          "lua-language-server",
          nullptr,
      }}},
    {13,
     {"pyright-langserver",
      {
          "pyright-langserver",
          "--stdio",
          nullptr,
      }}},
    {14,
     {"rust-analyzer",
      {
          "rust-analyzer",
          nullptr,
      }}},
    {15,
     {"intelephense",
      {
          "intelephense",
          "--stdio",
          nullptr,
      }}},
    {16,
     {"marksman",
      {
          "marksman",
          "server",
          nullptr,
      }}},
    {17,
     {"nginx-language-server",
      {
          "nginx-language-server",
          nullptr,
      }}},
    {18,
     {"taplo",
      {
          "taplo",
          "lsp",
          "stdio",
          nullptr,
      }}},
    {19,
     {"yaml-language-server",
      {
          "yaml-language-server",
          "--stdio",
          nullptr,
      }}},
    {20,
     {"sqls",
      {
          "sqls",
          "serve",
          nullptr,
      }}},
    {21,
     {"make-language-server",
      {
          "make-language-server",
          nullptr,
      }}},
    {22,
     {"sql-language-server",
      {
          "sql-language-server",
          "up",
          "--method",
          "stdio",
          nullptr,
      }}},
};

static const std::unordered_map<std::string, Language> kLanguages = {
    {"bash", {"bash", LANG(bash), 4}},
    {"c", {"c", LANG(cpp), 1}},
    {"cpp", {"cpp", LANG(cpp), 1}},
    {"h", {"h", LANG(cpp), 1}},
    {"css", {"css", LANG(css), 5}},
    {"fish", {"fish", LANG(fish), 7}},
    {"go", {"go", LANG(go), 8}},
    {"gomod", {"gomod", LANG(gomod), 8}},
    {"haskell", {"haskell", LANG(haskell), 9}},
    {"html", {"html", LANG(html), 10}},
    {"javascript", {"javascript", LANG(javascript), 11}},
    {"typescript", {"typescript", LANG(tsx), 11}},
    {"json", {"json", LANG(json), 6}},
    {"jsonc", {"jsonc", LANG(json), 6}},
    {"erb", {"erb", LANG(embedded_template), 10}},
    {"ruby", {"ruby", LANG(ruby), 3}},
    {"lua", {"lua", LANG(lua), 12}},
    {"python", {"python", LANG(python), 13}},
    {"rust", {"rust", LANG(rust), 14}},
    {"php", {"php", LANG(php), 15}},
    {"markdown", {"markdown", LANG(markdown), 16}},
    {"markdown_inline", {"markdown_inline", LANG(markdown_inline), 16}},
    {"nginx", {"nginx", LANG(nginx), 17}},
    {"toml", {"toml", LANG(toml), 18}},
    {"yaml", {"yaml", LANG(yaml), 19}},
    {"sql", {"sql", LANG(sql), 20}}, // Can use `22` for more accuracy but need
                                     // config to connect to database
    {"make", {"make", LANG(make), 21}},
    {"gdscript", {"gdscript", LANG(gdscript)}}, // TODO: connect to godot
    {"man", {"man", LANG(man)}},
    {"diff", {"diff", LANG(diff)}},
    {"gitattributes", {"gitattributes", LANG(gitattributes)}},
    {"gitignore", {"gitignore", LANG(gitignore)}},
    {"query", {"query", LANG(query)}},
    {"regex", {"regex", LANG(regex)}},
    {"ini", {"ini", LANG(ini)}},
};

static const std::unordered_map<std::string, std::string> kExtToLang = {
    {"sh", "bash"},
    {"bash", "bash"},
    {"c", "c"},
    {"cpp", "cpp"},
    {"cxx", "cpp"},
    {"cc", "cpp"},
    {"hpp", "h"},
    {"hh", "h"},
    {"hxx", "h"},
    {"h", "h"},
    {"css", "css"},
    {"fish", "fish"},
    {"go", "go"},
    {"hs", "haskell"},
    {"html", "html"},
    {"htm", "html"},
    {"js", "javascript"},
    {"jsx", "javascript"},
    {"ts", "typescript"},
    {"tsx", "typescript"},
    {"json", "json"},
    {"jsonc", "jsonc"},
    {"lua", "lua"},
    {"make", "make"},
    {"mk", "make"},
    {"makefile", "make"},
    {"man", "man"},
    {"py", "python"},
    {"rb", "ruby"},
    {"rs", "rust"},
    {"diff", "diff"},
    {"patch", "diff"},
    {"erb", "erb"},
    {"gd", "gdscript"},
    {"gitattributes", "gitattributes"},
    {"gitignore", "gitignore"},
    {"mod", "gomod"},
    {"ini", "ini"},
    {"gitmodules", "ini"},
    {"md", "markdown"},
    {"markdown", "markdown"},
    {"conf", "nginx"},
    {"php", "php"},
    {"scm", "query"},
    {"regex", "regex"},
    {"sql", "sql"},
    {"toml", "toml"},
    {"yaml", "yaml"},
    {"yml", "yaml"},
};

static const std::unordered_map<std::string, std::string> kMimeToLang = {
    {"text/x-c", "c"},
    {"text/x-c++", "cpp"},
    {"text/x-shellscript", "bash"},
    {"application/json", "json"},
    {"text/javascript", "javascript"},
    {"text/html", "html"},
    {"text/css", "css"},
    {"text/x-python", "python"},
    {"text/x-ruby", "ruby"},
    {"text/x-go", "go"},
    {"text/x-haskell", "haskell"},
    {"text/x-rust", "rust"},
    {"text/x-lua", "lua"},
    {"text/x-diff", "diff"},
    {"text/x-gdscript", "gdscript"},
    {"text/x-gitattributes", "gitattributes"},
    {"text/x-gitignore", "gitignore"},
    {"text/x-gomod", "gomod"},
    {"text/x-ini", "ini"},
    {"text/markdown", "markdown"},
    {"text/x-nginx-conf", "nginx"},
    {"application/x-php", "php"},
    {"text/x-tree-sitter-query", "query"},
    {"text/x-regex", "regex"},
    {"text/x-sql", "sql"},
    {"text/x-toml", "toml"},
    {"text/x-yaml", "yaml"},
    {"text/x-man", "man"},
};

#endif