---@class startup.utils
local U = {}
local flag = false
local new_cursor_pos
local help_window

local log = require("startup.log")

local oldfiles_total = 0
local all_oldfiles = {}

local set_buf_opt = vim.api.nvim_buf_set_option

local line_count = function()
    return vim.api.nvim_buf_line_count(0)
end
-- local startup = require"startup"

---sets cursor to position in current window
---@param cursor table table in form {row,column}
local function set_cursor(cursor)
    vim.api.nvim_win_set_cursor(0, cursor)
end

function U.breaking_changes()
    local buf = vim.api.nvim_create_buf(false, true)
    local ns = vim.api.nvim_create_namespace("Startup_breaking_changes")
    vim.api.nvim_buf_set_option(buf, "bufhidden", "wipe")
    vim.api.nvim_buf_set_keymap(
        buf,
        "n",
        "q",
        "<cmd>q<CR>",
        { noremap = true, silent = true, nowait = true }
    )
    local lines = {
        "",
        "  # Breaking Changes in startup.nvim",
        "",
        "  ## 18-12-2021:",
        "  The syntax for mappings has changed. This is because",
        "  before it wasn't possible to keep the mappings in the",
        "  order in which they were defined.",
        "",
        "  ### Old syntax:",
        "  ```lua",
        "  content = {",
        '    [" Find File"] = { "Telescope find_files", "<leader>ff" }',
        '    [" Find Word"] = { "Telescope live_grep", "<leader>lg" }',
        '    [" Recent Files"] = { "Telescope oldfiles", "<leader>of" }',
        '    [" File Browser"] = { "Telescope file_browser", "<leader>fb" }',
        '    [" Colorschemes"] = { "Telescope colorscheme", "<leader>cs" }',
        [[    [" New File"] = { "lua require'startup'.new_file()", "<leader>nf" }]],
        "  }",
        "  ```",
        "",
        "  ### New syntax:",
        "  ```lua",
        "  content = {",
        '    {" Find File",  "Telescope find_files", "<leader>ff" }',
        '    {" Find Word",  "Telescope live_grep", "<leader>lg" }',
        '    {" Recent Files", "Telescope oldfiles", "<leader>of" }',
        '    {" File Browser", "Telescope file_browser", "<leader>fb" }',
        '    {" Colorschemes", "Telescope colorscheme", "<leader>cs" }',
        [[    {" New File", "lua require'startup'.new_file()", "<leader>nf" }]],
        "  }",
        "  ```",
    }
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
    local width = vim.api.nvim_win_get_width(0)
    local height = vim.api.nvim_win_get_height(0)
    local win = vim.api.nvim_open_win(buf, true, {
        relative = "win",
        win = 0,
        -- width = math.floor(width * 0.8),
        width = 85,
        height = math.floor(height * 0.9),
        col = math.floor((width - 80) * 0.4),
        row = math.floor(height * 0.1),
        border = "shadow",
        style = "minimal",
    })
    -- vim.api.nvim_buf_add_highlight(buf, ns, "Special", 1, 0, -1)
    vim.api.nvim_win_set_option(win, "winblend", 0)
    vim.api.nvim_buf_set_option(buf, "modifiable", false)
    vim.api.nvim_buf_set_option(buf, "filetype", "markdown")
end

---load the theme specified
---@param theme_name string theme to load
---@return table settings
function U.load_theme(theme_name)
    local path = "lua/startup/themes/" .. theme_name .. ".lua"
    local files = vim.api.nvim_get_runtime_file(path, true)
    local settings
    if #files == 0 then
        path = "lua/startup/themes" .. theme_name .. "/init.lua"
        files = vim.api.nvim_get_runtime_file(path, true)
    end
    if #files == 0 then
        error("lua/startup/themes/" .. theme_name .. ".lua" .. " not found")
    elseif #files == 1 then
        settings = dofile(files[1])
    else
        local startup_pattern = "startup.nvim/lua/startup"
        local valid_file = false
        for _, file in ipairs(files) do
            if not file:find(startup_pattern) then
                settings = dofile(file)
                valid_file = true
            end
        end
        if not valid_file then
            -- multiple files but in startup repo shouldn't happen so just use first one
            settings = dofile(files[1])
        end
    end
    return settings
end

---checks if cursor should be able to move on current line
local function bad_line()
    for _, line in ipairs(require("startup").good_lines) do
        if line == vim.trim(vim.api.nvim_get_current_line()) and line ~= "" then
            return false
        end
    end
    return true
end

U.cursor_pos = vim.api.nvim_win_get_cursor(0)

---returns string with specified amount of spaces
---@param amount number the amount of space to return
---@return string
function U.spaces(amount)
    return string.rep(" ", amount)
end

---returns table with empty strings
---@param amount number amount of empty strings
function U.empty(amount)
    for _ = 1, amount, 1 do
        table.insert(
            require("startup").lines,
            { " ", "center", false, "normal" }
        )
    end
end

local function parse_mapping(mapping)
    mapping = string.gsub(mapping, "C%-", "ctrl+")
    mapping = string.gsub(mapping, "c%-", "ctrl+")
    mapping = string.gsub(mapping, "%<leader%>", "leader+")
    mapping = string.gsub(mapping, "%<(.+)%>", "%1")
    return mapping
end

---open float with all the keybindings
function U.key_help()
    local ns = vim.api.nvim_create_namespace("Float help")
    local settings = require("startup").settings
    local buf = vim.api.nvim_create_buf(false, true)
    local user_mappings = require("startup").user_mappings
    set_buf_opt(buf, "bufhidden", "wipe")
    local lines = {
        "    Startup.nvim Mappings    ",
        "",
        "    Execute command:    " .. parse_mapping(
            settings.mappings.execute_command
        ),
        "    Open file:          " .. parse_mapping(settings.mappings.open_file),
        "    Open file in split: " .. parse_mapping(
            settings.mappings.open_file_split
        ),
        "    Open section:       " .. parse_mapping(
            settings.mappings.open_section
        ),
    }
    local length
    if not vim.tbl_isempty(user_mappings) then
        local user_map_commands = {}
        table.insert(lines, "")
        table.insert(lines, "   User Mappings:")
        table.insert(lines, "")
        for _, lhs in pairs(user_mappings) do
            table.insert(user_map_commands, lhs)
        end
        length = U.longest_line(user_map_commands)
        for rhs, lhs in pairs(user_mappings) do
            table.insert(
                lines,
                "    "
                    .. lhs
                    .. ":"
                    .. U.spaces(length + 3 - #lhs)
                    .. parse_mapping(rhs)
            )
        end
    end
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
    local height = 6
    if not vim.tbl_isempty(user_mappings) then
        height = 9 + vim.tbl_count(user_mappings)
    end
    help_window = vim.api.nvim_open_win(buf, false, {
        relative = "cursor",
        width = 55,
        height = height,
        col = 0,
        row = 1,
        border = "shadow",
        style = "minimal",
    })
    if not vim.tbl_isempty(user_mappings) then
        vim.api.nvim_buf_add_highlight(buf, ns, "Special", 7, 1, -1)
        for i = 9, 9 + vim.tbl_count(user_mappings), 1 do
            vim.api.nvim_buf_add_highlight(buf, ns, "String", i, length + 5, -1)
            vim.api.nvim_buf_add_highlight(buf, ns, "Number", i, 1, length + 5)
        end
    end
    vim.api.nvim_win_set_option(help_window, "winblend", 20)
    vim.api.nvim_buf_add_highlight(buf, ns, "Special", 0, 1, -1)
    for i = 2, 5, 1 do
        vim.api.nvim_buf_add_highlight(buf, ns, "String", i, 24, -1)
        vim.api.nvim_buf_add_highlight(buf, ns, "Number", i, 1, 23)
    end
    set_buf_opt(buf, "modifiable", false)
    vim.cmd(
        [[autocmd CursorMoved * ++once lua require"startup.utils".close_help()]]
    )
end

---close the help window
function U.close_help()
    vim.api.nvim_win_close(help_window, false)
    -- vim.cmd([[autocmd! CursorMoved * lua require"startup.utils".close_help() ++once]])
end

---the default header
---@return table header strings with the default header
function U.default_header()
    local header = {
        "                                          /$$              ",
        "                                         |__/              ",
        " /$$$$$$$   /$$$$$$   /$$$$$$  /$$    /$$ /$$ /$$$$$$/$$$$ ",
        "| $$__  $$ /$$__  $$ /$$__  $$|  $$  /$$/| $$| $$_  $$_  $$",
        "| $$  \\ $$| $$$$$$$$| $$  \\ $$ \\  $$/$$/ | $$| $$ \\ $$ \\ $$",
        "| $$  | $$| $$_____/| $$  | $$  \\  $$$/  | $$| $$ | $$ | $$",
        "| $$  | $$|  $$$$$$$|  $$$$$$/   \\  $/   | $$| $$ | $$ | $$",
        "|__/  |__/ \\_______/ \\______/     \\_/    |__/|__/ |__/ |__/",
    }
    return header
end

---get oldfiles
---@param amount number amount of oldfiles to return
---@return table oldfiles table with all the oldfiles in it
function U.get_oldfiles(amount)
    local home = vim.fn.expand("~")
    local oldfiles = {}
    local oldfiles_raw = vim.fn.execute("oldfiles")
    local oldfiles_amount = 0
    for file in oldfiles_raw:gmatch("[^\n]+") do
        if oldfiles_amount >= amount then
            break
        end
        table.insert(oldfiles, (string.sub(file, 4, -1)))
        table.insert(all_oldfiles, (string.sub(file, 4, -1)))
        oldfiles_amount = oldfiles_amount + 1
    end
    local oldfiles_shortened = {}
    for _, file in ipairs(oldfiles) do
        if oldfiles_total < 10 then
            oldfiles_shortened[#oldfiles_shortened + 1] = "["
                .. oldfiles_total
                .. "] "
                .. string.gsub(file, home, "~")
        else
            oldfiles_shortened[#oldfiles_shortened + 1] = string.gsub(
                file,
                home,
                "~"
            )
        end
        oldfiles_total = oldfiles_total + 1
    end
    oldfiles = oldfiles_shortened
    table.insert(oldfiles, 1, "Last Files:")
    table.insert(oldfiles, 2, "")

    local length = U.longest_line(oldfiles) + 2
    local oldfiles_aligned = {}
    for _, file in ipairs(oldfiles) do
        table.insert(oldfiles_aligned, file .. U.spaces(length - #file))
    end
    return oldfiles_aligned
end

---get oldfiles of current directory
---@param amount number amount of oldfiles to return
---@return table oldfiles table with all the oldfiles in it
function U.get_oldfiles_directory(amount)
    local home = vim.fn.expand("~")
    local oldfiles_raw = vim.fn.execute("oldfiles")
    local oldfiles_amount = 0
    local directory = vim.api.nvim_exec([[pwd]], true)
    local oldfiles = {}
    for file in oldfiles_raw:gmatch(directory .. "[^\n]+") do
        if oldfiles_amount >= amount then
            break
        end
        table.insert(oldfiles, (string.sub(file, #directory + 1, -1)))
        table.insert(all_oldfiles, file)
        oldfiles_amount = oldfiles_amount + 1
    end
    local oldfiles_shortened = {}
    for _, file in ipairs(oldfiles) do
        if oldfiles_total < 10 then
            oldfiles_shortened[#oldfiles_shortened + 1] = "["
                .. oldfiles_total
                .. "] "
                .. string.gsub(file, home, "~")
        else
            oldfiles_shortened[#oldfiles_shortened + 1] = string.gsub(
                file,
                home,
                "~"
            )
        end
        oldfiles_total = oldfiles_total + 1
    end
    oldfiles = oldfiles_shortened
    table.insert(
        oldfiles,
        1,
        "Last Files in " .. string.gsub(directory, home, "~") .. ":"
    )
    table.insert(oldfiles, 2, "")

    local length = U.longest_line(oldfiles) + 2
    local oldfiles_aligned = {}
    for _, file in ipairs(oldfiles) do
        table.insert(oldfiles_aligned, file .. U.spaces(length - #file))
    end
    return oldfiles_aligned
end

function U.oldfiles_mappings()
    if not all_oldfiles then
        return
    end
    for i = 0, #all_oldfiles >= 10 and 9 or #all_oldfiles - 1, 1 do
        vim.api.nvim_buf_set_keymap(
            0,
            "n",
            tostring(i),
            "<cmd>e " .. all_oldfiles[i + 1] .. "<CR>",
            { noremap = true, silent = true }
        )
    end
end

---return column on which cursor should be positioned
local column = function()
    local settings = require("startup").settings
    local column_calc
    local cursor_column = settings.options.cursor_column or 0.5
    if cursor_column < 1 then
        column_calc = math.floor(
            vim.fn.winwidth(require("startup").window_id) * cursor_column
        )
    else
        column_calc = cursor_column
    end
    return column_calc
end

---reposition cursor if cursor moved up
local function move_up()
    flag = true
    local i
    if new_cursor_pos[1] < U.cursor_pos[1] then
        if new_cursor_pos[1] == 1 then
            set_cursor(new_cursor_pos)
            i = 1
            while true do
                if not bad_line() then
                    flag = false
                    return
                end
                set_cursor({ new_cursor_pos[1] + i, column() })
                i = i + 1
            end
        else
            set_cursor(new_cursor_pos)
            i = 0
        end
    else
        set_cursor(U.cursor_pos)
        i = 1
    end
    while true do
        set_cursor({ new_cursor_pos[1] - i, column() })
        if not bad_line() then
            flag = false
            return
        end
        i = i + 1
        if new_cursor_pos[1] - i <= 1 then
            i = 1
            set_cursor({ 1, column() })
            while true do
                if not bad_line() then
                    flag = false
                    return
                end
                set_cursor({ new_cursor_pos[1] - 1 + i, column() })
                i = i + 1
            end
        end
    end
    flag = false
end

---reposition cursor if cursor moved down
local function move_down()
    flag = true
    local i
    if new_cursor_pos[1] > U.cursor_pos[1] then
        if new_cursor_pos[1] == line_count() then
            set_cursor(new_cursor_pos)
            i = 1
            while true do
                if not bad_line() then
                    flag = false
                    return
                end
                set_cursor({ new_cursor_pos[1] - i, column() })
                i = i + 1
            end
            i = 0
        else
            set_cursor(new_cursor_pos)
            i = 0
        end
    else
        set_cursor(U.cursor_pos)
        i = 1
    end
    while true do
        set_cursor({ new_cursor_pos[1] + i, column() })
        if not bad_line() then
            flag = false
            return
        end
        i = i + 1
        if new_cursor_pos[1] + i >= line_count() then
            set_cursor(U.cursor_pos)
            flag = false
            return
        end
    end
    flag = false
end

---reposition cursor after it moved
function U.reposition_cursor()
    if vim.o.filetype ~= "startup" or flag then
        return
    end
    new_cursor_pos = vim.api.nvim_win_get_cursor(0)
    if new_cursor_pos[1] > U.cursor_pos[1] then
        move_down()
    elseif
        (new_cursor_pos[1] < U.cursor_pos[1])
        or new_cursor_pos[2] < U.cursor_pos[2]
    then
        move_up()
    elseif
        (new_cursor_pos[1] > U.cursor_pos[1])
        or new_cursor_pos[2] > U.cursor_pos[2]
    then
        move_down()
    end
    U.cursor_pos = vim.api.nvim_win_get_cursor(0)
end

---return longest line length
---@param lines table
---@return number longest
function U.longest_line(lines)
    local longest = 0
    for _, line in ipairs(lines) do
        if vim.fn.strdisplaywidth(line) > longest then
            longest = vim.fn.strdisplaywidth(line)
        end
    end
    return longest
end

---set all the options that should be set for the startup buffer
function U.set_buf_options()
    local settings = require("startup").settings
    local last_status = vim.api.nvim_get_option("laststatus")
    local tab_line = vim.api.nvim_get_option("showtabline")
    set_buf_opt(0, "bufhidden", "wipe")
    set_buf_opt(0, "buftype", "nofile")
    vim.cmd([[set wrap]])
    if settings.options.disable_statuslines then
        vim.opt.laststatus = 0
        vim.opt.showtabline = 0
    end
    set_buf_opt(0, "filetype", "startup")
    set_buf_opt(0, "swapfile", false)
    vim.cmd([[setlocal nonu nornu]])
    vim.api.nvim_set_current_dir(
        vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ":h")
    )
    vim.cmd(
        [[autocmd BufEnter * lua if vim.opt.filetype~="startup" then vim.opt.laststatus=]]
            .. last_status
            .. [[;vim.opt.showtabline=]]
            .. tab_line
            .. [[ end]]
    )
end

---validate the settings
---@param options table the settings for a section
function U.validate_settings(options)
    if not options.oldfiles_directory then
        options.oldfiles_directory = false
    end
    if not options.fold_section then
        options.fold_section = false
    end
    if not options.margin then
        options.margin = 5
    end
    if not options.title then
        options.title = ""
    end
    if not options.default_color then
        options.default_color = ""
    end
    if not options.highlights then
        options.highlights = ""
    end
    if not options.oldfiles_amount then
        options.oldfiles_amount = 5
    end
    vim.validate({
        type = {
            options.type,
            function(arg)
                for _, v in ipairs({ "mapping", "oldfiles", "text" }) do
                    if v == arg then
                        return true
                    end
                end
                return false
            end,
            '"mapping" "text" or "oldfiles"',
        },
        align = {
            options.align,
            function(arg)
                for _, v in ipairs({ "right", "left", "center" }) do
                    if v == arg then
                        return true
                    end
                end
                return false
            end,
            '"center" "left" or "right"',
        },
        content = {
            options.content,
            function(content)
                if
                    options.type == "text"
                    and (
                        type(content) == "table"
                        or type(content)
                            == "function"
                    )
                then
                    return true
                elseif
                    options.type == "mapping" and type(content) == "table"
                then
                    return true
                elseif options.type == "oldfiles" then
                    return true
                end
                return false
            end,
            "table for type=mapping and table or function for type=text",
        },
    })
    return options
end

return U