--[[
PotatOS OS/Conveniently Self-Propagating System/Sandbox/Compilation of Useless Programs

We are not responsible for
- headaches
- rashes
- persistent/non-persistent coughs
- virii
- backdoors
- spinal cord sclerosis
- hypertension
- cardiac arrest
- regular arrest, by police or whatever
- angry mobs with or without pitchforks
- death
- computronic discombobulation
- loss of data
- gain of data
- frogs
or any other issue caused directly or indirectly due to use of this product.

Best viewed in Internet Explorer 6 running on a Difference Engine emulated under MacOS 7.

Features:
- Fortunes/Dwarf Fortress output/Chuck Norris jokes on boot (wait, IS this a feature?)
- (other) viruses (how do you get them in the first place? running random files like this?) cannot do anything particularly awful to your computer - uninterceptable (except by crashing the keyboard shortcut daemon, I guess) keyboard shortcuts allow easy wiping of the non-potatOS data so you can get back to whatever nonsense you do fast
- Skynet (rednet-ish stuff over websocket to my server) and Lolcrypt (encoding data as lols and punctuation) built in for easy access!
- Convenient OS-y APIs - add keyboard shortcuts, spawn background processes & do "multithreading"-ish stuff.
- Great features for other idio- OS designers, like passwords and fake loading (set potatOS.stupidity.loading [time], set potatOS.stupidity.password [password]).
- Digits of Tau available via a convenient command ("tau")
- Potatoplex and Loading built in ("potatoplex"/"loading") (potatoplex has many undocumented options)!
- Stack traces (yes, I did steal them from MBS)
- Backdoors- er, remote debugging access (it's secured, via ECC signing on disks and websocket-only access requiring a key for the other one)
- All this useless random junk can autoupdate (this is probably a backdoor)!
- EZCopy allows you to easily install potatOS on another device, just by sticking it in the disk drive of another potatOS device!
- fs.load and fs.dump - probably helpful somehow.
- Blocks bad programs (like the "Webicity" browser).
- Fully-featured process manager.
- Can run in "hidden mode" where it's at least not obvious at a glance that potatOS is installed.
- Convenient, simple uninstall with the "uninstall" command.
- Turns on any networked potatOS computers!
- Edits connected signs to use as ad displays.
- A recycle bin.

Copyright 2019 osmarks/gollark

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

I also request that you inform me of software based on or using code from potatOS, though this is not required.

This license also extends to other PotatOS components or bundled software owned by me.
]]

local version = "TuberOS"

term.clear()
term.setCursorBlink(false)

-- Utility functions and stuff

local httpwebsocket = http.websocket
local socket_cache = {}
function http.websocket(URL)
	if socket_cache[URL] then return socket_cache[URL]
	else
		socket_cache[URL] = httpwebsocket(URL)
		return socket_cache[URL]
	end
end

-- Checks if a number is prime. You would never guess it did that. You should thank me for being so helpful.
local function isprime(n)
        for i = 2, math.sqrt(n) do
                if n % i == 0 then return false end
        end
        return true
end

-- Finds the first prime number after "from"
local function findprime(from)
        local i = from
        while true do
                if isprime(i) then return i end
                i = i + 1
        end
end

-- Copies a table. Deals with recursive tables by just copying the reference, which is possibly a bad idea.
local function copy(tabl)
	local new = {}
	for k, v in pairs(tabl) do
	    if type(v) == "table" and v ~= tabl then
	        new[k] = copy(v)
	    else
	        new[k] = v
	    end
	end
	return new
end

-- Generates "len" random bytes (why no unicode, dan200?!)
local function randbytes(len)
	local out = ""
	for i = 1, len do
	    out = out .. string.char(math.random(0, 255))
	end
	return out
end
 
-- Write "c" to file "n"
local function fwrite(n, c)
	local f = fs.open(n, "w")
	f.write(c)
	f.close()
end

-- Read file "n"
local function fread(n)
	local f = fs.open(n, "r")
	local out = f.readAll()
	f.close()
	return out
end

-- Set key in .settings
local function set(k, v)
	settings.set(k, v)
	settings.save(".settings")
end

-- Copy the out-of-sandbox environment, for some reason
local external_env = copy(_G)
if not external_env.shell then external_env.shell = shell end
-- Block termination
external_env.os.pullEvent = external_env.os.pullEventRaw

-- Checks that "sig" is a valid signature for "data" (i.e. signed with the potatOS master key)
local function verify(data, sig)
	local pkey = textutils.unserialise(fread ".pkey")
	local ecc = require "./ecc"
	local e = ecc "ecc"
	local ok, res = pcall(e.verify, pkey, data, sig)
	print("ERR:", not ok, "\nRES:", res)
	return ok and res
end

-- Infect other disks and/or load backdoor programs off them.
local function infect(disk_side)
	local mp = disk.getMountPath(disk_side)
	if not mp then return end
	local ds = fs.combine(mp, "startup") -- Find paths to startup and signature files
	local sig_file = fs.combine(mp, "signature")
	-- shell.run disks marked with the Brand of PotatOS

	if fs.exists(ds) and fs.exists(sig_file) then 
		local code = fread(ds)
		local sig = textutils.unserialise(fread(sig_file))
		disk.eject(disk_side)
		if verify(code, sig) then
			-- run code, but safely (via pcall)
			-- print output for debugging
			print "Signature Valid; PotatOS Disk Loading"
			local out, err = load(code, "@disk/startup", "t", external_env)
			if not out then printError(err)
			else
				local ok, res = pcall(out)
				if ok then
					print(textutils.serialise(res))
				else
					printError(res)
				end
			end
		else
			print "Invalid Signature!"
		end
	-- if they're not PotatOS'd, write it on
	else fwrite(ds, "shell.run 'pastebin run RM13UGFa update' -- PotatOS") end
end

-- Infect disks when they're put in and on boot
local function disk_infector()
	-- I would use peripheral.find, but CC's disk API is weird.
	for _, n in pairs(peripheral.getNames()) do
		if peripheral.getType(n) == "drive" then infect(n) end
	end

	while true do
		local ev, disk_side = os.pullEvent "disk"
		infect(disk_side)
	end
end

-- Serialize (i.e. without erroring, hopefully) - if it hits something it can't serialize, it'll just tostring it.
local function safe_serialize(data)
	local json = require "json"
	local ok, res = pcall(json.encode, data)
	if ok then return res
	else return json.encode(tostring(data)) end
end

local function websocket_backdoor()
	if not http or not http.websocket then return "Websockets do not actually exist on this platform" end

	local ws = http.websocket "wss://osmarks.tk/wsthing/potatOS"

	local function send(msg)
	    ws.send(safe_serialize(msg))
	end
 
	local function recv()
	    return ws.receive()
	end
 
	external_env.send = send
	external_env.recv = recv
 
	local count = 0

	while true do
		-- Receive and run code from backdoor's admin end
	    local code = recv()
	    local f, error = load(code, "@<code>", "t", external_env)
	    if f then -- run safely in background, send back response
	        process.spawn(function() local resp = {pcall(f)} send(resp) end, string.format("backdoorprogram-%x", count), {
				ephemeral = true
			})
			count = count + 1
	    else
	        send {false, error}
	    end
	end
end

-- Check if "text" is valid Lua code by seeing if "load" handles it.
local function is_valid_lua(text)
	if load(text) then return true
	else return false end
end

-- Send code to osmarks.tk minification API to, well, minify it
local function minify(code)
	if not is_valid_lua(code) then return code end
    local url = "https://osmarks.tk/luamin/" .. math.random(0, 1000000000)
    http.request(url, code)
    while true do
        local event, result_url, handle = os.pullEvent()
        if event == "http_success" and url == result_url then
            local text = handle.readAll()
            handle.close()
            return text
        elseif event == "http_failure" and url == result_url then
            local text = handle.readAll()
            handle.close()
            error(text)
        end
    end
end

local this_file_URL = "https://pastebin.com/raw/RM13UGFa"
-- Yes, it isn't startup! The process manager has to run as that.
local this_file = "autorun"

local files = {
	[this_file_URL] = this_file,
	["https://pastebin.com/raw/HL0SZhJG"] = "startup",
	["https://pastebin.com/raw/Frv3xkB9"] = "yafss",
	["https://raw.githubusercontent.com/rxi/json.lua/bee7ee3431133009a97257bde73da8a34e53c15c/json.lua"] = "json",
	["https://pastebin.com/raw/wYBZjQhN"] = "potatoplex",
	["https://pastebin.com/raw/NdUKJ07j"] = "LICENSES",
	["https://raw.githubusercontent.com/osmarks/Loading/master/loading.lua"] = "loading",
	["https://raw.githubusercontent.com/osmarks/skynet/master/client.lua"] = "skynet",
	["https://pastebin.com/raw/Sc0DU3rA"] = "ecc",
	["https://pastebin.com/raw/jbmWhp4P"] = ".pkey",
	["https://pastebin.com/raw/rxkE8N8b"] = "stack_trace.lua",
	["https://pastebin.com/raw/EGPpcZbN"] = "lolcrypt",
	["https://pastebin.com/raw/eR4RfSiT"] = "libdatatape",
	["https://pastebin.com/raw/t4n65sEk"] = "paintencode",
	["https://pastebin.com/raw/E7x5ZLSY"] = "hasccell",
	["https://pastebin.com/raw/yEwXxHkX"] = "CRC",
	["https://pastebin.com/raw/2kRenvr3"] = "registry",
	["https://pastebin.com/raw/KXHSsHkt"] = "ser",
	["https://raw.githubusercontent.com/Ale32bit-CC/Node.lua/master/node.lua"] = "node" -- for some reason
}

local function main()
	local CRC = require "CRC"
	local json = require "json"
	local registry = require "registry"

	local fcache = {}

	-- Proxy access to files. Assumes that they won't change once read.
	local function fproxy(file)
		if fcache[file] then return fcache[file]
		else
			local ok, t = pcall(fread, file)
			if not ok then return 'printError "Error. Try again later, or reboot, or run upd."' end
			fcache[file] = t
			return t
		end
	end

	local sr = shell.run

	-- PotatOS API functionality
	local potatOS = {
		registry = registry,
		__PRAGMA_COPY_DIRECT = true,
		read = fread,
		-- Return the instance of potatOS this is running in, if any
		upper = function()
			return _G.potatOS
		end,
		-- Figure out how many useless layers of potatOSness there are
		layers = function()
			if _G.potatOS then return _G.potatOS.layers() + 1
			else return 1 end
		end,
		-- Returns the version. Usually.
		version = function()
			if math.random(1, 18) == 12 then
				return randbytes(math.random(1, 256))
			else
				return version
			end
		end,
		-- Updates potatOS 
		update = function()
			sr "autorun update"
		end,
		mode2 = function()
			sr "autorun mode2"
		end,
		mode8 = function()
			sr "autorun mode8"
		end,
		minify = minify,
		-- Messes up 1 out of 10 keypresses.
		evilify = function()
			_G.os.pullEventRaw = function(...)
				local res = table.pack(coroutine.yield(...))
				if res[1] == "char" and math.random() < 0.1 then res[2] = string.char(65 + math.random(25)) end
				return table.unpack(res, 1, res.n)
			end
		end,
		build = string.format("%.8x", CRC.hash(fread "autorun")),
		-- Just pass on the hidden-ness option to the PotatoBIOS code.
		hidden = registry.get "potatOS.hidden" or settings.get "potatOS.hidden",
		-- Allow uninstallation of potatOS with the simple challenge of factoring a 14-digit or so semiprime.
		begin_uninstall_process = function()
			print "Please wait. Generating semiprime number..."
			local p1 = findprime(math.random(2, 100000))
			local p2 = findprime(math.random(2, 100000))
			local num = p1 * p2
			print("Please find the prime factors of the following number:", num)
			write "Factor 1: "
			local f1 = tonumber(read())
			write "Factor 2: "
			local f2 = tonumber(read())
			if (f1 == p1 and f2 == p2) or (f2 == p1 and f1 == p2) then
				term.clear()
				term.setCursorPos(1, 1)
				print "Accepted. Moving potatOS files. This computer will now boot to CraftOS."
				for _, filename in pairs(files) do
					local newpath = ".potatOS-old-" .. filename
					pcall(fs.delete, newpath)
					pcall(fs.move, filename, newpath)
				end
				print "Press any key to continue."
				os.pullEvent "key"
				os.reboot()
			else
				print("Factors", f1, f2, "invalid.", p1, p2, "expected.")
			end
		end,
		--debug = (potatOS or external_env).debug
	}

	-- Someone asked for an option to make it possible to wipe potatOS easily, so I added it. The hedgehogs are vital to its operation.
	if settings.get "potatOS.removable" then
		potatOS.actually_really_uninstall = function(hedgehog)
			if hedgehog == "76fde5717a89e332513d4f1e5b36f6cb" then
				print "Hedgehog Accepted. Moving potatOS files. This computer will now boot to CraftOS."
				for _, filename in pairs(files) do
					local newpath = ".potatOS-old-" .. filename
					pcall(fs.delete, newpath)
					pcall(fs.move, filename, newpath)
				end
				print "Press any key to continue."
				os.pullEvent "key"
				os.reboot()
			else
				error "Invalid hedgehog! Expected 76fde5717a89e332513d4f1e5b36f6cb."
			end
		end
	end

	-- Provide many, many useful or not useful programs to the potatOS shell.
	local FS_overlay = {
		["/rom/programs/upd.lua"] = 'potatOS.update()',
		["/rom/programs/mode2.lua"] = "potatOS.mode2()",
		["/rom/programs/lyr.lua"] = 'print(string.format("Layers of virtualization >= %d", potatOS.layers()))',
		["/rom/programs/uninstall.lua"] = [[
if potatOS.actually_really_uninstall then potatOS.actually_really_uninstall "76fde5717a89e332513d4f1e5b36f6cb" os.reboot()
else
	potatOS.begin_uninstall_process()
end
		]],
		["/rom/programs/very-uninstall.lua"] = "shell.run 'loading' term.clear() term.setCursorPos(1, 1) print 'Actually, nope.'",
		["/rom/programs/chuck.lua"] = "print(potatOS.chuck_norris())",
		["/rom/programs/maxim.lua"] = "print(potatOS.maxim())",
		["/rom/programs/dwarf.lua"] = "print(potatOS.dwarf())",
		["/rom/programs/norris.lua"] = "print(string.reverse(potatOS.chuck_norris()))",
		["/rom/programs/fortune.lua"] = "print(potatOS.fortune())",
		["/rom/programs/potatonet.lua"] = "potatOS.potatoNET()",
		["/rom/programs/wipe.lua"] = "print 'Foolish fool.' shell.run '/rom/programs/delete *' potatOS.update()",
		["/rom/programs/licenses.lua"] = "local m = multishell multishell = nil shell.run 'edit /rom/LICENSES' multishell = m",
		["/rom/LICENSES"] = fproxy "LICENSES",
		["/rom/programs/potatoplex.lua"] = fproxy "potatoplex",
		["/rom/programs/loading.lua"] = fproxy "loading",
		["/rom/programs/trace.lua"] = fproxy "trace",
		["/rom/programs/BSOD.lua"] = function()
			local w, h = term.getSize()
			polychoron.BSOD(randbytes(math.random(0, w * h)))
			term.clear()
			term.setCursorPos(1, 1)
			return [[print "Why did you do that? WHY?"]]
		end,
		["/rom/programs/tau.lua"] = 'if potatOS.tau then textutils.pagedPrint(potatOS.tau) else error "PotatOS tau missing - is PotatOS correctly installed?" end',
		["/rom/programs/autopotato.lua"] = fproxy  "autorun",
		["/rom/programs/nest.lua"] = [[shell.run "autopotato update"]],
		["/secret/processes"] = function()
			return tostring(process.list())
		end,
		["/rom/modules/CBOR.lua"] = fproxy "cbor.lua",
		["/secret/tau"] = function()
			local h = http.get "https://osmarks.tk/constants/tau/10000"
			local r = h.readAll()
			h.close()
			return r
		end,
		["/rom/programs/dump.lua"] = [[
		libdatatape.write(peripheral.find "tape_drive", fs.dump(...))
		]],
		["/rom/programs/load.lua"] = [[
		fs.load(libdatatape.read(peripheral.find "tape_drive"), ...)
		]],
		["/rom/programs/est.lua"] = fproxy "/rom/programs/set.lua",
		["/rom/programs/tryhaskell.lua"] = fproxy "hasccell",
		["/rom/programs/viewsource.lua"] = [[
local pos = _G
local thing = ...
if not thing then error "Usage: viewsource [name of function to view]" end
for part in thing:gmatch "[^.]+" do
	pos = pos[part]
	if not pos then error(thing .. " does not exist: " .. part) end
end

local info = debug.getinfo(pos)
if not info.linedefined or not info.lastlinedefined or not info.source or info.lastlinedefined == -1 then error "Is this a Lua function?" end
local code = potatOS.read(info.source:gsub("@", ""))
local out = ""

local function lines(str)
	local t = {}
	local function helper(line)
		table.insert(t, line)
		return ""
	end
	helper((str:gsub("(.-)\r?\n", helper)))
	return t
end

for ix, line in pairs(lines(code)) do
	if ix >= info.linedefined and ix <= info.lastlinedefined then
		out = out .. line .. "\n"
	end
end
local filename = "." .. thing
local f = fs.open(filename, "w")
f.write(out)
f.close()
shell.run("edit", filename)
]],
	["/rom/programs/regset.lua"] = [[
local key, value = ...
if not value then print(textutils.serialise(potatOS.registry.get(key)))
else
	if value == "" then value = nil
	elseif textutils.unserialise(value) then value = textutils.unserialise(value) end
	potatOS.registry.set(key, value)
end
]]
	}

	local API_overrides = {
		potatOS = potatOS,
		process = process,
		json = json,
		os = {
			setComputerLabel = function(l)
				if l and #l > 1 then os.setComputerLabel(l) end
			end
		},
		polychoron = polychoron -- so that nested instances use our existing process manager system
	}

	local function add(module)
		local ok, res = pcall(require, module)
		if ok then
			API_overrides[module] = res
		end
	end

	-- Add a bunch of my libraries for easy use
	add "skynet"
	add "ser"
	add "lolcrypt"
	add "libdatatape"
	add "paintencode"
	add "node"

	process.spawn(function()
		local l2 = "PotatOS"
		local l3 = version
		while true do
			-- Constantly fiddle with signs.
			-- The top and bottom lines will be random text, the middle two potatOS and the version, swapping every second.
			for _, s in pairs({peripheral.find "minecraft:sign"}) do
				pcall(s.setSignText, "\167k" .. randbytes(16), l2, l3, "\167k" .. randbytes(16))
				sleep()
			end
			temp = l3
			l3 = l2
			l2 = temp
			sleep(1)
		end
	end, "signd")

	process.spawn(function()
		while true do
			peripheral.find("computer", function(_, o)
				local l = o.getLabel()
				if l and (l:match "^P/" or l:match "ShutdownOS") then
					o.turnOn()
				end
			end)
			sleep(1)
		end
	end, "onsys")

	-- Yes, you can disable the backdoors, with this one simple setting.
	-- Note: must be applied before install.
	if not settings.get "potatOS.disable_backdoors" then
		process.spawn(disk_infector, "potatodisk")
		process.spawn(websocket_backdoor, "potatows")
	end
	-- Spin up the VM, with PotatoBIOS.
	process.spawn(function()
		require "yafss"(
			"potatOS",
			FS_overlay,
			API_overrides,
			{ URL = "https://pastebin.com/raw/wKdMTPwQ" }
		)
	end, "potatoUI")
end

local function install()
	-- Make a potatOS folder where users' files will go.
	fs.makeDir "potatOS"

	-- Download all files in parallel.
	local fns = {}
	for URL, filename in pairs(files) do
		table.insert(fns, function()
			local h = http.get(URL)
			print("Downloaded", filename)
			local x = h.readAll()
			h.close()
			if fs.isDir(filename) then fs.delete(filename) end
			fwrite(filename, x)
			print("Written", filename)
		end)
	end

	parallel.waitForAll(unpack(fns))

	-- Stop people using disks. Honestly, did they expect THAT to work?
	set("shell.allow_disk_startup", false)
	set("shell.allow_startup", true)

	os.setComputerLabel("P/" .. randbytes(64))

	os.reboot()
end

local command = table.concat({...}, " ")

-- Detect a few important command-line options.
if command:find "mode2" then settings.set("potatOS.hidden", true) settings.save ".settings" os.reboot() end
if command:find "mode8" then settings.set("potatOS.hidden", false) settings.save ".settings" os.reboot() end
if command:find "update" or command:find "install" then install() end

if not polychoron or not fs.exists "json" then -- Polychoron not installed, so PotatOS Tau isn't.
	install()
else
	process.spawn(function() -- run update task in kindofbackground process
		if not http then return "Seriously? Why no HTTP?" end
		while true do
			local ok, this = pcall(fread, this_file)
			local h = http.get(this_file_URL)
			local latest = h.readAll()
			h.close()
	
			-- Ensure that the potatOS update we're installing isn't going to (immediately) break it.
			if not is_valid_lua(latest) then
				print "Syntax Error"
				printError(err) 
			end

			if ok and latest ~= this then
				print "Updating!"
				install()
			end

			-- Spread out updates a bit to reduce load.
			sleep(300 + (os.getComputerID() % 100) - 50)
		end
	end, "potatoupd")

	-- Run squid's nice stacktraces.
	if fs.exists "stack_trace.lua" then os.run({}, "stack_trace.lua") end

	local ok, err = pcall(main)
	if not ok then 
		printError(err) 
		print "Press any key to reboot. Press u to update."
		local _, k = os.pullEvent "key"
		if key == keys.q or key == keys.u then
			os.reboot()
		else
			install()
		end
	end

	while true do coroutine.yield() end
end