MudDev [WIP]

--[[
		MudDev: An extension of shell made to appeal to developers.
		Credit to Espen for his epic tab completing read.
		Credit to the ComputerCraft team for making the original shell.
]]
if not term.isColor then printError("Cannot run without color support.") error("",0) end
local mX,mY=term.getSize()
local function centerPrint(text, ny, tC, bC)
	if tC then term.setTextColor(tC) end
	if bC then term.setBackgroundColor(bC) end
	if type(text) == "table" then for _, v in pairs(text) do centerPrint(v) end
	else
		local x, y = term.getCursorPos()
		local w, h = term.getSize()
		term.setCursorPos(w/2 - text:len()/2 + (#text % 2 == 0 and 1 or 0), ny or y)
		print(text)
	end
end

local ideas={
firstword={
"Rednet",
"Turtle",
"Bacon",
"File",
"Working",
"Advanced",
"GUI",
},
secondword={
"Bootloader",
"Packaging",
"Cheesecake",
"Encryption",
"Sandbox",
"Anti-Virus",
"Role-Playing",
},
thirdword={
"OS",
"API",
"Game",
"Browser",
"Program",
"Derpcake",
"Dev Tool",
},
}

local fw=ideas.firstword
local sw=ideas.secondword
local tw=ideas.thirdword

local function getIdea()
local promptColour, textColour, bgColour
	if term.isColour() then
		promptColour = colours.orange
		textColour = colours.lightBlue
		bgColour = colours.black
	else
		promptColour = colours.white
		textColour = colours.white
		bgColour = colours.black
	end
	while true do
	term.setBackgroundColor(bgColour)
	term.clear()
	paintutils.drawLine(1, 1, 1, mY, promptColour)
	paintutils.drawLine(1, 1, mX, 1, promptColour)
	paintutils.drawLine(1, mY, mX, mY, promptColour)
	paintutils.drawLine(mX, 1, mX, mY, promptColour)
	term.setTextColor(promptColour)
	term.setBackgroundColor(bgColour)
	centerPrint("Your program idea is....",math.floor(mY/2)-1)
	centerPrint(fw[math.random(#fw)].." "..sw[math.random(#sw)].." "..tw[math.random(#tw)],math.floor(mY/2))
	centerPrint("Press Space to exit",mY-2)
	centerPrint("Press any other key to generate a new idea.",mY-4)
	local e,key=os.pullEventRaw("key")
	if key==keys.space then return end
	end
end


local function drawMenu()
	local promptColour, textColour, bgColour
	if term.isColour() then
		promptColour = colours.orange
		textColour = colours.lightBlue
		bgColour = colours.black
	else
		promptColour = colours.white
		textColour = colours.white
		bgColour = colours.black
	end

	local promptColor=promptColour
	local textColor=textColour
	local bgColor=bgColour
	local mX,mY=term.getSize()
	term.setBackgroundColor(bgColor)
	term.clear()
	paintutils.drawLine(1, 1, 1, mY, promptColour)
	paintutils.drawLine(1, 1, mX, 1, promptColour)
	paintutils.drawLine(1, mY, mX, mY, promptColour)
	paintutils.drawLine(mX, 1, mX, mY, promptColour)
	centerPrint("MudDev Controls",2,promptColor,bgColor)
	centerPrint("TAB: Toggle Tab-Completion",4)
	centerPrint("R: Reboot",6)
	centerPrint("S: Shutdown",8)
	centerPrint("I: Program Ideas",10)
	centerPrint("ALT: Exit Menu",11)
end

local cTable={
	["tab"]=function() tabAuto=not tabAuto print("test") end,
	["r"]=function() os.reboot() end,
	["s"]=function() os.shutdown() end,
	["i"]=function() getIdea() drawMenu() end,
}

local tabAuto=true
local parentShell = shell

local bExit = false
local sDir = (parentShell and parentShell.dir()) or ""
local sPath = (parentShell and parentShell.path()) or ".:/rom/programs"
local tAliases = (parentShell and parentShell.aliases()) or {}
local tProgramStack = {}
local shell = {}
local tEnv = {
	["shell"] = shell,
}
local mX,mY=term.getSize()


-- Install shell API
function shell.run( ... )
	return runLine( table.concat( { ... }, " " ) )
end

function shell.exit()
    bExit = true
end

function shell.dir()
	return sDir
end

function shell.setDir( _sDir )
	sDir = _sDir
end

function shell.path()
	return sPath
end

function shell.setPath( _sPath )
	sPath = _sPath
end

function shell.resolve( _sPath )
	local sStartChar = string.sub( _sPath, 1, 1 )
	if sStartChar == "/" or sStartChar == "\\" then
		return fs.combine( "", _sPath )
	else
		return fs.combine( sDir, _sPath )
	end
end

function shell.resolveProgram( _sCommand )
	-- Substitute aliases firsts
	if tAliases[ _sCommand ] ~= nil then
		_sCommand = tAliases[ _sCommand ]
	end

    -- If the path is a global path, use it directly
    local sStartChar = string.sub( _sCommand, 1, 1 )
    if sStartChar == "/" or sStartChar == "\\" then
    	local sPath = fs.combine( "", _sCommand )
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then
			return sPath
    	end
		return nil
    end

 	-- Otherwise, look on the path variable
    for sPath in string.gmatch(sPath, "[^:]+") do
    	sPath = fs.combine( shell.resolve( sPath ), _sCommand )
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then
			return sPath
    	end
    end

	-- Not found
	return nil
end

function shell.programs( _bIncludeHidden )
	local tItems = {}

	-- Add programs from the path
    for sPath in string.gmatch(sPath, "[^:]+") do
    	sPath = shell.resolve( sPath )
		if fs.isDir( sPath ) then
			local tList = fs.list( sPath )
			for n,sFile in pairs( tList ) do
				if not fs.isDir( fs.combine( sPath, sFile ) ) and
				   (_bIncludeHidden or string.sub( sFile, 1, 1 ) ~= ".") then
					tItems[ sFile ] = true
				end
			end
		end
    end

	-- Sort and return
	local tItemList = {}
	for sItem, b in pairs( tItems ) do
		table.insert( tItemList, sItem )
	end
	table.sort( tItemList )
	return tItemList
end

function shell.getRunningProgram()
	if #tProgramStack > 0 then
		return tProgramStack[#tProgramStack]
	end
	return nil
end

function shell.setAlias( _sCommand, _sProgram )
	tAliases[ _sCommand ] = _sProgram
end

function shell.clearAlias( _sCommand )
	tAliases[ _sCommand ] = nil
end

function shell.aliases()
	-- Add aliases
	local tCopy = {}
	for sAlias, sCommand in pairs( tAliases ) do
		tCopy[sAlias] = sCommand
	end
	return tCopy
end

local function nRead( _sReplaceChar, _tHistory )
	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( _sCustomReplaceChar )
		local nScroll = 0
		if sx + nPos >= w then
			nScroll = (sx + nPos) - w
		end

		term.setCursorPos( sx, sy )
		local sReplace = _sCustomReplaceChar or _sReplaceChar
		if sReplace then
			term.write( string.rep(sReplace, 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 == keys.enter then
				-- Enter
				break

			elseif param == keys.left then
				-- Left
				if nPos > 0 then
					nPos = nPos - 1
					redraw()
				end

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

			elseif param == keys.up or param == keys.down then
                -- Up or down
				if _tHistory then
					redraw(" ");
					if param == keys.up 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 == keys.backspace then
				-- Backspace
				if nPos > 0 then
					redraw(" ");
					sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
					nPos = nPos - 1
					redraw()
				end
			elseif param == keys.home then
				-- Home
				nPos = 0
				redraw()
			elseif param == keys.delete then
				if nPos < string.len(sLine) then
					redraw(" ");
					sLine = string.sub( sLine, 1, nPos ) .. string.sub( sLine, nPos + 2 )
					redraw()
				end
			elseif param == keys["end"] then
				-- End
				nPos = string.len(sLine)
				redraw()
			elseif (param == keys["leftAlt"]) or (param == keys["rightAlt"]) then
				return 1337
			end
		end
	end

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

	return sLine
end

--[[
Modified read() with Tab-Completion v1.2 by Espen
Original from shell-file of ComputerCraft v1.46

Changelog:
v1.2 - Added a separate program to to allow runtime-injection of the custom read() into the running shell of an individual computer.
        Thanks @BigSHinyToys for making me aware of the global table's dropped protection. ^_^
v1.12 - Fixed: Pressing Tab without entering anything threw an error.
v1.11 - Removed previously introduced, but now unnecessary parameter from read()
v1.1 - Path traversal implemented
v1.0 - Initial release
--]]

local function mRead( _sReplaceChar, _tHistory )
        term.setCursorBlink( true )

    local sLine = ""
    local tMatches = { pointer = 0, get = function( self ) return self[ self.pointer ] end }    -- tMatches:get() == tMatches[ tMatches.pointer ]
        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( _sCustomReplaceChar )
                local nScroll = 0
                if sx + nPos >= w then
                        nScroll = (sx + nPos) - w
                end

                term.setCursorPos( sx, sy )
                local sReplace = _sCustomReplaceChar or _sReplaceChar
                if sReplace then
                        term.write( string.rep(sReplace, 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
            tMatches = { pointer = 0, get = function( self ) return self[ self.pointer ] end }  -- Reset completion match-table.
                        sLine = string.sub( sLine, 1, nPos ) .. param .. string.sub( sLine, nPos + 1 )
                        nPos = nPos + 1
                        redraw()

                elseif sEvent == "key" then
            if not (param == keys.tab) then
                tMatches = { pointer = 0, get = function( self ) return self[ self.pointer ] end }  -- Reset completion match-table.
            end
                    if param == keys.enter then
                                -- Enter
                                break

            elseif param == keys.tab then
                -- Tab
                if #tMatches > 0 then   -- tab was pressed before.
                    -- [[ We already have matches, show the next one ]]
                    local nLastMatchSize = string.len( tMatches:get() )

                    -- Shift pointer to next match.
                    tMatches.pointer = tMatches.pointer + 1
                    if tMatches.pointer > #tMatches then tMatches.pointer = 1 end  -- Wrap around if the pointer has gone past the end.

                    -- Clear the line if the new match is smaller than the previous.
                    if string.len(tMatches:get()) < nLastMatchSize then redraw(" ") end
                    -- Assemble the new line.
                    sLine = string.sub( sLine, 1, nPos - nLastMatchSize ) .. tMatches:get()
                    nPos = string.len(sLine)
                    redraw()
                else
                    -- [[ No matches yet, look for some now. ]]
                    local sLastPar = string.match( sLine, "[^%s]+$" ) or ""     -- Get last entered parameter.
                    local sToMatch = string.match( sLastPar, "[^%s/\.]+$" ) or ""   -- Get filename-part of sLastPar.

                    -- Only look for matches if there was something afters the last slash.
                    if sToMatch and sToMatch ~= "" then
                        -- Get absolute path of the entered location.
                        local sAbsPath = shell.resolve( sLastPar )
                        -- Cut off filename, e.g. /some/test/path -> /some/test/
                        if not fs.isDir( sAbsPath ) then
                            sAbsPath = string.match( sAbsPath, "^([^%s]+[/\])[^%s/\]+[/\]?$" )
                        end
                        if not sAbsPath then sAbsPath = shell.resolve( "/" ) end

                        -- Search for matches in the resolved folder.
                        local ok, tFileList = pcall( fs.list, sAbsPath )
                        if ok then
                            local match = nil
                            -- Populate table with all matches.
                            for k, v in ipairs(tFileList) do
                                match = string.match( v, "^"..sToMatch..".*$" )
                                if match then
                                    table.insert( tMatches, match )
                                end
                            end
                        end

                        -- Show first match.
                        if #tMatches > 0 then
                            tMatches.pointer = 1
                            local partialMatch = string.gsub( tMatches:get(), "^"..sToMatch, "" )
                            sLine = sLine..partialMatch
                            nPos = nPos + string.len( partialMatch )
                            redraw()
                        end
                    end
                end

                        elseif param == keys.left then
                                -- Left
                                if nPos > 0 then
                                        nPos = nPos - 1
                                        redraw()
                                end

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

                        elseif param == keys.up or param == keys.down then
                -- Up or down
                                if _tHistory then
                                        redraw(" ");
                                        if param == keys.up 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 == keys.backspace then
                                -- Backspace
                                if nPos > 0 then
                                        redraw(" ");
                                        sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
                                        nPos = nPos - 1
                                        redraw()
                                end
                        elseif param == keys.home then
                                -- Home
                                nPos = 0
                                redraw()
                        elseif param == keys.delete then
                                if nPos < string.len(sLine) then
                                        redraw(" ");
                                        sLine = string.sub( sLine, 1, nPos ) .. string.sub( sLine, nPos + 2 )
                                        redraw()
                                end
                        elseif param == keys["end"] then
                                -- End
                                nPos = string.len(sLine)
                                redraw()
                        elseif param==keys.leftAlt or param==keys.rightAlt then
                        	return 1337
                        end
                end
        end

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

        return sLine
end

-- Colours
local promptColour, textColour, bgColour
if term.isColour() then
	promptColour = colours.orange
	textColour = colours.lightBlue
	bgColour = colours.black
else
	promptColour = colours.white
	textColour = colours.white
	bgColour = colours.black
end

local promptColor=promptColour
local textColor=textColour
local bgColor=bgColour


local function run( _sCommand, ... )
	local sPath = shell.resolveProgram( _sCommand )
	if sPath ~= nil then
		tProgramStack[#tProgramStack + 1] = sPath
   		local result = os.run( tEnv, sPath, ... )
		tProgramStack[#tProgramStack] = nil
		return result
   	else
    	printError( "No such program" )
    	return false
    end
end

local function runLine( _sLine )
	local tWords = {}
	for match in string.gmatch( _sLine, "[^ \t]+" ) do
		table.insert( tWords, match )
	end

	local sCommand = tWords[1]
	if sCommand then
		return run( sCommand, unpack( tWords, 2 ) )
	end
	return false
end

term.setBackgroundColor( bgColour )
term.setTextColour( promptColour )
print( "MudDev: "..os.version() )
term.setTextColour( textColour )

-- If this is the toplevel shell, run the startup programs
if parentShell == nil then
	-- Run the startup from the ROM first
	local sRomStartup = shell.resolveProgram( "/rom/startup" )
	if sRomStartup then
		shell.run( sRomStartup )
	end

	-- Then run the user created startup, from the disks or the root
	local sUserStartup = shell.resolveProgram( "/startup" )
	for n,sSide in pairs( peripheral.getNames() ) do
	--for n,sSide in pairs( redstone.getSides() ) do
		if disk.isPresent( sSide ) and disk.hasData( sSide ) then
			local sDiskStartup = shell.resolveProgram( fs.combine(disk.getMountPath( sSide ), "startup") )
			if sDiskStartup then
				sUserStartup = sDiskStartup
				break
			end
		end
	end

	if sUserStartup then
		shell.run( sUserStartup )
	end
end

-- Run any programs passed in as arguments
local tArgs = { ... }
if #tArgs > 0 then
	shell.run( ... )
end

-- Read commands and execute them
local tCommandHistory = {}
while not bExit do
	local sRead=tabAuto and mRead or nRead
	term.setBackgroundColor( bgColour )
	term.setTextColour( promptColour )
	write( shell.dir() .. "> " )
	term.setTextColour( textColour )

	local sLine = sRead( nil, tCommandHistory )
	if sLine ~= 1337 then
		table.insert( tCommandHistory, sLine )
		runLine( sLine )
	else
		drawMenu()
		while true do
			local e,param=os.pullEventRaw("key")
			if (param == keys["leftAlt"]) or (param == keys["rightAlt"]) then
				break
			elseif param==keys["tab"] then tabAuto=not tabAuto
			elseif cTable[keys.getName(param)] then
				cTable[keys.getName(param)]()
			end
		end
		term.setBackgroundColor(bgColor)
		term.clear()
		term.setCursorPos(1,1)
	end
end

-- If this is the toplevel shell, run the shutdown program

term.setTextColor(promptColor)
print("Goodbye")
sleep(1)

os.shutdown() -- just in case