///<reference path="../../plankton/base/build/logic-decl.d.ts"/>
///<reference path="../../plankton/call/build/logic-decl.d.ts"/>
///<reference path="../../plankton/lang/build/logic-decl.d.ts"/>


/**
 * @author fenris
 */
type type_myreader = lib_lang.class_reader<char, lib_lang.type_terminal_default, string, lib_lang.type_tree<lib_lang.type_terminal_default>>;


/**
 * @author fenris
 */
var generate_reader : (path : string)=>lib_call.type_promise<type_myreader, Error> =
	path => lib_call.promise_resolve(path)
		.then<Buffer, Error>
			(
				path => lib_call.promise_make<Buffer, Error>
					(
						(resolve, reject) =>
							{
								let _fs = require("fs");
								_fs.readFile
									(
										path,
										{
											"encoding": "utf8",
											"flag": "r",
										},
										(error, buffer) =>
											{
												if (error == null)
													{
														resolve(buffer);
													}
												else
													{
														reject(error);
													}
											}
									)
								;
							}
					)
			)
		.then<any, Error>
			(
				buffer => lib_call.promise_make<any, Error>
					(
						(resolve, reject) =>
							{
								resolve(JSON.parse(buffer.toString()));
							}
					)
			)
		.then<type_myreader, Error>
			(
				data => lib_call.promise_make<type_myreader, Error>
					(
						(resolve, reject) =>
							{
								resolve(lib_lang.class_reader.default_raw(data));
							}
					)
			)
;


/**
 * @author fenris
 */
var transform_arguments : (args : Array<string>)=>lib_call.type_promise<{path ?: string; input ?: Array<char>;}, Error> =
	args => lib_call.promise_resolve<{path ?: string; input ?: Array<char>;}, Error>({})
		.then<{path ?: string; input ?: Array<char>;}/*, Error*/>
			(
				parameters => lib_call.promise_make<{path ?: string; input ?: Array<char>;}, Error>
					(
						(resolve, reject) =>
							{
								let path : string;
								path = ((args.length >= 1) ? args.shift() : null);
								if (path == null)
									{
										reject(new Error("no path specified"));
									}
								else
									{
										resolve({"path": path, "input": parameters.input});
									}
							}
					)
			)
		.then<{path ?: string; input ?: Array<char>;}/*, Error*/>
			(
				parameters => lib_call.promise_make<{path ?: string; input ?: Array<char>;}, Error>
					(
						(resolve, reject) =>
							{
								let input : Array<char>;
								let input_raw : string = args.join(" ");
								if (input_raw == "")
									{
										reject(new Error("no input given"));
									}
								else
									{
										input = input_raw.split("");
										resolve({"path": parameters.path, "input": input});
									}
							}
					)
			)
;


/**
 * @author fenris
 */
var main : (args : Array<string>)=>lib_call.type_promise<void, Error> = 
	args => lib_call.promise_resolve<void, Error>(undefined)
		.then<{path ?: string; input ?: Array<char>;}/*, Error*/>
			(
				_ => transform_arguments(args)
			)
		.then<{parameters : {path ?: string; input ?: Array<char>;}; reader : type_myreader;}/*, Error*/>
			(
				parameters => generate_reader(parameters.path)
					.then<{parameters : {path ?: string; input ?: Array<char>;}; reader : type_myreader;}, Error>
						(
							reader => lib_call.promise_make<{parameters : {path ?: string; input ?: Array<char>;}; reader : type_myreader;}, Error>
								(
									(resolve_, reject_) =>
										{
											resolve_({"parameters": parameters, "reader": reader});
										}
								)
						)
			)
		.then<lib_lang.type_tree<lib_lang.type_terminal_default>/*, Error*/>
			(
				vars => lib_call.promise_make<lib_lang.type_tree<lib_lang.type_terminal_default>, Error>
					(
						(resolve, reject) =>
							{
								lib_log.level_push(1);
								let result : lib_lang.type_tree<lib_lang.type_terminal_default> = vars.reader.run(vars.parameters.input);
								lib_log.level_pop();
								if (result == null)
									{
										reject(new Error("didn't work"));
									}
								else
									{
										resolve(result);
									}
							}
					)
			)
		.then<void/*, Error*/>
			(
				result => lib_call.promise_make<void, Error>
					(
						(resolve, reject) =>
							{
								console.info(JSON.stringify(result, undefined, "\t"));
								resolve(undefined);
							}
					)
			)
;


/**
 * @author fenris
 */
main(process.argv.slice(2))
	.then
		(
			output =>
				{
					// console.info("--", "done:", output);
				}
			,
			error =>
				{
					console.error("--", "failed:", error);
				}
		)
;