VFS API

local function createVFSInstance(oldFS)
        local vfs = {}

        --[[
        Structure of a FS object:
        {
                function isReadOnly(self, path)
                function exists(self, path)
                function open(self, path, mode)
                function isDir(self, path) -- optional, defaults to false
                function list(self, path) -- optional, defaults to throwing error
                function getDrive(self, path) -- optional, defaults to "unknown"
                function mkdir(self, path) -- optional, defaults to throwing error
                function delete(self, path) -- optional, defaults to throwing error
                function getSize(self, path) -- optional, defaults to always 512
                function move(self, from1, from2) -- optional
                function copy(self, from1, from2) -- optional
                function getFreeSpace(self, path) -- optional, defaults to 2MiB
        }
        ]]

        local _registeredFS = {}

        -- factory is a function(mountPoint, options) that returns a FS object
        function vfs.registerFS(name, factory)
                assert(type(name) == "string", "name must be a string")
                assert(type(factory) == "function", "factory must be a function")

                if _registeredFS[name] then
                        print("Warning: Re-registering filesystem type "..name)
                        print("Existing mounted filesystems will not be affected.")
                end
                _registeredFS[name] = factory
        end

        local _mountPoints = {}

        -- fsType is the name of a FS previously registered with vfs.registerFS
        function vfs.mount(mountPoint, fsType, options)
                assert(mountPoint:sub(mountPoint:len()) == "/", "mount point must end with a slash")
                assert(_mountPoints[mountPoint] == nil, "already mounted")
                assert(_registeredFS[fsType] ~= nil, "unknown fs type "..tostring(fsType))

                _mountPoints[mountPoint] = _registeredFS[fsType](mountPoint, options)
        end

        function vfs.unmount(mountPoint)
                _mountPoints[mountPoint] = nil
        end

        -- returns FS, FS-relative-path
        function vfs._resolve(path)
                if path:sub(1,1) ~= "/" then
                        path = "/" .. path
                end
                if _mountPoints[path .. "/"] then
                        return _mountPoints[path .. "/"], "/"
                end
                if _mountPoints[path] then
                        return _mountPoints[path], "/"
                end
                local best = ""
                for k,v in pairs(_mountPoints) do
                        --print(path," ",k," ",path:sub(1,k:len())," ",best)
                                if path:sub(1, k:len()) == k and k:len() > best:len() then
                                best = k
                        end
                end
                return _mountPoints[best], "/" .. path:sub(best:len() + 1)
        end

        vfs.oldFS = oldFS

        local fs = {}

        function fs.combine(basePath, localPath)
                return oldFS.combine(basePath, localPath)
        end

        function fs.isReadOnly(path)
                local fs, rel = vfs._resolve(path)
                if not fs then return true end
                return fs:isReadOnly(rel)
        end

        function fs.getSize(path)
                local fs, rel = vfs._resolve(path)
                if not fs then return 0 end
                if fs.getSize then return fs:getSize(path) else return 512 end
        end

        function fs.move(p1, p2)
                local fs1, rel1 = vfs._resolve(p1)
                local fs2, rel2 = vfs._resolve(p2)
                if not fs1 then error("doesn't exist: "..fs1) end
                if not fs2 then error("Fuck!") end
                if fs2:exists(rel2) then
                        error("already exists: "..p2)
                end
                if fs1 == fs2 and fs1.move then
                        fs1:move(rel1, rel2)
                elseif fs1:exists(rel1) then
                        fs.copy(p1, p2)
                        fs.delete(p1)
                end
        end

        function fs.exists(path)
                local fs, rel = vfs._resolve(path)
                if not fs then return false end
                return fs:exists(rel)
        end

        local function copyFile(p1, p2)
                local f = fs.open(p1, "r")
                local d = f.readAll()
                f.close()
                f = fs.open(p2, "w")
                f.write(d)
                f.close()
        end

        local function copyDir(p1, p2)
                if not fs.exists(p2) then fs.makeDir(p2) end
                for k,v in ipairs(fs.list(p1)) do
                        local p = fs.combine(p1, v)
                        if fs.isDir(p) then
                                copyDir(p, fs.combine(p2, v))
                        else
                                copyFile(p, fs.combine(p2, v))
                        end
                end
        end

        function fs.copy(p1, p2)
                local fs1, rel1 = vfs._resolve(p1)
                local fs2, rel2 = vfs._resolve(p2)
                if not fs1 or not fs1:exists(rel1) then error("doesn't exist: "..p1) end
                if fs2:exists(rel2) then
                        error("already exists: "..p2)
                end
                if fs1 == fs2 and fs1.copy then
                        fs1:copy(rel1, rel2)
                elseif fs.isDir(p1) then
                        copyDir(p1, p2)
                else
                        copyFile(p1, p2)
                end
        end

        function fs.getFreeSpace(path)
                local fs, rel = vfs._resolve(path)
                if not fs then return 0 end
                if not fs.getFreeSpace then return 2097152 end
                return fs:getFreeSpace(rel)
        end

        function fs.makeDir(path)
                local fs, rel = vfs._resolve(path)
                if not fs or not fs.mkdir then error("Not supported on this device") end
                if fs:exists(rel) then error("Already exists: "..path) end
                fs:mkdir(rel)
        end

        function fs.delete(path)
                local fs, rel = vfs._resolve(path)
                if not fs or not fs.delete then error("Not supported on this device") end
                fs:delete(rel)
        end

        function fs.open(path, mode)
                local fs, rel = vfs._resolve(path)
                if not fs then return nil end
                return fs:open(rel, mode)
        end

        local function tablefind(t, v)
                for _,v2 in ipairs(t) do
                        if v2 == v then return true end
                end
        end

        function fs.list(path)
                if not fs.isDir(path) then error("Not a directory",2) end
                local fs, rel = vfs._resolve(path)
                if not fs.list then error("Not supported on this device") end
                local rv
                if fs == nil then
                        rv = {}
                else
                        rv = fs:list(rel)
                end
                -- add mount points to list
                while path:sub(path:len()) == "/" do path = path:sub(1, path:len() - 1) end
                path = path .. "/"
                for k,v in pairs(_mountPoints) do
                        if k:sub(1, path:len()) == path and k ~= path then
                                local after = k:sub(path:len() + 1)
                                after = after:sub(1, after:len() - 1)
                                if after:find("/") == nil and not tablefind(rv, after) then
                                        table.insert(rv, after)
                                end
                        end
                end
                return rv
        end

        function fs.getDrive(path)
                local fs, rel = vfs._resolve(path)
                if not fs.getDrive then return "unknown" end
                return fs:getDrive(rel)
        end

        function fs.getName(path)
                return oldFS.getName(path)
        end

        function fs.isDir(path)
                local fs, rel = vfs._resolve(path)
                if not fs.isDir then return false end
                return fs:isDir(rel)
        end

        local fs_craftos = {
                isReadOnly = function(self, path) return oldFS.isReadOnly(self.prefix .. path) end,
                exists = function(self, path) return oldFS.exists(self.prefix .. path) end,
                open = function(self, path, mode) return oldFS.open(self.prefix .. path, mode) end,
                isDir = function(self, path) return oldFS.isDir(self.prefix .. path) end,
                list = function(self, path) return oldFS.list(self.prefix .. path) end,
                getDrive = function(self, path) return oldFS.getDrive(self.prefix .. path) end,
                mkdir = function(self, path) return oldFS.makeDir(self.prefix .. path) end,
                delete = function(self, path) return oldFS.delete(self.prefix .. path) end,
                getSize = function(self, path) return oldFS.getSize(self.prefix .. path) end,
                getFreeSpace = function(self, path) return oldFS.getFreeSpace(self.prefix .. path) end,
                move = function(self, path1, path2) return oldFS.move(self.prefix .. path1, self.prefix .. path2) end,
                copy = function(self, path1, path2) return oldFS.copy(self.prefix .. path1, self.prefix .. path2) end,
        }

        vfs.registerFS("craftos", function(mount, opts)
                local t = {prefix=opts.prefix or ""}
                setmetatable(t, {__index=fs_craftos})
                return t
        end)

        vfs.mount("/", "craftos", {})

        return vfs, fs
end

local vfs, fs = createVFSInstance(fs)

rawset(_G, "vfs", vfs)
rawset(_G, "fs", fs)

vfs.createVFSInstance = createVFSInstance