cc-haxe/src/bin/Terminal.hx

package bin;

import kernel.ps.Process;
import kernel.ps.ProcessManager;
import kernel.ps.ProcessHandle;
import lib.ui.UIApp;
import lib.Color;
import kernel.ui.WindowContext;
import kernel.ui.WindowManager;

using tink.CoreApi;

class Terminal extends UIApp {
	private var context:WindowContext;
	private var input:String = "";
	private var backlog:Array<String> = [];
	private var exitTrigger: Bool -> Void;

	public function new() {}

	public function invoke(context: WindowContext): Future<Bool> {
		this.context = context;

		this.context.onChar.handle(char -> {
			this.input += char;
			this.redrawInput();
		});

		this.context.onKey.handle(e -> {
			if (e.keyCode == 259) {
				this.input = this.input.substr(0, this.input.length - 1);
				this.redrawInput();
			} else if (e.keyCode == 257) {
				this.backlog.push("> " + this.input);
				var command = this.input;
				this.input = "";
				this.redrawBacklog();
				this.redrawInput();
				this.invokeCommand(command);
			}
		});

		WindowManager.instance.focusContextToOutput(context, "main");
		this.redrawInput();

		return new Future<Bool>(cb -> {
			this.exitTrigger = cb;
			return null;
		});
	}

	private function redrawBacklog() {
		var size = this.context.getSize();
		var linesAvailable = size.y - 1;

		var start:Int = this.backlog.length - linesAvailable;

		for (i in 0...linesAvailable) {
			var line = this.backlog[start + i];

			this.context.setCursorPos(0, i);
			this.context.clearLine();

			if (line != null) {
				this.context.write(line);
			}
		}
		this.moveCursorToInput();
	}

	private function redrawInput() {
		var size = this.context.getSize();

		this.context.setCursorPos(0, size.y - 1);
		this.context.clearLine();

		this.context.setTextColor(Color.Blue);
		this.context.write("> ");

		this.context.setTextColor(Color.White);
		this.context.write(this.input);

		this.context.setCursorBlink(true);
	}

	private function invokeCommand(command:String):Void {
		var args = this.parseArgs(command);

		if (args.length == 0) {
			return;
		}
		var commandName = args[0];

		// Handle built-in commands
		switch (commandName) {
			case "clear":
				this.clear();
				return;
		}

		var commandArgs:Array<String> = args.slice(1);
		var hadInput = false;

		var ps = getProgByName(commandName);
		if (ps == null) {
			this.backlog.push("Unknown command: " + commandName);
			this.redrawBacklog();
			this.redrawInput();
			return;
		}

		ProcessManager.run(ps,{
			args: commandArgs,
			onWrite: (s:String) -> {
				if (!hadInput) {
					this.backlog.push("");
					hadInput = true;
				}
				this.backlog[this.backlog.length - 1] += s;
				this.redrawBacklog();
			},
			onExit: (success:Bool) -> {
				if (this.backlog[this.backlog.length - 1] == "") {
					this.backlog.pop();
				}

				this.redrawInput();
			}
		});

		this.context.setCursorBlink(false);
	}

	private function parseArgs(command:String):Array<String> {
		// TODO: tim and quote handling
		return command.split(" ");
	}

	private function clear() {
		this.backlog = [];
		this.redrawBacklog();
	}

	private function getProgByName(name:String):Process {
		switch (name) {
			case "hello":
				return new HelloWorld();
			case "net":
				return new Net();
			case "rs":
				return new Redstone();
			case "disk":
				return new Disk();
			case "gps":
				return new GPS();
			case "turtle":
				return new Turtle();
			default:
				return null;
		}
	}

	private function moveCursorToInput() {
		var size = this.context.getSize();
		this.context.setCursorPos(this.input.length + 2, size.y - 1);
	}
}