import std.conv;
import std.stdio;
import std.string;
import std.ascii;

import std.file;

class ShellException : Exception {
	string command;
	string message;
	this(string command, string message, string file = __FILE__, int line = __LINE__) {
		this.command = command;
		this.message = message;
		super(command ~ ": " ~ message, file, line);
	}
}

class CommandShell {
	CommandWrapper[string] _builtins;

	const:

	ProgramData eval(string line) {
		auto commands = parseCommands(line);

		ProgramData newestResult;
		foreach(command; commands) {
			if(command.app in _builtins) {
				newestResult = _builtins[command.app](command, newestResult);
			} else {
				throw new ShellException(command.app, "no such command");
			}
		}

		return newestResult;
	}

	auto ls(string pattern) {
		if(pattern.length == 0)
			pattern = "*";
		return dirEntries(".", pattern, SpanMode.shallow);
	}

	string echo(string[] argv) {
		return argv.join(" ");
	}

	int[] numbers() {
		return [1, 2, 3, 4];
	}

	int sum(ProgramData input) {
		int s = 0;
		foreach(num; originalProgramData!(int[])(input)) {
			s += num;
		}

		return s;
	}

	ProgramData cat(ProgramData input) {
		return input;
	}
}


struct ProgramDataByLine {
	ProgramData base;
	this(ProgramData b) {
		assert(b !is null);

		this.base = b;
		if(!empty)
			currentString = base.getFrontAsString();
	}

	string currentString;
	@property bool empty() { return base.empty(); }
	@property string front() { return currentString; }
	void popFront() {
		base.popFront();
		if(!empty())
			currentString = base.getFrontAsString();
	}
}

interface ProgramData {
	bool empty();
	void popFront();
	string getFrontAsString();

	/*
		front is implemented however you want in the derived classes
		this lets you do them with other type for more static goodness

		as long as you can convert to a string in getFrontAsString we'll
		be ok for the simpler stuffs.
	*/

	// formatting to the user
	string header();
	string footer();
	string itemSeperator();
	string item();
}

import std.range;

class ProgramDataImpl(T) if(!(is(T == string) || is(T == int))) : ProgramData {
	T range;
	this(T r) {
		this.range = r;
	}

	override bool empty() {
		return range.empty();
	}

	override void popFront() {
		range.popFront();
	}

	auto front() {
		return range.front();
	}

	override string getFrontAsString() {
		static if(is(typeof(range.front()) == DirEntry))
			return range.front().name;
		else
			return to!string(range.front());
	}

	string header() { return ""; }
	string footer() { return ""; }
	string itemSeperator() { return "\n"; }
	string item() { return getFrontAsString(); }
}

class ProgramDataImpl(T) if(is(T == string) || is(T == int)) : ProgramData {
	T s;
	bool consumed;
	this(T r) {
		this.s = r;
	}

	override bool empty() {
		return consumed;
	}

	override void popFront() {
		consumed = true;
	}

	auto front() {
		return s;
	}

	override string getFrontAsString() {
		return to!string(s);
	}

	string header() { return ""; }
	string footer() { return ""; }
	string itemSeperator() { return "\n"; }
	string item() { return getFrontAsString(); }
}

ProgramDataImpl!T originalProgramData(T)(ProgramData t) {
	auto data = cast(ProgramDataImpl!T) t;
	if(data is null)
		throw new Exception("can't do it");
	return data;
}

ProgramData makeProgramData(T)() if(is(T == void)) {
	return makeProgramData("");
}

ProgramData makeProgramData(T)(T t) {
	static if(is(T : ProgramData))
		return t;
	else
		return new ProgramDataImpl!T(t);
}


extern(C) {
	char* readline(const char* prompt);
	void using_history();
	void add_history(const char* s);
}

string[] lex(string line) {
	auto specialCharacters = `|`;//"'{}[]()|><!#$&\`;
	bool isSpecial(char c) {
		foreach(char ch; specialCharacters) {
			if(c == ch)
				return true;
		}
		return false;
	}

	string[] tokens;
	size_t tokenStart;
	bool readingSomething;
	foreach(size_t i, char c; line) {
		if(!readingSomething) {
			if(c == ' ')
				continue; // skip whitespace
			else {
				if(isSpecial(c)) {
					tokens ~= line[i .. i + 1];
				} else {
					readingSomething = true;
					tokenStart = i;
				}
			}
		} else {
			if(isSpecial(c)) {
				tokens ~= line[tokenStart .. i];
				readingSomething = false;
				tokens ~= line[i .. i + 1];
			} else if (c == ' ') {
				tokens ~= line[tokenStart .. i];
				readingSomething = false;
			}
			// just keep scanning otherwise
		}
	}

	if(readingSomething)
		tokens ~= line[tokenStart .. $];

	return tokens;
}

struct Command {
	string app;

	string fullCommandLine;
	string[] args;

	string operation;
	uint flags;
	string[string] longArgs;
}

alias ProgramData delegate(Command, ProgramData) CommandWrapper;
void prepareCommandSet(Set)(Set set) if(is(Set : CommandShell)) {
	foreach(name; __traits(derivedMembers, Set)) {
		static if(name[0] != '_') {
			CommandWrapper dle;
			/*
			static if(
			__traits(compiles,
				dle = wrap(&__traits(getMember, set, name))
			))
			*/
				dle = wrap(&__traits(getMember, set, name));

			if(dle !is null)
				set._builtins[name] = dle;
		}
	}
}

CommandWrapper wrap(T)(T t) if(is(T == delegate)) {
	import std.traits;
	return delegate ProgramData(Command c, ProgramData input) {
		if(input is null)
			input = makeProgramData(stdin.byLine);

		string[] argv = c.args[1 .. $];

		ParameterTypeTuple!(t) args;
		foreach(idx, arg; args) {
			// FIXME: enum flags and long form structs
			// FIXME: int[] perhaps?
			static if(is(typeof(arg) : ProgramData))
				args[idx] = input;
			else static if(is(typeof(arg) == string[])) {
				args[idx] = argv;
				argv = null;
			} else {
				if(argv.length != 0) {
					args[idx] = to!(typeof(arg))(argv[0]);
					argv = argv[1 .. $];
				}
				//else throw new Exception("needs moar argz");
			}
		}
		return makeProgramData(t(args));
	};
}

Command[] parseCommands(string cmd) {
	auto tokens = lex(cmd);

	if(tokens.length == 0)
		return null;

	Command current;
	Command[] toRun;

	bool first = true;

	while(tokens.length) {
		auto token = tokens[0];
		if(first) {
			current.app = token;
			first = false;
		}

		if(token == "|") {
			toRun ~= current;
			current = current.init;
			first = true;
		} else {
			current.args ~= token;
		}

		tokens = tokens[1 .. $];
	}

	toRun ~= current;

	return toRun;
}

void printProgramData(ProgramData data) {
	if(data is null)
		writeln();
	writef("%s", data.header);

	bool first = true;
	for( ; !data.empty(); data.popFront()) {
		if(first)
			first = false;
		else
			writef("%s", data.itemSeperator());

		writef("%s", data.item());
	}

	writefln("%s", data.footer);
}

void main() {
	auto set = new CommandShell();
	prepareCommandSet(set);

	using_history();
	for(;;) {
		auto str_c = readline(toStringz(format("[dshell]:%s$ ", getcwd())));
		if(str_c is null) {
			writeln("");
			break;
		}
		add_history(str_c);

		auto str = to!string(str_c);
		if(str == "exit")
			break;

		try {
			printProgramData(set.eval(str));
		} catch (Exception e) {
			writeln(e.msg);
		}
	}
}