namespace _mimir
{
	/**
	 */
	function get_stamp() : string
	{
		const date : Date = (new Date(Date.now()));
		return lib_plankton.string.coin(
			// "{{year}}{{month}}{{day}}T{{hour}}{{minute}}{{second}}",
			"{{year}}-{{month}}-{{day}}",
			{
				"year": date.getFullYear().toFixed(0).padStart(4, "0"),
				"month": (date.getMonth() + 1).toFixed(0).padStart(2, "0"),
				"day": date.getDate().toFixed(0).padStart(2, "0"),
				"hour": date.getHours().toFixed(0).padStart(2, "0"),
				"minute": date.getMinutes().toFixed(0).padStart(2, "0"),
				"second": date.getSeconds().toFixed(0).padStart(2, "0"),
			}
		);
	}


	/**
	 */
	export async function main(
		args_raw : Array<string>
	) : Promise<void>
	{
		// args
		const arg_handler : lib_plankton.args.class_handler = new lib_plankton.args.class_handler({
			"action": lib_plankton.args.class_argument.positional({
				"index": 0,
				"type": lib_plankton.args.enum_type.string,
				"mode": lib_plankton.args.enum_mode.replace,
				"default": "run",
				"name": "action",
				"info": lib_plankton.string.coin(
					"{{description}}:\n{{options}}\n\t\t",
					{
						"description": "what to do",
						"options": (
							[
								{
									"name": "run",
									"description": "run"
								},
								{
									"name": "borg-init",
									"description": "borg-init"
								},
								{
									"name": "borg-run",
									"description": "borg-run"
								},
							]
							.map(
								entry => lib_plankton.string.coin(
									"\t\t- {{name}}\n\t\t\t{{description}}\n",
									{
										"name": entry.name,
										"description": entry.description,
									}
								)
							)
							.join("")
						),
					}
				),
			}),
			"conf_path": lib_plankton.args.class_argument.volatile({
				"indicators_long": ["conf_path"],
				"indicators_short": ["c"],
				"type": lib_plankton.args.enum_type.string,
				"mode": lib_plankton.args.enum_mode.replace,
				"default": "conf.json",
				"info": "conf_path",
				"name": "conf-path",
			}),
			"help": lib_plankton.args.class_argument.volatile({
				"indicators_long": ["help"],
				"indicators_short": ["h"],
				"type": lib_plankton.args.enum_type.boolean,
				"mode": lib_plankton.args.enum_mode.replace,
				"default": false,
				"info": "help",
				"name": "help",
			}),
		});
		const args : Record<string, any> = arg_handler.read(lib_plankton.args.enum_environment.cli, args_raw.join(" "));	
		
		if (args.help) {
			process.stdout.write(
				arg_handler.generate_help(
					{
						"programname": "Mimir",
						"description": "backup tool",
						"executable": "mimir",
					}
				)
				+
				"\n"
			);
		}
		else {
			const conf : _mimir.conf.type_conf = await lib_plankton.conf.load(_mimir.conf.schema, args["conf_path"]);
			// process.stdout.write(JSON.stringify(conf, undefined, "\t"));
			const stamp: string = get_stamp();
			/**
			 * @todo get from configuration
			 */
			const base_directory : string = "/tmp/mimir";
			
			switch (args["action"]) {
				case "init": {
					return Promise.reject(new Error("not implemented"));
					break;
				}
				case "run": {
					for await (const concern of conf.concerns) {
						let commands : Array<string> = [];
						const commands_add : ((command : string) => void) = (command) => {
							commands.push(command);
						};
						const commands_apply : (() => void) = () => {
							// TODO
							process.stdout.write(commands.join("\n") + "\n");
						};
						
						if (! concern.active) {
							// do nothing
						}
						else {
							const directory : string = (base_directory + "/" + stamp + "/" + concern.name);
							
							// prepare
							{
								commands_add(
									lib_plankton.string.coin(
										"## {{name}}\n",
										{
											"name": concern.name,
										}
									)
								);
								commands_add(
									lib_plankton.string.coin(
										"echo '-- {{name}}' > /dev/stderr",
										{
											"name": concern.name,
											"kind": concern.kind,
										}
									)
								);
								commands_add(
									lib_plankton.string.coin(
										"mkdir --parents {{directory}}",
										{
											"directory": directory,
										}
									)
								);
							}
							
							// serialize
							{
								switch (concern.kind) {
									case "files": {
										commands = commands.concat(
											_mimir.serialization.files.execute(
												concern.parameters,
												directory
											)
										);
										break;
									}
									case "postgresql_dump": {
										commands = commands.concat(
											_mimir.serialization.postgresql_dump.execute(
												concern.parameters,
												directory
											)
										);
										break;
									}
									default: {
										throw (new Error("unhandled kind: " + concern["kind"]));
										break;
									}
								}
							}
 
							// transfer
							{
								switch (conf.target.kind) {
									case "keep": {
										commands = commands.concat(
											_mimir.transfer.keep.execute(
												conf.target.parameters,
												concern.name,
												stamp,
												directory
											)
										);
										break;
									}
									case "borg": {
										commands = commands.concat(
											_mimir.transfer.borg.execute(
												conf.target.parameters,
												concern.name,
												stamp,
												directory
											)
										);
										break;
									}
									default: {
										throw (new Error("unhandled target kind: " + conf.target["kind"]));
										break;
									}
								}
							}

							// clean
							{
								/**
								 * @todo
								 */
							}
							
							commands_add(
								""
							);
							commands_add(
								""
							);
							commands_apply();
						}
					}
					
					return Promise.resolve<void>(undefined);
					break;
				}
				default: {
					throw (new Error("invalid action: " + args["action"]));
					
					return Promise.resolve<void>(undefined);
					break;
				}
			}
		}

	}
}

_mimir.main(process.argv.slice(2));