CCOS 0.2 for ComputerCraft

require 'org.luaj.vm2.lib.DebugLib'
require 'org.luaj.vm2.lib.jse.LuajavaLib'
local debug = debug

local function duplicate(table, base)
    local t = base or { }
    for i, v in pairs(table) do
        t[i] = v
    end
    return t
end

local function clone(table)
    local t = { }
    local function clones(table)
        if type(table) ~= 'table' then
            return table
        end
        if not t[table] then
            t[table] = { }
            for i, v in pairs(table) do
                t[table][i] = clones(v)
            end
        end
        return t[table]
    end
    return clones(table)
end

local empty = { }
local userfun = { }
local error

local print

local function rvpack(...)
    local arg = {...}
    arg.n = select('#', ...)
    arg.s = 1
    return arg
end

local function rvunpack(t, s, n)
    return unpack(t, s or t.s, n or t.n)
end

local function rvshift(t, d)
    t.s = t.s + d
    return t
end

local function protectenv(table, force)
    local t = { }
    local getfenv = getfenv
    local setfenv = setfenv
    local select = select
    local function sub(table)
        if not t[table] then
            t[table] = true
            for i, v in pairs(table) do
                if force or userfun[v] then
                    table[i] = setfenv(function(...)
                        local p, err = getfenv(v)
                        local f = setfenv(v, getfenv(0))
                        local r = rvpack(f(...))
                        if p then
                            setfenv(v, p)
                        end
                        return rvunpack(r)
                    end, empty)
                elseif type(v) == 'table' then
                    sub(v)
                end
            end
        end
    end
    sub(table)
end

local parallels = { }
local currentParallel = nil
local currentProcess = nil
local processInfo = setmetatable({}, { __mode = 'k' })
local handles = setmetatable({}, { __mode = 'k' })
local returnValue
local timers = { }

function pullEventRaw()
    local event = rvpack(coroutine.yield())
    if event[1] == 'terminate' then
        local info = processInfo[parallels[1].currentProcess]
        info.status = 'dead'
        info.parent.returnValue = rvpack('error', 'terminated')
    else
        if event[1] == 'timer' and timers[event[2]] then
            timers[event[2]]()
            timers[event[2]] = nil
        end
        return event
    end
end

local events = { }
events.back = events
local ignoreEvents = false
local waiting = false
local listener = { }

local function queueEvent(event)
    local e = { value = event }
    events.back.next = e
    events.back = e
end

local function pullEvent(wait)
    if currentParallel.events.next then
        currentParallel.events = currentParallel.events.next
        return assert(currentParallel.events.value)
    end
    return nil
end

--TODO: work with parallel
local function sleep(time)
    local timer = os.startTimer(time)
    local info = processInfo[currentProcess]
    if info.status ~= 'dead' then
        info.status = 'wait'
        info.wait = function() end
        timers[timer] = function()
            if info.status ~= 'dead' then
                info.status = 'normal'
            end
        end
    end
end

local function flushEvent()
    --sleep(0)
    coroutine.yield('sleep', 0)
end

loadfile = function(fn)
    local file = fs.open(fn, "r")
    if file then
        local func, err = loadstring(file.readAll(), fn)
        file.close()
        return func, err
    end
    return nil, "File not found"
end

dofile = function(fn)
    local fun, e = loadfile(fn)
    if fun then
        return fun()
    else
        error(e)
    end
end

function write( sText )
    local w,h = term.getSize()
    local x,y = term.getCursorPos()

    local nLinesPrinted = 0
    local function newLine()
        if y + 1 <= h then
            term.setCursorPos(1, y + 1)
        else
            term.scroll(1)
            term.setCursorPos(1, h)
        end
        x, y = term.getCursorPos()
        nLinesPrinted = nLinesPrinted + 1
    end

    -- Print the line with proper word wrapping
    while string.len(sText) > 0 do
        local whitespace = string.match( sText, "^[ \t]+" )
        if whitespace then
            -- Print whitespace
            term.write( whitespace )
            x,y = term.getCursorPos()
            sText = string.sub( sText, string.len(whitespace) + 1 )
        end

        local newline = string.match( sText, "^\n" )
        if newline then
            -- Print newlines
            newLine()
            sText = string.sub( sText, 2 )
        end

        local text = string.match( sText, "^[^ \t\n]+" )
        if text then
            sText = string.sub( sText, string.len(text) + 1 )
            if string.len(text) > w then
                -- Print a multiline word
                while string.len( text ) > 0 do
                if x > w then
                    newLine()
                end
                    term.write( text )
                    text = string.sub( text, (w-x) + 2 )
                    x,y = term.getCursorPos()
                end
            else
                -- Print a word normally
                if x + string.len(text) > w then
                    newLine()
                end
                term.write( text )
                x,y = term.getCursorPos()
            end
        end
    end

    return nLinesPrinted
end

function print( ... )
    local nLinesPrinted = 0
    for n,v in ipairs( { ... } ) do
        nLinesPrinted = nLinesPrinted + write( tostring( v ) )
    end
    nLinesPrinted = nLinesPrinted + write( "\n" )
    return nLinesPrinted
end

function read( _sReplaceChar, _tHistory )
    setfenv(1, getfenv(0))
    term.setCursorBlink( true )

    local sLine = ""
    local nHistoryPos = nil
    local nPos = 0
    if _sReplaceChar then
        _sReplaceChar = string.sub( _sReplaceChar, 1, 1 )
    end

    local w, h = term.getSize()
    local sx, sy = term.getCursorPos()
    local function redraw()
        local nScroll = 0
        if sx + nPos >= w then
            nScroll = (sx + nPos) - w
        end

        term.setCursorPos( sx, sy )
        term.write( string.rep(" ", w - sx + 1) )
        term.setCursorPos( sx, sy )
        if _sReplaceChar then
            term.write( string.rep(_sReplaceChar, string.len(sLine) - nScroll) )
        else
            term.write( string.sub( sLine, nScroll + 1 ) )
        end
        term.setCursorPos( sx + nPos - nScroll, sy )
    end

    while true do
        local sEvent, param = os.pullEvent()
        if sEvent == "char" then
            sLine = string.sub( sLine, 1, nPos ) .. param .. string.sub( sLine, nPos + 1 )
            nPos = nPos + 1
            redraw()

        elseif sEvent == "key" then
            if param == 28 then
                -- Enter
                break

            elseif param == 203 then
                -- Left
                if nPos > 0 then
                    nPos = nPos - 1
                    redraw()
                end

            elseif param == 205 then
                -- Right
                if nPos < string.len(sLine) then
                    nPos = nPos + 1
                    redraw()
                end

            elseif param == 200 or param == 208 then
                -- Up or down
                if _tHistory then
                    if param == 200 then
                        -- Up
                        if nHistoryPos == nil then
                            if #_tHistory > 0 then
                                nHistoryPos = #_tHistory
                            end
                        elseif nHistoryPos > 1 then
                            nHistoryPos = nHistoryPos - 1
                        end
                    else
                        -- Down
                        if nHistoryPos == #_tHistory then
                            nHistoryPos = nil
                        elseif nHistoryPos ~= nil then
                            nHistoryPos = nHistoryPos + 1
                        end
                    end

                    if nHistoryPos then
                        sLine = _tHistory[nHistoryPos]
                        nPos = string.len( sLine )
                    else
                        sLine = ""
                        nPos = 0
                    end
                    redraw()
                end
            elseif param == 14 then
                -- Backspace
                if nPos > 0 then
                    sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
                    nPos = nPos - 1
                    redraw()
                end
            end
        end
    end

    term.setCursorBlink( false )
    term.setCursorPos( w + 1, sy )
    print()

    return sLine
end

local function split(str, sub)
    local t = { }
    local p = 1
    local q = string.find(str, sub, p, true)
    local l = string.len(sub)
    while q do
        table.insert(t, string.sub(str, p, q - 1))
        p = q + l
        q = string.find(str, sub, p, true)
    end
end

local tenv = {
    os = {
        version = function()
            return 'CCOS 0.2'
        end,
        computerID = os.computerID,
        run = function (env, path, ...)
            local file, err = loadfile(path)
            if file then
                local ret = rvpack(coroutine.yield('exec', loadfile(path), rvpack(...), nil, setmetatable(env, { __index = _G })))
                if ret[1] == 'error' then
                    ret[1] = false
                    print(ret[2])
                end
                return rvunpack(ret)
            else
                return false, err
            end
        end,
        loadAPI = function(path)
            return false, 'Premission denied'
        end,
        unloadAPI = function(name)
            return false, 'Premission denied'
        end,
        pullEvent = function()
            return coroutine.yield('pull')
        end,
        pullEventRaw = function()
            return coroutine.yield('pull')
        end,
        queueEvent = os.queueEvent,
        clock = os.clock,
        startTimer = os.startTimer,
        sleep = function(time, hold)
            coroutine.yield('sleep', time)
            if not hold then
                coroutine.yield('discard')
            end
        end,
        time = os.time,
        shutdown = function()
            coroutine.yield('shutdown')
        end,
        reboot = os.reboot,
        setAlarm = os.setAlarm,
    },
    coroutine = coroutine,
    redstone = redstone,
    term = term,
    math = math,
    table = table,
    fs = fs,
    rs = rs,
    string = string,
    sleep = function(time)
        coroutine.yield('sleep', time)
    end,
    disk = disk,
    getmetatable = getmetatable,
    unpack = unpack,
    __inext = __inext,
    _VERSION = _VERSION,
    ipairs = ipairs,
    load = load,
    print = print,
    read = read,
    write = write,
    pcall = pcall,
    assert = assert,
    tonumber = tonumber,
    rawequal = rawequal,
    loadstring = loadstring,
    loadfile = loadfile,
    dofile = dofile,
    pairs = pairs,
    collectgarbage = collectgarbage,
    xpcall = xpcall,
    error = error,
    setfenv = setfenv,
    require = function(name)
        if package.loaded[name] then
            return package.loaded[name]
        end
        for i, v in ipairs(package.loaders) do
            local f = v(name)
            if type(f) == 'function' then
                package.loaded[name] = f(name)
                if not package.loaded[name] == nil then
                    package.loaded[name] = true
                end
                return package.loaded[name]
            end
        end
        error('cannot find module ' .. name)
    end,
    module = function(name, ...)
        local function do_at(fun, table, name, ...)
            if select('#', ...) ~= 0 then
                return do_at(fun, table[name], ...)
            else
                return fun(table, name)
            end
        end
        local l = split(name, '.')
        local t
        if package.loaded[name] then
            t = package.loaded[name]
        else
            t = do_at(function(t, n) return t[n] end, _G, unpack(l))
            if not t then
                package.loaded[name] = t
                do_at(function(g, n) g[n] = t end, _G, unpack(l))
            end
        end
        t._NAME = name
        t._M = t
        t._PACKAGE = string.sub(name, 1, string.len(name) - string.len(l[#l]) - 1)
        package.loaded[name] = t
        setfenv(0, t)
        for i, v in ipairs({...}) do
            v(t)
        end
        return t
    end,
    getfenv = getfenv,
    rawget = rawget,
    type = type,
    rawset = rawset,
    setmetatable = setmetatable,
    select = select,
    tostring = tostring,
    next = next,
    http = http,
    parallel = {
        create = function(f, ...)
            if select('#', ...) ~= 0 then
                return coroutine.yield('parallel', f), parallel.create(...)
            else
                return coroutine.yield('parallel', f)
            end
        end,
        waitForAny = function(...)
            coroutine.yield('wait', 1, parallel.create(...))
        end,
        waitForAll = function(...)
            coroutine.yield('wait', select('#', ...), parallel.create(...))
        end,
    },
    package = {
        cpath = '/',
        loaded = { },
        loaders = {
            function(name)
                return package.preload[name]
            end,
            function(name)
                name = string.gusb(string.gsub(name, '%.', '/'), '%%', '%%%%')
                local s = split(package.path, ';')
                for i, v in ipairs(s) do
                    local fun = loadfile(string.gsub(s[i], '%?', name))
                    if fun then
                        return fun
                    end
                end
            end,
            function(name)
                return nil
            end,
            function(name)
                return nil
            end,
        },
        path = '?;?.lua',
        preload = { },
        seeall = function(module)
            setmetatable(module, { __index = _G })
        end
    },
}

userfun[tenv.os.run] = true
userfun[tenv.require] = true
userfun[tenv.module] = true
userfun[tenv.package.seeall] = true
userfun[tenv.read] = true
userfun[tenv.parallel.create] = true
userfun[tenv.parallel.waitForAny] = true
userfun[tenv.parallel.waitForAll] = true
protectenv(tenv.package.loaders, true)
--assert(userfun[nil] ~= true)
local syscall = { }

local function cycle()
    while parallels[1].currentProcess do
        local running = false
        for i, v in ipairs(parallels) do
            currentParallel = v
            currentProcess = v.currentProcess
            while currentProcess and processInfo[currentProcess].status == 'dead' do
                if listener[currentProcess] then
                    for i, v in ipairs(listener[currentProcess]) do
                        v()
                    end
                end
                listener[currentProcess] = nil
                currentProcess = processInfo[currentProcess].parent
            end
            v.currentProcess = currentProcess
            if not currentProcess then
                if listener[v] then
                    for i, f in ipairs(listener[v]) do
                        f()
                    end
                    listener[v] = nil
                end
            elseif processInfo[currentProcess].status ~= 'wait' or processInfo[currentProcess].wait() then
                running = true
                returnValue = processInfo[currentProcess].returnValue
                local ret = rvpack(coroutine.resume(currentProcess, rvunpack(returnValue)))
                if not ret[1] then
                    processInfo[currentProcess].status = 'dead'
                    ret[1] = 'error'
                    local p = processInfo[currentProcess].parent
                    if p then
                        processInfo[p].returnValue = ret
                    else
                        print(rvunpack(ret))
                    end
                elseif coroutine.status(currentProcess) == 'dead' then
                    processInfo[currentProcess].status = 'dead'
                    ret[1] = true
                    local p = processInfo[currentProcess].parent
                    if p then
                        processInfo[p].returnValue = ret
                    end
                else
                    ret[2] = ret[2] or 'pull'
                    syscall[ret[2]](rvunpack(ret, 3))
                end
            end
        end
        if not running then
            queueEvent(pullEventRaw())
        end
    end
end

local function createProcess(file, argv, envp, eenv)
    envp = envp or duplicate(processInfo[currentProcess].environment)
    argv = argv or { }
    argv[0] = path
    argv.n = argv.n or #argv
    argv.s = argv.s or 1
    local penv = eenv or clone(tenv)
    penv._G = penv
    local co = coroutine.create(setfenv(file, penv))
    debug.setfenv(co, penv)
    debug.sethook(co, flushEvent, '', 2000)
    processInfo[co] = {
        environment = envp,
        arguments = argv,
        parent = currentProcess,
        parellel = currentParallel,
        returnValue = argv
    }
    return co
end

local function execf(file, argv, envp, eenv)
    local co = createProcess(file, argv, envp, eenv)
    currentParallel.currentProcess = co
end

local function exec(path, argv, envp, eenv)
    if type(path) == 'function' then
        return execf(path, argv, envp, eenv)
    end
    local file, err = loadfile(path)
    if file then
        return execf(file, argv, envp, eenv)
    end
    processInfo[currentProcess].returnValue = rvpack(false, err)
end

local function pull()
    local e = pullEvent()
    local info = processInfo[currentProcess]
    if e then
        info.returnValue = e
    elseif info.status ~= 'dead' then
        info.status = 'wait'
        e = currentParallel.events
        info.wait = function()
            if e.next then
                info.returnValue = assert(pullEvent())
                info.status = 'normal'
                return true
            end
        end
    end
end

local function discard()
    currentParallel.events = events.back
end

local function shutdown()
    os.shutdown()
    while true do
        coroutine.yield()
    end
end

local function parallel(func)
    local co = createProcess(func)
    local parallel = {
        currentProcess = co,
        events = currentParallel.events
    }
    local info = processInfo[co]
    info.parent = nil
    info.parallel = parallel
    table.insert(parallels, parallel)
    local v = { }
    handles[v] = parallel
    processInfo[currentProcess].returnValue = rvpack(v)
end

function wait(n, ...)
    for i, v in ipairs({...}) do
        if handles[v] then
            v = handles[v]
        end
        if not listener[v] then
            listener[v] = { }
        end
        if processInfo[v] and processInfo[v].status == 'dead' then
            n = n - 1
        end
        if v and v.currentProcess == nil then
            n = n - 1
        end
        table.insert(listener[v], function()
            n = n - 1
            if n <= 0 and info.status ~= 'dead' then
                info.status = 'normal'
            end
        end)
    end
    local info = processInfo[currentProcess]
    info.wait = function() end
    if info.status ~= 'dead' then
        info.status = 'wait'
    end
end

syscall.exec = execf
syscall.pull = pull
syscall.sleep = sleep
syscall.discard = discard
syscall.shutdown = shutdown
syscall.parallel = parallel
syscall.wait = wait

local tAPIsLoading = {}
function os.loadAPI( _sPath )
    local sName = fs.getName( _sPath )
    if tAPIsLoading[sName] == true then
        return false, "API "..sName.." is already being loaded"
    end
    tAPIsLoading[sName] = true

    local tEnv = {}
    setmetatable(tEnv, { __index = tenv })
    local fnAPI, err = loadfile( _sPath )
    if fnAPI then
        setfenv(fnAPI, tEnv)
        fnAPI()
    else
        return false, err
    end

    --_G[sName] = duplicate(tEnv)
    tenv[sName] = duplicate(tEnv, tenv[sName])
    tAPIsLoading[sName] = nil
    return true
end

function os.unloadAPI( _sName )
    if _sName ~= "_G" and type(_G[_sName] == "table") then
        tenv[sName] = nil
    end
end

-- Install the lua parts of the HTTP api (if enabled)
if http then
    http.get = function( _url )
        local requestID = http.request( _url )
        while true do
            local event, param1, param2 = os.pullEvent()
            if event == "http_success" and param1 == _url then
                return param2
            elseif event == "http_failure" and param1 == _url then
                return nil
            end
        end
    end
end

-- Load APIs
local tApis = fs.list( "rom/apis" )
for n,sFile in ipairs( tApis ) do
    if not fs.isDir( sFile ) and sFile ~= 'parallel' then
        os.loadAPI( fs.combine( "rom/apis", sFile ) )
    end
end

--tenv = clone(tenv)
protectenv(tenv)
currentProcess = createProcess(function()
        _G.parallel.create(rednet.run)
        os.run( {}, "rom/programs/shell" )
    end, nil, { })
local parallel = {
    currentProcess = currentProcess,
    events = events
}
local info = processInfo[currentProcess]
info.parent = nil
info.parallel = parallel
table.insert(parallels, parallel)
print(pcall(cycle))
local x = returnValue
print(rvunpack(returnValue))


--[[
-- Run the shell
local ok, err = pcall( function()
    parallel.waitForAny(
        function()
            rednet.run()
        end,
        function()
            os.run( {}, "rom/programs/shell" )
        end
    )
end )
if not ok then
    print( err )
end
]]
-- If the shell didn't shutdown the computer,
-- it probably errored, so let the user read it.

pcall( function()
    term.setCursorBlink( false )
    print( "Press any key to continue" )
    repeat
        local event = pullEventRaw()
    until event[1] == "key"
end )
os.shutdown() -- Just in case