/************************************************************************************************
  ALP2 - Uebung7  -  Jan Kellermann / Astrid Bertram / Gruppe 15        Tutorin: Susanne Richter
************************************************************************************************/

public class Zettel7 {

	public static char[] matrixEncode(char[] text, int cols) {
		int k =0;
		int rows=(int)Math.ceil((double)text.length/(double)cols);	// rows berechnen, aufrunden
		char[] solved = new char[(rows*cols)];						// Rückgabe-Array anlegen
		char[][] matrix = new char[rows][cols];						// Matrix anlegen, rows*cols
		for (int i=0; i<rows; i++) {								// Zeile für Zeile
			for (int j=0; j<cols; j++) {							// und Spalte für Spalte
				if (k<text.length) {								// und nur wenn Array-Länge
					matrix[i][j]=text[k++];							// noch nicht überschritten
				} else {											// Array in Matrix eintragen.
					matrix[i][j]='-';								// Sonst '-' eintragen.
				}
			}
		}
		k=0;
		for (int j=0; j<cols; j++) {								// Spalte für Spalte
			if (j%2==0) {											// abwechselnd
				for (int i=0; i<rows; i++) {						// die Zeilen vorwärts
					if (matrix[i][j]!='-') solved[k++]=matrix[i][j];
				}
			} else {
				for (int i=rows-1; i>=0; i--) {						// oder rückwärts ausgeben,
					if (matrix[i][j]!='-') solved[k++]=matrix[i][j];
				}													// wenn der aktuelle Inhalt
			}														// nicht ein '-' ist.
		}
		return solved;
	}

	public static char[] matrixDecode(char[] text, int cols) {
		int k =0;
		int rows=(int)Math.ceil((double)text.length/(double)cols);	// rows berechnen

		// Differenz zwischen Array-Länge und vollständiger Matrix analysieren, ab welcher Spalte
		// muss mit '-' aufgefüllt werden?
		int fehlt= cols-((cols*rows)-text.length);


		char[] solved = new char[(rows*cols)];						// matrix anlegen
		char[][] matrix = new char[rows][cols];						// Rückgabe-Array anlegen
		for (int j=0; j<cols; j++) {								// Spalte für Spalte
			if (j%2==0) {											// immer abwechselnd
				for (int i=0; i<rows; i++) {						// die Zeilen vorwärts
					if ((j>=fehlt) && (i==(rows-1))) { matrix[i][j]='-';  } else {
						if (k<text.length) { matrix[i][j]=text[k++]; } else { matrix[i][j]='-'; }
					}
				}
			} else {
				for (int i=rows-1; i>=0; i--) {						// und rückwärts ausgeben,
					if ((j>=fehlt) && (i==(rows-1))) { matrix[i][j]='-'; } else {
						if (k<text.length) { matrix[i][j]=text[k++]; } else { matrix[i][j]='-'; }
					}
				}				// WENN nicht gerade ein Platzhalter eingefügt werden muss,
			}					// wegen Matrix-Konsistenz oder Input-Array-Ende
		}
		k=0;
		for (int i=0; i<rows; i++) {
			for (int j=0; j<cols; j++) {
				if (matrix[i][j]!='-') solved[k++]=matrix[i][j];
			}					// Rückgabe-Array ermitteln, doppelte Schleife
		}
		return solved;
	}

	public static char[] replace(char[] text, char[] oldText, char[] newText) {
		boolean nixda;										// "nur-unvollständig-gefunden"-Flag
		for (int i=0; i<text.length; i++) { 				// jedes zeichen des "text" als startzeichen markieren
			if ((text[i]==oldText[0]) && (oldText.length<=(text.length-i))) {	// Wenn erstes Zeichen stimmt und Suchtext kürzer als verbleibender Rest
				nixda=false;								// rücksetzen auf false
				for (int j=1; j<oldText.length; j++) {		// alle zeichen weiter als das erste überprüfen
					if (text[i+j]!=oldText[j]) nixda=true;	// Wenns nicht mehr übereinstimmt nixda-Flag setzen.
				}
				if (nixda==false) { 						// scheinbar passts. --> ersetzen.
					for (int k=0; k<oldText.length; k++) {	// über die Länge von newText
						if (k<newText.length) text[i+k]=newText[k];	// alles ersetzen in text ab
					}
					int m=0;								// zum aufrutschen vorbereiten
					for (int n=(i+newText.length); n<text.length; n++) {	// über die restliche Länge von text (ab i+newText.length)
						if ((i+oldText.length+m+1)<=text.length) text[n]=text[((i+oldText.length)+(m++))];
						else text[n]=' ';	// alles von weiter hinten nach vorne ziehen, wenn hinten=Arrayende, Leerzeichen.
					}
					return text; // Rückgabe des fertigen Textes.
				}
			}
		}
		return text;
	}


///////////////////////////////////////////////////////////////////////////////////
    public static void main(String[] args) {

		String foobar1="THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG";
		char[] foobar1_a = foobar1.toCharArray();
		String foobar2="DIOOIDWTASBACNMAINSNSECIOTGFSOIHGEATRTEOFNNIPMEAFAEEDRLETDRASOYHEOFCRIUISESEMPHTITPRIIHNSAOERBAVTNVAAENNGIMTNEIHEB";
		char[] foobar2_a = foobar2.toCharArray();

		System.out.println(foobar1+" --> "); String s = new String(matrixEncode(foobar1_a, 9));	System.out.println(s);
		System.out.println(foobar2+" --> "); s = new String(matrixDecode(foobar2_a, 11)); System.out.println(s);

		// Ergebnis:
		// DECIPHERINGISINMYOPINIONONEOFTHEMOSTFASCINATINGOFARTSANDIFEARIHAVEWASTEDUPONITMORETIMETHANITDESERVESCHARLESBABBAGE

///////////////////////////////////////////////////////////////////////////////////
		String text_string="Dieser Satz ist ein Testsatz.";
		String oldText_string="ist ein";
		String newText_string="war'n";

		char[] text = text_string.toCharArray();
		char[] oldText = oldText_string.toCharArray();
		char[] newText = newText_string.toCharArray();

		System.out.println(replace(text,oldText,newText));
    }
}

/*
TESTLAUF: (leider aufm Ausdruck nicht mit dabei, war zu spät)

THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG -->
TRMELPOHEWSAZONQUFVYDEOICXROGTJKBUH
DIOOIDWTASBACNMAINSNSECIOTGFSOIHGEATRTEOFNNIPMEAFAEEDRLETDRASOYHEOFCRIUISESEMPHTITPRIIHNSAOERBAVTNVAAENNGIMTNEIHEB -->
DECIPHERINGISINMYOPINIONONEOFTHEMOSTFASCINATINGOFARTSANDIFEARIHAVEWASTEDUPONITMORETIMETHANITDESERVESCHARLESBABBAGE
Dieser Satz war'n Testsatz.

*/