/*
				"Schiffe" versenken
	(Wären das dann nicht eigendlich U-Boote wenn man sie nur sieht wenn sie getroffen wurden?)
		 Code geschrieben von Tobias Schmidt

		 Legende:
		 	~ - Wasser
		 	S - Schiff
		 	o - Getroffenes "Schiff"
		 	x - Fehlgeschlagener Schuss
	Developer Log:
		19.10.2017 - 10:00 - Irgendwie geht da was nicht.
		19.10.2017 - 11:47 - Fast den kleinen Schrank zerlegt.
		19.10.2017 - 11:49 - Der mist funktioniert nicht ...
		20.10.2017 - 8:00  - Es geht endlich! \(0.0)/

*/
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>

#define sizeX 8
#define sizeY 8
#define sizeTotal ((sizeX+1)*10+sizeY)
#define maxCachedGegnerZuege 4
#define maxShips sizeX+sizeX

// Interne Variablen
#define wasser 	0
#define daneben 1
#define treffer 2
#define schiff 	3
#define bereits_Daneben 	11
#define bereits_Getroffen 	22
#define player1_Gewonnen	42	// Lösung auf alles.
#define player1_Verloren	31	// 31 hör zu, eine Line macht dich nicht cool ...

// Das sieht man später anstatt der Variablen
#define wasser_Icon "~ "
#define daneben_Icon "x "
#define treffer_Icon "� "
#define schiff_Icon "0 "

static int spielFeldPlayer[sizeTotal] = { 0 }; // static soll sicherstellen das auch
static int spielFeldGegner[sizeTotal] = { 0 }; // wirklich nur DIESE variable genutzt wird, und keine kopie
static int playerShipsLeft;
static int gegnerShipsLeft;

static int mode;

static bool spieler1AmZug = true; 
static bool spielVerlassen = false;
static bool zumHauptmenu = false;

static int letzteComputerZuege[maxCachedGegnerZuege][2];
static int computerZuege = 0;

static int rundenZaehler;
static int timeSinceStart;
// Headerkrams

void generiereSpielFeld(bool istSpieler1);
void zeigeSpielFeld(bool nurGetroffen);
int macheSpielZug (int zugX, int zugY);
bool menschlicherSpielZug(int debugx, int debugy);
bool computerSpielZug(bool rekursive);
void clear();

void showFieldHeader();

void showFieldHeader() {
		int sekunde = (int)(time(NULL)-timeSinceStart), minute = 0;
		while(sekunde > 60)
		{
			sekunde -= 60;
			minute++;
		}
		printf("Runde %d | Zeit: %.2d:%.2d\n", rundenZaehler, minute, sekunde);
		if (spieler1AmZug && mode == 1) printf("\n\t\tDu bist am Zug!\n"
											   "\tKI Schiffe: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
		else if (spieler1AmZug && mode == 2) printf("\n\t\tSpieler 1 ist am Zug!\n"
													"\tSchiffe Spieler 2: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
		else if (!spieler1AmZug && mode == 2) printf("\n\t\tSpieler 2 ist am Zug!\n"
													 "\tSchiffe Spieler 1: %d | Deine Schiffe: %d\n", playerShipsLeft, gegnerShipsLeft);
		else if (spieler1AmZug && mode == 3) printf("\n\t\tTestmodus\n");
		else if (!spieler1AmZug && mode == 1) printf("\n\t\tDie KI ist am Zug!\n"
		   "\tKI Schiffe: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
}

void clear() {
	printf("\e[1;1H\e[2J");
}

bool computerSpielZug(bool rekursive) {
	bool ret = false;
	if (!rekursive) {
		clear();
		showFieldHeader();
		zeigeSpielFeld(false);
		sleep(1);
	}
	int nextx = rand() % sizeX-1;
	int nexty = rand() % sizeY-1;;
	/*if(computerZuege == 0){	// Es geht, ich fasse hier nichtsmehr an!
		nextx = rand() % sizeX-1;
		nexty = rand() % sizeY-1;
		letzteComputerZuege[computerZuege][0] = nextx;
		letzteComputerZuege[computerZuege][1] = nexty;
		computerZuege++;
	} */
	int status = macheSpielZug(nextx, nexty);
	//if (!rekursive) {
	clear();
	showFieldHeader();

	zeigeSpielFeld(false);
	//}
	if (status == treffer) {
		printf("\n\t Verdammt! Der Computer hat eins unserer Schiffe versenkt\n");
	} else if (status == daneben) {
		//ret = computerSpielZug(true);
		printf("\n\t Daneben! - Uns kann nichts aufhalten!\n");
	} else if (status == bereits_Daneben) {
		 ret = computerSpielZug(true);
		//printf("\n\t Erneut Daneben... - Das sollte eigendlich nicht möglich sein ...!\n");
	} else if (status == player1_Gewonnen) {
		printf("\n\t SIEG! Wir haben gewonnen!!\n");
		ret = true;
	} else if (status == player1_Verloren) {
		printf("\n\t NIEDERLAGE! Der Computer hat gewonnen..\n");
		ret = true;
	}
	else if ( status == bereits_Getroffen) {
		ret = computerSpielZug(true);
		//printf("\n\t Schiff bereits getroffen! - Entwickler hat verpennt das zu vermeiden...\n");
	}
	else {
		printf("\n\t Unbekannter Zustand... Der Entwickler ist immernoch Doof!\n");
	}
	if (!rekursive){
		sleep(3);
		clear();
	}
	return ret;
}

bool menschlicherSpielZug(int debugx, int debugy) {
	showFieldHeader();
	if (mode == 3) zeigeSpielFeld(false);
	else zeigeSpielFeld(true);
	int nextx;
	if (debugx == -1){
		do {	// Nested Loop, hurray!
			printf("\n\t Naechster Zug: X Koordinate: ");
			scanf("%d", &nextx);
			nextx--;
			if (nextx > sizeX-1)
			{
				printf("\tDie X Koordinate ist zu gross!\n");
			} else if (nextx < 0) {
				printf("\tDie X Koordinate ist zu klein!\n");
			} else {
				break;
			}
		} while (1);
	} else nextx = debugx;
	int nexty;
	if (debugy == -1) {
		do {	// Nested Loop again, hurray!
			printf("\n\t Naechster Zug: Y Koordinate: ");
			scanf("%d", &nexty);
			nexty--;
			if (nexty > sizeY-1)
			{
				printf("\tDie Y Koordinate ist zu gross!");
			} else if (nexty < 0) {
				printf("\tDie Y Koordinate ist zu klein!");
			} else {
				break;
			}

		} while (1);
	} else nexty = debugy;
	if (mode == 3 || mode == 4) printf("X: %d - Y: %d", nextx, nexty);
	int status = macheSpielZug(nextx, nexty);
	clear();
	showFieldHeader();
	if (mode == 3) zeigeSpielFeld(false);
	else zeigeSpielFeld(true);
	if (status == treffer) {
		printf("\n\t TREFFER! - Gegnerisches Schiff versenkt!\n");
	} else if (status == daneben) {

		printf("\n\t Daneben! - Leider nur Wasseratome getroffen!\n");
	} else if (status == bereits_Daneben) {
		printf("\n\t Immernoch Daneben! - Hier ist nach wie vor kein Schiff!\n\t\t\tNeuer versuch!\n");
		sleep(2);
		clear();
		return menschlicherSpielZug(debugx, debugy);
	} else if (status == player1_Gewonnen) {
		printf("\n\t SIEG! Spieler 1 Hat gewonnen!!\n");
		return true;
	} else if (status == player1_Verloren) {
		if(mode == 1) printf("\n\t NIEDERLAGE! Der Computer hat gewonnen..\n");
		else printf("\n\t SIEG! Spieler 2 Hat gewonnen!!\n");
		return true;
	}
	else if ( status == bereits_Getroffen) {
		printf("\n\t Schiff bereits getroffen! - Die sind doch bereits alle tot!...\n\t\t\tNeuer Versuch!");
		sleep(2);
		clear();
		return menschlicherSpielZug(debugx, debugy);
	}
	else {
		printf("\n\t Unbekannter Zustand... Der Entwickler ist Doof!\n");
	}
	sleep(2);
	clear();
	return false;
}

int macheSpielZug (int zugX, int zugY) {
	int status = -1;
	if (spieler1AmZug) status = spielFeldGegner[(zugX*10)+zugY];
	else status = spielFeldPlayer[(zugX*10)+zugY];
	if (status == schiff) {
		if (spieler1AmZug) {
			spielFeldGegner[(zugX*10)+zugY] = treffer;
			gegnerShipsLeft--;
			if(gegnerShipsLeft == 0) return player1_Gewonnen;
		}
		else {
			spielFeldPlayer[(zugX*10)+zugY] = treffer;
			playerShipsLeft--;
			if(playerShipsLeft == 0) return player1_Verloren;
		}
		return treffer;
	}
	else if (status == daneben) return bereits_Daneben;
	else if (status == wasser) {
		if (spieler1AmZug) spielFeldGegner[(zugX*10)+zugY] = daneben;
		else spielFeldPlayer[(zugX*10)+zugY] = daneben;
		return daneben;
	}
	else if (status == treffer) return bereits_Getroffen;
}

void generiereSpielFeld(bool istSpieler1) {
	int totalShipps = 0;
	/*for (int x = 0; x < sizeX; x++)
	{
		for (int y = 0; y < sizeY; y++)
		{
			if(istSpieler1) spielFeldPlayer[x][y] = 0;
			else spielFeldGegner[x][y] = 0;
		}
	}*/
	for (int k = 0; k<maxShips; k++) {
		int x = rand() % sizeX;
		int y = rand() % sizeY;
		if(istSpieler1)
		{
			if (spielFeldPlayer[(x*10)+y] != schiff) {
				spielFeldPlayer[(x*10)+y] = schiff;
				playerShipsLeft++;
			}
			else k--;
		} else {
			if (spielFeldGegner[(x*10)+y] != schiff) {
				spielFeldGegner[(x*10)+y] = schiff;
				gegnerShipsLeft++;
			}
			else k--;
		}
	}

}

void zeigeSpielFeld(bool nurGetroffen)
{
	for (int y = 0; y < sizeY; y++)
	{	
		for (int x = 0; x < sizeX; x++)
		{
			// AußenBorder Start
			if (x == 0 && y == 0){
				printf("\n\t\t# X ");
				for (int k = 0; k < sizeX; k++)
				{
					printf("%d ", k+1);
				}
				printf("\n\t\tY\n\t\t1   ");
			}
			if (x == 0 && y != 0)
			{
				printf("\t\t%d   ", y + 1);
			}
			// AußenBorder Ende
			// Spielfeld Zeichnen Start
			int toPrint = -1;
			if(spieler1AmZug) toPrint = spielFeldGegner[(x*10)+y];
			else toPrint = spielFeldPlayer[(x*10)+y];
			if (nurGetroffen){
				if(toPrint == schiff) toPrint = wasser;
			}

			switch (toPrint)
			{
				case wasser: 	printf(wasser_Icon); break;
				case daneben: 	printf(daneben_Icon); break;
				case treffer: 	printf(treffer_Icon); break;
				case schiff:	printf(schiff_Icon); break;
			}
			// Spielfeld Zeichnen Ende

		}
		//int temp;
		//scanf("%d", &temp);
		printf("\n");
	}
}

int main() {
	// Variablen Initialisieren

	
	// Modi: 0 - Ungenutzt, 1 - gegen KI, 2 - 2 Spieler, 3 - Testmodus, 4 - Ein Feld automatisch ausfüllen. 
	bool spielVerlassen = false;

	int debugx = 0;
	int debugy = 0;
	srand(time(NULL)); // Wir setzten einen Seed für den Zufallsgenerator.
	clear();
	printf("**********************************\n");
	printf("* \"Schiffe\" versenken! Oder so...*\n");
	printf("**********************************\n\n");
	printf("\t\t Hauptmenue:\n");
	printf("\t1) Neues Spiel (gegen KI)\n");
	printf("\t2) Neues Spiel (2 Spieler Modus)\n");
	printf("\t3) Testmodus\n");
	printf("\t4) Autofill\n");
	printf("\n\t0) Spiel Beenden\n");
	printf("\n\tAuswaehlen: ");
	int hauptMenue = 1;
	scanf("%d", &hauptMenue);

	switch (hauptMenue)
	{
		case 1: mode = 1; break;
		case 2: mode = 2; break;
		case 3: mode = 3; break;
		case 4: mode = 4; break;
		case 0: return 0; break; // break ist echt voll super sinnvoll hier. Echt jetzt... nicht ...
	}
	timeSinceStart = (int)time(NULL);
	clear();
	//generiereSpielFeld(false);
	if(mode != 3 && mode != 4){
		//printf("Generiere Spielfelder:");
		//printf("\n\t- Spieler 1 Komplett -");
		generiereSpielFeld(true); // Wir generieren für den Spieler das Spielfeld
		//if (mode == 1) printf("\n\t- KI-Gegner Komplett - \n");
		//else printf("\n\t- Spieler 2 Komplett - \n");
		generiereSpielFeld(false); // Wir generieren für den (KI-)Gegner das Spielfeld
	} else if (mode == 4) generiereSpielFeld(false);
	else printf("\n");
	do {
		if (spieler1AmZug)
		{
			rundenZaehler++;
			if (mode == 4) {
				menschlicherSpielZug(debugx, debugy);
				if (debugx < 7) debugx++;
				else {
					debugx = 0;
					debugy++;
				}
				if (debugy == 8)  {
					spielVerlassen = !spielVerlassen;
					break;
				}
				//sleep(1);

			} else {
				spielVerlassen = menschlicherSpielZug(-1, -1);
				if (mode != 3) spieler1AmZug = !spieler1AmZug;
			}

		} else {
			if (mode == 1) {
				spielVerlassen = computerSpielZug(false);
				spieler1AmZug = !spieler1AmZug;
			} else {
				spielVerlassen = menschlicherSpielZug(-1, -1); // Mode ist total sinnlos hier... | Wir das das Spielfeld von Spieler 1.
				spieler1AmZug = !spieler1AmZug;
			}
		}
	} while(!spielVerlassen);
	return 0;
}