/*
 * 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_aufbau
			{
				
				export module mod_welt
					{
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export type typ_welt =
							{
								felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>;
							}
						;
						

						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function erstellen
							(
								felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash))
							)
							: typ_welt
							{
								return {
									"felder": felder,
								};
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function felder_lesen(welt : typ_welt) : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}>
							{
								let felder : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}> = [];
								welt.felder.iterieren
									(
										(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
									)
								;
								return felder;
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function feld_holen(welt : typ_welt, stelle : mod_stelle.typ_stelle) : schnittstelle_fehlermonade<mod_aktor.typ_aktor>
							{
								return welt.felder.holen(stelle);
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function feld_setzen(welt : typ_welt, stelle : mod_stelle.typ_stelle, aktor : mod_aktor.typ_aktor) : void
							{
								welt.felder.setzen(stelle, aktor);
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function feld_wechseln(welt : typ_welt, stelle : mod_stelle.typ_stelle, umgekehrt : boolean = false) : void
							{
								let erweitert : boolean = true;
								let liste : Array<{pruefer : (aktor : mod_aktor.typ_aktor)=>boolean; ersteller : ()=>mod_aktor.typ_aktor;}> = (
									[]
									.concat
										(
											[
												{
													"pruefer": (aktor) => (aktor.art === "befoerderer"),
													"ersteller": () => mod_aktor_befoerderer.erstellen_aktor(0),
												},
											]
										)
									.concat
										(
											mod_vtm.mod_helfer.sequenz(erweitert ? 4 : 2).map
												(
													symbol => (
														{
															"pruefer": (aktor) =>
																{
																	if (aktor.art === "schreiber")
																		{
																			return (mod_aktor_schreiber.symbol_lesen(aktor.angaben) === symbol);
																		}
																	else
																		{
																			return false;
																		}
																}
															,
															"ersteller": () => mod_aktor_schreiber.erstellen_aktor(0, symbol)
														}
													)
												)
										)
									.concat
										(
											mod_vtm.mod_helfer.sequenz(erweitert ? 2 : 1).map
												(
													index =>
														{
															let symbol_links : mod_symbol.typ_symbol = (2*index+0);
															let symbol_rechts : mod_symbol.typ_symbol = (2*index+1);
															return (
																{
																	"pruefer": (aktor) =>
																		{
																			if (aktor.art === "leser")
																				{
																					return (
																						(mod_aktor_leser.symbol_links_lesen(aktor.angaben) === symbol_links)
																						&&
																						(mod_aktor_leser.symbol_rechts_lesen(aktor.angaben) === symbol_rechts)
																					);
																				}
																			else
																				{
																					return false;
																				}
																		}
																	,
																	"ersteller": () => mod_aktor_leser.erstellen_aktor(0, symbol_links, symbol_rechts)
																}
															);
														}
												)
										)
									.concat
										(
											[
												{
													"pruefer": (aktor) => (aktor.art === "verwerfer"),
													"ersteller": () => mod_aktor_verwerfer.erstellen_aktor(),
												},
											]
										)
								);
								let index_alt : schnittstelle_fehlermonade<int>;
								let aktor_alt_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle);
								if (aktor_alt_.ist_schlicht())
									{
										let aktor_alt : mod_aktor.typ_aktor = aktor_alt_.lesen();
										let gefunden : boolean = (
											liste.some
												(
													(eintrag, index) =>
														{
															if (eintrag.pruefer(aktor_alt))
																{
																	index_alt = (new klasse_schlicht<int>(index));
																	return true;
																}
															else
																{
																	return false;
																}
														}
												)
										);
										if (! gefunden)
											{
												index_alt = (new klasse_nichts<int>());
											}
										else
											{
												// nichts tun
											}
									}
								else
									{
										let meldung : string = "kein Aktor gesetzt";
										// console.warn(meldung);
										index_alt = (new klasse_schlicht<int>(0));
									}
								if (index_alt.ist_schlicht())
									{
										let index_neu : int = mod_vtm.mod_helfer.mod_mathematik.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length);
										let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
										feld_setzen(welt, stelle, aktor_neu);
									}
								else
									{
										let meldung : string = ("Aktor nicht gefunden");
										// throw (new Error(meldung));
										console.warn(meldung);
									}
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function feld_drehen(welt : typ_welt, stelle : mod_stelle.typ_stelle, inkrement : int = +1) : void
							{
								let aktor_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle);
								if (aktor_.ist_schlicht)
									{
										mod_aktor.drehen(aktor_.lesen(), inkrement);
									}
								else
									{
										console.warn("kein Aktor gesetzt");
									}
							}
						

						/**
						 * @author kcf <vidofnir@folksprak.org>
						 * @throws {Error}
						 */
						export function erzeuger_finden(welt : typ_welt) : mod_stelle.typ_stelle
							{
								let stelle : schnittstelle_fehlermonade<mod_stelle.typ_stelle> = (new klasse_nichts<mod_stelle.typ_stelle>());
								welt.felder.iterieren
									(
										(stelle_, aktor) =>
											{
												if (aktor.art === "erzeuger")
													{
														if (stelle.ist_schlicht())
															{
																let meldung : string = "mehrere Erzeuger gefunden";
																throw (new Error(meldung));
															}
														else
															{
																stelle = (new klasse_schlicht<mod_stelle.typ_stelle>(stelle_));
															}
													}
											}
									)
								;
								if (stelle.ist_schlicht())
									{
										return stelle.lesen();
									}
								else
									{
										let meldung : string = "kein Erzeuger gefunden";
										throw (new Error(meldung));
									}
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function blanko(groesse : int = 3) : typ_welt
							{
								let welt : typ_welt = erstellen();
								for (let u : int = -groesse; u <= +groesse; u += 1)
									{
										for (let v : int = -groesse; v <= +groesse; v += 1)
											{
												if (Math.abs(u-v) <= groesse)
													{
														let stelle : mod_stelle.typ_stelle = {"u": u, "v": v};
														let aktor : mod_aktor.typ_aktor;
															if ((u === -groesse) && (v === 0))
															{
																aktor = mod_aktor_erzeuger.erstellen_aktor(0);
															}
														else if ((u === +groesse) && (v === 0))
															{
																aktor = mod_aktor_annehmer.erstellen_aktor();
															}
														else
															{
																aktor = mod_aktor_verwerfer.erstellen_aktor();
															}
														welt.felder.setzen(stelle, aktor);
													}
											}
									}
								return welt;
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function exportieren(welt : typ_welt) : any
							{
								let roh : any = {};
								roh["felder"] = {};
								welt.felder.iterieren
									(
										(stelle, aktor) =>
											{
												let stelle_ : string = mod_stelle.exportieren(stelle);
												let aktor_ : any = mod_aktor.exportieren(aktor);
												roh["felder"][stelle_] = aktor_;
											}
									)
								;
								return roh;
							}
						
						
						/**
						 * @author kcf <vidofnir@folksprak.org>
						 */
						export function importieren(roh : any) : typ_welt
							{
								let felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash));
								for (let stelle_ in roh["felder"])
									{
										let stelle : mod_stelle.typ_stelle = mod_stelle.importieren(stelle_);
										let aktor_ : mod_aktor.typ_aktor = roh["felder"][stelle_];
										let aktor : mod_aktor.typ_aktor = mod_aktor.importieren(aktor_);
										felder.setzen(stelle, aktor);
									}
								return (
									erstellen
										(
											felder
										)
								);
							}
						
					}
				
			}
		
	}