#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <locale.h>
#include <Windows.h>

#define MAXSTRLEN 100

int odczyt_pliku(struct obraz* hp1);
int zapis_pliku(struct obraz hp1);
void czyszczenie_pamieci(struct obraz* hp1);
void zwalnianie_blad(struct obraz* hp1, int ile);
int obrot(struct obraz* hp1);
void histogram(struct obraz* hp1);
void negatyw(struct obraz* hp1);
void pieprz_sol(struct obraz* hp1);
int filtr(struct obraz* hp1);
struct obraz kopia_zapasowa(struct obraz* hp1);

struct obraz
{
	char* nazwa_pliku;
	char* standard;
	int szerokosc;
	int wysokosc;
	int zakres;	//maksymalna wartosc piksela
	int** piksele; //tablica na piksele
};

int main()
{
	//zmienne wejsciowe do poruszania sie w menu
	int pomocnicza = 0;
	int krok_programu = 0;
	char nazwa[MAXSTRLEN];
	struct obraz* hp1;//deklaracja zmiennej strukturalnej
	hp1 = (struct obraz*)malloc(1 * sizeof(struct obraz));//alokacja pamieci
	struct obraz kopia_robocza;
	//do robienia kilku obrazow
	int wybranyObraz = 0;
	int dlugoscTablicyObrazow = 1;
	struct obraz* tablicaObrazow = malloc(1 * sizeof(struct obraz));	//deklaracja tablicy struktur - poczatkowo 1 element
	struct obraz* tablicaObrazow2;	//deklaracja tablicy struktur pomocnicza do przepisywania


	srand(time(NULL));

	//menu
	do
	{
		switch (krok_programu)
		{
		case 0:	//miejsce na wprowadzanie danych przez uzytkownika i nastepnie przejscie do programu
		menu:
			puts("Menu");
			puts("1 - wczytaj plik");
			puts("2 - obrot obrazu");
			puts("3 - negatyw");
			puts("4 - szum");
			puts("5 - filtr");
			puts("6 - histogram");
			puts("7 - zapisz obraz");
			puts("8 - wyjscie z programu");
			puts("9 - wybor obrazu");

			while (!scanf("%s", nazwa))	//pobieranie
			{
				char c;
				while (c = getchar() != '\n');
			}

			system("cls");

			if (!strcmp(nazwa, "8"))
			{
				krok_programu = 8;
			}
			else if (!strcmp(nazwa, "1"))
			{
				krok_programu = 1;
			}
			else if ((!strcmp(nazwa, "2")) && krok_programu == 10)
			{
				krok_programu = 2;
			}
			else if ((!strcmp(nazwa, "3")) && krok_programu == 10)
			{
				krok_programu = 3;
			}
			else if ((!strcmp(nazwa, "4")) && krok_programu == 10)
			{
				krok_programu = 4;
			}
			else if ((!strcmp(nazwa, "5")) && krok_programu == 10)
			{
				krok_programu = 5;
			}
			else if ((!strcmp(nazwa, "6")) && krok_programu == 10)
			{
				krok_programu = 6;
			}
			else if ((!strcmp(nazwa, "7")) && krok_programu == 10)
			{
				krok_programu = 7;
			}
			else if ((!strcmp(nazwa, "9")) && krok_programu == 10)
			{
				krok_programu = 9;
			}
			else
			{
				krok_programu = -1;
			}

			break;
		case 1:	//wczytywanie pliku
			if (odczyt_pliku(hp1))
			{
				puts("Poprawnie wczytano plik");
				kopia_robocza = kopia_zapasowa(hp1);	//utworzenie kopii roboczej do dalszej obrobki obrazu
				puts("utworzono kopie robocza pliku");

				//miejsce na realokacje tablicy struktur po udanym odczycie
				dlugoscTablicyObrazow++;
				tablicaObrazow2 = realloc(tablicaObrazow, dlugoscTablicyObrazow * sizeof(struct obraz));
				if (tablicaObrazow2 != NULL)	//zabezpieczenie przed wysypaniem
				{
					tablicaObrazow = tablicaObrazow2;
					puts("nastapila realokacja tablicy");
				}
				else
				{
					free(tablicaObrazow2);
					puts("blad przy realokacji pamieci - powrot do menu");
					krok_programu = 0;
				}
				//koniec realokacji

				//miejsce na przepisanie odczytanego pliku do tablicy struktur(1)
				tablicaObrazow[dlugoscTablicyObrazow - 2] = kopia_robocza;
				puts("odczytany obraz zostal przypisany do tablicy struktur");
				//wyswietlanie odczytanych obrazow
				/*
				puts("Obrazy ktore zostaly wczytane");
				for (int i = 0; i < dlugoscTablicyObrazow - 1; i++)
				{
					printf("[%d] - %s\n", i, (tablicaObrazow + i)->nazwa_pliku);	//wyswietlanie nazwy pliku z tablicy
				}
				printf("\n");
				//koniec przepisywania(1)

				//wybor obrazu
				puts("Ktory obraz chcesz wybrac ?");
				while (scanf("%d", &wybranyObraz) != 1) //dopóki nie uda się wczytać, zabezpieczenie na wybranie liczby calkowitej
				{
					printf("Podano zla wartosc\n");
					int d;
					while ((d = getchar()) != '\n' && d != EOF); //pętla wyciągająca znaki z bufora
				}
				kopia_robocza = tablicaObrazow[wybranyObraz];	//przepisanie kopii roboczej do wybranego elementu
				printf("\nwybrano [%d] - %s\n", wybranyObraz, tablicaObrazow[wybranyObraz]);
				//koniec wyboru obrazu
				*/
				krok_programu = 10;	//otwarcie bramki do edycji obrazu
			}
			else
			{
				printf("Problem z alokacja, zwalniam pamiec\n", 0);
				zwalnianie_blad(hp1, 0);
				krok_programu = 0;
			}

			break;
		case 2:	//obrot
			puts("Podaj wielokrotnosc kata 90 stopni:");

			//zabezpieczenie aby wybrano cyfre z zakresu menu
			while (scanf("%d", &pomocnicza) != 1) //dopóki nie uda się wczytać
			{
				printf("Podano zla wartosc\n");
				int c;
				while ((c = getchar()) != '\n' && c != EOF); //pętla wyciągająca znaki z bufora
			}
			int pomocnicza1 = fabs(pomocnicza);	//na wypadek wpisania ujemnej wartosci
			//koniec zabezpieczenia

			//miejsce na funkcje do obrotu
			for (int i = 0; i < pomocnicza1; i++)
			{
				obrot(&kopia_robocza);	//przekazanie kopii roboczej do edycji
			}
			puts("Wykonano obrot");
			Sleep(2000);

			krok_programu = 10;
			break;
		case 9:	//wybor obrazu
			//wyswietlanie odczytanych obrazow
			puts("Obrazy ktore zostaly wczytane");
			for (int i = 0; i < dlugoscTablicyObrazow - 1; i++)
			{
				printf("[%d] - %s\n", i, (tablicaObrazow + i)->nazwa_pliku);	//wyswietlanie nazwy pliku z tablicy
			}
			printf("\n");
			//koniec przepisywania(1)

			//wybor obrazu
			puts("Ktory obraz chcesz wybrac ?");
			while (scanf("%d", &wybranyObraz) != 1) //dopóki nie uda się wczytać, zabezpieczenie na wybranie liczby calkowitej
			{
				printf("Podano zla wartosc\n");
				int d;
				while ((d = getchar()) != '\n' && d != EOF); //pętla wyciągająca znaki z bufora
			}
			kopia_robocza = tablicaObrazow[wybranyObraz];	//przepisanie kopii roboczej do wybranego elementu
			printf("\nwybrano [%d] - %s\n", wybranyObraz, tablicaObrazow[wybranyObraz]);
			//koniec wyboru obrazu
			krok_programu = 10;
			break;
		case 3:	//negatyw
			negatyw(&kopia_robocza);
			puts("wykonano negatyw");
			Sleep(2000);

			krok_programu = 10;
			break;

		case 4:	//szum
			pieprz_sol(&kopia_robocza);
			puts("wykonano szum - efekt sol i pieprz");
			Sleep(2000);

			krok_programu = 10;
			break;
		case 5:	//filtr
			filtr(&kopia_robocza);
			puts("wykonano filtr");
			Sleep(2000);

			krok_programu = 10;
			break;
		case 6:	//histogram
			histogram(&kopia_robocza);
			puts("histogram zostal utworzony");
			Sleep(2000);

			krok_programu = 10;
			break;
		case 7:	//zapisz obraz
			if (zapis_pliku(kopia_robocza))	//procedura zapisywania obrazu
			{
				puts("Plik zostal zapisany");
				puts("Powrot do menu - nastapilo czyszczenie pamieci");
				krok_programu = 10;
			}
			else
			{
				puts("Nie udalo sie zapisac pliku");
				puts("Powrot do menu - nastapilo czyszczenie pamieci");
				krok_programu = 10;
			}

			czyszczenie_pamieci(hp1);	//procedura czyszczenia pamieci

			krok_programu = 0;
			break;
		case 8:	//wyjscie
			break;
		case 10:
			goto menu;
			break;
		}


		if (krok_programu == -1)	//czyszczenie dla porzadku + informacja o wprowadzeniu zlej zmiennej
		{
			system("cls");
			puts("wprowadzono zla wartosc\n");
			krok_programu = 0;
		}

	} while (krok_programu != 8);
}

void histogram(struct obraz* hp1)//to dziala, problem z zapisem
{
	int i, j, z;
	int licznik = 0;
	int max = 0;
	int* tab;
	//deklaracja tablicy na zapisywanie wynikow do histogramu
	tab = (int**)malloc(hp1->zakres * sizeof(int));

	for (z = 0; z < hp1->zakres + 1; z++)   //+1 bo nie lapalo maksymalnej wartosci piksela
	{
		for (i = 0; i < hp1->wysokosc; i++)
		{
			for (j = 0; j < hp1->szerokosc; j++)
			{
				if (hp1->piksele[i][j] == z)
				{
					licznik++;
				}

			}
		}
		//printf("pikseli o wartosci [%d] jest %d\n", z, licznik);	//wyswietlanie czy dziala poprawnie
		tab[z] = licznik;
		licznik = 0;
	}

	//zapis do pliku csv

	FILE* plik;

	z = 0;
	plik = fopen("histogram.csv", "w");

	if (plik == NULL)//czy plik sie otworzyl
	{
		perror("histogram.csv");//komunikat dlaczego blad

	}

	for (z = 0; z < hp1->zakres + 1; z++)
	{
		fprintf(plik, "%d; %d\n", z, tab[z]);

	}

	fclose(plik);

}

int filtr(struct obraz* hp1)
{
	int gauss[3][3] = {
	{1,2,1},
	{2,4,2},
	{1,2,1}
	};	//deklaracja okienka

	int i, j, k, l;
	int okno = 0;
	int suma = 16;
	struct obraz kopia_robocza;
	kopia_robocza = kopia_zapasowa(hp1);

	for (i = 0; i < hp1->wysokosc - 2; i++)
	{
		for (j = 0; j < hp1->szerokosc - 2; j++)
		{
			for (k = 0; k < 3; k++)
			{
				for (l = 0; l < 3; l++)
				{
					okno = okno + kopia_robocza.piksele[i + k][j + l] * gauss[k][l];
				}
			}
			hp1->piksele[i + 1][j + 1] = okno / suma;
			okno = 0;
		}
	}

	for (i = 0; i < kopia_robocza.wysokosc; i++)
	{
		free(kopia_robocza.piksele[i]);
	}
	free(kopia_robocza.piksele);

	return 0;
}

void pieprz_sol(struct obraz* hp1)
{
	int i, j;
	for (i = 0; i < hp1->wysokosc; i++)
	{
		for (j = 0; j < hp1->szerokosc; j++)
		{
			if (rand() % 11 < 1)//prawdopodobienstwo
			{
				if (rand() % 2) hp1->piksele[i][j] = 0;
				else
				{
					hp1->piksele[i][j] = hp1->zakres;
				}
			}

		}
	}
}

void negatyw(struct obraz* hp1)
{
	int i, j;
	for (i = 0; i < hp1->wysokosc; i++)
	{
		for (j = 0; j < hp1->szerokosc; j++)
		{
			hp1->piksele[i][j] = hp1->zakres - hp1->piksele[i][j];//wzor z instrukcji
		}
	}

}

int obrot(struct obraz* hp1)
{
	int i, j;
	struct obraz kopia_robocza;
	kopia_robocza = kopia_zapasowa(hp1);//utworzenie lokalnej kopi
	for (i = 0; i < hp1->wysokosc; i++)//pamiec sie sypala dlatego czyszczenie
	{
		free(hp1->piksele[i]);
	}
	free(hp1->piksele);

	hp1->szerokosc = kopia_robocza.wysokosc;//przepisanie wartosci
	hp1->wysokosc = kopia_robocza.szerokosc;
	hp1->piksele = (int**)malloc(hp1->wysokosc * sizeof(int));//alokacja
	if (hp1->piksele != NULL)
	{
		for (i = 0; i < hp1->wysokosc; i++)
		{
			hp1->piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));
			if (hp1->piksele == NULL)
				return 1;
		}
	}
	for (i = 0; i < hp1->wysokosc; i++)
	{
		for (j = 0; j < hp1->szerokosc; j++)
		{
			hp1->piksele[i][j] = kopia_robocza.piksele[j][kopia_robocza.szerokosc - i - 1];//obrot
		}
	}
	for (i = 0; i < kopia_robocza.wysokosc; i++)
	{
		free(kopia_robocza.piksele[i]);//zwalnianie lokalnej
	}
	free(kopia_robocza.piksele);

	return 0;
}

void zwalnianie_blad(struct obraz* hp1, int ile)
{
	for (int i = 0; i < ile; i++)
	{
		free((hp1->piksele[i]));
	}
	free((hp1->piksele));

}

struct obraz kopia_zapasowa(struct obraz* hp1)//kopia robocza aby mozna ten sam obraz przekształcać
{
	int i, j;
	struct obraz kopia_robocza;
	kopia_robocza.zakres = hp1->zakres;//przepisanie wartosci
	kopia_robocza.szerokosc = hp1->szerokosc;
	kopia_robocza.wysokosc = hp1->wysokosc;
	kopia_robocza.standard = hp1->standard;
	kopia_robocza.nazwa_pliku = hp1->nazwa_pliku;
	kopia_robocza.piksele = (int**)malloc(hp1->wysokosc * sizeof(int));//alokacja pamieci
	if (kopia_robocza.piksele != NULL)
	{
		for (i = 0; i < hp1->wysokosc; i++)
		{
			kopia_robocza.piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));
			if (kopia_robocza.piksele == NULL)
			{
				printf("problem z alokacja pamieci dla tablicy dynamicznej");
				zwalnianie_blad(&kopia_robocza, i);
			}
		}
	}
	else printf("problem z alokacja pamieci dla tablicy dynamicznej");
	for (i = 0; i < hp1->wysokosc; i++)
	{
		for (j = 0; j < hp1->szerokosc; j++)
		{
			kopia_robocza.piksele[i][j] = hp1->piksele[i][j];

		}
	}
	return kopia_robocza;

}

void czyszczenie_pamieci(struct obraz* hp1)
{

	for (int i = 0; i < (hp1->wysokosc); i++)
	{
		free((hp1->piksele[i]));
	}
	free((hp1->piksele));

}

int zapis_pliku(struct obraz hp1)
{
	FILE* plik;
	char x = 0;
	hp1.nazwa_pliku = (char*)malloc(100 * sizeof(char));//alokacja tablicy z nazwa
	puts("Podaj nazwe pliku:");
	scanf("%s", hp1.nazwa_pliku);//wczytanie nazyw obrazu
	plik = fopen(hp1.nazwa_pliku, "w");//otwarcie pliku o podanej nazwie
	if (plik == NULL)//czy plik sie utworzyl
	{
		return 0;
	}

	fprintf(plik, "%s\n", &hp1.standard);
	fprintf(plik, "%d %d\n", hp1.szerokosc, hp1.wysokosc);
	fprintf(plik, "%d\n", hp1.zakres);

	for (int i = 0; i < hp1.wysokosc; i++)//wpisanie wartosci z pliku
	{
		for (int j = 0; j < hp1.szerokosc; j++)
		{

			fprintf(plik, "%d ", hp1.piksele[i][j]);

		}
		fprintf(plik, "\n");
	}
	fclose(plik);
	Sleep(1000);

	return 1;
}


int odczyt_pliku(struct obraz* hp1)
{
	FILE* plik;
	char komentarze;
	hp1->nazwa_pliku = (char*)malloc(100 * sizeof(char));//alokacja tablicy z nazwa
nazwa:
	printf("Podaj nazwe pliku:\n");
	scanf("%s", hp1->nazwa_pliku);//wczytanie nazwy obrazu


	plik = fopen(hp1->nazwa_pliku, "r");//otwarcie pliku o podanej nazwie
	if (plik == NULL)//czy plik sie otworzyl
	{
		puts("Plik nie zostal odnaleziony");//komunikat dlaczego blad
		goto nazwa;
	}
	else
	{
		puts("Znaleziono plik");
		puts("Trwa wczytywanie pliku");
	}

	//czytanie standardu
	//Jezeli napotka # to usuwa wszystko co jest dalej po nim (wrzuca do zmiennej komentarz ktora przyjmuje kolejno wartosci pobrane) az do nowej lini a jezeli nie bedzie to # to sie cofnie o 1 i zapisze to wszystko do standardu

	fscanf(plik, "%c", &komentarze);    //czytanie pojedynczego znaku
	while (komentarze == '#')//szukanie komentarzy
	{
		while (komentarze != '\n')//dopoki nie jest nowa linia (spacja)
		{
			fscanf(plik, "%c", &komentarze);

		}
		fscanf(plik, "%c", &komentarze);//przeskok do nowej lini
	}

	fseek(plik, -1, SEEK_CUR); //przesuniecie znacznika pliku o jeden w tył
	fscanf(plik, "%s\n", &hp1->standard);//musi być na adres :)(hp1->wysokosc) * sizeof&(hp1->piksele) //czytanie do nowej linii

	//czytanie szerokosci
	//taka sama zasada

	fscanf(plik, "%c", &komentarze);
	while (komentarze == '#')
	{
		while (komentarze != '\n')
		{
			fscanf(plik, "%c", &komentarze);

		}
		fscanf(plik, "%c", &komentarze);

	}

	fseek(plik, -1, SEEK_CUR);
	fscanf(plik, "%d", &hp1->szerokosc);

	//czytanie wysokosci

	fscanf(plik, "%c", &komentarze);
	while (komentarze == '#')
	{
		while (komentarze != '\n')
		{
			fscanf(plik, "%c", &komentarze);

		}
		fscanf(plik, "%c", &komentarze);

	}

	fseek(plik, -1, SEEK_CUR);
	fscanf(plik, "%d", &hp1->wysokosc);

	//czytanie maksWartosciSzarosci

	fscanf(plik, "%c", &komentarze);
	while (komentarze == '#')
	{
		while (komentarze != '\n')
		{
			fscanf(plik, "%c", &komentarze);

		}
		fscanf(plik, "%c", &komentarze);

	}
	fseek(plik, -1, SEEK_CUR);
	fscanf(plik, "%d", &hp1->zakres);

	//DEKLARACJA pamieci na tablice 2 wymiary

	hp1->piksele = (int**)malloc(hp1->wysokosc * sizeof(int));      //tworzenie tablicy dynamicznej w pionie
	if (hp1->piksele != NULL)
	{
		for (int i = 0; i < (hp1->wysokosc); i++)
		{

			hp1->piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));       //tworzenie tablic dynamicznych w poziomie - w kazdym elemencie tablicy z pionu powstaje tablica w poziomie tworzac macierz
			if (hp1->piksele[i] == NULL)
			{
				return i;
			}

		}

		//Odczytanie wartosci pikseli z pliku i przepisanie ich do utworzonej tablicy dynamicznej

		for (int i = 0; i < hp1->wysokosc; i++)
		{
			for (int j = 0; j < hp1->szerokosc; j++)
			{
				fscanf(plik, "%c", &komentarze);//czyta znak


				while (komentarze == '#')//jezeli komentarz
				{
					while (komentarze != '\n')//dopóki nie \n
					{
						fscanf(plik, "%c", &komentarze);

					}
					fscanf(plik, "%c", &komentarze);

				}
				fseek(plik, -1, SEEK_CUR);  //jezeli nie komentarz to cofa sie o 1
				fscanf(plik, "%d", &hp1->piksele[i][j]);    //i pobiera go do macierzy
			}

		}
		printf("standard:%s\n", &hp1->standard);
	}
	else
	{
		puts("problem z alokacja tablicy");
		fclose(plik);
		return 0;
	}

	fclose(plik);
	return 1;

}