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


void instrukcja()
{
    printf("Żartowałem, nie mam siły opisywać wszystkiego krok po kroku :D \n");
    printf("Spróbuj czegoś innego");
    printf("\n");

}

void wstepniak()
{
    printf("Program służy do pracy z funkcją postaci f(x)=sin(x-a) * cos(x-b) + c,\n");
    printf("Dostępne opcje:\n");
    printf("1. Określenie przedziału (zbioru argumentów) naszej funkcji.\n");
    printf("2. Deklaracja parametrów - a,b,c dla naszej funkcji.\n");
    printf("3. Generowanie naszej funkcji (musi być zdefiniowany przedział i parametry.\n");
    printf("4. Dodanie szumu o wskazanej przez użytkownika amplitudzie.\n");
    printf("5. Usrednienie (odszumienia) funkcji wskazanym promieniem. \n");
    printf("6. Zapis naszej funkcji do pliku nazwa.csv. \n");
    printf("7. Wczytanie funkcji z pliku nazwa.csv. \n");
    printf("0. Instrukcja działania programu i poszczegolnych funkcji. \n");
    printf("\n");
}

void wstepniak_mini()
{
    printf("1.Dziedzina. \n");
    printf("2.Parametry. \n");
    printf("3.Generowanie. \n");
    printf("4.Szum. \n");
    printf("5.Odszumienie. \n");
    printf("6.Zapis do pliku. \n");
    printf("7.Wczytanie z pliku. \n");
    printf("0.Instrukcja. \n");
    printf("\n");
}

float wczytajf()    //zabezpieczenie poprawnosci wprowadzania wlasciwego formatu zmiennych
{
    float ret;
    char buf[100];      //tworzy bufor znaków

    for(;;)
    {
        scanf("%100s",buf);
        if(sscanf(buf,"%f",&ret)==1) return ret;        //warunek sprawdzenia tego czy ten znak jest liczbą
        printf("Błędny format. Wprowadź jeszcze raz! \n");
        printf("\n");
    }
}

int wczytaj_menu()
{
    int ret;
    char buf[100];

    for(;;)
    {
        scanf("%100s",buf);
        if((sscanf(buf,"%d",&ret)==1)&&(ret>=0)&&(ret<=7)) return ret;      //warunek sprawdzenia tego czy ten znak jest liczbą całk z zakr 0-7
        printf("Wprowadź liczby z zakresu 0-7, nie kombinuj! Obserwuję Cię! \n");
        printf("\n");
    }
}

int wczytaj_promien()
{
    int ret;
    char buf[100];

    for(;;)
    {
        scanf("%100s",buf);
        if((sscanf(buf,"%d",&ret)==1)&&(ret>=1)) return ret;        //warunek sprawdzenia tego czy ten znak jest liczbą całk, dodatnią
        printf("Promień musi być liczbą dodatnią, całkowitą, nie kombinuj!\n Obserwuję Cię! \n");
        printf("\n");
    }
}

void dziedzina (float *pdmin, float *pdmax)         //wskaźniki są argumentami funkcji, więc w tej funkcji możemy i będziemy je zmieniać 'globalnie'
{
    for(printf("Podaj zakres dziedziny dla naszej funkcji. \n");;)
    {
        printf("Zakres minimum - X1: \n");
        *pdmin = wczytajf();                        //odwołujemy się do wskaźnika i zapisujemy do niego wartość
        printf("Zakres maksimum - X2: \n");
        *pdmax = wczytajf();                        //oczywiście jednocześnie sprawdzamy, czy nie siedzi przed komputerem małpa
        if( *pdmin< *pdmax) break;                  //muszą być *(operator wyłuskiwania), ponieważ chcemy się dobrać do wartości wskazywanej przez wskaźniki
        printf("UWAGA! X1 musi byc mniejszy od X2! Spróbuj ponownie! \n");

    }

}

void wczytaj_parametry(float *param)
{
    printf("Funkcja dla przypomnienia jest postaci sin(x-a)*cos(x-b) + c,\n podaj parametry: a,b,c \n");

    printf("Parametr a:\n");
        *param=wczytajf();          //wskaznik param traktujemy jako zmienna tablicowa (adres) i odwolujemy sie do kolejnych adresow ponizej
    printf("Parametr b:\n");
        *(param+1)=wczytajf();      //oczywiście sprawdzając czy małpa dalej siedzi przed komputerem
    printf("Parametr c:\n");
        *(param+2)=wczytajf();
}

void generuj(float *param, float dmin, float dmax, float *wyniki, int wielkosc)
{
    int i;
    float delta;
    float x;

    delta=(dmax-dmin)/(wielkosc - 1);                                           //delta to 'wielkość' naszego skoku, co ile będziemy badać wartość funkcji

    printf("Generowanie wartości funkcji dla podanej dziedziny, tj <%.3f, %.3f>\n i parametrow a=%.3f, b=%.3f, c=%.3f: \n", dmin, dmax, param[0], param[1], param[2]);

    for(i=0, x=dmin; i<wielkosc ;i++, x+=delta)
    {
        wyniki[i]=(float)(sin(x-*param) * cos(x-*(param+1)) + *(param+2));      //zapisujemy do naszej tablicy wartości funkcji
    }

    printf("Wygenerowano! \n");
}

void szum(float *wyniki, int wielkosc)
{
    int i;
    float a;

    printf("Podaj amplitude zaklocenia \n");

    for(;;)
    {
        a = wczytajf();
        if (a>=0) break;
        else printf("Amplituda musi byc liczbą wiekszą lub rowna 0 i nie kombinuj z literami!\n Obserwuję Cię! \n");
    }


    for(i=0;i<wielkosc; i++)
    {
        wyniki[i]+=((2.0f*rand()/RAND_MAX - 1)*2)*a ;       //nasz algorytm szumienia
    }

    printf("Zaszumiono!\n");
    printf("\n");
}

void zapis (float dmin, float dmax, float wyniki[], int wielkosc)
{
    float delta;
    float x;
    int i;
    FILE *f;

    delta=(dmax-dmin)/(wielkosc - 1);
    f = fopen("nazwa.csv", "wt");                             //wt-write text

    if(f==NULL) printf("Błąd zapisu! Sprawdź, czy w folderze z plikiem nie ma już jakiegoś pliku .csv,\n a najlepiej przeinstaluj Windowsa.\n");
    else
    {
        for(i=0, x=dmin; i<wielkosc ;i++, x+=delta)
            {
                fprintf(f,"%f ; %f \n", x, wyniki[i]);       //najpierw deskryptor pliku! musi wiedziec gdzie ma zapisac
            }
    fclose(f);      //zawsze zamykamy plik na końcu

    printf("Zapisano do pliku poprawnie!\n");
    printf("\n");
    }

}

void wczytaj (float *wyniki, int wielk_MAX, int *wielkosc_akt, float *pdmin, float *pdmax, int *l4)

{
    FILE *f;         //zmienna plikowa
    int i;
    float min;      //początek zakresu naszej dziedziny
    float max;      //koniec -||-


    f = fopen("nazwa.csv", "rt");

    if(f!=NULL)
    {
        for(i=0;i<wielk_MAX;i++)
        {
            if(fscanf(f, "%f ; %f", &min, &max)==2)         //ilosc poprawnych zczytań
            {
                wyniki[i]=max;
                if(i==0) *pdmin=min;
                *pdmax=min;
                *l4=1;
            }

            else
            {
                printf("Nie udalo sie wczytac pliku! \n");
                break;
                *l4=0;          //przekazujemy aby móc zapisać/zaszumieć
            }
        }
    *wielkosc_akt=i;        //przekazujemy po to aby wiedzieć jak dużą tablicę wczytaliśmy i aby szumić/odszumiać i zapisywać poprawnie
    fclose(f);
    printf("Wczytano poprawnie! \n");
    printf("\n");
    }
}

void usrednianie(int wielkosc, float wyniki[])
{
    int i;
    int j;
    float suma;
    float srednie[100];
    int r;

    printf("Podaj promien usrednienia \n");
    r=wczytaj_promien();

    for(i=0;i<wielkosc;i++)
    {
        suma = 0;
        for(j=i-r; j<i+r ;++j) //petla wewnetrzna do liczenia sredniej
        {
            if(j<0) suma += wyniki[-j];
            else if(j>=wielkosc) suma+=wyniki[2*wielkosc-j-1];
            else suma+=wyniki[j];
        }
        srednie[i]=suma/(2*r+1);

    }
    for(i=0;i<wielkosc;i++) wyniki[i]=srednie[i]; //po usrednieniu wyniki zapisujemy do naszej glownej
    printf("Odszumiono!\n");
}



int main()
{
    int wielk = WIELKOSC;
    int wybor;
    int l1=0;
    int l2=0;
    int l3=0;
    int l4=0;
    float arg_min; //Nasz X1
    float arg_max; //Nasz X2
    float parametry[3];
    float wyn[WIELKOSC];

    srand((unsigned int)time(NULL));    //raz w mainie tylko deklarujemy, usigned w nawiasie, bo srand chce unsigned
    setlocale(LC_ALL, "polish");
    wstepniak();

    for(;;)
    {

    printf("Przejdź do: \n");
    wybor=wczytaj_menu();

    switch(wybor)
    {
    case 1: //dziedzina
        dziedzina(&arg_min, &arg_max);
        l1 = 1;
        printf("\n");
        break;

    case 2:  //parametry
        wczytaj_parametry(parametry);
        l2=1;
        printf("\n");
        break;

    case 3: //generowanie
        wielk=WIELKOSC;
        if(l1 && l2)
        {
            generuj(parametry, arg_min, arg_max, wyn, wielk);
            l3=1;
        }
        else printf("Do wygenerowania funkcji musisz podać dziedzinę i parametry! \n");
        printf("\n");
        break;

    case 4: //szum
        if(l3 || l4) szum(wyn, wielk);
        else printf("Aby dodać szum do funkcji musisz ją wygenerować LUB wczytać z pliku! \n");
        printf("\n");
        break;

    case 5: //odszumienie
        if(l3 || l4) usrednianie(wielk, wyn);
        else printf("Aby odszumić funkcję musisz ją wygenerować LUB wczytać z pliku! \n");
        printf("\n");
        break;

    case 6: //zapis do pliku
        if(l3 || l4) zapis(arg_min, arg_max, wyn, wielk);
        else printf("Aby zapisać funkcję musisz ją wygenerować LUB wczytać z pliku! \n");
        printf("\n");
        break;

    case 7: //wczyt z pliku
        wczytaj(wyn, WIELKOSC, &wielk ,&arg_min, &arg_max, &l4);
        printf("\n");
        break;

    case 0: //instrukcja :D
        instrukcja();
        printf("\n");
        break;
    }
    wstepniak_mini();
    }
    //dziedzina(&x, &y);
    //wczytaj_parametry(parametry);
    //wielk=WIELKOSC;
    //generuj(parametry,x,y,wyn, wielk);        //nazwa tablicy jest adresem, bez &
    //szum(wyn, wielk);
    //zapis(x, y, wyn, wielk);
    //usrednianie(wielk, wyn);
    //zapis(x, y, wyn, wielk);
    //wczytaj(wyn, WIELKOSC, &wielk ,&x, &y);

    printf ("No i koniec");

    return 0;
}