//---------------------------------------------------------------------------
//Programm 2D_Feld
//2D Felder als 1D Feld von Zeigern definieren
//Übergabe an Funktionen
//Speicherplatz dynamisch reservieren
//---------------------------------------------------------------------------
#define _CRT_SECURE_NO_WARNINGS
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<ctype.h>
#include "fhswf_service.h"

// Aufgabenstellung
// Bild als 2D Feld an Funktion übergeben und einzelnen Grauwert ändern
// 2D Feld als 1D Feld von Zeigern aufbauen
// hier: Bilddimension während der Laufzeit festlegen
// --> Speicherplatz dynamisch reservieren




// Funktionsprototypen
void reservierung(int***, int , int);
void set_array(int**, int, int);
void print_array(int**, int, int);
void rechnung(int**, int**, int**, int,int,int,int, int);
int check_Input_int(char*, int);

// Hauptprogramm
int main(void)
{

	int x_wert, y_wert, wert_neu, index;
	int anzahl_spalten_raum , wdh, anzahl_zeilen_raum,fehler, laenge, anzahl_spalten,menu, anzahl_zeilen, zahl, dim, anz, laufx, laufy, run, index_x, index_y;
	char menuu[100];
	char anzahl_zeilenc[100];
	char anzahl_spaltenc[100];
	char anzahl_zeilenc_raum[100];
	char anzahl_spaltenc_raum[100];
	char skalarc[100];
	do
	{
		x_wert = 0, y_wert = 0, wert_neu = 0, index = 0;
		 anzahl_spalten_raum = 0, wdh = 0, anzahl_zeilen_raum = 0, anzahl_spalten = 0, anzahl_zeilen = 0, zahl = 0, dim = 0, anz = 0, laufx = 0, laufy = 0, run = 0, index_x = 0, index_y = 0, menu = 0;


		 menuu[99] = { 0 };
		 anzahl_zeilenc[99] =  { 0 };
		 anzahl_spaltenc[99] = { 0 };
		 anzahl_zeilenc_raum[99] = { 0 };
		 anzahl_spaltenc_raum[99] = { 0 };

	//initialisieren

	// Zeigerfeld dynamisch anlegen
	int **bild = 0;
	int **raum = 0;
	int **ergebnis = 0;


	//menu abfrage
	do
	{


	printf("\n [1]: Addition\n [2]: Subtraktion\n [3]: multiplikation mit skalar\n [4]: Multiplikation\n [5]: Transponieren\n ");
	gets_s(menuu);
	laenge = strlen(menuu);
	fehler = check_Input_int(menuu, laenge);
	 menu = atoi(menuu);
	} while (fehler != 0 || menu >5 || menu <1);

	//vorraussetzungen
	if (menu == 1) { printf("bei der Addition von matrizen muessen beide matrizen die gleiche dimension aufweisen\n"); }
	if (menu == 2) { printf("bei der Subtraktion von matrizen muessen beide matrizen die gleiche dimension aufweisen\n"); }
	if (menu == 4) { printf("Bei der Multiplikation zweier matrizen muessen bei die gleiche dimension aufweisen und quadratisch sein\n"); }

	//matrix groesse
	do{
	printf("Bitte die Anzahl der zeilen fuer 1 eingeben\n");
	gets_s(anzahl_zeilenc);
	laenge = strlen(anzahl_zeilenc);
	fehler = check_Input_int(anzahl_zeilenc, laenge);
	anzahl_zeilen = atoi(anzahl_zeilenc);
	} while (fehler != 0 || anzahl_zeilen < 0);


do
{
	printf("Bitte die Anzahl der Spalten fuer 1 eingeben\n");
	gets_s(anzahl_spaltenc);
	laenge = strlen(anzahl_spaltenc);
	fehler = check_Input_int(anzahl_spaltenc, laenge);
	anzahl_spalten = atoi(anzahl_spaltenc);

	/*if (anzahl_spalten != anzahl_zeilen && menu == 4)
	{
		fehler++;
	}*/
} while(fehler != 0 || anzahl_spalten < 0);




	//matrix groesse 2
	if (menu == 1 || menu == 2 || menu == 4)
	{
	do
	{
		printf("Bitte die Anzahl der zeilen fuer 2 eingeben\n");
		gets_s(anzahl_zeilenc_raum);
		laenge = strlen(anzahl_zeilenc_raum);
		fehler = check_Input_int(anzahl_zeilenc_raum, laenge);
		anzahl_zeilen_raum = atoi(anzahl_zeilenc_raum);

		//if (anzahl_zeilen_raum != anzahl_zeilen && menu == 4) { fehler++; }
	} while (fehler != 0 || anzahl_zeilen_raum < 0);

	do{
		printf("Bitte die Anzahl der Spalten fuer 2 eingeben\n");
		gets_s(anzahl_spaltenc_raum);
		laenge = strlen(anzahl_spaltenc_raum);
		fehler = check_Input_int(anzahl_spaltenc_raum, laenge);
		anzahl_spalten_raum = atoi(anzahl_spaltenc_raum);
		//if (anzahl_spalten_raum != anzahl_spalten && menu == 4) { fehler++; }
		//if (anzahl_spalten_raum != anzahl_zeilen_raum && menu == 4)
		//{
		//	fehler++;
		//}
	} while (fehler != 0 || anzahl_spalten_raum < 0);
	}
	else
	{
		anzahl_zeilen_raum = 0;
		anzahl_spalten_raum = 0;
	}



	//reservierung(bild, raum, ergebnis, anzahl_zeilen, anzahl_spalten, anzahl_zeilen_raum, anzahl_spalten_raum);
	//skalar
	if (menu == 3)
	{
		do{

		printf("skalar 1: \n");
		gets_s(skalarc);
		laenge = strlen(skalarc);
		fehler = check_Input_int(skalarc, laenge);
		zahl = atoi(skalarc);
	} while (fehler != 0);
	}

	//dynamische zuewisung
	reservierung(&bild, anzahl_zeilen, anzahl_spalten);
	reservierung(&raum, anzahl_zeilen_raum, anzahl_spalten_raum);
	reservierung(&ergebnis, anzahl_zeilen, anzahl_spalten_raum);
	//dynamische zuweisung
	/*raum = (int**)malloc(anzahl_zeilen_raum * sizeof(int*));

	for (index = 0; index < anzahl_spalten_raum; index++)
	{
		raum[index] = (int*)malloc(anzahl_spalten_raum * sizeof(int));
	}



	//dynamische zuweisung je nach
	if (menu == 4)
	{
	ergebnis = (int**)malloc(anzahl_spalten_raum * sizeof(int*));

	for (index = 0; index < anzahl_zeilen; index++)
	{
	ergebnis[index] = (int*)malloc(anzahl_zeilen * sizeof(int));
	}
	}

	if(menu == 5)
	{
		ergebnis = (int**)malloc(anzahl_spalten * sizeof(int*));

		for (index = 0; index < anzahl_zeilen; index++)
		{
			ergebnis[index] = (int*)malloc(anzahl_zeilen * sizeof(int));
		}
	}

	else
	{


	ergebnis = (int**)malloc(anzahl_zeilen * sizeof(int*));

	for (index = 0; index < anzahl_spalten; index++)
	{
		ergebnis[index] = (int*)malloc(anzahl_spalten * sizeof(int));
	}
	}
	*/


	// Aufruf der Funktionen
	// Reihenfolge legt die Ablaufsteuerung fest
	printf("matrix 1: \n");
	set_array(bild, anzahl_zeilen, anzahl_spalten);


	printf("matrix 2: \n");
	set_array(raum, anzahl_zeilen_raum, anzahl_spalten_raum);


	printf("matrix 1: \n");
	print_array(bild, anzahl_zeilen, anzahl_spalten);


	printf("\nmatrix 2 : \n");
	print_array(raum, anzahl_zeilen_raum, anzahl_spalten_raum);


	rechnung(bild,raum, ergebnis, anzahl_zeilen,anzahl_spalten, anzahl_spalten_raum, menu, zahl);

	if (menu == 5)
	{
		printf("\nmatrix ergebnis : \n");
		print_array(ergebnis, anzahl_spalten, anzahl_zeilen);
	}
	else
	{
		printf("\nmatrix ergebnis : \n");
		print_array(ergebnis, anzahl_zeilen, anzahl_spalten);
	}







	getchar();
	free(bild);		// Speicherplatz wieder freigeben
	free(raum);
	free(ergebnis);

	//wdh

	printf("\nmoechten sie das prgramm wieder holen ? [1]\n");
	scanf("%i", &wdh);
	tastaturpuffer_leeren();


	} while (wdh == 1);
}
// Ende main


// Funktion set_array()
// Funktion zum Besetzen des Feldes



void reservierung(int*** bild,int anzahl_zeilen, int anzahl_spalten)
{
	int index;

	*bild = (int**)malloc(anzahl_zeilen * sizeof(int*));

	for (index = 0; index < anzahl_zeilen; index++)
	{
		(*bild)[index] = (int*)malloc(anzahl_spalten * sizeof(int));

	}

}



void set_array(int**feld, int zeilen, int spalten)
{
	int index_x = 0;		// Laufindizes
	int index_y = 0;
	int index = 0;
	int zahl = 0;

	// Feld in geschachtelter for Schleife durchlaufen
	// Feldelemente könnten individuell besetzt werden
	// hier alle selben Wert

		for (index_y = 0; index_y < zeilen; index_y++)
		{
			for (index_x = 0; index_x < spalten; index_x++)
			{
				printf("Geben sie die Zahl fuer die stell y = %i & x = %i an \n", index_y, index_x);
				scanf("%i", &zahl);
				feld[index_y][index_x] = zahl;
			}
		}






}
// Ende Funktion Feld besetzen


// Funktion change_array()
// Grauwerte ändern
void rechnung(int** feld, int** raum,int** loesung, int zeilen, int spalten, int spaltenraum, int menu, int zahl)
{
	int index_x, index_y, ergebnis = 0;
	int index_xv=0, index_yv = 0;



								// Koordinaten und neuen GW eingeben

	if (menu == 1)
	{

		for (int row_c = 0; row_c < zeilen; row_c++) // Setzt Ergebnismatrix auf 0
		{
			for (int col_c = 0; col_c < spaltenraum; col_c++)
			{
				loesung[row_c][col_c] = 0;
			}
		}

		for (index_x = 0; index_x < zeilen; index_x++)
		{
			for (index_y = 0; index_y < zeilen; index_y++)
			{
				loesung[index_x][index_y] = feld[index_x][index_y] + raum[index_x][index_y];
			}
		}
	}




	if (menu == 2)
	{
		for (index_x = 0; index_x < zeilen; index_x++)
		{
			for (index_y = 0; index_y < zeilen; index_y++)
			{
				loesung[index_x][index_y] = feld[index_x][index_y] - raum[index_x][index_y];
			}
		}
	}



	if (menu == 3)
	{
		for (index_x = 0; index_x < spalten; index_x++)
		{
			for (index_y = 0; index_y < spalten; index_y++)
			{
				loesung[index_y][index_x] = feld[index_x][index_y] * zahl;
			}
		}
	}






	if(menu == 4)
	{


		for (int row_c = 0; row_c < zeilen; row_c++) // Setzt Ergebnismatrix auf 0
		{
			for (int col_c = 0; col_c < spaltenraum; col_c++)
			{
				loesung[row_c][col_c] = 0;
			}
		}


		for (int row_c = 0; row_c < zeilen; row_c++)
		{
			for (int col_c = 0; col_c < spaltenraum; col_c++)
			{
				for (int add_c = 0; add_c < spalten; add_c++)
				{
					loesung[row_c][col_c] += feld[row_c][add_c] * raum[add_c][col_c];
				}
			}
		}
	}



	if (menu == 5)
	{
		for (index_x = 0; index_x < zeilen; index_x++)
		{
			for (index_y = 0; index_y < spalten; index_y++)
			{
				loesung[index_x][index_y] = feld[index_y][index_x];
			}
		}
	}



}




// Funktion print_array()
// Werte ausgeben
void print_array(int** feld, int zeilen, int spalten)
{



	int index_x = 0;	// Laufindizes
	int index_y = 0;

	// in geschachtelter Schleife einzelne GW ausgeben
	for (index_y = 0; index_y < zeilen; index_y++)
	{
		printf("\n");
		for (index_x = 0; index_x < spalten; index_x++)
		{
			printf("  %i", feld[index_y][index_x]);
		}
	}

}
// Ende Funktion GW ausgeben


/* Ende Beispielprogramm */


int check_Input_int(char* eingabe, int laenge)
{
	int punkt = 0;
	int fehler = 0;
	int rc = 0; // return_code
	int index;	         // Schleifenindex


						 // führendes + Zeichen eliminieren
	if (eingabe[0] == '+')
	{

		laenge = laenge - 1;
		index = 0;
		while (eingabe[index] != 0)
		{
			eingabe[index] = eingabe[index + 1];
			index++;
		}
		eingabe[index] = 0;  //Stringendezeichen setzen
	}

	// übergebenen String zeichenweise auswerten
	for (index = 0; index < laenge; index++)
	{
		rc = isdigit(eingabe[index]);   // Prüfung auf Ziffer 0 bis 9

										// Rückgabewert auswerten
		if (rc == 0)
		{
			fehler++;		    // Fehlervariable erhöhen
		}

		/*if (eingabe[index] == '.' && punkt == 0)
		{
			fehler--;
			punkt++;//fuer float
		}*/
	}

	// Prüfung auf Vorzeichen
	if (eingabe[0] == '-')
	{
		fehler--;
	}




	//Rückgabe an aufrufende Funktion
	return (fehler);
}

// Ende Funktion check_Input_int()