#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <malloc.h>


void generator_przebiegu_funkcji(int wsp[], int dziedzina[], double tablica_wyn[], int wielkosc_tab_wyn);
void generator_szumu(double tablica[], double tablica_zaszumiona[], int rozmiar);
void drukuj_tablice(double tablica[], int rozmiar);
double mediana(double t[], int n);
void filtr_medianowy(double wej[], int rozmiar);
double srednia(double t[], int rozm);
void filtr_srednia(double wej[], int rozm);
void parametry(int wsp[]);
void dziedzina(double dziedz[]);
int pobierz_ilosc_probek();
void zapisz_sygnal(double tab[], int rozm);
int wczytaj_sygnal(double **tabsygnalu);
int menu();
double pobierz_double();
float pobierz_int();
void pobierzDaneIGenerujFunkcje(int wielkosc_tab_wyn, double **tablica_wyn[], int **dziedz[], int **param[]);




double pobierz_double()
{
    double tmp;
    while (1)
    {
        while ('\n' != getchar());                              /* zwolnienie buforu (na poczatku funkcji bo zostawal newline po wprwadzeniu danych w buforze */
        if (scanf("%lf", &tmp))                                 /* jesli scanf poprawnie pobral dane zwaraca "1", jesli nie "0" */
        {

            return tmp;
        }
        else
        {
            printf("Bledny format danych, wprowadz ponownie \n");
        }
    }

}

float pobierz_int()
{
    float tmp;
    int rzutowanie;
    while (1)
    {
        while (getchar() != '\n');                              /* zwolnienie buforu */
        if (scanf("%f", &tmp))                                  /* jesli scanf poprawnie pobral dane zwaraca "1", jesli nie "0" */
        {

            rzutowanie = (int)tmp;                              /* W przypadku wprowadzenia liczby zmiennoprzecinkowej */

            printf("Zrzutowano do: %d\n", rzutowanie);
            return rzutowanie;
        }
        else
        {

            printf("Bledny format danych, wprowadz ponownie:  \n");
        }
    }

}


void generator_przebiegu_funkcji(int wsp[], double dziedzina[], double tablica_wyn[], int wielkosc_tab_wyn)
{
    int roznica = dziedzina[1] - dziedzina[0];
    double skok = ((double)roznica) / wielkosc_tab_wyn;         /* skok - podzielenie dziedziny wedlug zadanej ilosci probek */
    printf("Probkowanie: %f\n", skok);

    double x = (double)dziedzina[0];

    printf("Generowana funkcja: f(x) = A * sqrt((cos(x))^A + B)\n\n");

    if ((pow(cos(x), wsp[0]) + wsp[1]) < 0)                     /* Sprawdzenie wartosci dodatniej pod pierwiastkiem */
    {
        printf("Dla podanych parametrów funkcja generuje wyniki poza dziedzina funkcji. Sprobuj ponownie.");
        pobierzDaneIGenerujFunkcje(wielkosc_tab_wyn, tablica_wyn, dziedzina, wsp);
    }
    else                                                    /* W przypadku gdy parametr B jest ok */
    {
        //printf("%d \n", wielkosc_tab_wyn);
        for (int i = 0; i <= wielkosc_tab_wyn - 1; i++)
        {
            //printf("%d", x);
            if (x > dziedzina[1]) break;
            double wyn = wsp[0] * sqrt(pow(cos(x), wsp[0]) + wsp[1]);
            tablica_wyn[i] = wyn;
            //printf("%d", x);
            x += skok;
        }
    }
}

void generator_szumu(double tablica[], double tablica_zaszumiona[], int rozmiar)
{
    for (int i = 0; i < rozmiar; i++)
    {
        tablica_zaszumiona[i] = tablica[i] + (rand() % 100)*1.0 / 1000;
    }
}

void drukuj_tablice(double tablica[], int rozmiar)
{
    printf("DRUKUJE TABLICE \n==========\n");
    for (int i = 0; i < rozmiar; i++)
    {
        printf("[%d] %f \n", i, tablica[i]);
    }
}

double mediana(double t[], int n)
{
    double tmp;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - 1; j++)
        {
            if (t[j] > t[j + 1])
            {
                tmp = t[j];
                t[j] = t[j + 1];
                t[j + 1] = tmp;
            }
        }
    }

    return t[2];
}

void filtr_medianowy(double wej[], int rozmiar)
{

    for (int i = 2; i < rozmiar - 2; i++)
    {
        double tab_med[5];
        tab_med[0] = wej[i - 2];
        tab_med[1] = wej[i - 1];
        tab_med[2] = wej[i];
        tab_med[3] = wej[i + 1];
        tab_med[4] = wej[i + 2];
        wej[i] = mediana(tab_med, 5);
    }
}


double srednia(double t[], int rozm)
{
    double suma = 0;
    for (int i = 0; i < rozm; i++)
    {
        suma += t[i];
    }

    double reszta = suma / rozm;
    return reszta;
}

void filtr_srednia(double wej[], int rozm)
{

    for (int i = 2; i < rozm - 2; i++)
    {
        double tab_sr[5];
        tab_sr[0] = wej[i - 2];
        tab_sr[1] = wej[i - 1];
        tab_sr[2] = wej[i];
        tab_sr[3] = wej[i + 1];
        tab_sr[4] = wej[i + 2];
        wej[i] = srednia(tab_sr, 5);
    }
}

void parametry(int wsp[])
{
    printf("Podaj wartosc parametru A:\n");
    wsp[0] = pobierz_double();
    printf("Podaj wartosc parametru B:\n");
    wsp[1] = pobierz_double();
}

void dziedzina(double dziedz[])
{
    printf("Podaj dolna granice dziedziny (x>):\n");
    dziedz[0] = pobierz_double();
    printf("Podaj gorna granice dziedziny (x<):\n");
    dziedz[1] = pobierz_double();
    if (dziedz[1] < dziedz[0])
    {
        printf("\nZle podana dziedzina.\n");
        dziedzina(dziedz);
    }
}

int pobierz_ilosc_probek()
{
    printf("Podaj ilosc probek:\n");
    int ilosc_probek = pobierz_int();
    return ilosc_probek;
}

void zapisz_sygnal(double tab[], int rozm)
{
    FILE *plik;
    int i;
    plik = fopen("dane.csv", "w");

    if (plik == NULL)
    {
        printf("Brak takiego Pliku!");
    }
    else
    {
        for (i = 0; i < rozm; i++)
        {
            fprintf(plik, "%f;\n", tab[i]);
        }
        fclose(plik);
    }
}

int wczytaj_sygnal(double **tabsygnalu)
{
    double *temp = NULL;
    int rozmiartab = 0;
    double tmp = 0;
    FILE *file;
    file = fopen("dane.csv", "r");
    if (file != NULL)
    {
        while (fscanf(file, "%lf;\n", &tmp) == 1)
        {
            temp = (double*)realloc(*tabsygnalu, (rozmiartab + 1) * sizeof(double));

            if (temp != NULL)
            {
                *tabsygnalu = temp;
                (*tabsygnalu)[rozmiartab] = tmp;
                rozmiartab++;
            }
            else
            {
                printf("Błąd");
                free(*tabsygnalu);
                *tabsygnalu = NULL;
                return 0;
            }
        }
    }
    return rozmiartab;
}

int menu()
{
    int wartosc;
    printf("\tMENU\n");
    printf("Jeśli chcesz stworzyc sygnal: 1\n");
    printf("Jeśli chcesz wczytac sygnal wybierz: 2\n");
    printf("Jeśli chcesz zaszumic sygnal wybierz: 3\n");
    printf("Jeśli chcesz filtrowac mediana sygnal wybierz: 4\n");
    printf("Jeśli chcesz filtrowac srednia wybierz: 5\n");
    printf("Jesli chcesz zapisac sygnal wybierz: 6 \n");
    printf("Jesli chcesz wyswietlic sygnal wybierz: 7 \n\n");
    scanf("%d", &wartosc);
    return wartosc;
}

void pobierzDaneIGenerujFunkcje(int wielkosc_tab_wyn, double **tablica_wyn[], int **dziedz[], int **param[])
{
    wielkosc_tab_wyn = pobierz_ilosc_probek();
    tablica_wyn= (double*)malloc(wielkosc_tab_wyn * sizeof(double));
    parametry(param);
    dziedzina(dziedz);
    printf("%d", dziedz[1]);
    generator_przebiegu_funkcji(param, dziedz, tablica_wyn, wielkosc_tab_wyn);
    drukuj_tablice(tablica_wyn, wielkosc_tab_wyn);
}


int main()
{

    int wielkosc_tab_wyn = 0;
    double* tablica_wyn = (double*)malloc(wielkosc_tab_wyn * sizeof(double));
    double* tablica_zaszumiona = (double*)malloc(wielkosc_tab_wyn * sizeof(double));
    double dziedz[2];
    int param[2];
    srand(time(NULL));

    bool CzyTablicaWynStworzona = false;
    bool CzyTablicaZaszumionaStworzona = false;

    do
    {
        int odp = menu();

        switch (odp)
        {
        case 1:
            pobierzDaneIGenerujFunkcje(wielkosc_tab_wyn, tablica_wyn, dziedz, param);
            CzyTablicaWynStworzona = true;
            break;
        case 2:
            wielkosc_tab_wyn = wczytaj_sygnal(&tablica_wyn);
            CzyTablicaWynStworzona = true;
            break;
        case 3:
            if (!CzyTablicaWynStworzona)
                printf("Tablica jest pusta.");
            else
            {
                tablica_zaszumiona = (double*)malloc(wielkosc_tab_wyn * sizeof(double));
                generator_szumu(tablica_wyn, tablica_zaszumiona, wielkosc_tab_wyn);
                drukuj_tablice(tablica_zaszumiona, wielkosc_tab_wyn);
                CzyTablicaZaszumionaStworzona = true;
            }
            break;
        case 4:
            if (!CzyTablicaZaszumionaStworzona)
                printf("Tablica jest pusta.");
            else
            {
                filtr_medianowy(tablica_zaszumiona, wielkosc_tab_wyn);
                drukuj_tablice(tablica_zaszumiona, wielkosc_tab_wyn);
            }
            break;
        case 5:
            if (!CzyTablicaZaszumionaStworzona)
                printf("Tablica jest pusta.");
            else
            {
                filtr_srednia(tablica_zaszumiona, wielkosc_tab_wyn);
                drukuj_tablice(tablica_zaszumiona, wielkosc_tab_wyn);
            }
            break;
        case 6:
            printf("Sygnal oryginalny: 1 \n");
            printf("Sygnal zaszumiony: 2 \n");
            int ans = 0;
            scanf("%d", &ans);
            if (ans == 1)
            {
                zapisz_sygnal(tablica_wyn, wielkosc_tab_wyn);
            }
            else {
                zapisz_sygnal(tablica_zaszumiona, wielkosc_tab_wyn);
            }
            break;
        case 7:
            printf("Sygnal oryginalny: 1 \n");
            printf("Sygnal zaszumiony: 2 \n");
            int ans2 = 0;
            scanf("%d", &ans);
            if (ans2 == 1)
            {
                drukuj_tablice(tablica_wyn, wielkosc_tab_wyn);
            }
            else {
                drukuj_tablice(tablica_zaszumiona, wielkosc_tab_wyn);
            }
            break;
        default:
            printf("Zla opcja.\n");
            break;
        }
    } while (1 < 3);

    system("pause");
}