#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>



typedef struct Skladnik {
    char nazwa[100];    // nazwa skladnika
    double ilosc;       // ilosc danego skladnika
    char jednostka[10]; // szt, gramy itd..
} Skladnik;

typedef struct Przepis {
    char nazwa[100];
    char kategoria[100];
    int ilosc_osob;

    int ilosc_skladnikow;
    int aktualny_skladnik;
    Skladnik** skladniki;
} Przepis;

typedef struct Element {
    Przepis* przepis;
    struct Element* nast, *poprz;
} Element;

typedef struct Lista {
    struct Element* poczatek, *koniec;

    int rozmiar;
} Lista;

Lista* stworz_liste() {
    Lista* l = (Lista*)calloc(1, sizeof(Lista));
    l->rozmiar = 0;
    l->poczatek = NULL;
    l->koniec = NULL;

    return l;
}

void wypisz_skladnik(Skladnik* s) {
    if (s == NULL) {
        printf("Przekazano skladnik NULL do wypisania.\n");
        return;
    }

    printf("%s %.2lf %s\n", s->nazwa, s->ilosc, s->jednostka);
}
void wypisz_skladniki(Lista* l) {
    int i, numer;
    Element* tmp = l->poczatek;

    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }

    printf("Podaj numer przepisu do stworzenia listy zakupow: ");
    scanf("%d", &numer);

    // bo liczymy od 0
    numer--;

    // sprawdzenie czy poprawny numer
    if (numer < 0 || numer >= l->rozmiar) {
        printf("Niepoprawny numer. Numer powinien byc miedzy 1 a %d.\n", l->rozmiar - 1);
        return;
    }

    i = 0;
    while (tmp != NULL) {
        if (i == numer) {
            printf("\nDo przepisu o nazwie: %s\n", tmp->przepis->nazwa);
            printf("Nalezy zakupic nastepujace skladniki: \n");
            for (i = 0; i < tmp->przepis->ilosc_skladnikow; i++) {
                printf("\t");
                wypisz_skladnik(tmp->przepis->skladniki[i]);
            }
            return;
        }
        tmp = tmp->nast;
        i++;
    }


}
Skladnik* stworz_skladnik(char* nazwa, double ilosc, char* jednostka) {
    Skladnik* nowy = (Skladnik*)calloc(1, sizeof(Skladnik));

    if (nowy == NULL) {
        printf("Nie udalo sie zaalokowac pamieci na skladnik.\n");
        return NULL;
    }

    nowy->ilosc = ilosc;

    strcpy(nowy->nazwa, nazwa);
    strcpy(nowy->jednostka, jednostka);

    return nowy;
}
Przepis* stworz_przepis(char* nazwa, char* kategoria, int ilosc_osob, int ilosc_skladnikow) {
    Przepis* nowy = (Przepis*)calloc(1, sizeof(Przepis));

    if (nowy == NULL) {
        printf("Nie udalo sie zaalokowac pamieci na przepis.\n");
        return NULL;
    }
    strcpy(nowy->nazwa, nazwa);
    strcpy(nowy->kategoria, kategoria);

    nowy->ilosc_osob = ilosc_osob;
    nowy->ilosc_skladnikow = ilosc_skladnikow;
    nowy->aktualny_skladnik = 0;

    // alokacja miejsca na skladniki
    nowy->skladniki = (Skladnik**)calloc(nowy->ilosc_skladnikow, sizeof(Skladnik*));


    return nowy;
}
// dodaje skladnik do przepisy
void dodaj_skladnik(Przepis* p, Skladnik* s) {
    if (p->aktualny_skladnik >= p->ilosc_skladnikow) {
        printf("Nie mozna dodac wiecej skladnikow do tego przepisu.");
    }
    p->skladniki[p->aktualny_skladnik] = s;
    p->aktualny_skladnik++;
}
void wstaw(Lista* l, Przepis* p) {
    Element* nowy = (Element*)calloc(1, sizeof(Element));
    Element* ostatni = l->poczatek;

    l->rozmiar++;

    nowy->przepis = p;

    // jezeli nie ma jeszcze zadnych elementow
    if (l->poczatek == NULL) {
        nowy->poprz = NULL;
        l->poczatek = nowy;
        return;
    }

    // jezeli sa to przechodzi sie na koniec i dodaje
    while (ostatni->nast != NULL) {
        ostatni = ostatni->nast;
    }

    ostatni->nast = nowy;
    nowy->poprz = ostatni;
    l->koniec = nowy->poprz;
}
void wypisz_przepis(Przepis* p) {
    int i;

    printf("%s\n", p->nazwa);
    printf("Kategoria %s\n", p->kategoria);
    printf("Ilosc osob: %d\n", p->ilosc_osob);
    printf("Ilosc skladnikow: %d\n", p->ilosc_skladnikow);
    printf("Skladniki: \n");

    for (i = 0; i < p->ilosc_skladnikow; i++) {
        printf("\t");
        wypisz_skladnik(p->skladniki[i]);
    }

    printf("\n");

}
void wypisz_liste(Lista* l) {
    int i = 0;
    Element* e = l->poczatek;

    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }

    printf("\nLiczba przepisow: %d\n\n", l->rozmiar);


    while (e != NULL) {
        printf("%d)\n", ++i);
        wypisz_przepis(e->przepis);
        e = e->nast;
    }


}

void zapisz_przepis(FILE* f, Przepis* p) {
    int i;
    if (f == NULL) {
        printf("Nie moge zapisac do zamknietego pliku.\n");
        return;
    }

    fprintf(f, "%s;%s;%d;%d", p->nazwa, p->kategoria, p->ilosc_osob, p->ilosc_skladnikow);

    // teraz trzeba zapisac skladniki
    for (i = 0; i < p->ilosc_skladnikow; i++) {
        fprintf(f, ";%s;%lf;%s", p->skladniki[i]->nazwa, p->skladniki[i]->ilosc, p->skladniki[i]->jednostka);
    }
    fprintf(f, "\n");
}

void zapisz_przepisy(Lista* l) {
    char nazwa[100];
    FILE* f;
    Element* e = l->poczatek;
    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }
    printf("Podaj nazwe pliku: ");
    scanf("%s", nazwa);

    f = fopen(nazwa, "w");

    if (f == NULL) {
        printf("Nie udalo sie otworzyc pliku do zapisu.\n");
        return;
    }

    while (e != NULL) {
        zapisz_przepis(f, e->przepis);
        e = e->nast;
    }

    fclose(f);
}

Przepis* przepis_z_klawiatury() {
    int wybor, i;
    Przepis* p = (Przepis*)calloc(1, sizeof(Przepis));
    Skladnik* s;

    printf("Podaj nazwe przepisu: ");
    scanf("\n%[^\n]", p->nazwa);

    printf("Wybierz kategorie: \n");
    printf("1 - Sniadanie, 2 - Obiad, 3 - Kolacja, 4 - Deser: ");
    scanf("%d", &wybor);

    if (wybor == 1) {
        strcpy(p->kategoria, "sniadanie");
    }
    else if (wybor == 2) {
        strcpy(p->kategoria, "obiad");
    }
    else if (wybor == 3) {
        strcpy(p->kategoria, "kolacja");
    }
    else if (wybor == 4) {
        strcpy(p->kategoria, "deser");
    }
    else {
        printf("Niepoprawna kategoria.\n");
        free(p);
        return NULL;
    }

    printf("Podaj liczbe osob: ");
    scanf("%d", &p->ilosc_osob);
    printf("Podaj liczbe skladnikow: ");
    scanf("%d", &p->ilosc_skladnikow);

    p->aktualny_skladnik = 0;

    p->skladniki = (Skladnik**)calloc(p->ilosc_skladnikow, sizeof(Skladnik*));

    printf("Uzupelnij skladniki: \n");
    for (i = 0; i < p->ilosc_skladnikow; i++) {
        s = (Skladnik*)calloc(1, sizeof(Skladnik));
        printf("Podaj nazwe: ");
        scanf("\n%[^\n]", s->nazwa);

        printf("Podaj ilosc: ");
        scanf("%lf", &s->ilosc);

        printf("Podaj jednostke: ");
        scanf("%s", s->jednostka);
        dodaj_skladnik(p, s);

    }
    return p;
}
Lista* wczytaj_liste() {
    FILE* f;
    char nazwa[100];
    char linijka[500];
    char skladniki[300];

    // dane do przepisu i skladnika
    char n[100], k[100], j[10];
    int io, is;
    double ilosc;

    int i;


    Lista* l = stworz_liste();
    Przepis* p;

    printf("Podaj nazwe pliku: ");
    scanf("%s", nazwa);

    f = fopen(nazwa, "r");

    if (f == NULL) {
        printf("Nie udalo sie otworzyc pliku do odczytu.\n");
        return NULL;
    }

    while (!feof(f)) {
        fgets(linijka, 500, f);
        if (strcmp(linijka, "\n") == 0) {
            break; // jezeli wczytano pusta linijke to koniec
        }
        sscanf(linijka, "%[^;] ; %[^;] ; %d ; %d ; %[^\n]", n, k, &io, &is, skladniki);

        p = stworz_przepis(n, k, io, is);

        // teraz trzeba przetworzyc skladniki
        for (i = 0; i < p->ilosc_skladnikow; i++) {
            sscanf(skladniki, "%[^;] ; %lf ; %[^;] ; %[^\n]", n, &ilosc, k, skladniki);
            //printf("Skladnik %s %lf %s\n", n, ilosc, k);
            dodaj_skladnik(p, stworz_skladnik(n, ilosc, k));
        }
        wstaw(l, p);
    }

    return l;
}

Lista* wczytaj_liste_domyslnie() {
    FILE* f;
    char nazwa[13] = "przepisy.csv";
    char linijka[500];
    char skladniki[300];

    // dane do przepisu i skladnika
    char n[100], k[100], j[10];
    int io, is;
    double ilosc;

    int i;

    Lista* l = stworz_liste();
    Przepis* p;

    f = fopen(nazwa, "r");

    if (f == NULL) {
        printf("Nie udalo sie otworzyc pliku do odczytu.\n");
        return NULL;
    }
    while (!feof(f)) {
        fgets(linijka, 500, f);
        if (strcmp(linijka, "\n") == 0) {
            break; // jezeli wczytano pusta linijke to koniec
        }
        sscanf(linijka, "%[^;] ; %[^;] ; %d ; %d ; %[^\n]", n, k, &io, &is, skladniki);

        p = stworz_przepis(n, k, io, is);

        // teraz trzeba przetworzyc skladniki
        for (i = 0; i < p->ilosc_skladnikow; i++) {
            sscanf(skladniki, "%[^;] ; %lf ; %[^;] ; %[^\n]", n, &ilosc, k, skladniki);
            //printf("Skladnik %s %lf %s\n", n, ilosc, k);
            dodaj_skladnik(p, stworz_skladnik(n, ilosc, k));
        }
        wstaw(l, p);
    }

    return l;
}

void usun_przepis(Lista* l) {
    int i, numer;
    Element* tmp, *do_usuniecia = NULL;

    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }

    printf("Podaj numer przepisu do usuniecia: ");
    scanf("%d", &numer);

    // bo liczymy od 0
    numer--;

    // sprawdzenie czy poprawny numer
    if (numer < 0 || numer >= l->rozmiar) {
        printf("Niepoprawny numer. Numer powinien byc miedzy 1 a %d.\n", l->rozmiar - 1);
        return;
    }

    tmp = l->poczatek;

    i = 0;
    while (tmp != NULL) {
        do_usuniecia = tmp;
        if (i == numer) {
            break;
        }
        tmp = tmp->nast;
        i++;
    }


    printf("Usuwam:\n");
    wypisz_przepis(do_usuniecia->przepis);

    if (l->poczatek == do_usuniecia) { // jezeli usuwamy z poczatku
        l->poczatek = do_usuniecia->nast;
    }

    // zmieni nast jezeli element nie jest na koncu
    if (do_usuniecia->nast != NULL) {
        l->koniec = l->koniec->poprz;
        do_usuniecia->nast->poprz = do_usuniecia->poprz;
    }

    // zmieni poprz jezeli element nie jest piewrszy
    if (do_usuniecia->poprz != NULL) {
        do_usuniecia->poprz->nast = do_usuniecia->nast;
    }

    // zwolnienie pamieci
    free(do_usuniecia->przepis->skladniki);
    free(do_usuniecia->przepis);
    free(do_usuniecia);

    // zmniejszenie ilosci elementow
    l->rozmiar--;
}

char* pomniejsz_znaki(const char*text)
{
    int i = 0;
    char *c = malloc(strlen(text) * sizeof(char));
    strcpy(c, text);
    for (int i = 0; text[i]; i++) { //po wykonaniu iteracji to sie zwalnia, bo konczy sie blok instrukcji, jest czyszczony. statyczny - jest wykorzystywany tylko w bloku instrunkji, tak jak w if
        c[i] = tolower(text[i]);
    }
    return c;
}

void wyszukaj_po_skladniku(Lista* l) {
    char szukany[100];
    Element* e;
    int i;
    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }

    printf("Podaj nazwe szukanego skladnika: ");
    scanf("%s", szukany);
    e = l->poczatek;


    while (e != NULL) {
        for (i = 0; i < e->przepis->ilosc_skladnikow; i++) {
            if (strstr(pomniejsz_znaki(szukany), pomniejsz_znaki(e->przepis->skladniki[i]->nazwa)) != NULL) {
                wypisz_przepis(e->przepis);
            }
        }
        e = e->nast;
    }

}

void wylosuj_przepis(Lista* l) {
    int i = 0, n;

    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }
    Element* e = l->poczatek;


    n = rand() % l->rozmiar;

    printf("Losuje przepis: \n");
    while (e != NULL) {
        if (i == n) {
            wypisz_przepis(e->przepis);
            break;
        }
        e = e->nast;
        i++;
    }
}

void wyczysc_liste(Lista* l) {
    Element* e, *tmp;
    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }
    e = l->poczatek;

    while (e != NULL) {
        tmp = e->nast;

        free(e->przepis->skladniki);
        free(e->przepis);
        free(e);

        e = tmp;
    }

    l->rozmiar = 0;
    l->poczatek = NULL;
    l->koniec = NULL;
}
/* function to swap data of two nodes a and b*/
void zamien(Element* a, Element* b)
{
    Przepis* temp = a->przepis;
    a->przepis = b->przepis;
    b->przepis = temp;
}
//*Porownujace elementy, jezeli takie same = 0, jezeli nalezy przestawic > 1, jezeli zachowac kolejnosc < -1
int porownaj_nazwy(Element* a, Element* b) {
    return strcmp(a->przepis->nazwa, b->przepis->nazwa);
}
int porownaj_kategorie(Element* a, Element* b) {
    return strcmp(a->przepis->kategoria, b->przepis->kategoria);
}
void sortuj(Element* poczatek)
{
    int zamieniono, i;
    Element* ptr1 = poczatek;
    Element* lptr = NULL;

    int(*porownanie)(Element*, Element*);

    if (ptr1 == NULL)
        return;


    printf("1 - Sortuj po nazwie, 2 - Sortuj po kategorii: ");
    scanf("%d", &i);
    if (i == 1) {
        porownanie = porownaj_nazwy;
    }
    else if (i == 2) {
        porownanie = porownaj_kategorie;
    }
    else {
        printf("Brak takiej opcji.\n");
        return;
    }

    do {
        zamieniono = 0;
        ptr1 = poczatek;

        while (ptr1->nast != lptr) {
            if (porownanie(ptr1, ptr1->nast) > 0)
            {
                zamien(ptr1, ptr1->nast);
                zamieniono = 1;
            }
            ptr1 = ptr1->nast;
        }
        lptr = ptr1;
    } while (zamieniono);
}

void zmnien_ilosc_osob(Lista* l) {
    if (l->poczatek == NULL) {
        printf("Brak przepisow.\n");
        return;
    }
    Element* e = l->poczatek;
    int numer;
    int nowa_ilosc_osob;

    printf("Podaj numer przepisu do edycji: ");
    scanf("%d", &numer);

    numer--;

    if (numer < 0 || numer >= l->rozmiar) {
        printf("Niepoprawny numer. Numer powinien byc miedzy 1 a %d.\n", l->rozmiar - 1);
        return;
    }

    printf("Podaj nowa ilosc osob:");
    scanf("%d", &nowa_ilosc_osob);

    if (nowa_ilosc_osob <= 0)
    {
        printf("Niepoprawna ilosc osob.\n");
        return;
    }


    Element* tmp = l->poczatek;
    Element* do_zmiany = NULL;

    int i = 0;
    while (tmp != NULL) {
        do_zmiany = tmp;
        if (i == numer) {
            break;
        }
        tmp = tmp->nast;
        i++;
    }

    Przepis* do_edycji = do_zmiany->przepis;

    for (i = 0; i < do_edycji->ilosc_skladnikow; i++) {
        double nowa_wartosc = do_edycji->skladniki[i]->ilosc / (double)do_edycji->ilosc_osob;
        do_edycji->skladniki[i]->ilosc = nowa_wartosc* nowa_ilosc_osob;
    }
    do_edycji->ilosc_osob = nowa_ilosc_osob;
}

void main() {
    srand(time(NULL));
    int wybor;
    Lista* l = stworz_liste();
    l = wczytaj_liste_domyslnie();
    do {
        printf("1) Dodaj przepis\n");
        printf("2) Usun\n");
        printf("3) Wczytaj\n");
        printf("4) Zapisz\n");
        printf("5) Wypisz\n");
        printf("6) Wylosuj\n");
        printf("7) Wyszukaj\n");
        printf("8) Lista zakupow\n");
        printf("9) Sortuj\n");
        printf("10) Zmnien ilosc osob\n");
        printf("11) Wyjscie\n");

        scanf("%d", &wybor);
        system("cls");
        switch (wybor) {
        case 1:
            wstaw(l, przepis_z_klawiatury());
            break;
        case 2:
            usun_przepis(l);
            break;
        case 3:
            l = wczytaj_liste();
            break;
        case 4:
            zapisz_przepisy(l);
            break;
        case 5:
            wypisz_liste(l);
            break;
        case 6:
            wylosuj_przepis(l);
            break;
        case 7:
            wyszukaj_po_skladniku(l);
            break;
        case 8:
            wypisz_skladniki(l);
            break;
        case 9:
            sortuj(l->poczatek);
            break;
        case 10:
            zmnien_ilosc_osob(l);
            break;
        case 11:
            break;
        default:
            printf("Brak takiej opcji.\n");

        }
    } while (wybor != 11);

    wyczysc_liste(l);
    return 0;
}