-- :Minify:--
local kernel = ...
local apis = kernel.apis
local native = apis.peripheral
local sides = {"top", "bottom", "left", "right", "front", "back"}
local peripheral={}

function peripheral.getNames()
    local results = {}
    for n = 1, #sides do
        local side = sides[n]
        if native.isPresent(side) then
            table.insert(results, side)
            if native.hasType(side, "peripheral_hub") then
                local remote = native.call(side, "getNamesRemote")
                for _, name in ipairs(remote) do
                    table.insert(results, name)
                end
            end
        end
    end
    return results
end

function peripheral.isPresent(name)
    if native.isPresent(name) then
        return true
    end

    for n = 1, #sides do
        local side = sides[n]
        if native.hasType(side, "peripheral_hub") and native.call(side, "isPresentRemote", name) then
            return true
        end
    end
    return false
end

function peripheral.getType(peripheral)
    if type(peripheral) == "string" then
        if native.isPresent(peripheral) then
            return native.getType(peripheral)
        end
        for n = 1, #sides do
            local side = sides[n]
            if native.hasType(side, "peripheral_hub") and native.call(side, "isPresentRemote", peripheral) then
                return native.call(side, "getTypeRemote", peripheral)
            end
        end
        return nil
    else
        local mt = getmetatable(peripheral)
        if not mt or mt.__name ~= "peripheral" or type(mt.types) ~= "table" then
            error("bad argument #1 (table is not a peripheral)", 2)
        end
        return table.unpack(mt.types)
    end
end

function peripheral.hasType(peripheral, peripheral_type)
    if type(peripheral) == "string" then
        if native.isPresent(peripheral) then
            return native.hasType(peripheral, peripheral_type)
        end
        for n = 1, #sides do
            local side = sides[n]
            if native.hasType(side, "peripheral_hub") and native.call(side, "isPresentRemote", peripheral) then
                return native.call(side, "hasTypeRemote", peripheral, peripheral_type)
            end
        end
        return nil
    else
        local mt = getmetatable(peripheral)
        if not mt or mt.__name ~= "peripheral" or type(mt.types) ~= "table" then
            error("bad argument #1 (table is not a peripheral)", 2)
        end
        return mt.types[peripheral_type] ~= nil
    end
end

function peripheral.getMethods(name)
    if native.isPresent(name) then
        return native.getMethods(name)
    end
    for n = 1, #sides do
        local side = sides[n]
        if native.hasType(side, "peripheral_hub") and native.call(side, "isPresentRemote", name) then
            return native.call(side, "getMethodsRemote", name)
        end
    end
    return nil
end

function peripheral.getName(peripheral)
    local mt = getmetatable(peripheral)
    if not mt or mt.__name ~= "peripheral" or type(mt.name) ~= "string" then
        error("bad argument #1 (table is not a peripheral)", 2)
    end
    return mt.name
end

function peripheral.call(name, method, ...)
    if native.isPresent(name) then
        return native.call(name, method, ...)
    end

    for n = 1, #sides do
        local side = sides[n]
        if native.hasType(side, "peripheral_hub") and native.call(side, "isPresentRemote", name) then
            return native.call(side, "callRemote", name, method, ...)
        end
    end
    return nil
end

function peripheral.wrap(name)
    local methods = peripheral.getMethods(name)
    if not methods then
        return nil
    end

    local types = { peripheral.getType(name) }
    for i = 1, #types do types[types[i]] = true end
    local result = setmetatable({}, {
        __name = "peripheral",
        name = name,
        type = types[1],
        types = types,
    })
    for _, method in ipairs(methods) do
        result[method] = function(...)
            return peripheral.call(name, method, ...)
        end
    end
    return result
end

function peripheral.find(ty, filter)
    local results = {}
    for _, name in ipairs(peripheral.getNames()) do
        if peripheral.hasType(name, ty) then
            local wrapped = peripheral.wrap(name)
            if filter == nil or filter(name, wrapped) then
                table.insert(results, wrapped)
            end
        end
    end
    return table.unpack(results)
end

local icolors = {
    [0x1] = 1, -- #000000
    [0x2] = 2, -- #FFFFFF
    [0x4] = 3, -- #FF0000
    [0x8] = 4, -- #00FF00
    [0x10] = 5, -- #0000FF
    [0x20] = 6, -- #00FFFF
    [0x40] = 7, -- #FF00FF
    [0x80] = 8, -- #FFFF00
    [0x100] = 9, -- #FF6D00
    [0x200] = 10, -- #6DFF55
    [0x400] = 11, -- #24FFFF
    [0x800] = 12, -- #924900
    [0x1000] = 13, -- #6D6D55
    [0x2000] = 14, -- #DBDBAA
    [0x4000] = 15, -- #6D00FF
    [0x8000] = 16 -- #B6FF00
}

local colors = {
    0x0001, -- #000000
    0x0002, -- #FFFFFF
    0x0004, -- #FF0000
    0x0008, -- #00FF00
    0x0010, -- #0000FF
    0x0020, -- #00FFFF
    0x0040, -- #FF00FF
    0x0080, -- #FFFF00
    0x0100, -- #FF6D00
    0x0200, -- #6DFF55
    0x0400, -- #24FFFF
    0x0800, -- #924900
    0x1000, -- #6D6D55
    0x2000, -- #DBDBAA
    0x4000, -- #6D00FF
    0x8000 -- #B6FF00
}

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

    for i = 1, #text do
        local c = text:sub(i, i)

        if c == "\n" then
            y = y + 1
            x = 1
        elseif c == "\t" then
            local tabSize = 4
            local spaces = tabSize - ((x - 1) % tabSize)
            term.write(string.rep(" ", spaces))
            x = x + spaces
        elseif c == "\b" then
            if x > 1 then
                x = x - 1
                term.setCursorPos(x, y)
                term.write(" ")
                term.setCursorPos(x, y)
            end
        else
            if x <= w and y <= h then
                term.setCursorPos(x, y)
                term.write(c)
                x = x + 1
            end
        end

        if x > w then
            x = 1
            y = y + 1
        end

        if y - 1 >= h then
            term.scroll(1)
            y = h
            term.setCursorPos(x, y)
        end
    end

    term.setCursorPos(x, y)
end

kernel.devfs.data.tty={}
local ctrl,alt = false, false

local function serializeBool(bool)
    if bool then
        return "T"
    else
        return "F"
    end
end

local function newtty(obj, id, ev)
    kernel.devfs.data["tty"][id] = function(op, mode)
        if op=="type" then
            return "character device"
        elseif op=="open" then
            local h = {
                read=function(amount)
                    local rv=""
                    for i=1, amount or 1 do
                        local event = {ev()}
                        if event[1] then
                            rv=rv..event[1]
                        end
                    end
                    if rv=="" then rv=nil end
                    return rv
                end,
                write=function(content)
                    write(content, obj)
                end,
                size=function()
                    local s={obj.getSize()}
                    return table.concat(s,";")
                end,
                clear=function()
                    obj.clear()
                    obj.setCursorPos(1,1)
                end,
                gpos=function()
                    local s={obj.getCursorPos()}
                    return table.concat(s,";")
                end,
                spos=function(x,y)
                    return obj.setCursorPos(x,y)
                end,
                sfgc=function(c)
                    return obj.setTextColor(colors[c])
                end,
                sbgc=function(c)
                    return obj.setBackgroundColor(colors[c])
                end,
                gfgc=function()
                    return icolors[obj.getTextColor()]
                end,
                gbgc=function()
                    return icolors[obj.getBackgroundColor()]
                end,
                gctrl=function()
                    return serializeBool(ctrl)..";"..serializeBool(alt)
                end
            }
            if mode=="rw" then
                return h
            elseif mode=="r" then
                h["write"]=nil
                return h
            elseif mode=="w" then
                h["read"]=nil
                return h
            end
        end
    end
end

local fifo = kernel.newFifo()

local ctrlLetterKeys = nil
local specialKeys = nil

local function buildKeyMaps()
    if ctrlLetterKeys then return end
    local k = apis.keys
    ctrlLetterKeys = {}
    local letters = {
        {k.a,1},{k.b,2},{k.c,3},{k.d,4},{k.e,5},{k.f,6},{k.g,7},
        {k.h,8},        {k.j,10},{k.k,11},{k.l,12},{k.m,13},
        {k.n,14},{k.o,15},{k.p,16},
        {k.u,21},{k.v,22},{k.w,23},{k.x,24},{k.y,25},{k.z,26},
    }
    for _, pair in ipairs(letters) do
        ctrlLetterKeys[pair[1]] = string.char(pair[2])
    end
    specialKeys = {
        [k.home]    = "\1",
        [k.delete]  = "\4",
        [k["end"]] = "\5",
        [k.pageUp]  = "\2",
        [k.pageDown]= "\12",
    }
end

kernel.processes.cctmond = function()
    local _getTasks  = function()
        local ret = {}
        for _, v in pairs(kernel.tasks) do ret[#ret+1] = v.pid end
        return ret
    end
    local _sigsend   = kernel.signal.sigsend

    local timeout = false
    while true do
        local event = {kernel.computer:getMachineEvent()}

        if event[1] then
            local eventType = event[1]
            local charOrKey = event[3]

            buildKeyMaps()

            if eventType == "keyPressed" then
                if charOrKey == apis.keys.leftCtrl or charOrKey == apis.keys.rightCtrl then
                    ctrl = true
                elseif charOrKey == apis.keys.leftAlt or charOrKey == apis.keys.rightAlt then
                    alt = true
                end

                if ctrl and charOrKey == apis.keys.c then
                    for _, pid in ipairs(_getTasks()) do
                        _sigsend(pid, 1)
                    end
                end

                if ctrl and ctrlLetterKeys[charOrKey] then
                    fifo.push(ctrlLetterKeys[charOrKey])
                end

                if specialKeys[charOrKey] then
                    fifo.push(specialKeys[charOrKey])
                end
            elseif eventType == "keyReleased" then
                if charOrKey == apis.keys.leftCtrl or charOrKey == apis.keys.rightCtrl then
                    ctrl = false
                elseif charOrKey == apis.keys.leftAlt or charOrKey == apis.keys.rightAlt then
                    alt = false
                end
            elseif eventType == "keyTyped" then
                if charOrKey then fifo.push(charOrKey) end
            end

            timeout = false
        else
            timeout = true
        end

        if timeout then
            sleep(0.05)
        end
    end
end

newtty(apis.term, "tty1", fifo.pop)


for i,v in ipairs({peripheral.find("monitor")}) do
    v.setTextScale(.5)
    v.write("Initializing...")
    newtty(v,"tty"..tostring(i+1),function () end)
end