path: root/lua/inbox/indexers/notmuch.lua

local Job = require("plenary.job")
local Path = require("plenary.path")
local utils = require("inbox.utils")

---@class inbox.Indexer.Notmuch.Config
local default_config = {
	database_dir = Path:new(vim.env.XDG_DATA_HOME, "mail").filename,
	map_tag_signs = {},
}

---@class inbox.Indexer.Notmuch: inbox.Indexer, inbox.Indexer.Notmuch.Config
---@field _cache table<string, inbox.Notmuch.Entry>
---@field cache? fun(id: string): inbox.Notmuch.Entry?
---@field flatten_parts? fun(part: inbox.EntryPart, parts: inbox.EntryPart[]?): inbox.EntryPart[]
---@field show_id? fun(id: string): inbox.Notmuch.Entry
---@field parse_tags? fun(tags: string[]): string[]
---@field summarize? fun(item: inbox.Notmuch.SearchResult): inbox.Summary

---@class inbox.Notmuch.SearchResult
---@field authors string | string[]
---@field date_relative string
---@field matched integer
---@field query string[]
---@field subject string | string[]
---@field tags string[]
---@field thread integer
---@field timestamp integer
---@field total integer

---@class inbox.Notmuch.Entry
---@field id string
---@field filename string[]
---@field timestamp integer
---@field date_relative string?
---@field tags string[]
---@field duplicate integer
---@field body inbox.EntryPart[]
---@field crypto table
---@field headers inbox.Headers
---@field parts  inbox.EntryPart

---@type inbox.Indexer.Notmuch
local M = {
	_cache = {},
}

function M.cache(id)
	if M._cache[id] == nil then
		M._cache[id] = M.show_id(id)
	end

	return M._cache[id]
end

function M.available()
	return vim.fn.executable("notmuch") == 1
end

function M.index(maildir, callback, opts)
	opts = opts or {}

	local json = ""
	local job = Job:new({
		command = "notmuch",
		args = { "search", "--format=json" },
		on_stdout = vim.schedule_wrap(function(_, stdout)
			json = json .. stdout
		end),
		on_exit = vim.schedule_wrap(function()
			---@type inbox.Notmuch.SearchResult[]
			local results = utils.json_decode(json)

			---@type inbox.Summary[]
			local entries = {}
			local ids = {}
			local signs = {}

			for lnum, result in ipairs(results) do
				ids[lnum] = (result.query[1]:gsub("^id:", ""))
				entries[lnum] = M.summarize(result)
				for _, sign in pairs(M.parse_tags(result.tags)) do
					table.insert(signs, { sign, lnum })
				end
			end

			callback(ids, entries, signs)
		end),
	})

	local folder = Path:new(maildir):make_relative(M.database_dir)
	table.insert(job.args, ("folder:%s"):format(folder))

	-- TODO: handle different operators i.e. "not", "or", etc.
	for name, value in pairs(opts) do
		table.insert(job.args, "and")
		table.insert(job.args, ("%s:%s"):format(name, value))
	end

	job:start()
end

---@private
---@param tags string[]
---@return string[] parsed tags
function M.parse_tags(tags)
	local signs = {}
	for _, tag in ipairs(tags) do
		if M.map_tag_signs[tag] ~= nil then
			table.insert(signs, M.map_tag_signs[tag])
		else
			table.insert(signs, tag)
		end
	end
	return signs
end

---@private
---@param item inbox.Notmuch.SearchResult
---@return inbox.Summary summary
function M.summarize(item)
	local date = item.date_relative

	local from
	if type(item.authors) == "table" then
		from = item.authors[1] --[[@as string]]
	else
		from = item.authors --[[@as string]]
	end

	local subject
	if type(item.subject) == "table" then
		subject = item.subject[1] --[[@as string]]
	else
		subject = item.subject --[[@as string]]
	end
	subject = subject:gsub("\r?\n", " ")

	return {
		date,
		from,
		subject,
	}
end

---@private
---@param id string
---@return inbox.Notmuch.Entry?
function M.show_id(id)
	if id == nil then
		vim.notify(("Failed to find entry with id: '%s'"):format(id), vim.log.levels.ERROR)
		return nil
	end

	local job = Job:new({
		command = "notmuch",
		args = { "show", "--format=json", ("id:%s"):format(id) },
	})

	local stdout = job:sync()

	local entry = utils.json_decode(table.concat(stdout, "\n"))
	while not vim.tbl_isempty(entry) and vim.tbl_islist(entry) do
		entry = entry[1] --[[@as inbox.Notmuch.Entry]]
	end

	entry.tags = M.parse_tags(entry.tags)
	entry.parts = M.flatten_parts(entry.body[1])

	return entry
end

---@param id string
---@return inbox.Entry?
function M.get_entry(id)
	local entry = M.cache(id)
	if entry == nil then
		return nil
	end

	local parts = vim.tbl_map(function(part)
		return part["content-type"]
	end, entry.parts)

	---@type inbox.Entry
	return {
		id = entry.id,
		timestamp = entry.timestamp,
		filename = entry.filename[1],
		tags = entry.tags,
		parts = parts,
		headers = entry.headers,
	}
end

function M.flatten_parts(part, parts)
	if parts == nil then
		parts = {}
	end

	if type(part.content) == "table" then
		for _, p in
			pairs(part.content --[[@as inbox.EntryPart[] ]])
		do
			parts = M.flatten_parts(p, parts)
		end
	else
		table.insert(parts, part)
	end

	return parts
end

function M.get_part(id, content_type, callback)
	local entry = M.cache(id)

	if entry == nil then
		vim.notify(("Failed to get entry with id: %s"):format(id), vim.log.levels.ERROR)
		return nil
	end

	---@type inbox.EntryPart?
	local part
	if content_type == nil then
		for _, p in pairs(entry.parts) do
			if part == nil or p.id < part.id then
				part = p
			end
		end
	else
		for _, p in pairs(entry.parts) do
			if p["content-type"] ~= content_type then
				part = p
				break
			end
		end
	end

	if part == nil then
		vim.notify(("Failed to find message part for entry id: %s"):format(id), vim.log.levels.ERROR)
		return nil
	end

	local stdout = {}
	local job = Job:new({
		command = "notmuch",
		args = { "show", ("--part=%s"):format(part.id), ("id:%s"):format(entry.id) },
		on_stdout = vim.schedule_wrap(function(_, data)
			table.insert(stdout, data)
		end),
		on_exit = vim.schedule_wrap(function()
			callback(part["content-type"], stdout)
		end),
	})

	job:start()
end

---@param opts inbox.Indexer.Notmuch.Config
function M.setup(opts)
	local config = vim.tbl_deep_extend("keep", opts or {}, default_config)

	for k, v in pairs(config) do
		M[k] = v
	end
end

return M