local unpack = unpack or table.unpack

os.unloadAPI("package")

local args = {...}

local opwords = {
    install = true,
    remove = true,
    update = true,
    list = true,
    search = true,
    bootstrap = true,
}

local argwords = {
    fetch = true,
    force = true,
    auto = true,
    --target = 1,
}

if #args < 1 or (not opwords[args[1]] and not argwords[args[1]]) then
    io.write("Usage:\n")
    io.write("packman [options] install <package name[s]>\n")
    io.write("packman [options] update <package name[s]>\n")
    io.write("packman [options] remove <package name[s]>\n")
    io.write("packman [options] list [pattern]\n")
    io.write("packman [options] search [pattern]\n")
    io.write("packman bootstrap\n")
    io.write("\n")
    io.write("Options:\n")
    io.write("fetch\n")
    io.write("  Update repository and package lists before performing operations (can be used without an operation)\n")
    io.write("force\n")
    io.write("  Force requested operation, even if it appears to be unnecessary; answer all questions with yes\n")
    io.write("auto\n")
    io.write("  Automatically answer yes when manipulating packages\n")
    --io.write("target <directory>\n")
    --io.write("  Set root directory to install packages in\n")
    return
end

local mode = ""
local forced = false
local target = "/"
local fetch = false
local auto = false
local argState = nil
local argCount = 0
local operation = {options = {}, arguments = {}}

--lower all arguments
for i = 1, #args do
    args[i] = string.lower(args[i])
    if argState == nil and args[i] == "fetch" then fetch = true end
    if argState == nil and args[i] == "force" then forced = true end
    if argState == nil and args[i] == "auto" then auto = true end

    if argwords[args[i]] and type(argwords[args[i]]) == "number" then
        operation.options[args[i]] = {}
        argState = args[i]
        argCount = argwords[args[i]]
    elseif opwords[args[i]] then
        mode = args[i]
        if mode == "bootstrap" then fetch = false break end
        argState = "arguments"
        argCount = 0
    elseif argState and argCount > 0 then
        --option arguments
        table.insert(operation.options[argState], args[i])
        argCount = argCount - 1
        if argCount == 0 then argState = nil end
    elseif argState == "arguments" then
        --operation arguments
        table.insert(operation.arguments, args[i])
    end
end

if operation.options.target then
    target = operation.options.target[1]
end

local function resetScreen()
    term.setTextColor(colors.white)
    term.setBackgroundColor(colors.black)
end

local function printError(errorText)
    if term.isColor() then term.setTextColor(colors.red) end
    io.write(errorText.."\n")
    term.setTextColor(colors.white)
    error()
end

local function printWarning(warningText)
    if term.isColor() then term.setTextColor(colors.yellow) end
    io.write(warningText.."\n")
    term.setTextColor(colors.white)
end

local function printInformation(infoText)
    if term.isColor() then term.setTextColor(colors.lime) end
    io.write(infoText.."\n")
    term.setTextColor(colors.white)
end

local function getUserInput(default)
    if auto then
        return default
    else
        return io.read()
    end
end

local function loadPackageAPI()
    if not package then if shell.resolveProgram("package") then os.loadAPI(shell.resolveProgram("package")) elseif fs.exists("usr/apis/package") then os.loadAPI("usr/apis/package") elseif not (fetch or mode == "bootstrap") then error("Could not load package API!") end end

    if package then
        resetScreen()
        io.write("Loading database...\n")
        package.installRoot = target

        local co = coroutine.create(package.load)
        local event, filter, passback = {}
        while true do
            if (filter and (filter == event[1] or event[1] == "terminate")) or not filter then
                passback = {coroutine.resume(co, unpack(event))}
            end
            if passback[1] == false then printWarning(passback[2]) end
            if coroutine.status(co) == "dead" then break end
            filter = nil
            if passback and passback[1] and passback[2] then
                filter = passback[2]
            end
            event = {os.pullEventRaw()}
            if event[1] == "package_status" then
                if event[2] == "info" then
                    printInformation(event[3])
                elseif event[2] == "warning" then
                    printWarning(event[3])
                elseif event[2] == "error" then
                    printError(event[3])
                end
            end
        end
    end
end

loadPackageAPI()

local categoryList = {}
local categorySorted = {}

if fetch then
    local queue
    if package then
        queue = package.newTransactionQueue("main/package")
    end
    io.write("Fetching Repository List\n")
    local repolistContent
    remoteHandle = http.get("https://raw.githubusercontent.com/lyqyd/cc-packman/master/repolist")
    if remoteHandle then
        repolistContent = remoteHandle.readAll()
        if queue then
            queue:makeDir("/etc")
            queue:addFile("/etc/repolist", repolistContent)
        else
            local fileHandle = io.open("/etc/repolist", "w")
            if fileHandle then
                fileHandle:write(repolistContent)
                fileHandle:close()
            else
                printWarning("Could not write file /etc/repolist")
            end
        end
        remoteHandle.close()
    else
        printWarning("could not retrieve remote file.")
    end
    if repolistContent then
        if queue then
            queue:makeDir("/etc/repositories")
        else
            if not fs.exists("/etc/repositories") then fs.makeDir("/etc/repositories") end
        end

        for line in string.gmatch(repolistContent, "([^\n]+)\n?") do
            local file, url = string.match(line, "^(%S*)%s*(.*)")
            if file and url then
                io.write("Fetching Repository: "..file.."\n")
                local remoteHandle = http.get(url)
                if remoteHandle then
                    if queue then
                        queue:addFile(fs.combine("/etc/repositories", file), remoteHandle.readAll())
                    else
                        local fileHandle = io.open(fs.combine("/etc/repositories", file), "w")
                        if fileHandle then
                            fileHandle:write(remoteHandle.readAll())
                            fileHandle:close()
                        else
                            printWarning("Could not write file: "..fs.combine("/etc/repositories", file))
                        end
                    end
                    remoteHandle.close()
                else
                    printWarning("Could not retrieve remote file: "..file)
                end
            end
        end
    end

    if queue then
        queue:finish()
    end

    fetch = false

    if #mode > 0 then
        --reload package API.
        os.unloadAPI("package")
        loadPackageAPI()
    end
end

if #mode > 0 and package then
    for n, v in pairs(package.list) do
        if v.category then
            for category in pairs(v.category) do
                if not categoryList[category] then
                    categoryList[category] = {[n] = true}
                    table.insert(categorySorted, category)
                else
                    categoryList[category][n] = true
                end
            end
        end
    end
    table.sort(categorySorted)

    local badPackages = {}
    --flesh out dependencies
    for pName, pData in pairs(package.list) do
        if pData.dependencies then
            dependencies, errmsg = package.findDependencies(pName, {})
            if not dependencies then
                --if dependencies could not be resolved, remove the package.
                printWarning("Could not resolve dependency on "..errmsg.." in package "..pName)
                table.insert(badPackages, pName)
            else
                pData.dependencies = dependencies
            end
        end
    end
    --actual package removal and short-name lookup cleanup.
    for _, pack in pairs(badPackages) do
        local entry = package.list[pack]
        local name = entry.name
        local others, key = false
        for k, v in pairs(package.list[name]) do
            if v == entry then
                key = k
            else
                others = true
            end
        end
        if others then
            package.list[name][key] = nil
        else
            package.list[name] = nil
        end
        package.list[pack] = nil
    end
end

local function lookupPackage(name, installedOnly)
    if package.list[name] and not package.list[name].dependencies then
        local options = {}
        if installedOnly and package.installed[name] then
            for name, pack in pairs(package.installed[name]) do
                table.insert(options, name)
            end
        elseif installedOnly then
            --using installedOnly, but no packages of that name are installed.
            return false
        else
            for name, pack in pairs(package.list[name]) do
                table.insert(options, name)
            end
        end
        if #options > 1 then
            io.write("Package "..name.." is ambiguous.\n")
            for i = 1, #options do
                write(tostring(i)..": "..options[i].."  ")
            end
            io.write("\n")
            io.write("Select option: \n")
            local selection = getUserInput("1")
            if tonumber(selection) and options[tonumber(selection)] then
                return options[tonumber(selection)].."/"..name
            end
        elseif #options == 1 then
            return options[1].."/"..name
        else
            return false
        end
    elseif package.list[name] then
        --since it must have a dependencies table, the name is already fully unique.
        return name
    else
        return false
    end
end

local function raw_package_operation(name, funcName)
    local pack = package.list[name]
    if not pack then return nil, "No such package" end
    local co = coroutine.create(function() return pack[funcName](pack, getfenv()) end)
    local event, filter, passback = {}
    while true do
        if (filter and (filter == event[1] or event[1] == "terminate")) or not filter then
            passback = {coroutine.resume(co, unpack(event))}
        end
        if passback[1] == false then printWarning(passback[2]) end
        if coroutine.status(co) == "dead" then return unpack(passback, 2) end
        filter = nil
        if passback and passback[1] and passback[2] then
            filter = passback[2]
        end
        event = {os.pullEventRaw()}
        if event[1] == "package_status" then
            if event[2] == "info" then
                printInformation(event[3])
            elseif event[2] == "warning" then
                printWarning(event[3])
            elseif event[2] == "error" then
                printError(event[3])
            end
        end
    end
end

local function install(name)
    return raw_package_operation(name, "install")
end

local function remove(name)
    return raw_package_operation(name, "remove")
end

local function upgrade(name)
    return raw_package_operation(name, "upgrade")
end

if mode == "bootstrap" then
    --initial setup, results in main/packman and main/package packages being installed
    if not package or package.list["main/packman"] == nil then
        --grab the package API, since we have no transaction queue yet.
        io.write("Updating package API\n")
        remoteHandle = http.get("https://raw.githubusercontent.com/lyqyd/cc-packman/master/package")
        local apiContents = ""
        if remoteHandle then
            if not fs.exists("/usr/apis") then fs.makeDir("/usr/apis") end
            local fileHandle = io.open("/usr/apis/package", "w")
            if fileHandle then
                apiContents = remoteHandle.readAll()
                fileHandle:write(apiContents)
                fileHandle:close()
            else
                printWarning("Could not write file /usr/apis/package")
            end
            remoteHandle.close()
        else
            printWarning("Could not retrieve remote file.")
        end

        io.write("Fetching main package list\n")
        remoteHandle = http.get("https://raw.githubusercontent.com/lyqyd/cc-packman/master/packlist")
        local packlistContents = ""
        if remoteHandle then
            if not fs.exists("/etc/repositories") then fs.makeDir("/etc/repositories") end
            local fileHandle = io.open("/etc/repositories/main", "w")
            if fileHandle then
                packlistContents = remoteHandle.readAll()
                fileHandle:write(packlistContents)
                fileHandle:close()
            else
                printWarning("Could not write file /etc/repositories/main")
            end
            remoteHandle.close()
        else
            printWarning("Could not retrieve remote file.")
        end

        os.unloadAPI("package")
        loadPackageAPI()
        if not package then printError("Package API required for bootstrap!") end

        --re-do the file writes for the files above so they end up in the package file list.
        local queue = package.newTransactionQueue("main/package")
        queue:makeDir("/usr")
        queue:makeDir("/usr/apis")
        queue:addFile("/usr/apis/package", apiContents)
        queue:makeDir("/etc")
        queue:makeDir("/etc/repositories")
        queue:addFile("/etc/repositories/main", packlistContents)
        queue:finish()
    end

    package.list["main/packman"]:install(getfenv())

    --reload package API.
    os.unloadAPI("package")
    loadPackageAPI()
elseif mode == "install" then
    if #operation.arguments >= 1 then
        local installList = {}
        for packageNumber, packageName in ipairs(operation.arguments) do
            local result = lookupPackage(packageName)
            if not result then
                printWarning("Could not install package "..packageName..".")
            else
                for k,v in pairs(package.list[result].dependencies) do
                    if not package.installed[k] then
                        installList[k] = true
                    else
                        if k == result then
                            printInformation("Package "..k.." already installed")
                        else
                            printInformation("Dependency "..k.." already installed")
                        end
                    end
                end
            end
        end
        local installString = ""
        for k, v in pairs(installList) do
            installString = installString..k.." "
        end
        if #installString > 0 then
            if not forced then
                io.write("The following packages will be installed: "..installString.."\n")
                io.write("Continue? (Y/n)\n")
                local input = getUserInput("y")
                if string.sub(input:lower(), 1, 1) == "n" then
                    return true
                end
            end
            for packageName in pairs(installList) do
                if not install(packageName) then
                    printWarning("Could not "..mode.." package "..packageName)
                end
            end
        end
    end
elseif mode == "update" then
    local updateList = {}
    local installList = {}
    if #operation.arguments >= 1 then
        for _, name in ipairs(operation.arguments) do
            local result = lookupPackage(name, true)
            if result then
                table.insert(updateList, result)
            end
        end
    else
        for k, v in pairs(package.installed) do
            if v.files then
                --filters out the disambiguation entries.
                table.insert(updateList, k)
                for name, info in pairs(package.list[k].dependencies) do
                    if not package.installed[name] then
                        installList[name] = true
                    end
                end
            end
        end
    end
    local installString = ""
    for k, v in pairs(installList) do
        installString = installString..k.." "
    end
    if not forced then
        for i = #updateList, 1, -1 do
            if package.installed[updateList[i]].version == package.list[updateList[i]].version then
                table.remove(updateList, i)
            end
        end
    end
    if #updateList > 0 or #installString > 0 then
        local updateString = ""
        for i = 1, #updateList do
            updateString = updateString..updateList[i].." "
        end
        if not forced then
            io.write("The following packages will be updated: "..updateString.."\n")
            if #installString > 0 then
                io.write("The following packages will also be installed: "..installString.."\n")
            end
            io.write("Continue? (Y/n)\n")
            local input = getUserInput("y")
            if string.sub(input:lower(), 1, 1) == "n" then
                return true
            end
        end
        local failureCount = 0
        for packageName in pairs(installList) do
            if not install(packageName) then
                printWarning("Could not install package "..packageName)
            end
        end
        for _, packageName in pairs(updateList) do
            if not upgrade(packageName) then
                printWarning("Package "..packageName.." failed to update.")
                failureCount = failureCount + 1
            end
        end
        if failureCount > 0 then
            printWarning(failureCount.." packages failed to update.")
        else
            printInformation("Update complete!")
        end
    else
        io.write("Nothing to do!\n")
        return true
    end
elseif mode == "remove" then
    if #operation.arguments >= 1 then
        local packageList = {}
        for _, name in ipairs(operation.arguments) do
            local result = lookupPackage(name, true)
            if result then
                table.insert(packageList, result)
            end
        end
        dependeesList = {}
        --find packages which depend on the packages we are removing.
        for pName, pData in pairs(package.installed) do
            if pData.version then
                if not packageList[pName] then
                    for dName in pairs(package.list[pName].dependencies) do
                        for _, packName in pairs(packageList) do
                            if packName == dName then
                                dependeesList[pName] = true
                                break
                            end
                        end
                        if dependeesList[pName] then
                            break
                        end
                    end
                end
            end
        end
        local removeString = ""
        local dependeesString = ""
        for i = 1, #packageList do
            removeString = removeString..packageList[i].." "
            if dependeesList[packageList[i]] then
                dependeesList[packageList[i]] = nil
            end
        end
        for dName in pairs(dependeesList) do
            dependeesString = dependeesString..dName.." "
        end
        if #removeString > 0 then
            if not forced then
                io.write("The following packages will be removed: "..removeString.."\n")
                if #dependeesString > 0 then
                    io.write("The following packages will also be removed due to missing dependencies: "..dependeesString.."\n")
                end
                io.write("Continue? (y/N)\n")
                local input = getUserInput("y")
                if string.sub(input:lower(), 1, 1) ~= "y" then
                    return true
                end
            end
            for pName in pairs(dependeesList) do
                printInformation("Removing "..pName)
                remove(pName)
            end
            for _, pName in pairs(packageList) do
                printInformation("Removing "..pName)
                remove(pName)
            end
        else
            io.write("Nothing to do!\n")
        end
    end
elseif mode == "list" then
    --list all installed packages
    local match = ".*"
    if #operation.arguments == 1 then
        --list with matching.
        match = operation.arguments[1]
    end
    for name, info in pairs(package.installed) do
        if info.version then
            if string.match(name, match) then
                io.write(name.." "..info.version.."\n")
            end
        end
    end
elseif mode == "search" then
    --search all available packages
    local match = ".*"
    if #operation.arguments == 1 then
        --search using a match
        match = operation.arguments[1]
    end
    for name, info in pairs(package.list) do
        if info.version then
            if string.match(name, match) then
                io.write((package.installed[name] and "I " or "A " )..name.." "..info.version.."\n")
            end
        end
    end
end