local COMMANDS = {}
local CURRENT_COMMAND = nil
local data_path = vim.fn.stdpath("data")
local personalCommands = require("aotrix.personal_commands")
local PERSONAL_COMMAND_JSON_PATH = data_path .. "/personal_commands.json"

---@param command string|nil
---@return nil
local executeCommandInTerminal = function(command)
    if (command ~= nil) then
        vim.cmd.term()
        vim.cmd.startinsert()
        local channel = vim.bo.channel
        -- 'clear' is used to hide the command
        local exitMessage = "\nPress enter to exit..."
        local commandString = command()
        vim.api.nvim_chan_send(channel,
                               "clear && " .. commandString .. "; echo '" ..
                                   exitMessage .. "' && read -s && exit" .. "\n")
    end
end

local readJsonFromFile = function(filePath)
    local file, error = io.open(filePath, 'r')
    if file ~= nil then
        local content = file:read("*a")
        local decoded_json = vim.json.decode(content)
        return decoded_json
    else
        print("Error in readJsonFromFile: " .. error)
    end
    return nil
end

local addCommandToJsonFile = function(commandBlock, commandsFilePath, directory)
    local current_json = readJsonFromFile(commandsFilePath)
    if current_json ~= nil then
        if current_json[directory] == nil then
            current_json[directory] = {}
        end
        -- FIXME: duplicates
        table.insert(current_json[directory], {
            command = tostring(commandBlock.command()),
            description = tostring(commandBlock.description())
        })
    end
    local file, error = io.open(commandsFilePath, 'w')
    if file then
        local indent = vim.bo.expandtab and (' '):rep(vim.o.shiftwidth) or '\t'
        file:write(vim.json.encode(current_json, {indent = indent}))
        file:close()
    else
        print("Error in writeTableToJsonFile: " .. error)
    end
end

local updateJsonFile = function(listOfCommands, commandsFilePath, directory)
    local current_json = readJsonFromFile(commandsFilePath)
    current_json[directory] = {}
    for _, value in pairs(listOfCommands) do
        table.insert(current_json[directory], {
            command = tostring(value.command()),
            description = tostring(value.description())
        })
    end

    local file, error = io.open(commandsFilePath, 'w')
    if file then
        local indent = vim.bo.expandtab and (' '):rep(vim.o.shiftwidth) or '\t'
        file:write(vim.json.encode(current_json, {indent = indent}))
        file:close()
    else
        print("Error in updateJsonFile: " .. error)
    end
end

local appendCommandsFromFile = function(commands, commandsFilePath, directory)
    local current_list_of_commands_json = readJsonFromFile(commandsFilePath)
    if current_list_of_commands_json ~= nil and
        current_list_of_commands_json[directory] ~= nil then
        for _, block in pairs(current_list_of_commands_json[directory]) do
            local new_command_name = block["description"]
            commands[new_command_name] = {
                command = function() return block["command"] end,
                description = function() return new_command_name end
            }
        end
    end
end

local selectCommand = function(listOfCommands, callback)
    vim.ui.select(vim.tbl_keys(listOfCommands), {
        prompt = "Select your command.",
        format_item = function(item)
            return listOfCommands[item].description()
        end
    }, function(choice)
        if (choice ~= nil) then
            CURRENT_COMMAND = listOfCommands[choice].command
            callback(choice)
        end
    end)
end

local addCommand = function()
    local created_command = personalCommands.createCommand(COMMANDS)
    addCommandToJsonFile(created_command, PERSONAL_COMMAND_JSON_PATH,
                         vim.fn.getcwd())
    CURRENT_COMMAND = created_command.command
    executeCommandInTerminal(CURRENT_COMMAND)
end

local deleteCommand = function()
    local previous_command = CURRENT_COMMAND
    selectCommand(COMMANDS, function(choice)
        local index = 0
        for key, _ in pairs(COMMANDS) do
            index = index + 1
            if key == choice then
                COMMANDS[key] = nil
                updateJsonFile(COMMANDS, PERSONAL_COMMAND_JSON_PATH,
                               vim.fn.getcwd())
                break
            end
        end
        CURRENT_COMMAND = previous_command
    end)
end

vim.api.nvim_create_user_command("AddCommand", addCommand, {})

vim.api.nvim_create_user_command("DeleteCommand", deleteCommand, {})

local executeCommand = function(listOfCommands)
    if (CURRENT_COMMAND == nil) then
        selectCommand(listOfCommands,
                      function()
            executeCommandInTerminal(CURRENT_COMMAND)
        end)
    else
        executeCommandInTerminal(CURRENT_COMMAND)
    end
end

vim.api.nvim_create_autocmd({'BufEnter', 'BufWinEnter', 'DirChanged'}, {
    callback = function()
        COMMANDS = {}
        appendCommandsFromFile(COMMANDS, PERSONAL_COMMAND_JSON_PATH,
                               vim.fn.getcwd())
    end
})

vim.keymap.set("n", "mc", function() executeCommand(COMMANDS) end)
vim.keymap.set("n", "mC", function()
    selectCommand(COMMANDS,
                  function() executeCommandInTerminal(CURRENT_COMMAND) end)
end)