use("zk-org/zk-nvim")

{
  "zk-org/zk-nvim",
  config = function()
    require("zk").setup({
      -- See Setup section below
    })
  end
}

return {
  "zk-org/zk-nvim",
  dependencies = {
    'akinsho/bufferline.nvim', -- Optional: If you use bufferline integration
  },
  config = function()
    require("zk").setup({
      -- Can be "telescope", "fzf", "fzf_lua", "minipick", "snacks_picker",
      -- or select" (`vim.ui.select`).
      picker = "select",

      lsp = {
        -- `config` is passed to `vim.lsp.start(config)`
        config = {
          name = "zk",
          cmd = { "zk", "lsp" },
          filetypes = { "markdown" },
          -- on_attach = ...
          -- etc, see `:h vim.lsp.start()`
        },

        -- automatically attach buffers in a zk notebook that match the given filetypes
        auto_attach = {
          enabled = true,
        },
      },
      select = { "absPath", "filename", "filenameStem", "title" },
      integrations = {
        bufferline = {
          enabled = true,
          override = true,
          formatter = function(note)
            return note.title or note.filenameStem or note.filename
          end,
        },
      },
      update = { -- See `## Update Options`
        enabled = false,
        triggers = {},
      },
    })
  end,
}

require("zk").setup({
    picker_options = {
        telescope = require("telescope.themes").get_ivy(),

        -- or if you use snacks picker

        snacks_picker = {
            layout = {
                preset = "ivy",
            }
        },
    },
    ...
})

require("zk.commands").get("ZkNew")({ dir = "daily" })
require("zk.commands").get("ZkNewPrompt")({ title = vim.fn.input('Title: ') })
require("zk.commands").get("ZkNotes")({ createdAfter = "3 days ago", tags = { "work" } })
require("zk.commands").get("ZkNewFromTitleSelection")()

---A thin wrapper around `vim.api.nvim_add_user_command` which parses the `params.args` of the command as a Lua table and passes it on to `fn`.
---@param name string
---@param fn function
---@param opts? table {needs_selection} makes sure the command is called with a range
---@see vim.api.nvim_add_user_command
require("zk.commands").add(name, fn, opts)

local zk = require("zk")
local commands = require("zk.commands")

commands.add("ZkOrphans", function(options)
  options = vim.tbl_extend("force", { orphan = true }, options or {})
  zk.edit(options, { title = "Zk Orphans" })
end)

local zk = require("zk")
local commands = require("zk.commands")

local function make_edit_fn(defaults, picker_options)
  return function(options)
    options = vim.tbl_extend("force", defaults, options or {})
    zk.edit(options, picker_options)
  end
end

commands.add("ZkOrphans", make_edit_fn({ orphan = true }, { title = "Zk Orphans" }))
commands.add("ZkRecents", make_edit_fn({ createdAfter = "2 weeks ago" }, { title = "Zk Recents" }))

---Cd into the notebook root
--
---@param options? table
require("zk").cd(options)

---Creates and edits a new note
--
---@param options? table additional options
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zknew
require("zk").new(options)

---Prompt for a new note with groups, paths, templates, and directories selections.
--
---@param options? table
---@param cb fun(options: table?, toml: table?)
require("zk").new_prompt(options, cb)

---Indexes the notebook
--
---@param options? table additional options
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zkindex
require("zk").index(options)

---Opens a notes picker, and calls the callback with the selection
--
---@param options? table additional options
---@param picker_options? table options for the picker
---@param cb function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zklist
---@see zk.ui.pick_notes
require("zk").pick_notes(options, picker_options, cb)

---Opens a notes grep picker, and calls the callback with the selection
--
---@param options? table additional options
---@param picker_options? table options for the picker
---@param cb function
---@see zk.ui.grep_notes
require("zk").grep_notes(options, picker_options, cb)

---Opens a tags picker, and calls the callback with the selection
--
---@param options? table additional options
---@param picker_options? table options for the picker
---@param cb function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zktaglist
---@see zk.ui.pick_tags
require("zk").pick_tags(options, picker_options, cb)

---Opens a notes picker, and edits the selected notes
--
---@param options? table additional options
---@param picker_options? table options for the picker
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zklist
---@see zk.ui.pick_notes
require("zk").edit(options, picker_options)

---@param path? string path to explicitly specify the notebook
---@param options? table additional options
---@param cb function callback function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zkindex
require("zk.api").index(path, options, function(err, stats)
  -- do something with the stats
end)

---@param path? string path to explicitly specify the notebook
---@param options? table additional options
---@param cb function callback function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zknew
require("zk.api").new(path, options, function(err, res)
  file_path = res.path
  -- do something with the new file path
end)

---@param path? string path to explicitly specify the notebook
---@param options table additional options
---@param cb function callback function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zklist
require("zk.api").list(path, options, function(err, notes)
  -- do something with the notes
end)

---@param path? string path to explicitly specify the notebook
---@param options? table additional options
---@param cb function callback function
---@see https://github.com/zk-org/zk/blob/main/docs/tips/editors-integration.md#zktaglist
require("zk.api").tag.list(path, options, function(err, tags)
  -- do something with the tags
end)

---Opens a notes picker
--
---@param notes list
---@param options? table containing {picker}, {title}, {multi_select} keys
---@param cb function
require("zk.ui").pick_notes(notes, options, cb)

---Opens a grep picker
--
---@param options? table containing {notebook_path}, {picker}, {multi_select} keys
---@param picker_options? table
---@param cb function

require("zk.ui").grep_notes(options, picker_options, cb)

---Opens a tags picker
--
---@param tags list
---@param options? table containing {picker}, {title}, {multi_select} keys
---@param cb function
require("zk.ui").pick_tags(tags, options, cb)

---To be used in zk.api.list as the `selection` in the additional options table
--
---@param options table the same options that are use for pick_notes
---@return table api selection
require("zk.ui").get_pick_notes_list_api_selection(options)

local opts = { noremap=true, silent=false }

-- Create a new note after asking for its title.
vim.api.nvim_set_keymap("n", "<leader>zn", "<Cmd>ZkNew { title = vim.fn.input('Title: ') }<CR>", opts)

-- Open notes.
vim.api.nvim_set_keymap("n", "<leader>zo", "<Cmd>ZkNotes { sort = { 'modified' } }<CR>", opts)
-- Grep notes.
vim.api.nvim_set_keymap("n", "<leader>zg", "<Cmd>ZkGrep<CR>", opts)
-- Open notes associated with the selected tags.
vim.api.nvim_set_keymap("n", "<leader>zt", "<Cmd>ZkTags<CR>", opts)

-- Search for the notes matching a given query.
vim.api.nvim_set_keymap("n", "<leader>zf", "<Cmd>ZkNotes { sort = { 'modified' }, match = { vim.fn.input('Search: ') } }<CR>", opts)
-- Search for the notes matching the current visual selection.
vim.api.nvim_set_keymap("v", "<leader>zf", ":'<,'>ZkMatch<CR>", opts)

-- Toggle auto update
vim.api.nvim_set_keymap("n", "<leader>zu", ":ZkUpdateToggle<CR>", opts)

-- Open notes in another notebook.
vim.api.nvim_set_keymap("n", "<leader>zO", "<Cmd>ZkNotes { notebook_path = '/path/to/another/notebook' }<CR>", opts)
-- Open notes associated with a specific tag, in another notebook.
vim.api.nvim_set_keymap("n", "<leader>zT", "<Cmd>ZkNotes { notebook_path = '/path/to/another/notebook', tags = { 'todo' } }<CR>", opts)
-- Grep notes in another notebook.
vim.api.nvim_set_keymap("n", "<leader>zG", "<Cmd>ZkGrep { notebook_path = '/path/to/another/notebook' }<CR>", opts)

-- Add the key mappings only for Markdown files in a zk notebook.
if require("zk.util").notebook_root(vim.fn.expand('%:p')) ~= nil then
  local function map(...) vim.api.nvim_buf_set_keymap(0, ...) end
  local opts = { noremap=true, silent=false }

  -- Open the link under the caret.
  map("n", "<CR>", "<Cmd>lua vim.lsp.buf.definition()<CR>", opts)

  -- Create a new note after asking for its title.
  -- This overrides the global `<leader>zn` mapping to create the note in the same directory as the current buffer.
  map("n", "<leader>zn", "<Cmd>ZkNew { dir = vim.fn.expand('%:p:h'), title = vim.fn.input('Title: ') }<CR>", opts)
  -- Create a new note in the same directory as the current buffer, using the current selection for title.
  map("v", "<leader>znt", ":'<,'>ZkNewFromTitleSelection { dir = vim.fn.expand('%:p:h') }<CR>", opts)
  -- Create a new note in the same directory as the current buffer, using the current selection for note content and asking for its title.
  map("v", "<leader>znc", ":'<,'>ZkNewFromContentSelection { dir = vim.fn.expand('%:p:h'), title = vim.fn.input('Title: ') }<CR>", opts)

  -- Open notes linking to the current buffer.
  map("n", "<leader>zb", "<Cmd>ZkBacklinks<CR>", opts)
  -- Alternative for backlinks using pure LSP and showing the source context.
  --map('n', '<leader>zb', '<Cmd>lua vim.lsp.buf.references()<CR>', opts)
  -- Open notes linked by the current buffer.
  map("n", "<leader>zl", "<Cmd>ZkLinks<CR>", opts)

  -- Preview a linked note.
  map("n", "K", "<Cmd>lua vim.lsp.buf.hover()<CR>", opts)
  -- Open the code actions for a visual selection.
  map("v", "<leader>za", ":'<,'>lua vim.lsp.buf.range_code_action()<CR>", opts)
end

require("zk").setup({
  ...
  -- The fields to fetch
  select = { "absPath", "filename", "filenameStem", "title" },
  -- Available fields are:
  --   filename, filenameStem, path, absPath, title, lead, body, snippets,
  --   rawContent, wordCount, tags, metadata, created, modified, checksum
  -- See https://zk-org.github.io/zk/tips/editors-integration.html#zk-list

  integrations = {
    bufferline = {
      -- Enable/Disable bufferline integration
      enabled = false,

      -- How to apply the formatter
      override = true,
      -- true  : Completely replace bufferline's `name_formatter` using the
      --         formatter function defined below.
      -- false : Do not replace it automatically. You must configure bufferline's
      --         `name_formatter` yourself, which allows more flexibility.
      --         (e.g. combining zk's formatter logic with your own custom rules.)

      ---buffer name formatter
      ---@param note table
      ---@return string?
      formatter = function(note)
        return note.title or note.filenameStem or note.filename
      end,
      -- Only the fields set by `select` option above are available.
    },
  },
  ...
})

require("zk").setup({
  ...
  update = {
    enabled = true, -- true: enable auto content updating
    triggers = {
      on_save = { -- trigger name (as you like)
        enabled = true, -- true: enable auto content updating for this trigger
        event = "BufWritePre", -- attach for this vim event
        rules = {
          -- Add your rules here
        },
      },
      -- Add your triggers here
    },
  },
  ...
})

require("zk").setup({
  ...
  integrations = {
    select = { "absPath", "filename", "filenameStem", "title", "tags", "metadata" }, -- Add tags and metadata
    bufferline = {
      enabled = true,
      override = true,
      formatter = function(note)
        local tags = note.tags or {}
        local metadata = note.metadata or {}
        if vim.tbl_contains(tags, "book") then
          local title = metadata.title or '[NO TITLE]'
          local author = metadata.author or '[NO AUTHOR]'
          local published = metadata.published or '?'
          return string.format("%s / %s (%s)", title, author, published)
        end
        return note.title or note.filenameStem or note.filename
      end,
    },
  },
  ...
})

require("zk").setup({
  ...
  select = { "absPath", "filename", "filenameStem", "title", "tags", "metadata" }, -- Add tags and metadata
  integrations = {
    bufferline = {
      enabled = true,
      override = false, -- Not override
      formatter = function(note)
        return note.title or note.filenameStem or note.filename
      end,
    },
  },
  ...
})

require("bufferline").setup({
  options = {
    ---@param buf table
    ---@return string?
    name_formatter = function(buf)
      local ext = vim.fn.fnamemodify(buf.name, ":e")
      if ext == "md" then
        return require("zk.integrations.bufferline").name_formatter(buf) -- Call zk-nvim's `name_formatter` (Above `formatter` is internally used in refresh())
      elseif ext == "org" then
        return buf.name -- Add extra modifications here
      elseif ext == "norg" then
        return buf.name -- Add extra modifications here
      end
    end,
  },
})

rules = {
  ['Update datetime (`modified` as 2025-01-01 00:00:00)'] = {
    enabled = true, -- true: enable this rule
    scope = 'line',
    pattern = "^(modified *: *)(%d%d%d%d%-%d%d%-%d%d %d%d:%d%d:%d%d)$", -- line matching pattern
    ---@param captures table
    ---@param line string
    ---@return string
    format = function(captures, line) -- formatter for captured items
      captures[2] = os.date("%Y-%m-%d %H:%M:%S")
      return table.concat(captures)
    end,
    in_yaml = true, -- true: only matches in YAML frontmatter / false: only matches in content
    notebook_paths = {}, -- valie notebook_paths (default: allows all notebook_paths)
    dirs = {}, -- valid directories (default: allows all dirctories)
  },
},

rules = {
  ['Sort tags in YAML'] = {
    enabled = true,
    scope = 'line',
    pattern = '^(tags *: *)%[(.*)%]$',
    ---@param captures table
    ---@param line string
    ---@return string
    format = function(captures, line)
      local tags = captures[2]
      if tags then
        tags = string.gsub(tags, ' ', '')
        local tbl_tags = vim.fn.split(tags, ',')
        table.sort(tbl_tags, function(a, b) return a < b end)
        captures[2] = '[ ' .. table.concat(tbl_tags, ', ') .. ' ]'
      end
      return table.concat(captures)
    end,
    in_yaml = true,
    notebook_paths = {},
    dirs = {},
  },
},

rules = {
  ['Update tags style in YAML (block -> flow)'] = {
    enabled = true,
    scope = 'file',
    ---@param lines string[]
    ---@return string[]? lines
    format = function(lines) -- formatter for file
      local YAML_DELIMITER = '^%-%-%-$'
      local tag_key
      local tags = {}
      local in_yaml = false
      local lnum_start, lnum_end
      for i, line in ipairs(lines) do
        if line:match(YAML_DELIMITER) then in_yaml = not in_yaml end
        if not in_yaml then break end
        if in_yaml then
          if not lnum_start then
            tag_key = line:match('^(tags *:)$') -- Find "tags :"
            if tag_key then lnum_start = i end
          else
            local tag = line:match(' *%- (.*)$') -- Find "  - tag1"
            if tag then
              table.insert(tags, tag)
            else
              lnum_end = i - 1 -- End of the tags block
              break
            end
          end
        end
      end
      if #tags > 0 then
        for i = lnum_end, lnum_start, -1 do -- Remove block style tags
          table.remove(lines, i)
        end
        -- table.sort(tags, function(a, b) return a < b end) -- Sort if you need
        table.insert(lines, lnum_start, tag_key .. ' [ ' .. table.concat(tags, ', ') .. ' ]') -- Add tags in flow style
      end
      return lines
    end,
    notebook_paths = {},
    dirs = {},
  },
},

rules = {
  ['YAML title updates Heading'] = {
    enabled = true,
    scope = 'file',
    ---@param lines string[]
    ---@return string[]? lines
    format = function(lines) -- formatter for file
      local YAML_DELIMITER = '^%-%-%-$'
      local new_title
      local in_yaml = false
      for i, line in ipairs(lines) do
        if line:match(YAML_DELIMITER) then in_yaml = not in_yaml end
        if in_yaml then
          new_title = not new_title and line:match('^title *: *(.*)$') or new_title
        else
          local marker, heading = line:match('^(#+) *(.*)$')
          if marker and heading and new_title then
            lines[i] = string.format('%s %s', marker, new_title)
            break
          end
        end
      end
      return lines
    end,
    notebook_paths = {},
    dirs = {},
  },
},

require("nvim-treesitter.configs").setup({
  -- ...
  highlight = {
    -- ...
    additional_vim_regex_highlighting = { "markdown" }
  },
})

-- Redirect Neovim runtime paths to /tmp
vim.env.XDG_CONFIG_HOME = "/tmp/nvim/config"
vim.env.XDG_DATA_HOME = "/tmp/nvim/data"
vim.env.XDG_STATE_HOME = "/tmp/nvim/state"
vim.env.XDG_CACHE_HOME = "/tmp/nvim/cache"

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

-- Make sure to setup `mapleader` and `maplocalleader` before
-- loading lazy.nvim so that mappings are correct.
-- This is also a good place to setup other settings (vim.opt)
vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- Setup lazy.nvim
require("lazy").setup({
	{
		"neovim/nvim-lspconfig",
	},
	{
		"zk-org/zk-nvim",
		config = function()
			require("zk").setup()
		end,
	},
	-- automatically check for plugin updates
	checker = { enabled = true },
})

require("telescope").load_extension("zk")