/*
 * 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_manifestation
	{
		
		/**
		 * @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 class klasse_web_partie
			extends klasse_manifestation<mod_vtm_aufbau.klasse_partie, void>
			{
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private bereich : Element;
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private intervall : schnittstelle_fehlermonade<any>;

				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public constructor(aufbau : mod_vtm_aufbau.klasse_partie, bereich : Element)
					{
						super(aufbau);
						this.bereich = bereich;
						this.intervall = (new klasse_nichts<any>());
						this.aufbau.lauschen
							(
								"aenderung_welt",
								(angaben) =>
									{
										this.erneuern_welt();
									}
							)
						;
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 * @override
				 */
				public einrichten() : void
					{
						this.aufbau.lauschen
							(
								"aenderung_aufgabe",
								(angaben) =>
									{
										this.erneuern_aufgabe();
									}
							)
						;
						this.aufbau.lauschen
							(
								"aenderung_welt",
								(angaben) =>
									{
										this.erneuern_welt();
									}
							)
						;
						this.aufbau.lauschen
							(
								"aenderung_figur",
								(angaben) =>
									{
										this.erneuern_figur();
									}
							)
						;
						this.aufbau.lauschen
							(
								"aenderung_modus",
								(angaben) =>
									{
										this.erneuern_modus();
										this.erneuern_knoepfe();
									}
							)
						;
						this.darstellen();
						this.binden();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private erneuern_aufgabe() : void
					{
						document.querySelector("#aufgabe_text").innerHTML = text_nachbearbeiten(this.aufbau.aufgabe_lesen().text());
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private erneuern_welt() : void
					{
						let knoten_svg : mod_vtm_helfer.schnittstelle_xmlknoten = mod_vtm_manifestation.svg_wurzel
							(
								-4, -4,
								+4, +4,
								800, 800,
								[new klasse_svg_partie(this.aufbau).darstellen()]
							)
						;
						this.bereich.innerHTML = knoten_svg.darstellen();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private erneuern_figur() : void
					{
						/*
						 */
						let knoten_svg : mod_vtm_helfer.schnittstelle_xmlknoten = mod_vtm_manifestation.svg_wurzel
							(
								-4, -4,
								+4, +4,
								800, 800,
								[new klasse_svg_partie(this.aufbau).darstellen()]
							)
						;
						this.bereich.innerHTML = knoten_svg.darstellen();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private erneuern_modus() : void
					{
						let status : string;
						switch (this.aufbau.modus_lesen())
							{
								case mod_vtm_aufbau.modus_initial:
									{
										status = "Maschine aufbauen";
										break;
									}
								case mod_vtm_aufbau.modus_ungewiss:
									{
										status = "wird geprüft …";
										break;
									}
								case mod_vtm_aufbau.modus_fehlerhaft:
									{
										status = "fehlerhaft :/";
										break;
									}
								case mod_vtm_aufbau.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>
				 */
				public erneuern_knoepfe() : void
					{
						let modus : mod_vtm_aufbau.typ_modus = this.aufbau.modus_lesen();
						let klasse : string;
						switch (modus)
							{
								case mod_vtm_aufbau.modus_initial:
									{
										klasse = "initial";
										break;
									}
								case mod_vtm_aufbau.modus_ungewiss:
									{
										klasse = (
											this.intervall.ist_schlicht()
											? "ungewiss_laufend"
											: "ungewiss_stehend"
										);
										break;
									}
								case mod_vtm_aufbau.modus_fehlerhaft:
								case mod_vtm_aufbau.modus_korrekt:
									{
										klasse = "fertig";
										break;
									}
							}
						document.querySelector("#knoepfe").setAttribute("class", klasse);
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 * @implementation
				 */
				public darstellen() : void
					{
						this.erneuern_aufgabe();
						this.erneuern_welt();
						this.erneuern_figur();
						this.erneuern_modus();
						this.erneuern_knoepfe();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private anhalten() : void
					{
						if (this.intervall.ist_schlicht())
							{
								clearInterval(this.intervall.lesen());
								this.intervall = (new klasse_nichts<any>());
							}
						else
							{
								let meldung : string = "kein Intervall gesetzt";
								console.warn(meldung);
							}
						this.erneuern_knoepfe();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private fortfahren() : void
					{
						this.aufbau.fortfahren();
						let modus : mod_vtm_aufbau.typ_modus = this.aufbau.modus_lesen();
						if (modus <= 1)
							{
								// nichts tun
							}
						else
							{
								this.anhalten();
							}
						this.erneuern_knoepfe();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private testen() : void
					{
						let handle : any = setInterval(() => this.fortfahren(), 500);
						this.intervall = (new klasse_schlicht<any>(handle));
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private bearbeiten() : void
					{
						this.anhalten();
						this.aufbau.zuruecksetzen();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private leeren() : void
					{
						this.aufbau.welt_leeren();
						this.aufbau.zuruecksetzen();
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 * @implementation
				 */
				public binden() : void
					{
						let stelle_ermitteln = (target : EventTarget) =>
							{
								let stelle : schnittstelle_fehlermonade<mod_vtm_aufbau.typ_stelle>;
								let dom_feld : Element = target["closest"](".feld");
								if (dom_feld == null)
									{
										stelle = (new klasse_nichts<mod_vtm_aufbau.typ_stelle>());
									}
								else
									{
										let rel : string = dom_feld.getAttribute("rel")
										stelle = (new klasse_schlicht<mod_vtm_aufbau.typ_stelle>(mod_vtm_aufbau.stelle_von_hash(rel)));
									}
								return stelle;
							}
						;
						// Links-Klick
						this.bereich.addEventListener
							(
								"click",
								event =>
									{
										event.preventDefault();
										let stelle_ : schnittstelle_fehlermonade<mod_vtm_aufbau.typ_stelle> = stelle_ermitteln(event.target);
										if (stelle_.ist_schlicht())
											{
												this.aufbau.welt_feld_wechseln(stelle_.lesen(), false);
											}
										else
											{
												console.info("-- kein Feld");
											}
									}
							)
						;
						// Rechts-Klick
						this.bereich.addEventListener
							(
								"contextmenu",
								event =>
									{
										event.preventDefault();
										let stelle_ : schnittstelle_fehlermonade<mod_vtm_aufbau.typ_stelle> = stelle_ermitteln(event.target);
										if (stelle_.ist_schlicht())
											{
												this.aufbau.welt_feld_wechseln(stelle_.lesen(), true);
											}
										else
											{
												console.info("-- kein Feld");
											}
									}
							)
						;
						// Mausrad
						this.bereich.addEventListener
							(
								"wheel",
								event =>
									{
										event.preventDefault();
										let stelle_ : schnittstelle_fehlermonade<mod_vtm_aufbau.typ_stelle> = stelle_ermitteln(event.target);
										if (stelle_.ist_schlicht())
											{
												let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1);
												this.aufbau.welt_feld_drehen(stelle_.lesen(), inkrement);
											}
										else
											{
												console.info("-- kein Feld");
											}
									}
							)
						;
						// Schritt
						document.querySelector("#knopf_schritt").addEventListener
							(
								"click",
								event =>
									{
										this.anhalten();
										this.fortfahren();
									}
							)
						;
						// Testen
						document.querySelector("#knopf_testen").addEventListener
							(
								"click",
								event =>
									{
										this.testen();
									}
							)
						;
						// Anhalten
						document.querySelector("#knopf_anhalten").addEventListener
							(
								"click",
								event =>
									{
										this.anhalten();
									}
							)
						;
						// Bearbeiten
						document.querySelector("#knopf_bearbeiten").addEventListener
							(
								"click",
								event =>
									{
										this.bearbeiten();
									}
							)
						;
						// Leeren
						document.querySelector("#knopf_leeren").addEventListener
							(
								"click",
								event =>
									{
										this.leeren();
									}
							)
						;
					}
				
			}
		
	}