packman

local unpack = unpack or table.unpack

os.unloadAPI("backpack")

local args = {...}

local opwords = {
	install = true,
	remove = true,
	update = true,
	["install-help"] = true,
	["remove-help"] = true,
	["update-help"] = 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("packman [options] install-help <package name[s]>\n")
	io.write("packman [options] update-help <package name[s]>\n")
	io.write("packman [options] remove-help <package name[s]>\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 config = {}

function loadConfig()
	local path = "/etc/packman/packman.conf"
	--load a configuration file, given a fully-resolved path and an optional environment.
	if not fs.exists(path) or fs.isDir(path) then return nil, "not a file" end
	local env
	if not _env then
		--if we were not provided an environment, create one.
		env = setmetatable({}, {__index = _G})
	else
		env = _env
	end
	local fn, err = loadfile(path)
	if fn then
		setfenv(fn, env)
		local success, err = pcall(fn)
		if success then
			--strip the metatable from the environment before returning it.
			config = setmetatable(env, {})
		else
			return nil, err
		end
	else
		return nil, err
	end
end

function saveConfig()
	local path = "/etc/packman/packman.conf"
	if not config or type(config) ~= "table" then return nil, "Not a configuration" end
	local handle = io.open(path, "w")
	if handle then
		for k, v in pairs(config) do
			local success, str = pcall(textutils.serialize, v)
			if success then
				handle:write(k.." = "..str.."\n\n")
			end
		end
		handle:close()
	else
		return nil, "Could not write configuration."
	end
end

loadConfig()

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 backpack then if shell.resolveProgram("backpack") then os.loadAPI(shell.resolveProgram("backpack")) elseif fs.exists("usr/apis/backpack") then os.loadAPI("usr/apis/backpack") elseif not (fetch or mode == "bootstrap") then error("Could not load backpack API!") end end

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

		local co = coroutine.create(backpack.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 backpack then
		queue = backpack.newTransactionQueue("main/backpack")
	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 fs.exists("/etc/custom-repolist") then
		local fileHandle = io.open("/etc/custom-repolist", "r")
		if fileHandle then
			repolistContent = repolistContent.."\n"..fileHandle:read("*a")
			fileHandle:close()
		end
	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 backpack API.
		os.unloadAPI("backpack")
		loadPackageAPI()
	end
end

if #mode > 0 and backpack then
	for n, v in pairs(backpack.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(backpack.list) do
		if pData.dependencies then
			dependencies, errmsg = backpack.findDependencies(pName, {})
			if not dependencies then
				--if dependencies could not be resolved, remove the backpack.
				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 = backpack.list[pack]
		local name = entry.name
		local others, key = false
		for k, v in pairs(backpack.list[name]) do
			if v == entry then
				key = k
			else
				others = true
			end
		end
		if others then
			backpack.list[name][key] = nil
		else
			backpack.list[name] = nil
		end
		backpack.list[pack] = nil
	end
end

local function lookupPackage(name, installedOnly)
	if backpack.list[name] and not backpack.list[name].dependencies then
		local options = {}
		if installedOnly and backpack.installed[name] then
			for name, pack in pairs(backpack.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(backpack.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 backpack.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 = backpack.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)
	if config.manageHelp then
		return raw_package_operation(name, "installFiles") and raw_package_operation(name, "installHelp") and raw_package_operation(name, "finalizeInstall")
	else
		return raw_package_operation(name, "install")
	end
end

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

local function remove(name)
	if config.manageHelp then
		return raw_package_operation(name, "removeHelp") and raw_package_operation(name, "remove")
	else
		return raw_package_operation(name, "remove")
	end
end

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

local function upgrade(name)
	if config.manageHelp then
		return raw_package_operation(name, "upgradeFiles") and raw_package_operation(name, "upgradeHelp") and raw_package_operation(name, "finalizeUpgrade")
	else
		return raw_package_operation(name, "upgrade")
	end
end

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

if mode == "bootstrap" then
	--initial setup, results in main/packman and main/backpack packages being installed
	if not backpack or backpack.list["main/packman"] == nil then
		--grab the backpack API, since we have no transaction queue yet.
		io.write("Updating Backpack API\n")
		remoteHandle = http.get("https://raw.githubusercontent.com/lyqyd/cc-packman/master/backpack")
		local apiContents = ""
		if remoteHandle then
			if not fs.exists("/usr/apis") then fs.makeDir("/usr/apis") end
			local fileHandle = io.open("/usr/apis/backpack", "w")
			if fileHandle then
				apiContents = remoteHandle.readAll()
				fileHandle:write(apiContents)
				fileHandle:close()
			else
				printWarning("Could not write file /usr/apis/backpack")
			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("backpack")
		loadPackageAPI()
		if not backpack then printError("Backpack 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 = backpack.newTransactionQueue("main/backpack")
		queue:makeDir("/usr")
		queue:makeDir("/usr/apis")
		queue:addFile("/usr/apis/backpack", apiContents)
		queue:makeDir("/etc")
		queue:makeDir("/etc/repositories")
		queue:addFile("/etc/repositories/main", packlistContents)
		queue:finish()
	end

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

	--reload backpack API.
	os.unloadAPI("backpack")
	loadPackageAPI()

	config.manageHelp = false
	saveConfig()
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(backpack.list[result].dependencies) do
					if not backpack.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(backpack.installed) do
			if v.files then
				--filters out the disambiguation entries.
				table.insert(updateList, k)
				for name, info in pairs(backpack.list[k].dependencies) do
					if not backpack.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 backpack.installed[updateList[i]].version == backpack.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(backpack.installed) do
			if pData.version then
				if not packageList[pName] then
					for dName in pairs(backpack.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 == "install-help" then
	if #operation.arguments >= 1 then
		local installString = ""
		for packageNumber, packageName in ipairs(operation.arguments) do
			local result = lookupPackage(packageName)
			if not result then
				printWarning("Could not find package "..packageName..".")
			else
				installString = installString..result.." "
			end
		end
		if #installString > 0 then
			if not forced then
				io.write("The following packages' help files 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 string.gmatch(installString, "%S+") do
				if not installHelp(packageName) then
					printWarning("Could not install help files for package "..packageName)
				end
			end
		end
	end
elseif mode == "upgrade-help" then
	if #operation.arguments >= 1 then
		local upgradeString = ""
		for packageNumber, packageName in ipairs(operation.arguments) do
			local result = lookupPackage(packageName)
			if not result then
				printWarning("Could not find package "..packageName..".")
			else
				upgradeString = upgradeString..result.." "
			end
		end
		if #upgradeString > 0 then
			if not forced then
				io.write("The following packages' help files will be installed: "..upgradeString.."\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 string.gmatch(upgradeString, "%S+") do
				if not installHelp(packageName) then
					printWarning("Could not install help files for package "..packageName)
				end
			end
		end
	end
elseif mode == "remove-help" then
	if #operation.arguments >= 1 then
		local removeString = ""
		for _, name in ipairs(operation.arguments) do
			local result = lookupPackage(name, true)
			if not result then
				printWarning("Could not find package "..name)
			else
				removeString = removeString..result.." "
			end
		end
		if #removeString > 0 then
			if not forced then
				io.write("The following packages' help files will be removed: "..removeString.."\n")
				io.write("Continue? (y/N)\n")
				local input = getUserInput("y")
				if string.sub(input:lower(), 1, 1) ~= "y" then
					return true
				end
			end
			for packageName in string.gmatch(removeString, "%S+") do
				printInformation("Removing help files for package "..packageName)
				removeHelp(packageName)
			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(backpack.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(backpack.list) do
		if info.version then
			if string.match(name, match) then
				io.write((backpack.installed[name] and "I " or "A " )..name.." "..info.version.."\n")
			end
		end
	end
end