#include <windows.h>
#include <stdio.h>
#include <time.h>

//maksymalny rozmiar stringa zdefiniowany dla pozniejszego uzycia
#define MAX_STRING_SIZE 200

//ilosc przyciskow w rzedzie i kolumnie do odgadniecia
#define MEMORIES 4

//rozmiar przycisku w pixelach
#define MEMORY_BUTTON_SIZE 50


const char g_szClassName[] = "myWindowClass";

HWND stateText, finalText;


//tablica dwuwymiarowa (przyciskow), ktore klikamy by odgadywac slowa
HWND memory_buttons[MEMORIES][MEMORIES];
//i tablica dwuwymiarowa (intow) przetrzymujaca wylosowane liczby w odpowiednich polach, zadeklarowane globalnie, by miec dostep do nich w calym programie
int randomness[MEMORIES][MEMORIES];

//pozycja pierwszego (x,y - rzad, kolumna) wybranego przycisku
int firstChoose[] = { -1, -1 };
//pozycja drugiego (x,y) wybranego przycisku
int secondChoose[] = { -1, -1 };

//stałe stringi wyswietlane u gory pokazujace stan odgadnietych liczb
const char state_string1[] = { "Odganiete liczby: [" };
const char state_string2[] = { " / " };
const char state_string3[] = { "]" };

//liczba odgadnietych
int memoriesCollected = 0;

//flaga sluzaca do sprawdzanai czy chcemy zrobic opoznienie by przytrzymac odkryte liczby
BOOLEAN doDelay = FALSE;

//zmienna czasowa/daty przetrzymujaca znacznik czasu przy starcie programu (odejmujemy ją na koniec by uzyskac czas jaki zajelo graczowi odgadniecie wszystkich slow)
clock_t Launch_Time;

//metoda wywolujaca opoznienie
void delay(int time)
{
	clock_t start_time = clock();

	while (clock() < start_time + time);
}

//metoda odswiezajca napis u gory pokazujacy ilosc odgadnietych slow
void RefreshStateText()
{
	char int_string[4];
	sprintf(int_string, "%d", memoriesCollected);
	//zamiana int, ktory przechowuje ilosc odgadnietych na string
	char int_string2[4];
	sprintf(int_string2, "%d", MEMORIES * 2);
	//zamiana int, ktory przechowuje ilosc wszystkich liczb do odgadniecia na string

	int sum = strlen(state_string1) + strlen(state_string2) + strlen(state_string3) + strlen(int_string) + strlen(int_string2);
	//wyliczamy jak duzy powinien byc buffor ktory pomiesci zlozonego stringa, zliczamy ilosc liter
	char * buffer = (char*)malloc(sum * sizeof(char));
	//deklarujemy odpowiednia ilosc pamieci
	int i = 0, j = 0;
	for (i = 0; i < strlen(state_string1); ++i, ++j)
	{
		buffer[j] = state_string1[i];
	}
	//przepisanie pierwszego stringa - Odganiete liczby: [

	for (i = 0; i < strlen(int_string); ++i, ++j)
	{
		buffer[j] = int_string[i];
	}

	for (i = 0; i < strlen(state_string2); ++i, ++j)
	{
		buffer[j] = state_string2[i];
	}

	for (i = 0; i < strlen(int_string2); ++i, ++j)
	{
		buffer[j] = int_string2[i];
	}

	for (i = 0; i < strlen(state_string3); ++i, ++j)
	{
		buffer[j] = state_string3[i];
	}
	buffer[j] = '\0';
	//zakonczenie stringa bitem zerowym
	SetWindowText(stateText, buffer);
	//przypisanie tekstu do kontrolki tekstowej
}

//metoda windowsowa sluzaca do przetwarzania komuniaktow ktore przychodza do okna od uzytkownika a takze tych systemowych
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_CLOSE:
		DestroyWindow(hwnd);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	case WM_COMMAND:
		//sprawdzamy ktory przycisk zostal nacisniety, w tym celu musimy przejsc po calej naszej tablicy dwuwymiarowej w poszukiwaniu odpowiedniego obiektu
		for (int i = 0; i < MEMORIES; ++i)
		{
			for (int j = 0; j < MEMORIES; ++j)
			{
				if ((HWND)lParam == memory_buttons[i][j])
				{
					char buffer[2];
					sprintf(buffer, "%d", randomness[i][j]);
					//jesli to on to tworzymy buffer by zamienic int przetrzymywany w randomness na stringa, ktorego pozniej przypiszemy do przycisku
					SetWindowText(memory_buttons[i][j], buffer);

					EnableWindow(memory_buttons[i][j], FALSE);
					//dezaktywujemy przycisk, zeby nie mozna go bylo kliknac jeszcze raz
					if (firstChoose[0] == -1)
					{
						//jesli to pierwszy klikniety przycisk to zapisujemy jego wspolrzedne z tablicy
						firstChoose[0] = i;
						firstChoose[1] = j;
					} else {
						//jesli to drugi klikniety przycisk to zapisujemy jego wspolrzedne z tablicy
						secondChoose[0] = i;
						secondChoose[1] = j;
						doDelay = TRUE;//wymuszamy opoznienie, zeby tekst ktory przypisalismy do przyciskow nam od razu nie zniknal i zebysmy mogli zobaczyc co odkrylismy pod drugim przyciskiem
					}
					break;//konczymy petle bo na pewno kliknelismy tylko jeden przycisk
				}
			}
		}
		break;
	case WM_PAINT:
	{
		//Sekcja odpowiedzialna za rysowanie elementow okna, potrzebna w przypadku gdy uzywamy bitmap
		PAINTSTRUCT ps; // deklaracja struktury

		HDC hdc = BeginPaint(hwnd, &ps);
		EndPaint(hwnd, &ps); // zwalniamy hdc
	}
	default:
		return DefWindowProc(hwnd, msg, wParam, lParam);
	}
	return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{

	WNDCLASSEX wc;
	HWND hwnd;
	MSG Msg;

    //Rejestrowanie klasy Window, nadejemy tu okienku wszystkie parametry, takie jak kursor ikonka, tlo, tstyl
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = 0;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wc.lpszMenuName = NULL;
	wc.lpszClassName = g_szClassName;
	wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	if (!RegisterClassEx(&wc))
	{
		//jesli sie nei udalo zarejstrowac klasy wyrzucamy blad
		MessageBox(NULL, "Window Registration Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

    //Tworzenie Okna
	hwnd = CreateWindowEx(
		WS_EX_CLIENTEDGE,
		g_szClassName,
		"Gra Memory",
		WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
		CW_USEDEFAULT, CW_USEDEFAULT, 400, 400,
		NULL, NULL, hInstance, NULL);

	//Tekst powitalny
	HWND hTextWelcome = CreateWindowEx(0, "STATIC", NULL, WS_CHILD | WS_VISIBLE |
		SS_CENTER, 10, 0, 365, 30, hwnd, NULL, hInstance, NULL);

	//Tekst pokazujacy ile odgadlismy liczb
	stateText = CreateWindowEx(0, "STATIC", NULL, WS_CHILD | WS_VISIBLE |
		SS_CENTER, 10, 50, 365, 30, hwnd, NULL, hInstance, NULL);

	//Tekst koncowy pokazujacy wynik
	finalText = CreateWindowEx(0, "STATIC", NULL, WS_CHILD |
		SS_CENTER, 25, 310, 335, 30, hwnd, NULL, hInstance, NULL);

	srand(time(NULL));//inicjalizacja losowosci

	//wypelniam -1 zeby bylo wiadomo ze pola sa wolne poniewaz bedziemy losowac liczby od 0 do MEMORIES*2
	for (int i = 0; i < MEMORIES; ++i)
	{
		for (int j = 0; j < MEMORIES; ++j)
		{
			randomness[i][j] = -1;
		}
	}

	//wypelnianie tablicy randomness losowymi liczbami
	for (int i = 0; i < MEMORIES; ++i)
	{
		for (int j = 0; j < MEMORIES; ++j)
		{
			int foundCounter = 2; // kazda liczba musi byc dwukrotnie wylosowana (zeby miala pare)
			int r = rand() % (MEMORIES * 2); //dla pola 4x4 powinno byc 8 par
			while (foundCounter == 2)//dopoki nasza wylosowana liczba ma juz 2 powtorzenia probujemy znalezc inna
			{
				foundCounter = 0;//zerowanie licznika odnalezien wylosowanej liczby w tablicy
				r = rand() % (MEMORIES * 2);//losowanie nowej
				//szukam czy nie ma przypadkiem tej liczby
				for (int k = 0; k < MEMORIES; ++k)//przechodzimy jeszcze raz tablice
				{
					for (int l = 0; l < MEMORIES; ++l)
					{
						if (randomness[k][l] == r)
						{
							++foundCounter;//jesli odnalezlismy element zwiekszamy licznik
						}
					}
				}
				if (foundCounter < 2)//jesli udalo sie znalezc liczbe mniej niz 2 razy czyli 1 albo 0 to mozemy ja przypisac w miejsce w tablicy i  tak robimy do skutku
				{
					randomness[i][j] = r;
				}
			}
		}
	}
	int xOffset = 40;//odpowiednia ilosc pixeli w poziomie dla ustawienia na srodku przyciskow do zgadywania
	int yOffset = 45;//odpowiednia ilosc pixeli w pionie dla ustawienia na srodku przyciskow do zgadywania
	for (int i = 0; i < MEMORIES; ++i)
	{
		for (int j = 0; j < MEMORIES; ++j)
		{
			memory_buttons[i][j] = CreateWindowEx(0, "BUTTON", "", WS_CHILD | WS_VISIBLE,
				xOffset + MEMORY_BUTTON_SIZE + j* MEMORY_BUTTON_SIZE,
				yOffset + MEMORY_BUTTON_SIZE +i * MEMORY_BUTTON_SIZE,
				MEMORY_BUTTON_SIZE,
				MEMORY_BUTTON_SIZE,
				hwnd, NULL, hInstance, NULL
			);//tworzenie przyciskow
		}
	}

	SetWindowText(hTextWelcome, "GRA MEMORY");//tekst tytulowy na samej gorze
	RefreshStateText();
	Launch_Time = clock();//zapisujemy sobie czas startu by moc go potem odjac od czasu koncowego

	if (hwnd == NULL)
	{
		//jesli nie udalo sie stworzyc okna wyrzucamy blad
		MessageBox(NULL, "Window Creation Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	ShowWindow(hwnd, nCmdShow);//pokazujemy stworzone okienko
	UpdateWindow(hwnd);


	while (GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);

		//miejsce gdzie odswiezane jest okno wykorzystujemy to miejsce do zawieszenia go na chwile by moc przytrzymac na widoku odkryte liczby
		if (doDelay == TRUE)
		{
			doDelay = FALSE; //po wywolaniu zmieniamy na FALSE by te linijki wykonaly sie jednorazowo
			delay(450);//wywolanie opoznienia 450 milisekund
			if (randomness[secondChoose[0]][secondChoose[1]] == randomness[firstChoose[0]][firstChoose[1]])//sprawdzamy czy pierwsze odgadniecie pokazuje ta sama liczbe co drugie
			{
				//jesli tak to ukrywamy oba przyciski, zwiekszamy liczbe odgadnietych i odswiezamy tekst mowiacy o stanie odgadnietych
				ShowWindow(memory_buttons[firstChoose[0]][firstChoose[1]], SW_HIDE);
				ShowWindow(memory_buttons[secondChoose[0]][secondChoose[1]], SW_HIDE);
				++memoriesCollected;
				RefreshStateText();
			}
			else {
				//jesli nie to reaktywujemy przyciski, ktore wczesniej wylaczylismy i zmieniamy ich teksty na puste
				EnableWindow(memory_buttons[firstChoose[0]][firstChoose[1]], TRUE);
				SetWindowText(memory_buttons[firstChoose[0]][firstChoose[1]], "");
				EnableWindow(memory_buttons[secondChoose[0]][secondChoose[1]], TRUE);
				SetWindowText(memory_buttons[secondChoose[0]][secondChoose[1]], "");
			}
			firstChoose[0] = -1;
			firstChoose[1] = -1;
			secondChoose[0] = -1;
			secondChoose[1] = -1;
			//czyscimy zapisane pozycje w przypadku pierwszego wyboru i drugiego

			//sprwadzamy czy gra zostala ukonczona
			if (memoriesCollected >= MEMORIES * 2)
			{
				unsigned long playTime = (clock() - Launch_Time) / 1000; //odejmujemy czas poczatkowy od koncowego i dzielimy przez 1000 by otrzymac sekundy
				char buffer[MAX_STRING_SIZE];
				sprintf(buffer, "%ul", playTime);//zamieniamy to na stringa by moc to wypisac
				char str1[] = { "Gratulacje odkryles wszystkie liczby! Twoj czas to: " };
				char str2[] = { " sekund!" };
				int sum = strlen(str1) + strlen(buffer) + strlen(str2);
				int stringPointer = 0;
				char * mergedString = (char*)malloc(sum * sizeof(char));
				//tworzymy buffer do ktorego zlozymy stringi o odpowiedniej dlugosci
				int i = 0, j = 0;

				for (i = 0; i < strlen(str1); ++i, ++j)
				{
					mergedString[j] = str1[i];
				}
				for (i = 0; i < strlen(buffer)-1; ++i, ++j)
				{
					mergedString[j] = buffer[i];
				}
				for (i = 0; i < strlen(str2); ++i, ++j)
				{
					mergedString[j] = str2[i];
				}
				mergedString[j] = '\0';
				//zakanczamy stringa i przypisujemy go do tekstu koncowego i pokazujemy go w okienku
				SetWindowText(finalText, mergedString);
				ShowWindow(finalText, nCmdShow);
				MessageBox(hwnd, mergedString, "Wygrana!", MB_ICONINFORMATION);
			}
		}
	}
	return Msg.wParam;
}