/**
 */
namespace _dali.helpers
{
	
	/**
	 */
	var _template_cache : Record<string, string> = {};

	
	/**
	 */
	export function view_mode_determine(
		mode_descriptor : string
	) : _dali.enum_view_mode
	{
		if (mode_descriptor === "auto")
		{
			return (
				(window.innerWidth >= 800)
				?
				_dali.enum_view_mode.week
				:
				_dali.enum_view_mode.list
			);
		}
		else
		{
			return view_mode_decode(mode_descriptor);
		}
	}
	
	
	/**
	 */
	export async function template_coin(
		group : string,
		name : string,
		data : Record<string, string>
	) : Promise<string>
	{
		let content : string;
		const key : string = lib_plankton.string.coin(
			"{{group}}/{{name}}",
			{
				"group": group,
				"name": name,
			}
		);
		if (! (key in _template_cache)) {
			content = (
				(
					await lib_plankton.file.read(
						lib_plankton.string.coin(
							"templates/{{group}}/{{name}}.html.tpl",
							{
								"group": group,
								"name": name,
							}
						)
					)
				)
				.toString()
			);
			_template_cache[key] = content;
		}
		else {
			content = _template_cache[key];
		}
		return Promise.resolve<string>(
			lib_plankton.string.coin(
				content,
				data
			)
		);
	}
	
	
	/**
	 * @todo outsource
	 */
	export async function promise_row<type_result>(
		members : Array<
			() => Promise<type_result>
		>
	) : Promise<
		Array<
			type_result
		>
	>
	{
		let results : Array<type_result> = [];
		for await (const member of members) {
			results.push(await member());
		}
		return Promise.resolve<Array<type_result>>(results);
	}
	
	
	/**
	 */
	export function input_access_level(
	) : lib_plankton.zoo_input.interface_input<_dali.enum_access_level>
	{
		return (
			new lib_plankton.zoo_input.class_input_wrapped<
				/*("none" | "view" | "edit" | "admin")*/string,
				_dali.enum_access_level
			>(
				new lib_plankton.zoo_input.class_input_selection(
					[
						{
							"value": "none",
							"label": lib_plankton.translate.get("access_level.none"),
						},
						{
							"value": "view",
							"label": lib_plankton.translate.get("access_level.view")
						},
						{
							"value": "edit",
							"label": lib_plankton.translate.get("access_level.edit")
						},
						{
							"value": "admin",
							"label": lib_plankton.translate.get("access_level.admin")
						},
					]
				),
				(raw) => {
					switch (raw) {
						case "none": return _dali.enum_access_level.none;
						case "view": return _dali.enum_access_level.view;
						case "edit": return _dali.enum_access_level.edit;
						case "admin": return _dali.enum_access_level.admin;
					}
				},
				(access_level) => {
					switch (access_level) {
						case _dali.enum_access_level.none: return "none";
						case _dali.enum_access_level.view: return "view";
						case _dali.enum_access_level.edit: return "edit";
						case _dali.enum_access_level.admin: return "admin";
					}
				},
			)
		);
	}
	
	
	/**
	 */
	export function input_attributed_access_group(
		groups : Array<{id : _dali.type_group_id; object : _dali.type_group_object;}>
	)
	: lib_plankton.zoo_input.class_input_hashmap<
		_dali.type_group_id,
		_dali.enum_access_level
	>
	{
		return (
			new lib_plankton.zoo_input.class_input_hashmap<_dali.type_group_id, _dali.enum_access_level>(
				// hash_key
				(group_id) => group_id.toFixed(0),
				// key_input_factory
				() => new lib_plankton.zoo_input.class_input_wrapped<string, int>(
					new lib_plankton.zoo_input.class_input_selection(
						groups
						.map(
							(group) => ({
								"value": group.id.toFixed(0),
								"label": group.object.label,
							})
						)
					),
					x => parseInt(x),
					x => x.toFixed(0)
				),
				// value_input_factory
				() => input_access_level()
			)
		);
	}
	
	
	/**
	 */
	export function input_attributed_access_user(
		users : Array<{id : _dali.type_user_id; name : string;}>
	)
	: lib_plankton.zoo_input.class_input_hashmap<
		_dali.type_user_id,
		_dali.enum_access_level
	>
	{
		return (
			new lib_plankton.zoo_input.class_input_hashmap<_dali.type_user_id, _dali.enum_access_level>(
				// hash_key
				(user_id) => user_id.toFixed(0),
				// key_input_factory
				() => new lib_plankton.zoo_input.class_input_wrapped<string, int>(
					new lib_plankton.zoo_input.class_input_selection(
						users
						.map(
							(user) => ({
								"value": user.id.toFixed(0),
								"label": user.name,
							})
						)
					),
					x => parseInt(x),
					x => x.toFixed(0)
				),
				// value_input_factory
				() => input_access_level()
			)
		);
	}
	
	
	/**
	 */
	export function datetime_input(
	) : lib_plankton.zoo_input.interface_input<lib_plankton.pit.type_datetime>
	{
		return (
			_dali.conf.get().misc.use_central_europe_specific_datetime_inputs
			?
			new lib_plankton.zoo_input.class_input_datetime_central_europe(
				{
					"label_date": lib_plankton.translate.get("common.date"),
					"label_time": lib_plankton.translate.get("common.time"),
				}
			)
			:
			new lib_plankton.zoo_input.class_input_datetime(
				{
					"label_timezone_shift": lib_plankton.translate.get("common.timezone_shift"),
					"label_date": lib_plankton.translate.get("common.date"),
					"label_time": lib_plankton.translate.get("common.time"),
				}
			)
		);
	}
	
	
	/**
	 */
	export function event_color(
		hue : float
	)
	:
	string
	{
		return lib_plankton.color.output_hex(
			lib_plankton.color.make_hsv(
				{
					"hue": hue,
					"saturation": 0.375,
					"value": 0.375,
				}
			),
		);
	}
	
}