#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <locale.h>

void ustawKodowaniePolskichZnakow();
int czytajLiczbeCalkowita(const char* komunikat);
double czytajLiczbeRzeczywista(const char* komunikat);
const char* czytajTekst(const char* komunikat);
void czytaj(const char* komunikat, const char* format, const char* blad, void* rezultat);
void generator(double wspolczynniki[], double dMin, double dMax, double wyniki[], int rozmiartablicy);
void czytajWspolczynniki(double wspolczynniki[]);
void czytajDziedzine(double* dMin, double* dMax);
int czytajRozmiarTablicyWynikowej();
double losowanieSzumu();
void szum(double sygnalWejsciowy[], double sygnalZaszumiony[], int rozmiar);
void zapiszFunkcje(double funkcja[], int rozmiar, double dMin, double dMax, const char* sciezka);
int odczytajDlugoscFunkcji(const char* sciezka);
double* odczytajFunkcje(const char* sciezka, double* dMin, double* dMax);
double srednia(double a, double b, double c, double d, double e);
void filtrSredniej(double* funkcja, int rozmiar);
int porownaj(const void* x, const void* y);
double mediana(double a, double b, double c, double d, double e);
void filtrMedianowy(double* funkcja, int rozmiar);

int main()
{
	double wspolczynniki[4];
	double* funkcja;
	double dMin, dMax;
	int rozmiar, wybor, koniec;
	char* sciezka;
	ustawKodowaniePolskichZnakow();
	srand(time(NULL));

	dMin = 0;				//domyślne wartości
	dMax = 10;
	rozmiar = 100;
	wspolczynniki[0] = 1;	//a*sin(bx + c) + d (domyślnie po prostu sin x)
	wspolczynniki[1] = 1;
	wspolczynniki[2] = 0;
	wspolczynniki[3] = 0;
	funkcja = malloc(rozmiar * sizeof(double));
	generator(wspolczynniki, dMin, dMax, funkcja, rozmiar);
	koniec = 0;

	while (!koniec)
	{
		printf("Legenda:\n");
		printf(" 1 <- Podanie współczynników do funkcji a*sin(bx + c) + d (domyślnie sin x)\n");
		printf(" 2 <- Podanie zakresu dziedziny (domyślnie zakres [0;10])\n");
		printf(" 3 <- Podanie długości tablicy (domyślnie 100)\n");
		printf(" 4 <- Generuj funkcję\n");
		printf(" 5 <- Zaszum funkcję\n");
		printf(" 6 <- Filtr medianowy\n");
		printf(" 7 <- Filtr średniej ruchomej\n");
		printf(" 8 <- Zapisanie do pliku wyników\n");
		printf(" 9 <- Odczytanie danych z pliku\n");
		printf(" 10 <- Koniec działania programu\n");
		wybor = czytajLiczbeCalkowita("");
		switch (wybor)
		{
		case 1:
			czytajWspolczynniki(wspolczynniki);
			break;
		case 2:
			czytajDziedzine(&dMin, &dMax);
			break;
		case 3:
			rozmiar = czytajRozmiarTablicyWynikowej();
			free(funkcja);
			funkcja = malloc(rozmiar * sizeof(double));
			generator(wspolczynniki, dMin, dMax, funkcja, rozmiar); // generujemy nową funkcję podczas zmiany rozmiaru
			break;
		case 4:
			generator(wspolczynniki, dMin, dMax, funkcja, rozmiar);
			break;
		case 5:
			szum(funkcja, funkcja, rozmiar);
			break;
		case 6:
			filtrMedianowy(funkcja, rozmiar);
			break;
		case 7:
			filtrSredniej(funkcja, rozmiar);
			break;
		case 8:
			sciezka = czytajTekst("Podaj ścieżkę do pliku: ");
			zapiszFunkcje(funkcja, rozmiar, dMin, dMax, sciezka);
			break;
		case 9:
			sciezka = czytajTekst("Podaj ścieżkę do pliku: ");
			funkcja = odczytajFunkcje(sciezka, &dMin, &dMax);
			break;
		case 10:
			koniec = 1;
			break;
		default:
			printf("Wybrano nieprawidłową opcję\n");
		}
	}
	free(funkcja);
	return 0;
}

void ustawKodowaniePolskichZnakow()
{
	system("chcp 1250 > nul");
}

int czytajLiczbeCalkowita(const char* komunikat)
{
	int liczba;
	czytaj(komunikat, "%d", "Podana wartość nie jest liczbą całkowitą", &liczba);
	return liczba;
}

double czytajLiczbeRzeczywista(const char* komunikat)
{
	double liczba;
	czytaj(komunikat, "%lf", "Podana wartość nie jest liczbą rzeczywistą", &liczba);
	return liczba;
}

const char* czytajTekst(const char* komunikat)
{
	static char tekst[1024];
	czytaj(komunikat, "%s", "Podana wartość nie jest tekstem", tekst);
	return tekst;
}

void czytaj(const char* komunikat, const char* format, const char* blad, void* rezultat)
{
	while (1)
	{
		printf(komunikat);
		if (scanf(format, rezultat) == 1)
		{
			break;
		}
		printf("%s\n", blad);
		fseek(stdin, 0, SEEK_END);
	}
}

void generator(double wspolczynniki[], double dMin, double dMax, double wyniki[], int rozmiartablicy)
{
	double krok;
	int i;
	krok = (dMax - dMin) / rozmiartablicy;
	i = 0;
	for (double x = dMin; x <= dMax; x += krok)
	{
		if (i == rozmiartablicy)
		{
			break;
		}
		//a*sin(bx + c) + d
		wyniki[i++] = wspolczynniki[0] * sin(wspolczynniki[1] * x + wspolczynniki[2]) + wspolczynniki[3];
	}
}

void czytajWspolczynniki(double wspolczynniki[])
{
	wspolczynniki[0] = czytajLiczbeRzeczywista("Podaj współczynnik a: ");
	wspolczynniki[1] = czytajLiczbeRzeczywista("Podaj współczynnik b: ");
	wspolczynniki[2] = czytajLiczbeRzeczywista("Podaj współczynnik c: ");
	wspolczynniki[3] = czytajLiczbeRzeczywista("Podaj współczynnik d: ");
}

void czytajDziedzine(double* dMin, double* dMax)
{
	while (1)
	{
		*dMin = czytajLiczbeRzeczywista("Podaj początek dziedziny: ");	//zamienić dMin na zakres[0] a dMax na zakres[1]
		*dMax = czytajLiczbeRzeczywista("Podaj koniec dziedziny: ");
		if (*dMin < *dMax)
		{
			break;
		}
		printf("Początek dziedziny powinien być mniejszy od końca dziedziny\n");
	}
}

int czytajRozmiarTablicyWynikowej()
{
	int rozmiar;
	while (1)
	{
		rozmiar = czytajLiczbeCalkowita("Podaj rozmiar tablicy wynikowej: ");
		if (rozmiar > 0)
		{
			break;
		}
		printf("Rozmiar powinien być wiekszy od zera\n");
	}
	return rozmiar;
}

double losowanieSzumu()
{
	double n;
	n = (double)rand() / (double)RAND_MAX;	//losownie liczby [0,1]
	return n * 2.0 - 1.0;					//zamiana przedziału na [-1,1]
}

void szum(double sygnalWejsciowy[], double sygnalZaszumiony[], int rozmiar)
{
	int i;
	double n;
	n = 0.0;
	for (i = 0; i < rozmiar; i++)
	{
		if (rand() % 2 == 0)
		{
			n = losowanieSzumu();
		}
		sygnalZaszumiony[i] = sygnalWejsciowy[i] + n;
	}
}

void zapiszFunkcje(double funkcja[], int rozmiar, double dMin, double dMax, const char* sciezka)
{
	FILE* plik;
	int i;
	double krok;
	plik = fopen(sciezka, "wb");
	//setlocale(LC_ALL, "polish_poland");			//robi przecinki zamiast kropek w pliku
	if (plik == NULL)
	{
		return;
	}
	krok = (dMax - dMin) / rozmiar;
	i = 0;
	for (double x = dMin; x <= dMax; x += krok)
	{
		if (i == rozmiar)
		{
			break;
		}
		fprintf(plik, "%lf;%lf\n", x, funkcja[i++]);
	}
	fclose(plik);
}

int odczytajDlugoscFunkcji(const char* sciezka)
{
	FILE* plik;
	int dlugosc;
	double x, y;
	plik = fopen(sciezka, "rb");
	if (plik == NULL)
	{
		return -1;		// też może być return 0;
	}
	dlugosc = 0;
	while (1)
	{
		if (fscanf(plik, "%lf;%lf", &x, &y) != 2)		// bo jeden lf to 1, więc gdy jakiś nie spełniony (różne od 2) to break
		{
			break;
		}
		dlugosc++;
	}
	fclose(plik);
	return dlugosc;
}

double* odczytajFunkcje(const char* sciezka, double* dMin, double* dMax)
{
	FILE* plik;
	int dlugosc, i;
	double x, y;
	double* funkcja;
	plik = fopen(sciezka, "rb");
	if (plik == NULL)
	{
		return NULL;
	}
	dlugosc = odczytajDlugoscFunkcji(sciezka);
	funkcja = (double*)malloc(dlugosc * sizeof(double));
	i = 0;
	while (1)
	{
		if (fscanf(plik, "%lf;%lf", &x, &y) != 2)
		{
			break;
		}
		funkcja[i] = y;
		*dMax = x;
		if (i == 0)
		{
			*dMin = x;
		}
		i++;
	}
	fclose(plik);
	return funkcja;
}

/*double medianaPieciuElementow(double a, double b, double c, double d, double e)
{
	double x[5];
	x[0] = a;
	x[1] = b;
	x[2] = c;
	x[3] = d;
	x[4] = e;
	double temp;
	int i, j;
	for (i = 0; i < 4; i++) {
		for (j = i + 1; j < 5; j++) {
			if (x[j] < x[i]) {
				temp = x[i];
				x[i] = x[j];
				x[j] = temp;
			}
		}
	}
	return x[2];
}*/

double srednia(double a, double b, double c, double d, double e)
{
	return (a + b + c + d + e) / 5.0;
}
// funkcja Mean zwraca średnią arytmetyczną z pięciu wartości

void filtrSredniej(double* funkcja, int rozmiar)
{
	double a, b, c, d, e;
	int i;
	for (i = 0; i < (rozmiar - 5); i++)
	{
		a = funkcja[i];
		b = funkcja[i + 1];
		c = funkcja[i + 2];
		d = funkcja[i + 3];
		e = funkcja[i + 4];

		funkcja[i + 2] = srednia(a, b, c, d, e);
	}
}
// funkcja filtrSredniej środkowemu elementowi tablicy przypisuje średnią wartości a,b,c,d,e

int porownaj(const void* x, const void* y)
{
	double i, j, k;

	i = *(double*)x; // pierwsza gwiazdka - dereferencja, czyli pobranie wartości spod danego adresu
	// druga gwiazdka - rzutowanie wskaźnika void na wskaźnik double
	j = *(double*)y; // analogicznie
	k = i - j;
	if (k == 0)
	{
		return 0;
	}
	if (k < 0)
	{
		return -1;
	}
	return 1; // jeżeli zwrócona wartość z Compare jest dodatnia to qsort przestawia elementy tablicy
	// w przeciwnym wypadku zostawia je tak jak było (czy mamy zero, czy wartość ujemną)
}

double mediana(double a, double b, double c, double d, double e)
{
	double t[] = { a, b, c, d, e };

	qsort(t, 5, sizeof(double), porownaj);

	return t[2];
}
// funkcja mediana zwraca medianę
// qsort na podstawie porównania (Compare) sortuje każde kolejne pięć elementów tablicy
// i wyłania medianę

void filtrMedianowy(double* funkcja, int rozmiar)
{
	double a, b, c, d, e;
	int i;
	for (i = 0; i < rozmiar - 5; i++)
	{
		a = funkcja[i];
		b = funkcja[i + 1];
		c = funkcja[i + 2];
		d = funkcja[i + 3];
		e = funkcja[i + 4];

		funkcja[i + 2] = mediana(a, b, c, d, e);
	}
}