/*
 * Verrückte Turing-Maschinen — A turing complete game
 * Copyright (C) 2016 Christian Fraß <vidofnir@folksprak.org>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

module mod_vtm
	{
		
		export module mod_manifestation
			{
				
				export module mod_web
					{
						
						export module mod_partie
							{
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function text_nachbearbeiten(text : string) : string
									{
										let regexp : RegExp = (new RegExp("\\$\{s(\\d*)\}", "g"));
										return text.replace(regexp, "<span class=\"symbol_$1\">&nbsp;&nbsp;</span>");
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								export type typ_partie =
									{
										aufbau : mod_aufbau.mod_partie.typ_partie;
										bereich : Element;
										intervall : lib_fehlermonade.typ_fehlermonade<any>;
									}
								;
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erstellen
									(
										aufbau : mod_aufbau.mod_partie.typ_partie,
										bereich : Element
									)
									: typ_partie
									{
										return {
											"aufbau": aufbau,
											"bereich": bereich,
											"intervall": (lib_fehlermonade.erstellen_nichts<any>()),
										};
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								export function erstellen_erweitert
									(
										aufbau : mod_aufbau.mod_partie.typ_partie,
										bereich : Element
									)
									: typ_manifestation<mod_aufbau.mod_partie.typ_partie>
									{
										return {
											"art": "web_partie",
											"angaben": erstellen(aufbau, bereich)
										};
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erneuern_aufgabe(partie : typ_partie) : void
									{
										document.querySelector("#aufgabe_text").innerHTML = (
											text_nachbearbeiten
												(
													mod_vtm.mod_aufbau.mod_aufgabe.text
														(
															mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau)
														)
												)
										);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erneuern_welt(partie : typ_partie) : void
									{
										let knoten_svg : lib_xml.typ_knoten = mod_svg.wurzel
											(
												-4, -4,
												+4, +4,
												800, 800,
												[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))]
											)
										;
										partie.bereich.innerHTML = lib_xml.darstellen(knoten_svg);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erneuern_figur(partie : typ_partie) : void
									{
										let knoten_svg : lib_xml.typ_knoten = mod_svg.wurzel
											(
												-4, -4,
												+4, +4,
												800, 800,
												[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))]
											)
										;
										partie.bereich.innerHTML = lib_xml.darstellen(knoten_svg);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erneuern_modus(partie : typ_partie) : void
									{
										let status : string;
										switch (mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau))
											{
												case mod_vtm.mod_aufbau.mod_modus.initial:
													{
														status = "Maschine aufbauen";
														break;
													}
												case mod_vtm.mod_aufbau.mod_modus.ungewiss:
													{
														status = "wird geprüft …";
														break;
													}
												case mod_vtm.mod_aufbau.mod_modus.fehlerhaft:
													{
														status = "fehlerhaft :/";
														break;
													}
												case mod_vtm.mod_aufbau.mod_modus.korrekt:
													{
														status = "anscheinend korrekt :)";
														break;
													}
												default:
													{
														let meldung : string = "unbehandelter Modus";
														throw (new Error(meldung));
														break;
													}
											}
										document.querySelector("#aufgabe_status").textContent = status;
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erneuern_knoepfe(partie : typ_partie) : void
									{
										let modus : mod_vtm.mod_aufbau.mod_modus.typ_modus = mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau);
										let klasse : string;
										switch (modus)
											{
												case mod_vtm.mod_aufbau.mod_modus.initial:
													{
														klasse = "initial";
														break;
													}
												case mod_vtm.mod_aufbau.mod_modus.ungewiss:
													{
														klasse = (
															lib_fehlermonade.voll<any>(partie.intervall)
															? "ungewiss_laufend"
															: "ungewiss_stehend"
														);
														break;
													}
												case mod_vtm.mod_aufbau.mod_modus.fehlerhaft:
												case mod_vtm.mod_aufbau.mod_modus.korrekt:
													{
														klasse = "fertig";
														break;
													}
												default:
													{
														throw (new Error("unbehandelt!"));
														break;
													}
											}
										document.querySelector("#knoepfe").setAttribute("class", klasse);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function darstellen(partie : typ_partie) : void
									{
										erneuern_aufgabe(partie);
										erneuern_welt(partie);
										erneuern_figur(partie);
										erneuern_modus(partie);
										erneuern_knoepfe(partie);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function anhalten(partie : typ_partie) : void
									{
										if (lib_fehlermonade.voll(partie.intervall))
											{
												clearInterval(lib_fehlermonade.lesen(partie.intervall));
												partie.intervall = (lib_fehlermonade.erstellen_nichts<any>());
											}
										else
											{
												let meldung : string = "kein Intervall gesetzt";
												console.warn(meldung);
											}
										erneuern_knoepfe(partie);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function fortfahren(partie : typ_partie) : void
									{
										mod_vtm.mod_aufbau.mod_partie.fortfahren(partie.aufbau);
										let modus : mod_vtm.mod_aufbau.mod_modus.typ_modus = mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau);
										if (modus <= 1)
											{
												// nichts tun
											}
										else
											{
												anhalten(partie);
											}
										erneuern_knoepfe(partie);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function testen(partie : typ_partie) : void
									{
										let handle : any = setInterval(() => fortfahren(partie), 500);
										partie.intervall = (lib_fehlermonade.erstellen_schlicht<any>(handle));
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function bearbeiten(partie : typ_partie) : void
									{
										anhalten(partie);
										mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function leeren(partie : typ_partie) : void
									{
										mod_vtm.mod_aufbau.mod_partie.welt_leeren(partie.aufbau);
										mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function binden(partie : typ_partie) : void
									{
										let stelle_ermitteln = (target : EventTarget) =>
											{
												let stelle : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>;
												let dom_feld : Element = target["closest"](".feld");
												if (dom_feld == null)
													{
														stelle = (lib_fehlermonade.erstellen_nichts<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>());
													}
												else
													{
														let rel : string = dom_feld.getAttribute("rel")
														stelle = (lib_fehlermonade.erstellen_schlicht<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel)));
													}
												return stelle;
											}
										;
										mod_vtm.mod_aufbau.mod_partie.lauschen
											(
												partie.aufbau,
												"aenderung_aufgabe",
												(angaben) =>
													{
														erneuern_aufgabe(partie);
													}
											)
										;
										mod_vtm.mod_aufbau.mod_partie.lauschen
											(
												partie.aufbau,
												"aenderung_welt",
												(angaben) =>
													{
														erneuern_welt(partie);
													}
											)
										;
										mod_vtm.mod_aufbau.mod_partie.lauschen
											(
												partie.aufbau,
												"aenderung_figur",
												(angaben) =>
													{
														erneuern_figur(partie);
													}
											)
										;
										mod_vtm.mod_aufbau.mod_partie.lauschen
											(
												partie.aufbau,
												"aenderung_modus",
												(angaben) =>
													{
														erneuern_modus(partie);
														erneuern_knoepfe(partie);
													}
											)
										;
										// Links-Klick
										partie.bereich.addEventListener
											(
												"click",
												event =>
													{
														event.preventDefault();
														let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
														if (lib_fehlermonade.voll(stelle_))
															{
																mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), false);
															}
														else
															{
																console.info("-- kein Feld");
															}
													}
											)
										;
										// Rechts-Klick
										partie.bereich.addEventListener
											(
												"contextmenu",
												event =>
													{
														event.preventDefault();
														let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
														if (lib_fehlermonade.voll(stelle_))
															{
																mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), true);
															}
														else
															{
																console.info("-- kein Feld");
															}
													}
											)
										;
										// Mausrad
										partie.bereich.addEventListener
											(
												"wheel",
												event =>
													{
														event.preventDefault();
														let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
														if (lib_fehlermonade.voll(stelle_))
															{
																let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1);
																mod_vtm.mod_aufbau.mod_partie.welt_feld_drehen(partie.aufbau, lib_fehlermonade.lesen(stelle_), inkrement);
															}
														else
															{
																console.info("-- kein Feld");
															}
													}
											)
										;
										// Schritt
										document.querySelector("#knopf_schritt").addEventListener
											(
												"click",
												event =>
													{
														anhalten(partie);
														fortfahren(partie);
													}
											)
										;
										// Testen
										document.querySelector("#knopf_testen").addEventListener
											(
												"click",
												event =>
													{
														testen(partie);
													}
											)
										;
										// Anhalten
										document.querySelector("#knopf_anhalten").addEventListener
											(
												"click",
												event =>
													{
														anhalten(partie);
													}
											)
										;
										// Bearbeiten
										document.querySelector("#knopf_bearbeiten").addEventListener
											(
												"click",
												event =>
													{
														bearbeiten(partie);
													}
											)
										;
										// Leeren
										document.querySelector("#knopf_leeren").addEventListener
											(
												"click",
												event =>
													{
														leeren(partie);
													}
											)
										;
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_partie.typ_partie, void>>
									(
										brauch_manifestation,
										"web_partie",
										{
											"darstellen": (manifestation) => darstellen(manifestation.angaben),
											"binden": (manifestation) => binden(manifestation.angaben),
										}
									)
								;
								
							}
						
					}
				
			}
		
	}