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


double funkcja (double *wspolczynnik, double x)
{
    return (wspolczynnik[0] / wspolczynnik[1]) * sin(wspolczynnik[2] * (x - wspolczynnik[3]));
}

void dziedzina(double *xmin, double  *xmax)
{
    int wybor=0;
    double* pom;
    printf("Podaj poczatek twojej dziedziny: ");
    scanf_s("%lf", xmin);
    printf("Podaj koniec twojej dziedziny: ");
    scanf_s("%lf", xmax);

    if (*xmin > *xmax)

    {
        printf("podales zle dziedzine poczatek przedzialu nie moze byc wiekszy niz koniec!\n");
        printf("masz dwie mozliwosci do wyboru\n");
        printf("1. Zamien wartosc minimum i maksimum\n");
        printf("2. Podaj dziedzine jeszcze raz\n ");
        scanf_s("%d", &wybor);
        switch (wybor)
        {
            case 1:
                pom = xmin;
                xmin = xmax;
                xmax = pom;
                printf("twoja dziedzina teraz jest od  %lf do %lf\n", *xmin, *xmax);

                break;
            case 2:
                printf("Podaj poczatek twojej dziedziny: ");
                scanf_s("%lf", xmin);
                printf("Podaj koniec twojej dziedziny: ");
                scanf_s("%lf", xmax);
                break;

            default:
                if (wybor != 1 && wybor != 2)
                {
                    printf("wybrales opcje ktora nie istnieje w menu\n");
                    printf("sproboj jeszcze raz\n");
                    scanf_s("%d", &wybor);
                }
                break;
        }

    }


}

void wspolczynniki(double *tab)
{
    printf("podaj wspolczynnik A:\n");
    scanf_s("%lf", &tab[0]);
    printf("podaj wspolczynnik B:\n");
    scanf_s("%lf", &tab[1]);
    if(tab[1]==0)
    {
        printf("nie mozna dzielic przez 0, popraw!\n");
        printf("podaj wspolczynnik B jeszcze raz:\n");
        scanf_s("%lf", &tab[1]);

    }
    printf("podaj wspolczynnik C:\n");
    scanf_s("%lf", &tab[2]);
    printf("podaj wspolczynnik D:\n");
    scanf_s("%lf", &tab[3]);

}

void generuj(double  *wspolczynnik, double max, double  min, double *tab_wynik, int wielkosc)
{
    double skalowanie = (max - min + 1) / (double)wielkosc;

    for (int i = 0; i < wielkosc; i++)
    {
        double x = min + skalowanie * (double)i;
        double y = funkcja(wspolczynnik, x);
        tab_wynik[i] = y;
        printf("%lf\n", tab_wynik[i]);


    }
}

void zaszum(double* tab_zaszum, double* tab_sygnal, int rozmiar)
{

    for (int i = 0; i < rozmiar; i++)
    {
        int x = rand() % (100 +1);
        if (x <= 27)
        {

            double k = (rand() % 100) - 50;

            double szu = k * 1.0 / 1000.0;
            tab_zaszum[i] = tab_sygnal[i] + szu;

        }
        else
            tab_zaszum[i] = tab_sygnal[i];

    }
}

void zapisz_do_pliku(double* tab_sygnal, int rozmiar)
{
    FILE* plik;
    plik = fopen("sygnal.CSV", "w");
    if (plik == NULL)
    {
        printf("nie udalo sie");
        return;
    }
    for (int i = 0; i < rozmiar; i++)
    {
        fprintf(plik, "%lf\n", tab_sygnal[i]);
    }
    fclose(plik);
}

double* odczyt_z_pliku(char* nazwa_pliku, int* rozmiar_tabicy)
{
    FILE* plik;
    plik = fopen(nazwa_pliku, "r");
    if (plik == NULL)
    {
        printf("nie udalo sie");
        return;
    }
    int c;
    int licznik=0;
    while ((c=fgetc(plik)) != EOF)
    {
        if (c == '\n')
            licznik++;

    }
    double* tab = (double*)malloc(licznik * sizeof(double));
    fseek(plik, 0, SEEK_SET);
    for (int i = 0; i < licznik; i++)
    {
        fscanf(plik, "%lf\n", &tab[i]);
    }

    for (int i = 0; i < licznik; i++)
    {
        printf("%lf\n", tab[i]);
    }

    *rozmiar_tabicy = licznik;
    return tab;
}

void mediana(double* tab_zaszum, double* tab_odszum, int wielkosc_tablicy)
{
    for (int i = 0; i < wielkosc_tablicy; i++)
    {
        if (i >= 2 && i < wielkosc_tablicy - 2)
        {
            //1. przekopiuj 5 ele do okna
            //2. B¹belik !
            //3. zapisz mediane

            double okno[5];
            int poczind=i-2;
            for (int j = 0; j < 5; j++)
            {
                okno[j] = tab_zaszum[poczind];
                poczind++;
            }

            //2.bubble sort
            for (int z = 0; z < 5; z++)
            {
                for (int l = 0; l < 4; l++)
                {
                    if (okno[l] > okno[l + 1])
                    {
                        double temp;
                        temp = okno[l];
                        okno[l] = okno[l + 1];
                        okno[l + 1] = temp;


                    }
                }
            }

            tab_odszum[i] = okno[2];





        }
        tab_odszum[i] = tab_zaszum[i];
    }
}

void srednia(double* tab_zaszum, double* tab_odszum, int wielkosc_tablicy)
{
    for (int i = 0; i < wielkosc_tablicy; i++)
    {
        if (i >= 2 && i < wielkosc_tablicy - 2)
        {
            double suma = 0;
            for (int k = -2; k < 3; k++)
            {
                suma += tab_zaszum[i + k];
            }


            tab_odszum[i] = suma / 5.0;
        }
        tab_odszum[i] = tab_zaszum[i];
    }

}

int main()
{
    double xmax, xmin;
    double wspolczynnik[4];
    int wielkosc_tablicy=0;
    int liczba=0;
    srand(time(NULL)); //inicjalizacja losowych liczb

    double* tab_sygnal = NULL;


    double* tab_wynik = (double*)malloc(wielkosc_tablicy * sizeof(double));
    double* tab_zaszum_wyniki = (double*)malloc(wielkosc_tablicy * sizeof(double));
    double* odczytana_tab = NULL;
    double* odszumiona = malloc(wielkosc_tablicy * sizeof(double));
    while(1)
    {
        printf("menu:\n");
        printf("1. genreuj funkcje.\n");
        printf("2. zaszum funkcje.\n");
        printf("3. zapisz funkcje do pliku.\n");
        printf("4. odczytaj fukncje z istniejacego juz pliku.\n");
        printf("5. odfiltruj funkcje filtrem medianowym.\n");
        printf("6. odfiltruj funkcje filtrem srednia.\n");
        printf("7. zakoncz.\n");

        scanf_s("%d", &liczba);
        switch (liczba)
        {
            case 1:

                if (tab_sygnal != NULL)
                    free(tab_sygnal);
                tab_sygnal = malloc(wielkosc_tablicy * sizeof(double));

                printf("funkcja: y(x)= a/b*sin(c*(x-d))\n");
                wspolczynniki(wspolczynnik);
                printf("%lf %lf %lf %lf\n", wspolczynnik[0], wspolczynnik[1], wspolczynnik[2], wspolczynnik[3]);

                dziedzina(&xmin, &xmax);


                printf("podaj wielkosc twojej funkcji: ");
                scanf_s("%d", &wielkosc_tablicy);
                if (wielkosc_tablicy < 0)
                {
                    printf("wielkosc tablicy nie moze byc liczba ujemna, sprobuj podac jeszcze raz:\n");
                    scanf_s("%d", &wielkosc_tablicy);
                    printf("aktualna wielkosc twojej funkcji wynosi: %d ", wielkosc_tablicy);
                }
                generuj(wspolczynnik, xmax, xmin, tab_wynik, wielkosc_tablicy);


                break;

            case 2:

                if (tab_sygnal != NULL)

                {
                    zaszum(tab_zaszum_wyniki, tab_wynik, wielkosc_tablicy);
                    for (int i = 0; i < wielkosc_tablicy; i++)
                    {
                        printf("%lf\n", tab_zaszum_wyniki[i]);
                    }
                }
                else
                {
                    printf("musisz najpierw wygenerowac funkcje!!\n");
                    break;
                }



            case 3 :

                if (tab_sygnal != NULL)

                {
                    zapisz_do_pliku(tab_zaszum_wyniki, wielkosc_tablicy);
                }
                else
                {
                    printf("musisz najpierw wygenerowac funkcje!!\n");
                    break;}



            case 4 :


                if (tab_sygnal == NULL)

                {
                    double* odczyt_tablica = odczyt_z_pliku("sygnal.CSV", &wielkosc_tablicy);
                }
                else
                {
                    printf("wygeneruj sobie nowa funkcje!\n");
                    break;

                }



            case 5:
                if (tab_sygnal != NULL)

                {
                    mediana(tab_zaszum_wyniki, odszumiona, wielkosc_tablicy);

                    printf("Odszumiona\n");
                    for (int i = 0; i < wielkosc_tablicy; i++)
                    {
                        printf("%lf\n", odszumiona[i]);
                    }

                }
                else
                {
                    printf("musisz najpierw wygenerowac funkcje!!\n");
                    break;
                }


            case 6:
                if (tab_sygnal != NULL)

                {
                    srednia(tab_zaszum_wyniki, odszumiona, wielkosc_tablicy);

                    printf("Odszumiona\n");
                    for (int i = 0; i < wielkosc_tablicy; i++)
                    {
                        printf("%lf\n", odszumiona[i]);
                    }

                }
                else
                {
                    printf("musisz najpierw wygenerowac funkcje!!\n");
                    break;
                }




            default:
                if (liczba != 1 && liczba != 2 && liczba != 3 && liczba != 4 && liczba != 5 && liczba != 6 && liczba != 7)
                {
                    printf("wybrales opcje ktora nie istnieje w menu\n");
                    printf("sproboj jeszcze raz\n");
                    scanf_s("%d", &liczba);
                    break;
                }



        }
    }

    free(tab_wynik);
    free(tab_zaszum_wyniki);
    free(odczytana_tab);
    free(odszumiona);

    return 0;

}