#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>

#define MAXSTRLEN 100
#define DEKLARACJATABLICY tab = malloc(dlugosc_tablicy * sizeof(*tab));
#define SPRAWDZTABLICE if (!ptr) {printf("\nBlad przy przydzielaniu pamieci.\n"); return -1;};
#define WYBOBR (tablicaObrazow + wybranyObraz)

struct obraz {
	char nazwa[MAXSTRLEN];
	int szerokosc;
	int wysokosc;
	int maksWartoscSzarosci;
	int standard; //2 to P2 (ASCII), 5 to P5 (binary)

	int* tablicaPikseli;
	char** komentarze;
	int indeksKomentarza;
}; typedef struct obraz obraz;

int WczytajLiczbe(FILE* plik);
int CzytajPlik(FILE* plik, obraz* wczytObraz, obraz** tabObrazow, int* dlugoscTablicyObrazow);
int WczytajPlik(obraz* wczytObraz, obraz** tabObrazow, int* dlugoscTablicyObrazow);
int WczytajKonsola(char komunikat[], int granica_dolna, int granica_gorna, int* kontrolka);
int UsunObraz(obraz** tabObr, int* tabObrLen, int indeksObr);
int ZapiszPlik(obraz* zapObraz, char nazwaPliku[]);
void Transpozycja(obraz* obrazTransponowany, int liczba_obrotow);
int Szum(obraz* obrazSzumiony, int procent_szumu);
int* Histogram(obraz* Obraz);
int FiltrGaussa(obraz* Obraz);
int Progowanie(obraz* Obraz, int* histogram);

int main(int argc, char* argv[]) {
	char nazwa[MAXSTRLEN];
	int krok_programu = 0;
	int wyswietl = 0;
	int wybranyObraz = 0;
	int k = 0;
	int srodekHist = 0;
	int krok_obrobki = 0;
	int* histogram = { 1 };
	obraz NowyObraz;
	obraz* tablicaObrazow = malloc(2 * sizeof(obraz));
	int dlugoscTablicyObrazow = 0;

	while (1)
	{
		switch (krok_programu)
		{
		case 0:

			printf("Podaj nazwe pliku ktory chcesz otworzyc lub wpisz:\
				\n\r'clr' zeby wyczyscic ekran\n\
				\n\r'sel' zeby wybrac obraz\n\
				\n\r'mod' zeby rozpoczac obrobke wybranego obrazu\n\
				\n\r'del' zeby usunac wybrany obraz\n\
				\n\r'sv' zeby zapisac wybrany obraz\n\
				\n\r'exit' zeby wyjsc\n");

			while (!scanf("%s", nazwa))
			{
				char c;
				while (c = getchar() != '\n');
			}
			if (!strcmp(nazwa, "exit")) {
				krok_programu = 100;
				continue;
			}
			else if (!strcmp(nazwa, "clr")) {
				system("cls");
				continue;
			}
			else if (!strcmp(nazwa, "mod")) {
				krok_programu = 5;
			}
			else if (!strcmp(nazwa, "sel")) {
				krok_programu = 3;
			}
			else if (!strcmp(nazwa, "del")) {
				krok_programu = 6;
			}
			else if (!strcmp(nazwa, "sv")) {
				krok_programu = 7;
			}

			if (krok_programu != 0)
			{
				if (!dlugoscTablicyObrazow) {
					printf("\nZeby wybrac ta funkcje musisz wczytac obraz.\n");
					krok_programu = 0;
					continue;
				}
				else
				{
					continue;
				}
			}
			krok_programu = 1;
			break;

		case 1:
			printf("Wczytuje plik %s\n", nazwa);
			strcpy(NowyObraz.nazwa, nazwa);
			if (WczytajPlik(&NowyObraz, &tablicaObrazow, &dlugoscTablicyObrazow))	// 2 jezeli wyrzuci NULL -1 jezeli blad przy odczycie 0 jezeli poprawnie wczytany
			{
				krok_programu = 0;
				continue;
			}

			wybranyObraz = dlugoscTablicyObrazow - 1;
			krok_programu = 0;
			break;
		case 3:
			printf("\nObrazy: ");
			for (int i = 0; i < dlugoscTablicyObrazow; i++)
			{
				printf("%d - \"%s\", ", i, (tablicaObrazow + i)->nazwa);
			}
			printf("\n");
			if (WczytajKonsola("\rWybierz indeks obrazu ktory chcesz wybrac\n", 0, dlugoscTablicyObrazow - 1, &wybranyObraz))
			{
				wybranyObraz = 0;
				printf("Wybrano obraz \"%s\"\n", WYBOBR->nazwa);
				krok_programu = 0;
				break;
			}
			srodekHist = 0;
			printf("Wybrano obraz \"%s\"\n", WYBOBR->nazwa);
			krok_programu = 0;
			break;

		case 5:

			system("cls");
			if (WczytajKonsola("\rWybierz, co chcesz zrobic z obrazem\
				\n\r'0' - obrot w lewo\n\
				\n\r'1' - obrot w prawo\n\
				\n\r'2' - obrot w lewo o k * 90 stopni\n\
				\n\r'3' - dodaj szum 'sol i pieprz'\n\
				\n\r'4' - zastosuj filtr Gaussa\n\
				\n\r'5' - stworz histogram i zapisz do pliku csv\n\
				\n\r'6' - progowanie obrazu (na podstawie histogramu)\n\
				", 0, 6, &krok_obrobki))
			{
				krok_programu = 0;
				continue;
			}

			switch (krok_obrobki) {
			case 0:
				printf("Obracam obraz w lewo...\n");
				Transpozycja(WYBOBR, 1);
				break;
			case 1:
				printf("Obracam obraz w prawo...\n");
				Transpozycja(WYBOBR, 3);
				break;
			case 2:

				if (WczytajKonsola("\rPodaj liczba obrotow (k)\n", 1, 4, &k))
				{
					continue;
				}
				printf("Obracam obraz w lewo o k * 90 stopni...\n");
				Transpozycja(WYBOBR, k);
				break;
			case 3:
				if (WczytajKonsola("\rPodaj procentowa szanse na zaszumienie piksela\n", 1, 100, &k))
				{
					continue;
				}
				printf("Zaszumiam obraz...\n");
				Szum(WYBOBR, k);
				break;
			case 4:
				if (WczytajKonsola("\rWybierz filtr\n 0 - Dolnoprzepustowy ('rozmazujacy')\n 1 - Gornoprzepustowy ('Wyostrzajacy')\n 2 - bardziej Gornoprzepustowy\n", 0, 2, &k))
				{
					continue;
				}
				printf("Filtruje...\n");
				FiltrGaussa(WYBOBR, k);
				break;
			case 5:
				printf("Tworze histogram...\n");
				srodekHist = 1;
				histogram = Histogram(WYBOBR);
				break;
			case 6:
				if (!srodekHist) {
					printf("Najpierw trzeba stworzyc histogram!\n");
					continue;
				}

				printf("Proguje obraz...\n");
				Progowanie(WYBOBR, histogram);
			default:
				break;
			}

			break;
		case 6:
			printf("Usuwam obraz \"%s\"...\n", WYBOBR->nazwa);
			UsunObraz(&tablicaObrazow, &dlugoscTablicyObrazow, wybranyObraz);
			srodekHist = 0;
			if (dlugoscTablicyObrazow)
			{
				krok_programu = 3;
			}
			else {
				krok_programu = 0;
				wybranyObraz = 0;
			}
			break;
		case 7:

			printf("Podaj nazwe pod ktora chcesz zapisac plik (bez .pgm)\n");
			while (!scanf("%s", nazwa))
			{
				char c;
				while (c = getchar() != '\n');
			}

			strcat(nazwa, ".pgm");
			printf("Zapisuje plik pod nazwa %s\n", nazwa);
			ZapiszPlik(WYBOBR, nazwa);
			krok_programu = 0;
			break;

		case 100:
			for (int i = 0; i < dlugoscTablicyObrazow; i++) {
				for (int j = 0; j < tablicaObrazow[i].indeksKomentarza; j++)
				{
					free(tablicaObrazow[i].komentarze[j]);
				}
				free(tablicaObrazow[i].komentarze);
				free(tablicaObrazow[i].tablicaPikseli);
			}
			free(tablicaObrazow);
			return 0;
		default:
			krok_programu = 0;
			continue;
		}
	}
}

int Progowanie(obraz* Obraz, int* histogram) {
	int* tab;
	int dlugosc_tablicy = Obraz->wysokosc * Obraz->szerokosc;
	int prog = 0;
	int t = Obraz->maksWartoscSzarosci / 2;
	int tcz = 0;
	int tb = 0;
	int tstare = 0;
	int sumaPikseli = 0;
	int suma = 0;

	DEKLARACJATABLICY
		int* ptr = tab;

	SPRAWDZTABLICE

		do
		{
			for (int i = 0; i < t; i++)
			{
				sumaPikseli += histogram[i];
				suma += histogram[i] * i;
			}
			tcz = suma / sumaPikseli;
			for (int i = t; i < (Obraz->maksWartoscSzarosci + 1); i++)
			{
				sumaPikseli += histogram[i];
				suma += histogram[i] * i;
			}
			tb = suma / sumaPikseli;
			tstare = t;
			t = (tcz + tb) / 2;
		} while (t != tstare);

		prog = t;
		printf("Prog wynosi: %d \n", prog);

		for (int i = 0; i < Obraz->wysokosc; i++)
		{
			for (int j = 0; j < Obraz->szerokosc; j++)
			{
				tab[i * Obraz->szerokosc + j] = Obraz->tablicaPikseli[i * Obraz->szerokosc + j] < prog ? 0 : Obraz->maksWartoscSzarosci;
			}
		}

		free(Obraz->tablicaPikseli);
		Obraz->tablicaPikseli = tab;

		return 0;
}

int FiltrGaussa(obraz* Obraz, int wybrana_maska) {
	int* tab;
	int dlugosc_tablicy = Obraz->wysokosc * Obraz->szerokosc;
	int szerokosc_okna = 3;
	int maska[3][3][3] = {
							{ {-1,-1,-1}, {-1,14,-1}, {-1,-1,-1} },
							{ {0,-1,0}, {-1,5,-1},		{0,-1,0} },
							{ {1,2,1}, {2,4,2},	{1,2,1} }
	};

	DEKLARACJATABLICY
		int* ptr = tab;

	SPRAWDZTABLICE

		int sumaWag = 0;

	for (int i = 0; i < 3; i++)
	{

		for (int j = 0; j < 3; j++)
		{
			sumaWag += maska[wybrana_maska][i][j];
		}
	}

	int offset = szerokosc_okna / 2;
	for (int i = offset; i < Obraz->wysokosc - offset; i++)
	{
		for (int j = offset; j < Obraz->szerokosc - offset; j++)
		{
			int suma = 0;
			for (int k = 0; k < 3; k++)
			{
				for (int l = 0; l < 3; l++)
				{
					suma += maska[wybrana_maska][k][l] * Obraz->tablicaPikseli[(i + k - 1) * Obraz->szerokosc + j + l - 1];
				}
			}
			tab[i * Obraz->szerokosc + j] = suma / sumaWag < 0 ? 0 : suma / sumaWag > Obraz->maksWartoscSzarosci ? Obraz->maksWartoscSzarosci : suma / sumaWag;
		}
	}
	for (int j = 0; j < Obraz->szerokosc; j++) {
		tab[j] = Obraz->tablicaPikseli[j];
	}
	for (int j = 0; j < Obraz->szerokosc; j++) {
		tab[Obraz->szerokosc * (Obraz->wysokosc - 1) + j] = Obraz->tablicaPikseli[Obraz->szerokosc * (Obraz->wysokosc - 1) + j];
	}
	for (int j = 0; j < Obraz->wysokosc; j++) {
		tab[j * Obraz->szerokosc] = Obraz->tablicaPikseli[j * Obraz->szerokosc];
	}
	for (int j = 0; j < Obraz->wysokosc; j++) {
		tab[j * Obraz->szerokosc + Obraz->szerokosc - 1] = Obraz->tablicaPikseli[j * Obraz->szerokosc + Obraz->szerokosc - 1];
	}


	free(Obraz->tablicaPikseli);
	Obraz->tablicaPikseli = tab;
	return 0;
}

int* Histogram(obraz* Obraz) {
	int* bins = calloc((Obraz->maksWartoscSzarosci + 1), sizeof(*bins));
	int iloscPikseli = Obraz->szerokosc * Obraz->wysokosc;
	int srodekHistogramu = 0;

	if (!bins) {
		printf("Blad alokacj pamieci\n");
		return -1;
	}

	int suma = 0;
	for (int i = 0; i < Obraz->wysokosc; i++)
	{
		for (int j = 0; j < Obraz->szerokosc; j++)
		{
			++bins[Obraz->tablicaPikseli[i * Obraz->szerokosc + j]];
		}
	}
	FILE* plik;
	char nazwaPliku[MAXSTRLEN] = "Histogram ";
	strcat(nazwaPliku, Obraz->nazwa);
	strcat(nazwaPliku, ".txt");
	fopen_s(&plik, nazwaPliku, "w");

	if (plik == NULL) {
		printf("Blad przy otwieraniu pliku.\n");
		return -1;
	}
	for (int i = 0; i < Obraz->maksWartoscSzarosci + 1; i++)
	{
		fprintf(plik, "%d,%d\n", i, bins[i]);
		suma += bins[i];
	}
	printf("Ilosc pikseli w binach: %d\n\nIlosc oczekiwana: %d\n\n", suma, iloscPikseli);

	char komenda[MAXSTRLEN] = "python3 HistogramPlotter.py \"";
	strcat(komenda, nazwaPliku);
	strcat(komenda, "\"");

	fclose(plik);
	system(komenda);

	return bins;
}

int Szum(obraz* obrazSzumiony, int procent_szumu) {
	int* tab;
	int dlugosc_tablicy = obrazSzumiony->wysokosc * obrazSzumiony->szerokosc;

	DEKLARACJATABLICY
		int* ptr = tab;

	SPRAWDZTABLICE

		srand(time(NULL));

	for (int i = 0; i < obrazSzumiony->wysokosc; i++)
	{
		for (int f = 0; f < obrazSzumiony->szerokosc; f++)
		{
			tab[i * obrazSzumiony->szerokosc + f] = (rand() % 100 + 1) <= procent_szumu ? rand() % 2 ? obrazSzumiony->maksWartoscSzarosci : 0 : obrazSzumiony->tablicaPikseli[i * obrazSzumiony->szerokosc + f];
		}
	}

	free(obrazSzumiony->tablicaPikseli);
	obrazSzumiony->tablicaPikseli = tab;
	return 0;
}

void Transpozycja(obraz* obrazTransponowany, int liczba_obrotow) {
	int* obroconaTablica;

	for (int i = 0; i < liczba_obrotow; i++)
	{
		obroconaTablica = malloc(obrazTransponowany->wysokosc * obrazTransponowany->szerokosc * sizeof(*obrazTransponowany->tablicaPikseli));

		if (!obroconaTablica) {
			printf("blad alokacji pamieci\n");
			return;
		}

		for (int wys = 0; wys < obrazTransponowany->wysokosc; wys++)
		{
			for (int szer = 0; szer < obrazTransponowany->szerokosc; szer++)
			{
				obroconaTablica[(obrazTransponowany->szerokosc - 1 - szer) * obrazTransponowany->wysokosc + wys] = obrazTransponowany->tablicaPikseli[wys * obrazTransponowany->szerokosc + szer];
			}
		}

		int temp = obrazTransponowany->wysokosc;
		obrazTransponowany->wysokosc = obrazTransponowany->szerokosc;
		obrazTransponowany->szerokosc = temp;

		free(obrazTransponowany->tablicaPikseli);
		obrazTransponowany->tablicaPikseli = obroconaTablica;
	}
	return;
}

int ZapiszPlik(obraz* zapObraz, char nazwaPliku[]) {
	FILE* plik;
	int i = 0;
	int j = 0;
	fopen_s(&plik, nazwaPliku, "w");

	if (plik == NULL) {
		printf("Blad przy otwieraniu pliku.\n");
		return 2;
	}

	int krok_zapisu = 0;

	while (krok_zapisu != 100) {
		switch (krok_zapisu) {
		case 0:
			fprintf(plik, "P%d\n", zapObraz->standard);
			krok_zapisu = 1;
			break;
		case 1:
			for (i = 0; i < zapObraz->indeksKomentarza; i++) {
				fprintf(plik, "#%s\n", zapObraz->komentarze[i]);
			}
			krok_zapisu = 2;
			break;
		case 2:
			fprintf(plik, "%d %d\n", zapObraz->szerokosc, zapObraz->wysokosc);
			krok_zapisu = 3;
			break;
		case 3:
			fprintf(plik, "%d\n", zapObraz->maksWartoscSzarosci);
			krok_zapisu = 4;
			break;
		case 4:
			for (i = 0; i < zapObraz->wysokosc; i++) {
				for (j = 0; j < zapObraz->szerokosc; j++) {
					fprintf(plik, "%d ", *(zapObraz->tablicaPikseli + j + i * zapObraz->szerokosc));
				}
				fprintf(plik, "\n");
			}
			krok_zapisu = 100;
			break;
		default:
			break;
		}
	}

	fclose(plik);

	printf("Zapisano plik %s\n", nazwaPliku);
	return 0;
}

int WczytajPlik(obraz* wczytObraz, obraz** tabObrazow, int* dlugoscTablicyObrazow) {
	int test = 0;
	int status_skanu = 0;
	fpos_t pozycja_wskaznika = 0;
	FILE* plik = NULL;

	//system("cls");

	fopen_s(&plik, wczytObraz->nazwa, "r");
	if (plik == NULL) {
		printf("Blad przy otwieraniu pliku.\n");
		return 2;
	}
	if ((test = CzytajPlik(plik, wczytObraz, tabObrazow, dlugoscTablicyObrazow)) != 8) {
		printf("\nBlad odczytu danych z pliku\nKod Bledu: %d\n", test);
		return -1;
	}

	fclose(plik);

	printf("Wczytano plik %s\n", wczytObraz->nazwa);

	return 0;
}

int UsunObraz(obraz** tabObr, int* tabObrLen, int indeksObr) {
	int ostatni = *tabObrLen;
	int m = 0;
	int nr = indeksObr;

	ostatni--;
	free((*tabObr)[indeksObr].tablicaPikseli);
	free((*tabObr)[indeksObr].komentarze);
	for (m = nr; m < ostatni; m++) {
		(*tabObr)[m] = (*tabObr)[m + 1];
	}

	if (!ostatni) {
		*tabObr = malloc(sizeof(obraz));
		*tabObrLen = ostatni;
		return 0;
	}

	obraz* ptr = realloc(*tabObr, ostatni * sizeof(**tabObr));
	SPRAWDZTABLICE
		* tabObr = ptr;
	*tabObrLen = ostatni;
	return 0;
}

int CzytajPlik(FILE* plik, obraz* wczytObraz, obraz** tabObrazow, int* dlugoscTablicyObrazow) {
	int krok_wczytania = 1;
	int poprzedni_krok = 0;
	int koniec_odczytu = 0;
	int i = 0;
	int j = 0;
	int k = 0;
	char znak;
	int* tab = NULL;
	int dlugosc_tablicy = 0;
	char liczba[MAXSTRLEN];

	char* ptr2;	//tworzenie tablicy dla komentarzy
	ptr2 = malloc(1 * sizeof(char*));

	if (!ptr2) {
		printf("Blad przy przydzielaniu pamieci do bufora\n");
		return -1;
	}

	wczytObraz->komentarze = ptr2;
	wczytObraz->indeksKomentarza = 0;

	while (!feof(plik))
	{
		if ((znak = fgetc(plik)) > 32 || (znak == '\n' && krok_wczytania == 0)) //jezeli pobrany znak jest w z tablicy ASCI jakims symbolem (wszystkie maja powyzej 32 wartosc) lub trafiono na bialy znak i tryb komentarza
		{
			if (znak == '#')	//realokacja tablicy w przypadku napotkania komentarzu
			{
				if (krok_wczytania != 0)
				{
					char* ptr = realloc(wczytObraz->komentarze, (wczytObraz->indeksKomentarza + 1) * sizeof(char*));

					SPRAWDZTABLICE	//warunek globalny czy jest jeszcze miejsce na powiekszenie tablicy


					wczytObraz->komentarze = ptr;
					wczytObraz->komentarze[wczytObraz->indeksKomentarza] = malloc(MAXSTRLEN * sizeof(char));	//przepisanie komentarzy do realokowanej tablicy

					if (!(wczytObraz->komentarze[wczytObraz->indeksKomentarza])) {
						printf("\nBlad przy przydzielaniu pamieci\n");
						return -1;
					}

					poprzedni_krok = krok_wczytania;
				}
				krok_wczytania = 0;
				continue;
			}
			switch (krok_wczytania)
			{
			case 0: //tryb komentarza
				if (znak == '\n') {
					wczytObraz->komentarze[wczytObraz->indeksKomentarza][k] = '\0';
					wczytObraz->indeksKomentarza++;
					k = 0;
					krok_wczytania = poprzedni_krok;
					continue;
				}
				(wczytObraz->komentarze[wczytObraz->indeksKomentarza])[k] = znak;
				k++;
				break;
			case 1://SprawdŸz pierwszy element standardu - sposób kodowania
				if (znak == 'P' || znak == 'p')
				{
					krok_wczytania = 2;
					continue;
				}
				else
				{
					printf("\nNie znaleziono standardu kodowania obrazu (powinien sie znalezc na pierwszym miejscu w pliku)\n");
					return krok_wczytania;
				}
				break;
			case 2://SprawdŸz czy numer standardu kodowania jest prawidłowy...
				if (znak - 48 != 2) //w ASCI 2 ma 50
				{
					printf("\nNiepoprawny standard kodowania - obraz musi byc zakodowany w standardzie P2.\n");
					return krok_wczytania;
				}
				else
				{
					wczytObraz->standard = znak - 48;
					krok_wczytania = 3;
					continue;
				}
				break;
			case 3://Wczytaj szerokosc obrazu...
				i = WczytajLiczbe(plik, znak); //po prawidlowym odczycie zwracana jest dodatnia wartosc a jezeli nie to ujemna
				if (i > 0)
				{
					wczytObraz->szerokosc = i;
					krok_wczytania = 4;
				}
				else
				{
					if (!i)	//na wypadek gdyby odczytano 0
					{
						printf("\nSzerokosc obrazu nie moze byc 0\n");
					}
					return krok_wczytania;	//powrot do case 3
				}
				i = 0;
				break;
			case 4://Wczytaj wysokosc obrazu...
				i = WczytajLiczbe(plik, znak);
				if (i > 0) {
					wczytObraz->wysokosc = i;
					krok_wczytania = 5;
				}
				else
				{
					if (!i)
					{
						printf("\nWysokosc obrazu nie moze byc 0\n");
					}
					return krok_wczytania;
				}
				i = 0;
				break;
			case 5://Wczytaj maksymalny odcien szarosci...
				i = WczytajLiczbe(plik, znak);
				if (i >= 0) {
					wczytObraz->maksWartoscSzarosci = i;
					krok_wczytania = 6;
				}
				else
				{
					return krok_wczytania;
				}
				i = 0;
				j = 0;
				break;
			case 6:	//Sprawdz czy dlugosc danych sie zgadza a jezeli tak to utworz tablice i sprawdz czy przydzielono pamiec
				dlugosc_tablicy = wczytObraz->szerokosc * wczytObraz->wysokosc < INT_MAX ? wczytObraz->szerokosc * wczytObraz->wysokosc : 0;

				if (!dlugosc_tablicy)
				{
					printf("\nPrzekroczenie maksymalnej wartosci zmiennej typu int\n");
					return krok_wczytania;
				}

				DEKLARACJATABLICY;
				if (!tab) {
					printf("\nBlad przy przydzielaniu pamieci do tablicy.\n");
					return krok_wczytania;
				}

				krok_wczytania = 7;
				//fseek(plik, -1, SEEK_CUR);
			case 7://Wczytaj tablice pikseli...

				if (j >= wczytObraz->szerokosc) {
					i++;
					j = 0;
				}

				if (i < wczytObraz->wysokosc) {
					int test = 0;
					*(tab + i * wczytObraz->szerokosc + j) = (((test = WczytajLiczbe(plik, znak)) >= 0) && (test <= wczytObraz->maksWartoscSzarosci)) ? test : -2;

					if (*(tab + i * wczytObraz->szerokosc + j) < 0) {
						printf("\nBlad wartosci pikseli w pliku obrazu.\n");
						return krok_wczytania;
					}
					j++;
					continue;
				}

				krok_wczytania = 8;
				continue;
			case 8://krok bledu
				printf("\nNiepoprawna tablica pikseli w pliku - niejezdoznacznosc wysokosci i szerokosci z podanymi danymi.\n");
				return 0;
			}
		}
	}
	if (i == wczytObraz->wysokosc - 1 && j == wczytObraz->szerokosc)
	{
		wczytObraz->tablicaPikseli = tab;
		obraz* ptr;
		(*dlugoscTablicyObrazow) += 1;
		ptr = realloc(*tabObrazow, *dlugoscTablicyObrazow * sizeof(**tabObrazow));

		SPRAWDZTABLICE

			* tabObrazow = ptr;
		(*tabObrazow)[*dlugoscTablicyObrazow - 1] = *wczytObraz;
		krok_wczytania = 8;
		printf("\nPoprawnie wczytano tablice o szerokosci %d i wysokosci %d\n", wczytObraz->szerokosc, wczytObraz->wysokosc);
	}
	else {
		krok_wczytania = -1;
		printf("\nNiepoprawna tablica pikseli w pliku - niejezdoznacznosc wysokosci i szerokosci z podanymi danymi.\n");
		return krok_wczytania;
	}
	return krok_wczytania;
}

int WczytajLiczbe(FILE* plik, char cyfra)
{
	int i = 0;
	char liczba[MAXSTRLEN];	//char bo konwercja inaczej by sie nie dalo w tablice wpisac 123\0
	int liczbaInt = -2;
	do
	{
		if (i < MAXSTRLEN - 1)
		{
			liczba[i] = cyfra;
			i++;
		}
		else //jesli szerokosc wyszlaby po za zakres - co jest raczej niemozliwe ale lepiej dmuchac na zimne
		{
			printf("\nPrzekroczono dlugosc bufora odczytu\n");
			return -4;
		}
	} while ((cyfra = fgetc(plik)) - 48 <= 9 && cyfra - 48 >= 0);	//dopoki sa z zakresu 48 - 57 w kodzie ascii czyli cyfry, to bedzie przypisywac do tablicy


	if (cyfra == '#')
	{
		fseek(plik, -1, SEEK_CUR);		//cofnij pozycje wskaznika o 1 do tylu jezeli napotka komentarz bo potem juz nic nie ma
	}

	if (i) //gdy skonczy czytac szerokosc to przypisz ostatniemu elementowi tablicy bialy znak
	{
		liczba[i] = '\0';
	}
	else {
		printf("\nBlad przy pobieraniu danej liczbowej.\n");
		return -1;
	}

	if (!(liczbaInt = strtol(liczba, NULL, 10) <= INT_MAX ? (int)strtol(liczba, NULL, 0) : 0) && strcmp("0", liczba)) //warunek 3 argumentowy jezeli long int poza zakres wyleci to bedzie rownal sie 0
	{
		printf("\nBlad przy pobieraniu danej liczbowej.\n");
		return -3;		//zabezpieczenie gdyby w buforze bylo np. 113a ... bez tego # ale to juz jest poza zakres programu ktory robimy
	} // przekonwertowanie liczb na system dziesietny - gotowy wzór

	return liczbaInt; //zwracana zmienna ma wartosc przekonwertowanej liczby na int w postaci 64 bitowego zapisu - INT_MAX to maksymalna wartosc int
}


int WczytajKonsola(char komunikat[], int granica_dolna, int granica_gorna, int* kontrolka) {
	char c;

	printf("\n %s \nWcisnij ',' aby powrocic do menu\nZakres: %d do %d\n", komunikat, granica_dolna, granica_gorna);
	while (scanf("%d", kontrolka) == 0 || (*kontrolka < granica_dolna || *kontrolka > granica_gorna)) {
		while ((c = getchar()) != '\n') {
			if (c == ',') {
				printf("\nWracam do menu\n");
				return -1;
			}
		}
		printf("Podaj prawidlowa cyfre z odpowiedniego zakresu\n");
	}

	return 0;
}