#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define CRT_SECURE_NO_WARNINGS

struct obraz
{
	char title[50];
	char standard;                                                      //deklaruje strukture na zmienne: standard,szerokosc,wysokosc,
	int szer;                                                          //skala szarosci, obraz(tablica dwuwymiarowa)
	int wys;
	int skal_szar;
	int **obraz;
};
void wczytajplik(struct obraz *tablica, int *licznik_obraz);         //wybor pliku, wczytywanie, alokowanie pamieci
void bufor();                                                        //funkcja czyszczaca bufor klawiatury
void drukujobraz(struct obraz* tablica, int *aktobraz);              //drukowanie obrazu w konsoli
void fri(struct obraz* o1);                                          //uwalnianie tablicy dwuwymiarowej
void zapiszobraz(struct obraz* tablica, int *aktobraz);
struct obraz* usunobraz(struct obraz* tablica, int *aktobraz, int licznik_obraz);
struct obraz* realokuj(struct obraz *tablica, int licznik_obraz);
void filtr_gaussa(struct obraz* tablica, int aktobraz, int **kopia);
void tworz_kopie(struct obraz* tablica, int aktobraz, int **kopia);
int main()
{
	struct obraz *tablica;                                          //tworze wskaznik na tablice struktur
	int licznik_obraz = 1, i, **kopia;                                           //licznik_obraz zlicza ile aktualnie w programie jest obrazow
	int aktobraz = 0;                                                  //wybiera ktory obraz jest aktywny (domyslnie 0)
	char menu;
	menu = 'z';
	tablica = malloc(1 * sizeof(struct obraz));                          //alokujê tablice na rozmiar 1 struktury
	while (menu != 'a')                                                 //petla pozwalajaca na wielokrotne wybieranie funckji z menu
	{
		printf("nWybierz jedna opcje z Menuna. Wyjscienb. Dodaj obraznc. Pokaz obraz w konsolind. Lista obrazowne. Zapisz obraz do pliku .pgmnf. Usun aktywny obrazng. Filtr Gaussa");
		while (_kbhit() == 0);                                          //petla oczekujace na wcisniecie przycisku na klawiaturze
		menu = _getch();
		switch (menu)
		{
		case 'a':
			//WYJSCIE, czysci tablice 2-wym, tablice struktur
			if (sizeof(tablica)>20 * sizeof(int))
			{
				for (i = 0; i<licznik_obraz; i++)
				{
					fri(&tablica[i]);
				}
			}
			free(tablica);
			break;
		case 'b':                                               //wczytaj plik, inkrementuj licznik, realokuj tablice struktur
			wczytajplik(tablica, &licznik_obraz);
			licznik_obraz = licznik_obraz + 1;
			tablica = realokuj(tablica, licznik_obraz);
			break;
		case 'c':
			if (tablica[aktobraz].szer<31 && tablica[aktobraz].wys<31) {
				drukujobraz(tablica, &aktobraz);                     //wyswietl obraz w konsoli (dla obrazow mniejszych niz 30x30)
			}
			else {
				printf("nTEN OBRAZ JEST ZA DUZY ABY WYSWIETLIC GO W KONSOLIn");
			}
			break;
		case 'd':
			if (licznik_obraz == 1) {                               //wyswietla liste wczytanych obrazow
				printf("nNie wczytales jeszcze zadnych obrazow");
			}
			for (i = 1; i<licznik_obraz; i++)
			{
				printf("nn%d. %s", i, tablica[i - 1].title);
			}
			if (licznik_obraz>1) {
				do
				{
					bufor();
					printf("nWybierz aktywny obraz:n");
					scanf("%d", &aktobraz);
				}                          //pozwala na wybranie aktywnego obrazu (tego ktory bedzie uzyty w nastepnych funkcjach)
				while (aktobraz >= licznik_obraz || aktobraz <= 0);
			}
			aktobraz--;
			break;
		case'e':
			//funkcja zapisujaca aktywny obraz do pliku
			zapiszobraz(tablica, &aktobraz);
			break;
		case'f':
			usunobraz(tablica, &aktobraz, licznik_obraz);         //usuwam aktywny obraz i dekrementuje licznik obrazow
			licznik_obraz--;

			break;
		case'g':
			tworz_kopie(tablica, aktobraz, kopia);
			printf("dadadn");
			filtr_gaussa(tablica, aktobraz, kopia);
			break;
		default:
			printf("nNIE MA TAKIEJ OPCJI W MENUn");           //jezeli uzytkownik wcisnal nieodpowiedni klawisz wyswietlam komunikat
			break;


		}

	}
	system("pause");
	return 0;
}
void bufor()
{
	int c;
	while ((c = getc(stdin)) != 'n'&&c != EOF);                           //czysci bufor klawiatury
}
void wczytajplik(struct obraz *tablica, int *licznik_obraz)
{
	char help;                                                      //zmienne pomocnicza do oczytywania z pliku
	int helps, i = 0, j = 0, k;
	char tytul[50];
	printf("nPodaj tytul obrazu: ");                                //wczytuje tytul pliku do otwarcia
	scanf("%s", tytul);
	strcpy(tablica[*licznik_obraz - 1].title, tytul);
	FILE *plik;
	plik = fopen(tytul, "r");                                             //otwieram plik
	while (plik == NULL)
	{
		printf("nNIE MA TAKIEGO PLIKU");                               //zabezpieczenie przed nieotwartym plikiem
		printf("nPodaj tytul obrazu: ");
		scanf("%s", tytul);
		plik = fopen(tytul, "r");
	}
	fseek(plik, 1, SEEK_SET);
	fscanf(plik, "%c", &help);
	tablica[*licznik_obraz - 1].standard = help;                             //odczytuje standard pliku
	fseek(plik, 1, SEEK_CUR);                                               //poczatek algorytmu obslugi komentarzy
	while (getc(plik) == '#')
	{
		while (getc(plik) != 'n');
	}
	fseek(plik, -1, SEEK_CUR);                                       //i jego koniec
	fscanf(plik, "%d", &helps);
	tablica[*licznik_obraz - 1].wys = helps;
	fscanf(plik, "%d", &helps);                                        //odczytuje szerokosc,wysokosc,skale szarosci
	tablica[*licznik_obraz - 1].szer = helps;
	fseek(plik, 1, SEEK_CUR);                                          //poczatek algorytmu obslugi komentarzy
	while (getc(plik) == '#')
	{
		while (getc(plik) != 'n');
	}
	fseek(plik, -1, SEEK_CUR);                                         //i jego koniec
	fscanf(plik, "%d", &helps);
	tablica[*licznik_obraz - 1].skal_szar = helps;
	fseek(plik, 1, SEEK_CUR);                                       //poczatek algorytmu obslugi komentarzy
	while (getc(plik) == '#')
	{
		while (getc(plik) != 'n');
	}
	fseek(plik, -1, SEEK_CUR);                                         //i jego koniec
	tablica[*licznik_obraz - 1].obraz = malloc((tablica[*licznik_obraz - 1].szer + 1) * sizeof(*tablica[*licznik_obraz - 1].obraz));     //alokuje pamiec na tablice dwu_wym
	if (tablica[*licznik_obraz - 1].obraz != NULL)
	{
		for (helps = 0; helps<tablica[*licznik_obraz - 1].szer + 1; helps++)
		{
			tablica[*licznik_obraz - 1].obraz[helps] = malloc((tablica[*licznik_obraz - 1].wys + 1) * sizeof(int));
			if (tablica[*licznik_obraz - 1].obraz[helps] == NULL)                                                                 //zabezpieczenie przed wyciekiem pamieci w razie niepoprawnego alokowania
			{
				printf("nBLAD ALOKACJI PAMIECI DLA TABLICY DWUWYMIAROWEJnSPROBOJ UROCHOMIC PROGRAM PONOWNIE");
				for (k = 0; k <= helps; k++)
				{
					free(tablica[*licznik_obraz - 1].obraz[k]);                 //czyszcze tablice "podrzedne" tablicy dwu_wym
				}
				free(tablica[*licznik_obraz - 1].obraz);                    //czyszcze tablice "matke"

			}
		}
	}
	else {
		printf("nBLAD ALOKACJI PAMIECI DLA TABLICY DWUWYMIAROWEJnSPROBOJ UROCHOMIC PROGRAM PONOWNIE");
	}
	while (getc(plik) != EOF)                                         //petla wczytujaca piksele az do konca pliku
	{
		fseek(plik, -1, SEEK_CUR);
		if (j == 0)
		{
			if (getc(plik) == '#')                                   //sprawdzenie na poczatku linii nastepuje komentarz
			{
				while (getc(plik) != 'n');
			}
			else { fseek(plik, -1, SEEK_CUR); }
		}
		fscanf(plik, "%d", &helps);
		fseek(plik, 1, SEEK_CUR);
		tablica[*licznik_obraz - 1].obraz[i][j] = helps;                //wczytuje 'piksele' do tablicy dwu_wym
		j++;
		if (j >= tablica[*licznik_obraz - 1].szer)
		{
			if (i<tablica[*licznik_obraz - 1].wys - 1) {
				if (getc(plik) == '#')                                      //sprawdzenie czy po koncu linii nastepuje kometarz
				{
					while (getc(plik) != 'n');
				}
				else { fseek(plik, -1, SEEK_CUR); }

			}
			j = 0;
			i = i + 1;
		}
		if (i == tablica[*licznik_obraz - 1].wys && j == 0)                 //instrukcja zakonczy petle wczytujaca obraz po osiagnieciu ostatniego piksela
		{
			fseek(plik, -1, SEEK_END);
		}
	}
	fclose(plik);
}
void drukujobraz(struct obraz* tablica, int *aktobraz)
{
	int i, j;
	printf("nStandard: P%c", tablica[*aktobraz].standard);
	printf("nSzerokosc: %d", tablica[*aktobraz].szer);
	printf("nWysokosc: %d", tablica[*aktobraz].wys);               //wypisuje parametry pliku
	printf("nSkala szarosci: %dnObraz:n", tablica[*aktobraz].skal_szar);
	for (i = 0; i<tablica[*aktobraz].wys; i++)
	{
		for (j = 0; j<tablica[*aktobraz].szer; j++)
		{
			printf("%d ", tablica[*aktobraz].obraz[i][j]);          //drukuje piksele obrazu

		}
		printf("n");
	}
}
void fri(struct obraz* o1)
{
	int helps;
	for (helps = 0; helps<o1->szer + 1; helps++)
	{
		free(o1->obraz[helps]);                                      //czyszcze tablice "podrzedne" tablicy dwu_wym
	}
	free(o1->obraz);                                                   //czyszcze tablice "matke"
}
struct obraz* realokuj(struct obraz *tablica, int licznik_obraz)
{
	//realokowanie tablicy o jenda strukture wiecej
	struct obraz *temp;

poczatek:

	temp = realloc(tablica, (licznik_obraz + 1) * sizeof(struct obraz));
	if (temp != NULL)                                           // sprawdzenie powodzenia realokacji
	{
		tablica = temp;
	}
	else
	{
		free(temp);
		goto poczatek;
	}
	return tablica;                                             //zwracam wskaznik do realokowanej tablicy
}
void zapiszobraz(struct obraz* tablica, int *aktobraz)
{
	int i, j;
	FILE *plik;
	char nazwa[50];
	printf("nPodaj nazwe pliku do zapisu (razem z typem np. nazwa.pgm):n");       //pobieram nazwe pliku do zapisu
	scanf("%s", nazwa);
	plik = fopen(nazwa, "w");
	fprintf(plik, "P%cn", tablica[*aktobraz].standard);
	fprintf(plik, "%d %dn", tablica[*aktobraz].wys, tablica[*aktobraz].szer);         //zapisuje parametry obrazu do pliku
	fprintf(plik, "%dn", tablica[*aktobraz].skal_szar);
	for (i = 0; i<tablica[*aktobraz].wys; i++)
	{
		for (j = 0; j<tablica[*aktobraz].szer; j++)
		{
			fprintf(plik, "%d", tablica[*aktobraz].obraz[i][j]);                          //zapisuje obraz do pliku
			if (j<tablica[*aktobraz].szer - 1)
			{
				fprintf(plik, " ");
			}
			if (j == tablica[*aktobraz].szer - 1)
			{
				fprintf(plik, "n");
			}
		}
	}
	fclose(plik);
	printf("nZapisano plik %s", nazwa);
}
struct obraz* usunobraz(struct obraz* tablica, int *aktobraz, int licznik_obraz)
{
	int i = 1;
	fri(&tablica[*aktobraz]);                                   //zwalniam tablice dwuwymiarowa obrazu aktywnego
	for (i = *aktobraz; i<licznik_obraz; i++)                        //przesuwam 'obrazy' w tablicy struktur
	{
		tablica[i] = tablica[i + 1];
	}
	tablica = realokuj(tablica, licznik_obraz - 1);                    //realokuje tablice struktur po usunieciu obrazu
	printf("nUsunieto obraz nr %dnUstawiam wskaznik aktywnego obrazu na 0", *aktobraz + 1);
	*aktobraz = 0;
	return 0;
}
void tworz_kopie(struct obraz* tablica, int aktobraz, int **kopia)
{
	int i, k;
	do
	{
		kopia = malloc((tablica[aktobraz].szer + 1) * sizeof(int));
	} while (kopia == NULL);
	for (i = 0; i<tablica[aktobraz].szer + 1; i++)
	{
		kopia[i] = malloc((tablica[aktobraz].wys + 1 * sizeof(int)));
		if (kopia[i] == NULL)
		{
			printf("nBlad alokacji pamieci na kopie obrazu - sproboj uruchomic program ponownie");
		}
	}
	for (i = 0; i<tablica[aktobraz].wys; i++)
	{
		for (k = 0; k<tablica[aktobraz].szer; k++)
		{
			kopia[i][k] = tablica[aktobraz].obraz[i][k];
		}
	}
}
void filtr_gaussa(struct obraz* tablica, int aktobraz, int **kopia)
{
	int x = 1, y, i = 0, piksel = 0;
	printf("nPodaj czy filtr Gaussa ma byc dodatni czy ujemny (1 albo 2):n1. Dodatnin2.Ujemnyn");
	while (i != 1 && i != 2)
	{
		bufor();
		scanf("%d", &i);
	}
	while (x<tablica[aktobraz].wys - 1)
	{
		y = 1;
		while (y<tablica[aktobraz].szer - 1)
		{
			if (i == 1) {
				piksel = kopia[x - 1][y - 1] + kopia[x - 1][y] * 2 + kopia[x - 1][y + 1] + kopia[x][y - 1] * 2 + kopia[x][y] * 4 + kopia[x][y + 1] * 2;
				piksel = piksel + kopia[x + 1][y - 1] + kopia[x + 1][y] * 2 + kopia[x + 1][y + 1];
				piksel = piksel / 16;
				tablica[aktobraz].obraz[x][y] = piksel;
			}
			if (i == 2)
			{
				piksel = kopia[x - 1][y] * (-1) + kopia[x][y - 1] * (-1) + kopia[x][y] * 5 + kopia[x][y + 1] * (-1) + kopia[x + 1][y] * (-1);
				tablica[aktobraz].obraz[x][y] = piksel;
			}
			y++;
		}
		x++;
	}


}