namespace lib_loc
{
	
	/**
	 */
	var _data : Record<string, Record<string, string>> = {};
	
	
	/**
	 */
	var _language_order : Array<string> = [];
	
	
	/**
	 */
	var _resolve_path : ((language : string) => string);
	
	
	/**
	 */
	async function load
	(
		language : string
	) : Promise<void>
	{
		if (_data.hasOwnProperty(language))
		{
			// do nothing
		}
		else
		{
			try
			{
				_data[language] = ((await fetch(_resolve_path(language), {"method": "GET"}).then(x => x.json())) as Record<string, string>);
			}
			catch (error)
			{
				console.warn
				(
					lib_string.coin
					(
						"could not load localization data for language '{{language}}': {{error}}",
						{
							"language": language,
							"error": String(error),
						}
					)
				);
			}
		}
		// return Promise.resolve<void>(undefined);
	}
	
	
	/**
	 */
	export function get
	(
		key : string,
		options :
		{
			language ?: (null | string);
		} = {}
	) : string
	{
		options = Object.assign
		(
			{
				"language": null,
			},
			options
		);
		const language_list : Array<string> = (
			[]
			.concat((options.language === null) ? [] : [options.language])
			.concat(_language_order)
		);
		for (const language of language_list)
		{
			if (_data.hasOwnProperty(language) && _data[language].hasOwnProperty(key))
			{
				return _data[language][key];
			}
			else
			{
				// do nothing
			}
		}
		return ("{" + key + "}");
	}
	
	
	/**
	 */
	export function translate_item
	(
		selector : string,
		key : string,
		options :
		{
			kind ?: string;
			parameters ?: Record<string, any>;
			language ?: (null | string);
			context ?: (HTMLElement | DocumentFragment);
		} = {}
	) : void
	{
		options = Object.assign
		(
			{
				"kind": "textcontent",
				"parameters": {},
				"language": null,
				"context": document,
			},
			options
		);
		const dom_element : Element = options.context.querySelector(selector);
		const value : string = get(key, {"language": options.language});
		switch (options.kind)
		{
			default:
			{
				console.warn("unhandeld kind");
				break;
			}
			case "textcontent":
			{
				dom_element.textContent = value;
				break;
			}
			case "attribute":
			{
				dom_element.setAttribute(options.parameters["key"], value);
				break;
			}
		}
	}
	
	
	/**
	 */
	export async function setup
	(
		language_order : Array<string>,
		options : 
		{
			resolve_path ?: ((language : string) => string),
		} = {}
	) : Promise<void>
	{
		options = Object.assign
		(
			{
				"resolve_path": (language => lib_string.coin("localization/{{language}}.json", {"language": language})),
			},
			options
		);
		_resolve_path = options.resolve_path;
		_language_order = language_order;
		for await (const language of _language_order)
		{
			await load(language);
		}
	}
	
}