/*
 * 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;</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.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 = "scheinbar 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
					{
						// Knöpfe anzeigen/ausblenden
						{
							document.querySelector("#knoepfe").setAttribute
								(
									"class",
									(
										(this.aufbau.modus_lesen() === mod_vtm_aufbau.modus_initial)
										? "initial"
										: (
											this.intervall.ist_schlicht()
											? "testen_laufend"
											: "testen_stehend"
										)
									)
								)
							;
						}
					}
				
				
				/**
				 * @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>
				 * @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(), true);
											}
										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(), false);
											}
										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");
											}
									}
							)
						;
						// Testen
						document.querySelector("#knopf_testen").addEventListener
							(
								"click",
								event =>
									{
										this.intervall = (
											new klasse_schlicht<any>
												(
													setInterval
														(
															() =>
																{
																	this.aufbau.fortfahren();
																	let modus : mod_vtm_aufbau.typ_modus = this.aufbau.modus_lesen();
																	if (modus <= 1)
																		{
																			// nichts tun
																		}
																	else
																		{
																			if (this.intervall.ist_schlicht())
																				{
																					clearInterval(this.intervall.lesen());
																					this.intervall = (new klasse_nichts<int>());
																				}
																			else
																				{
																					let meldung : string = "kein Intervall gesetzt";
																					console.warn(meldung);
																				}
																		}
																	this.erneuern_knoepfe();
																}
															,
															500
														)
												)
										);
									}
							)
						;
						// Anhalten
						document.querySelector("#knopf_anhalten").addEventListener
							(
								"click",
								event =>
									{
										if (this.intervall.ist_schlicht())
											{
												clearInterval(this.intervall.lesen());
												this.intervall = (new klasse_nichts<int>());
											}
										else
											{
												let meldung : string = "kein Intervall gesetzt";
												console.warn(meldung);
											}
										this.erneuern_knoepfe();
									}
							)
						;
						// Bearbeiten
						document.querySelector("#knopf_bearbeiten").addEventListener
							(
								"click",
								event =>
									{
										if (this.intervall.ist_schlicht())
											{
												clearInterval(this.intervall.lesen());
												this.intervall = (new klasse_nichts<int>());
											}
										else
											{
												// nichts tun
											}
										this.aufbau.zuruecksetzen();
										this.erneuern_knoepfe();
									}
							)
						;
					}
				
			}
		
	}