local vim = vim
local util = vim.lsp.util
local symbols = require('symbols')

local D = {}

-- needs plenary
local reload = require('plenary.reload').reload_module

function D.R(name)
    reload(name)
    return require(name)
end

local function setup_commands()
    vim.cmd("command! " .. "DSymbolsOutline " ..
                ":lua require'symbols-outline'.R('symbols-outline').toggle_outline()")
    vim.cmd("command! " .. "SymbolsOutline " ..
                ":lua require'symbols-outline'.toggle_outline()")
end

local function setup_autocmd()
    vim.cmd(
        "au InsertLeave,BufEnter,BufWinEnter,TabEnter,BufWritePost * :lua require('symbols-outline')._refresh()")
    vim.cmd "au BufDelete * lua require'symbols-outline'._prevent_buffer_override()"
    if D.opts.highlight_hovered_item then
        vim.cmd(
            "autocmd CursorHold * :lua require('symbols-outline')._highlight_current_item()")
    end
end

local function getParams()
    return {textDocument = vim.lsp.util.make_text_document_params()}
end

local function get_hover_params(node, winnr)
    local bufnr = vim.api.nvim_win_get_buf(winnr)
    local fn = "file://" .. vim.api.nvim_buf_get_name(bufnr)

    return {
        textDocument = {uri = fn},
        position = {line = node.line, character = node.character},
        bufnr = bufnr
    }
end

-------------------------
-- STATE
-------------------------
D.state = {
    outline_items = {},
    flattened_outline_items = {},
    outline_win = nil,
    outline_buf = nil,
    code_win = nil
}

local function wipe_state()
    D.state = {outline_items = {}, flattened_outline_items = {}}
end

-------------------------
-- UI STUFF
-------------------------
local markers = {
    bottom = "└",
    middle = "├",
    vertical = "│",
    horizontal = "─"
}

local hovered_hl_ns = vim.api.nvim_create_namespace("hovered_item")

local function highlight_text(name, text, hl_group)
    vim.cmd(string.format("syn match %s /%s/", name, text))
    vim.cmd(string.format("hi def link %s %s", name, hl_group))
end

local function setup_highlights()
    -- markers
    --
    highlight_text("marker_middle", markers.middle, "Comment")
    highlight_text("marker_vertical", markers.vertical, "Comment")
    highlight_text("markers_horizontal", markers.horizontal, "Comment")
    highlight_text("markers_bottom", markers.bottom, "Comment")

    for _, value in ipairs(symbols.kinds) do
        local symbol = symbols[value]
        highlight_text(value, symbol.icon, symbol.hl)
    end
    vim.cmd('hi FocusedSymbol guibg=#e50050')
end

----------------------------
-- PARSING AND WRITING STUFF
----------------------------

-- copies an array and returns it because lua usually does references
local function array_copy(t)
    local ret = {}
    for _, value in ipairs(t) do table.insert(ret, value) end
    return ret
end

-- parses result into a neat table
local function parse(result, depth, heirarchy)
    local ret = {}

    for index, value in pairs(result) do
        -- the heirarchy is basically a table of booleans which tells whether
        -- the parent was the last in its group or not
        local hir = heirarchy or {}
        -- how many parents this node has, 1 is the lowest value because its
        -- easier to work it
        local level = depth or 1
        -- whether this node is the last in its group
        local isLast = index == #result

        local children = nil
        if value.children ~= nil then
            -- copy by value because we dont want it messing with the hir table
            local child_hir = array_copy(hir)
            table.insert(child_hir, isLast)
            children = parse(value.children, level + 1, child_hir)
        end

        table.insert(ret, {
            deprecated = value.deprecated,
            kind = value.kind,
            icon = symbols.icon_from_kind(value.kind),
            name = value.name,
            detail = value.detail,
            line = value.selectionRange.start.line,
            range_start = value.range.start.line,
            range_end = value.range["end"].line,
            character = value.selectionRange.start.character,
            children = children,
            depth = level,
            isLast = isLast,
            heirarchy = hir
        });
    end
    return ret
end

local function flatten(outline_items)
    local ret = {}
    for _, value in ipairs(outline_items) do
        table.insert(ret, value)
        if value.children ~= nil then
            local inner = flatten(value.children)
            for _, value_inner in ipairs(inner) do
                table.insert(ret, value_inner)
            end
        end
    end
    return ret
end

local function table_to_str(t)
    local ret = ""
    for _, value in ipairs(t) do ret = ret .. tostring(value) end
    return ret
end

local function str_to_table(str)
    local t = {}
    for i = 1, #str do t[i] = str:sub(i, i) end
    return t
end

local function get_lines(flattened_outline_items)
    local lines = {}
    for _, value in ipairs(flattened_outline_items) do
        local line = str_to_table(string.rep(" ", value.depth))

        -- makes the guides
        for index, _ in ipairs(line) do
            -- all items start with a space (or two)
            if index == 1 then
                line[index] = " "
                -- if index is last, add a bottom marker if current item is last,
                -- else add a middle marker
            elseif index == #line then
                if value.isLast then
                    line[index] = markers.bottom
                else
                    line[index] = markers.middle
                end
                -- else if the parent was not the last in its group, add a
                -- vertical marker because there are items under us and we need
                -- to point to those
            elseif not value.heirarchy[index] then
                line[index] = markers.vertical
            end
        end

        local final_prefix = {}
        -- Add 1 space between the guides
        for _, v in ipairs(line) do
            table.insert(final_prefix, v)
            table.insert(final_prefix, " ")
        end

        table.insert(lines, table_to_str(final_prefix) .. value.icon .. " " ..
                         value.name)
    end
    return lines
end

local function get_details(outline_items, bufnr, winnr, lines)
    lines = lines or {}
    for _, value in ipairs(outline_items) do

        if value.children ~= nil then
            get_details(value.children, bufnr, winnr, lines)
        end
    end
    return lines
end

local function write_outline(bufnr, lines)
    vim.api.nvim_buf_set_option(bufnr, "modifiable", true)
    vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
    vim.api.nvim_buf_set_option(bufnr, "modifiable", false)
end

local function write_details(bufnr, lines)
    for index, value in ipairs(lines) do
        vim.api.nvim_buf_set_virtual_text(bufnr, -1, index - 1,
                                          {{value, "Comment"}}, {})
    end
end

local function clear_virt_text(bufnr)
    vim.api.nvim_buf_clear_namespace(bufnr, -1, 0, -1)
end

function D._refresh()
    if D.state.outline_buf ~= nil then
        vim.lsp.buf_request(0, "textDocument/documentSymbol", getParams(),
                            function(_, _, result)

            D.state.code_win = vim.api.nvim_get_current_win()
            D.state.outline_items = parse(result)
            D.state.flattened_outline_items = flatten(parse(result))

            local lines = get_lines(D.state.flattened_outline_items)
            write_outline(D.state.outline_buf, lines)

            clear_virt_text(D.state.outline_buf)
            local details = get_details(D.state.outline_items,
                                        D.state.outline_buf, D.state.outline_win)
            write_details(D.state.outline_buf, details)
        end)
    end
end

function D._goto_location()
    local current_line = vim.api.nvim_win_get_cursor(D.state.outline_win)[1]
    local node = D.state.flattened_outline_items[current_line]
    vim.fn.win_gotoid(D.state.code_win)
    vim.fn.cursor(node.line + 1, node.character + 1)
end

-- handler yoinked from the default implementation
function D._hover()
    local current_line = vim.api.nvim_win_get_cursor(D.state.outline_win)[1]
    local node = D.state.flattened_outline_items[current_line]

    local hover_params = get_hover_params(node, D.state.code_win)

    vim.lsp.buf_request(hover_params.bufnr, "textDocument/hover", hover_params,
                        function(_, method, result)

        util.focusable_float(method, function()
            if not (result and result.contents) then
                -- return { 'No information available' }
                return
            end

            local markdown_lines = util.convert_input_to_markdown_lines(
                                       result.contents)
            markdown_lines = util.trim_empty_lines(markdown_lines)
            if vim.tbl_isempty(markdown_lines) then
                -- return { 'No information available' }
                return
            end
            local bufnr, winnr = util.fancy_floating_markdown(markdown_lines, {
                border = {
                    {"┌", "FloatBorder"}, {"─", "FloatBorder"},
                    {"┐", "FloatBorder"}, {"│", "FloatBorder"},
                    {"┘", "FloatBorder"}, {"─", "FloatBorder"},
                    {"└", "FloatBorder"}, {"│", "FloatBorder"}
                }
            })
            util.close_preview_autocmd({
                "CursorMoved", "BufHidden", "InsertCharPre"
            }, winnr)

            return bufnr, winnr
        end)
    end)
end

function D._highlight_current_item()
    if D.state.outline_buf == nil or vim.api.nvim_get_current_buf() ==
        D.state.outline_buf then return end

    local hovered_line = vim.api.nvim_win_get_cursor(
                             vim.api.nvim_get_current_win())[1] - 1

    local nodes = {}
    for index, value in ipairs(D.state.flattened_outline_items) do
        if value.line == hovered_line or
            (hovered_line > value.range_start and hovered_line < value.range_end) then
            value.line_in_outline = index
            table.insert(nodes, value)
        end
    end

    -- clear old highlight
    vim.api.nvim_buf_clear_namespace(D.state.outline_buf, hovered_hl_ns, 0, -1)
    for _, value in ipairs(nodes) do
        vim.api.nvim_buf_add_highlight(D.state.outline_buf, hovered_hl_ns,
                                       "FocusedSymbol",
                                       value.line_in_outline - 1,
                                       value.depth * 2, -1)
        vim.api.nvim_win_set_cursor(D.state.outline_win,
                                    {value.line_in_outline, 1})
    end
end

-- credits: https://github.com/kyazdani42/nvim-tree.lua
function D._prevent_buffer_override()
    vim.schedule(function()
        local curwin = vim.api.nvim_get_current_win()
        local curbuf = vim.api.nvim_win_get_buf(curwin)
        local wins = vim.api.nvim_list_wins()

        if curwin ~= D.state.outline_win or curbuf ~= D.state.outline_buf then
            return
        end

        vim.cmd("buffer " .. D.state.outline_buf)

        local current_win_width = vim.api.nvim_win_get_width(curwin)
        if #wins < 2 then
            vim.cmd("vsplit")
            vim.cmd("vertical resize " .. math.ceil(current_win_width * 0.75))
        else
            vim.cmd("wincmd l")
        end

        vim.cmd("buffer " .. curbuf)
        vim.cmd("bnext")
        vim.cmd("wincmd r")
    end)
end

local function setup_keymaps(bufnr)
    -- goto_location of symbol
    vim.api.nvim_buf_set_keymap(bufnr, "n", "<Cr>",
                                ":lua require('symbols-outline')._goto_location()<Cr>",
                                {})
    -- hover symbol
    vim.api.nvim_buf_set_keymap(bufnr, "n", "<C-space>",
                                ":lua require('symbols-outline')._hover()<Cr>",
                                {})
    -- close outline when escape is pressed
    vim.api.nvim_buf_set_keymap(bufnr, "n", "<Esc>", ":bw!<Cr>", {})
end

----------------------------
-- WINDOW AND BUFFER STUFF
----------------------------
local function setup_buffer()
    D.state.outline_buf = vim.api.nvim_create_buf(false, true)
    vim.api.nvim_buf_attach(D.state.outline_buf, false,
                            {on_detach = function(_, _) wipe_state() end})
    vim.api.nvim_buf_set_option(D.state.outline_buf, "bufhidden", "delete")

    local current_win = vim.api.nvim_get_current_win()
    local current_win_width = vim.api.nvim_win_get_width(current_win)

    vim.cmd("vsplit")
    vim.cmd("vertical resize " .. math.ceil(current_win_width * 0.25))
    D.state.outline_win = vim.api.nvim_get_current_win()
    vim.api.nvim_win_set_buf(D.state.outline_win, D.state.outline_buf)

    setup_keymaps(D.state.outline_buf)

    vim.api.nvim_win_set_option(D.state.outline_win, "number", false)
    vim.api.nvim_win_set_option(D.state.outline_win, "relativenumber", false)
    vim.api.nvim_buf_set_name(D.state.outline_buf, "OUTLINE")
    vim.api.nvim_buf_set_option(D.state.outline_buf, "modifiable", false)
end

local function handler(_, _, result)
    if result == nil then return end
    D.state.code_win = vim.api.nvim_get_current_win()

    setup_buffer()
    D.state.outline_items = parse(result)
    D.state.flattened_outline_items = flatten(parse(result))

    local lines = get_lines(D.state.flattened_outline_items)
    write_outline(D.state.outline_buf, lines)

    local details = get_details(D.state.outline_items, D.state.outline_buf,
                                D.state.outline_win)
    write_details(D.state.outline_buf, details)
    setup_highlights()
end

function D.toggle_outline()
    if D.state.outline_buf == nil then
        vim.lsp.buf_request(0, "textDocument/documentSymbol", getParams(),
                            handler)
    else
        vim.api.nvim_win_close(D.state.outline_win, true)
    end
end

function D.setup(opts)
    vim.tbl_deep_extend("force", D.opts, opts or {})

    setup_commands()
    setup_autocmd()
end

D.opts = {highlight_hovered_item = true}

return D