screens-API

local screens = {}
local screenFuncs = {}

local activeScreen = nil
local displayScreen = nil

local termHooks = {}
local hookFuncs = {}
local screenSizeX,screenSizeY = term.getSize()


local function unhookTerm()
    for k,v in pairs(termHooks) do
        term[k] = v
    end
end

function getScreenByName(screenID)
    return screens[screenID]
end

function getActiveScreen()
    return getScreenByName(activeScreen)
end

function getDisplayScreen()
    return getScreenByName(displayScreen)
end

function setActiveScreen(screenID)

    activeScreen = screenID
    log("Changed active screen to "..screenID)
end

function setDisplayScreen(screenID)
    displayScreen = screenID
    log("Changed display screen to "..screenID)
    --setActiveScreen(screenID)
    local screen = getDisplayScreen()
    screen:redrawAll()
    log("Display Screen CPOS:" .. screen.cursorPosX.."/"..screen.cursorPosY.." // Blink: " ..tostring(screen.cursorBlink))
    termHooks.setCursorBlink(screen.cursorBlink)
    termHooks.setCursorPos(screen.cursorPosX,screen.cursorPosY)
    termHooks.setCursorBlink(screen.cursorBlink)
end

function setActiveAndDisplayScreen(screenID)
    setActiveScreen(screenID)
    setDisplayScreen(screenID)
end

function addScreen(screen)
    screens[screen.screenName] = screen
    log("Screen added: "..screen.screenName)
end

function screenFuncs:redraw(sX,sY,w,h)
    log("Redrawing screen "..self.screenName.." Area: "..sX.."/"..sY.."/"..w.."/"..h)
    for y=1,h,1 do

        termHooks.setCursorPos(sX,sY+y-1)
        termHooks.write(string.sub(self.screenData[sY+y-1],sX,sX+w-1))
    end
    log("Redraw done")
end

function screenFuncs:redrawAll()
    log("Full redraw of screen "..self.screenName)
    self:redraw(1,1,screenSizeX,screenSizeY)
end

function initBlankScreenData()
    local data = {}
    local dataLine = string.rep(" ",screenSizeX)
    for y=1,screenSizeY,1 do
        table.insert(data,dataLine)
    end
    return data
end

function newScreen(screenName,autoAdd)
    autoAdd = autoAdd or true
    local t = {}

    t.screenName = screenName
    t.screenData = initBlankScreenData()
    t.cursorBlink = true
    t.cursorPosX,t.cursorPosY = 1,1
    setmetatable(t,{__index=screenFuncs})
    log("Screen created: " .. screenName)
    if autoAdd then addScreen(t) end
    return t
end

function removeScreen(screenName)
    local screen = getActiveScreen()
    local screenD = getDisplayScreen()
    screens[screenName] = nil
    if screen.screenName == screenName then
        setActiveScreen("shell")
    end
    if screenD.screenName == screenName then
        setDisplayScreen("shell")
    end

end

hookFuncs.write = function(str)

    local screen = getActiveScreen()
    log("Writeing /"..str.."/ on /"..screen.screenName.."/")
    local wLine = screen.screenData[screen.cursorPosY]
    local sX = screen.cursorPosX
    local pre = ""
    if sX > 1 then
        pre = string.sub(wLine,1,sX-1)
    end
    local post = ""
    sX = screen.cursorPosX + string.len(str)
    if sX <= screenSizeX then
        post = string.sub(wLine,sX)
    end
    local newLine = string.sub(pre..str..post,1,screenSizeX)
    screen.screenData[screen.cursorPosY] = newLine
    if getDisplayScreen().screenName == screen.screenName then
        screen:redraw(screen.cursorPosX,screen.cursorPosY,string.len(str),1)
    end
    screen.cursorPosX = math.min(screen.cursorPosX + string.len(str),screenSizeX)
end

hookFuncs.getCursorPos = function()

    local screen = getActiveScreen()
    --log("Cursor pos of "..screen.screenName)
    return screen.cursorPosX,screen.cursorPosY
end

hookFuncs.setCursorPos = function(x,y)
    local screen = getActiveScreen()
    x = math.min(screenSizeX,x)
    x = math.max(x,1)
    y= math.min(screenSizeY,y)
    y = math.max(y,1)
    screen.cursorPosX,screen.cursorPosY = x,y
    if getDisplayScreen().screenName == screen.screenName then
        termHooks.setCursorPos(x,y)
    end
end

hookFuncs.clearLine = function()
    local screen = getActiveScreen()
    screen.screenData[screen.cursorPosY] = string.rep(" ",screenSizeX)
    if getDisplayScreen().screenName == screen.screenName then
        screen:redraw(1,screen.cursorPosY,screenSizeX,1)
    end
end

hookFuncs.setCursorBlink = function(b)
    local screen = getActiveScreen()
    screen.cursorBlink = b
    log("Change Cursor Blink on " .. screen.screenName .. " to "..tostring(b))
    if getDisplayScreen().screenName == screen.screenName then termHooks.setCursorBlink(b) end
end

hookFuncs.clear = function()
    local screen = getActiveScreen()
    log("Clearing: "..screen.screenName)
    screen.screenData = initBlankScreenData()
    if getDisplayScreen().screenName == screen.screenName then screen:redrawAll() end
end

hookFuncs.scroll = function(n)
    if n <= screenSizeY then
        term.clear()
    else
        local screen = getActiveScreen()
        for y=1,screenSizeY-n,1 do
            screen.screenData[y] = screen.screenData[y+n]
        end
        for y=screenSizeY-n+1,screenSizeY,1 do
            screen.screenData[y] = string.rep(" ",screenSizeX)
        end
        if screen.screenName == getDisplayScreen().screenName then
            screen:redrawAll()
        end
    end
end

local function hookTerm()
    log("Hooking term funcs")
    for k,v in pairs(hookFuncs) do
        log("Hooking "..k)
        --print("Hooking: "..k)
        termHooks[k]=term[k]
        term[k]=v
    end
end
hookTerm()
log("Creating shell screen")
newScreen("shell")
setActiveAndDisplayScreen("shell")