/**
 */
class class_input_datetime implements lib_plankton.zoo_input.interface_input<_zeitbild.frontend_web.helpers.type_datetime>
{
	
	/**
	 */
	private core : lib_plankton.zoo_input.class_input_group<_zeitbild.frontend_web.helpers.type_datetime>;
	
	
	/**
	 */
	public constructor(
		prefix : string
	)
	{
		this.core = new lib_plankton.zoo_input.class_input_group<_zeitbild.frontend_web.helpers.type_datetime>(
			[
				{
					"name": "timezone_shift",
					"input": new lib_plankton.zoo_input.class_input_number(
					),
					"label": (prefix + lib_plankton.translate.get("common.timezone_shift")),
				},
				{
					"name": "date",
					"input": new lib_plankton.zoo_input.class_input_date(
					),
					"label": (prefix + lib_plankton.translate.get("common.date")),
				},
				{
					"name": "time",
					"input": new lib_plankton.zoo_input.class_input_soft<type_time>(
						new lib_plankton.zoo_input.class_input_time(
						)
					),
					"label": (prefix + lib_plankton.translate.get("common.time")),
				},
			]
		);
	}
	
	
	/**
	 */
	public async setup(
		parent : HTMLElement
	) : Promise<void>
	{
		return this.core.setup(parent);
	}
	
	
	/**
	 */
	public async read(
	) : Promise<_zeitbild.frontend_web.helpers.type_datetime>
	{
		return this.core.read();
	}
	
	
	/**
	 */
	public async write(
		value : _zeitbild.frontend_web.helpers.type_datetime
	) : Promise<void>
	{
		return this.core.write(value);
	}
	
}


/**
 */
namespace _zeitbild.frontend_web
{
	
	/**
	 */
	export async function main(
	) : Promise<void>
	{
		// conf
		await _zeitbild.frontend_web.conf.init("conf.json");
		
		
		// init
		await _zeitbild.frontend_web.backend.init();
		await lib_plankton.translate.initialize(
			{
				"verbosity": 1,
				"packages": [
					JSON.parse(await lib_plankton.file.read("data/localization/deu.loc.json")),
					JSON.parse(await lib_plankton.file.read("data/localization/eng.loc.json")),
				],
				"order": ["deu", "eng"],
				"autopromote": false,
			}
		);
		lib_plankton.zoo_page.init(
			document.querySelector("main"),
			{
				"pool": {
					"login": async (parameters, target_element) => {
						const preparation : {kind : string; data : any;} = await _zeitbild.frontend_web.backend.session_prepare(
						);
						switch (preparation.kind) {
							case "internal": {
								target_element.innerHTML = await _zeitbild.frontend_web.helpers.template_coin(
									"login",
									{
									}
								);
								const form : lib_plankton.zoo_form.class_form<
									{name : string; password : string;},
									{name : string; password : string;}
								> = new lib_plankton.zoo_form.class_form<
									{name : string; password : string;},
									{name : string; password : string;}
								>(
									x => x,
									x => x,
									new lib_plankton.zoo_input.class_input_group<
										{name : string; password : string;}
									>(
										[
											{
												"name": "name",
												"input": new lib_plankton.zoo_input.class_input_text(),
												"label": lib_plankton.translate.get("page.login.internal.name"),
											},
											{
												"name": "password",
												"input": new lib_plankton.zoo_input.class_input_password(),
												"label": lib_plankton.translate.get("page.login.internal.password"),
											},
										]
									),
									[
										{
											"label": lib_plankton.translate.get("page.login.internal.do"),
											"target": "submit",
											"procedure": async (get_value, get_representation) => {
												const value : any = await get_value();
												try {
													await _zeitbild.frontend_web.backend.session_begin(
														value.name,
														value.password
													);
													lib_plankton.zoo_page.set(
														{
															"name": "events",
															"parameters": {}
														}
													);
												}
												catch (error) {
													lib_plankton.zoo_page.set(
														{
															"name": "login",
															"parameters": {
																"name": value.name,
															}
														}
													);
												}
											}
										},
									]
								);
								await form.setup(document.querySelector("#login"));
								await form.input_write(
									{
										"name": (parameters.name ?? ""),
										"password": "",
									}
								);
								break;
							}
							case "oidc": {
								let element_a : HTMLElement = document.createElement("a");;
								element_a.textContent = lib_plankton.string.coin(
									lib_plankton.translate.get("page.login.oidc.via"),
									{
										"title": preparation.data.label,
									}
								);
								element_a.setAttribute("href", preparation.data.url);
								target_element.innerHTML = "";
								target_element.appendChild(element_a);
								break;
							}
							default: {
								break;
							}
						}
					},
					"oidc_finish": async (parameters, target_element) => {
						await _zeitbild.frontend_web.backend.set_session_key(parameters["session_key"]);
						lib_plankton.zoo_page.set(
							{
								"name": "events",
								"parameters": {}
							}
						);
					},
					"logout": async (parameters, target_element) => {
						await _zeitbild.frontend_web.backend.session_end(
						);
						lib_plankton.zoo_page.set(
							{
								"name": "login",
								"parameters": {
								}
							}
						);
					},
					"calendar_add": async (parameters, target_element) => {
						target_element.innerHTML = await _zeitbild.frontend_web.helpers.template_coin(
							"calendar_add",
							{
								"label": lib_plankton.translate.get("page.calendar_add.title")
							}
						);
						const form : lib_plankton.zoo_form.class_form<
							_zeitbild.frontend_web.type.calendar_object,
							{
								name : string;
								access_default_level : string;
								resource_kind : string;
							}
						> = new lib_plankton.zoo_form.class_form<
							_zeitbild.frontend_web.type.calendar_object,
							{
								name : string;
								access_default_level : string;
								resource_kind : string;
							}
						>(
							(calendar_object) => ({
								"name": calendar_object.name,
								"access_default_level": (() => {
									switch (calendar_object.access.default_level) {
										case _zeitbild.frontend_web.type.enum_access_level.none: return "none";
										case _zeitbild.frontend_web.type.enum_access_level.view: return "view";
										case _zeitbild.frontend_web.type.enum_access_level.edit: return "edit";
										case _zeitbild.frontend_web.type.enum_access_level.admin: return "admin";
									}
								}) (),
								"resource_kind": calendar_object.resource.kind,
							}),
							(raw) => ({
								"name": raw.name,
								"access": {
									"default_level": (() => {
										switch (raw.access_default_level) {
											case "none": return _zeitbild.frontend_web.type.enum_access_level.none;
											case "view": return _zeitbild.frontend_web.type.enum_access_level.view;
											case "edit": return _zeitbild.frontend_web.type.enum_access_level.edit;
											case "admin": return _zeitbild.frontend_web.type.enum_access_level.admin;
										}
									}) (),
									"attributed": lib_plankton.map.hashmap.implementation_map(
										lib_plankton.map.hashmap.make(
											x => x.toFixed(0)
										)
									),
								},
								"resource": (() => {
									switch (raw.resource_kind) {
										case "local": {
											return {
												"kind": "local",
												"data": {
													"events": [],
												}
											};
											break;
										}
										case "caldav": {
											return {
												"kind": "caldav",
												"data": {
													"url": "", // TODO
													"read_only": true, // TODO
												}
											};
											break;
										}
										default: {
											throw (new Error("invalid resource kind: " + raw.resource_kind));
											break;
										}
									}
								}) (),
							}),
							new lib_plankton.zoo_input.class_input_group<any>(
								[
									{
										"name": "name",
										"input": new lib_plankton.zoo_input.class_input_text(),
										"label": lib_plankton.translate.get("calendar.name")
									},
									{
										"name": "access_default_level",
										"input": 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")
												},
											]
										),
										"label": lib_plankton.string.coin(
											"{{default_level}}",
											{
												"head": lib_plankton.translate.get("calendar.access.access"),
												"default_level": lib_plankton.translate.get("calendar.access.default_level"),
											}
										)
									},
									{
										"name": "resource_kind",
										"input": new lib_plankton.zoo_input.class_input_selection(
											[
												{
													"value": "local",
													"label": lib_plankton.translate.get("resource.kinds.local.title")
												},
												{
													"value": "caldav",
													"label": lib_plankton.translate.get("resource.kinds.caldav.title")
												},
											]
										),
										"label": lib_plankton.translate.get("resource.kind")
									},
								]
							),
							[
								{
									"label": lib_plankton.translate.get("page.calendar_add.actions.do"),
									"target": "submit",
									"procedure": async (get_value, get_representation) => {
										const value : any = await get_value();
										try {
											await _zeitbild.frontend_web.backend.calendar_add(
												value
											);
											lib_plankton.zoo_page.set(
												{
													"name": "events",
													"parameters": {}
												}
											);
										}
										catch (error) {
											// do nothing
											/*
											lib_plankton.zoo_page.set(
												{
													"name": "event_add",
													"parameters": {
													}
												}
											);
											 */
										}
									}
								},
							]
						);
						await form.setup(document.querySelector("#calendar_add_form"));
					},
					"event_add": async (parameters, target_element) => {
						const calendar_id : int = parseInt(parameters["calendar_id"]);
						target_element.innerHTML = await _zeitbild.frontend_web.helpers.template_coin(
							"event_add",
							{
								"label": lib_plankton.translate.get("page.event_add.title")
							}
						);
						const form : lib_plankton.zoo_form.class_form<
							{
								calendar_id : _zeitbild.frontend_web.type.calendar_id;
								event_object : _zeitbild.frontend_web.type.event_object;
							},
							{
								calendar_id : string;
								name : string;
								begin : _zeitbild.frontend_web.helpers.type_datetime;
								end : (null | _zeitbild.frontend_web.helpers.type_datetime);
								location : (null | string);
								description : (null | string);
							}
						> = new lib_plankton.zoo_form.class_form<
							{
								calendar_id : _zeitbild.frontend_web.type.calendar_id;
								event_object : _zeitbild.frontend_web.type.event_object;
							},
							{
								calendar_id : string;
								name : string;
								begin : _zeitbild.frontend_web.helpers.type_datetime;
								end : (null | _zeitbild.frontend_web.helpers.type_datetime);
								location : (null | string);
								description : (null | string);
							}
						>(
							(value) => ({
								"calendar_id": value.calendar_id.toFixed(0),
								"name": value.event_object.name,
								"begin": value.event_object.begin,
								"end": value.event_object.end,
								"location": value.event_object.location,
								"description": value.event_object.description,
							}),
							(representation) => ({
								"calendar_id": parseInt(representation.calendar_id),
								"event_object": {
									"name": representation.name,
									"begin": representation.begin,
									"end": representation.end,
									"location": representation.location,
									"description": representation.description,
								}
							}),
							new lib_plankton.zoo_input.class_input_group<any>(
								[
									{
										"name": "calendar_id",
										"input": new lib_plankton.zoo_input.class_input_selection(
											(await _zeitbild.frontend_web.backend.calendar_list())
											.filter(
												(entry) => (["edit","admin"].includes(entry.access_level))
											)
											.map(
												(entry) => ({
													"value": entry.id.toFixed(0),
													"label": entry.name,
												})
											)
										),
										"label": lib_plankton.translate.get("calendar.calendar")
									},
									{
										"name": "name",
										"input": new lib_plankton.zoo_input.class_input_text(
										),
										"label": lib_plankton.translate.get("event.name")
									},
									{
										"name": "begin",
										"input": new class_input_datetime(
											""
										),
										"label": lib_plankton.translate.get("event.begin")
									},
									{
										"name": "end",
										"input": new lib_plankton.zoo_input.class_input_soft<_zeitbild.frontend_web.helpers.type_datetime>(
											new class_input_datetime(
												""
											)
										),
										"label": lib_plankton.translate.get("event.end")
									},
									{
										"name": "location",
										"input": new lib_plankton.zoo_input.class_input_soft<string>(
											new lib_plankton.zoo_input.class_input_text(
											)
										),
										"label": lib_plankton.translate.get("event.location")
									},
									{
										"name": "description",
										"input": new lib_plankton.zoo_input.class_input_soft<string>(
											new lib_plankton.zoo_input.class_input_text(
											)
										),
										"label": lib_plankton.translate.get("event.description")
									},
								]
							),
							[
								{
									"label": lib_plankton.translate.get("page.event_add.actions.do"),
									"target": "submit",
									"procedure": async (get_value, get_representation) => {
										const value : any = await get_value();
										try {
											await _zeitbild.frontend_web.backend.calendar_event_add(
												value.calendar_id,
												value.event_object
											);
											lib_plankton.zoo_page.set(
												{
													"name": "events",
													"parameters": {}
												}
											);
										}
										catch (error) {
											// do nothing
											/*
											lib_plankton.zoo_page.set(
												{
													"name": "event_add",
													"parameters": {
													}
												}
											);
											 */
										}
									}
								},
							]
						);
						/*
						await form.write(
							{
								"calendar_id": parameters["calendar_id"],
							}
						);
						 */
						await form.setup(document.querySelector("#event_add_form"));
					},
					"events": async (parameters, target_element) => {
						const content = await _zeitbild.frontend_web.view.calendar_view_table_html(
							{
								"calendar_ids": null,
								// TODO
								"from": {
									"year": 2024,
									"week": 37
								},
								// TODO
								"to": {
									"year": 2024,
									"week": 43
								},
								"timezone_shift": /*conf.timezone_shift*/0,
							}
						);
						target_element.innerHTML = content;
					},
				},
				"fallback": {
					"name": "login",
					"parameters": {}
				}
			}
		);
		lib_plankton.zoo_page.add_nav_entry(
			{"name": "login", "parameters": {}},
			{"label": lib_plankton.translate.get("page.login.title")}
		);
		lib_plankton.zoo_page.add_nav_entry(
			{"name": "events", "parameters": {}},
			{"label": lib_plankton.translate.get("page.events.title")}
		);
		lib_plankton.zoo_page.add_nav_entry(
			{"name": "calendar_add", "parameters": {}},
			{"label": lib_plankton.translate.get("page.calendar_add.title")}
		);
		lib_plankton.zoo_page.add_nav_entry(
			{"name": "event_add", "parameters": {}},
			{"label": lib_plankton.translate.get("page.event_add.title")}
		);
		lib_plankton.zoo_page.add_nav_entry(
			{"name": "logout", "parameters": {}},
			{"label": lib_plankton.translate.get("page.logout.title")}
		);
		
		// exec
		lib_plankton.zoo_page.start();
		
		return Promise.resolve<void>(undefined);
	}
	
}