laboratoria6

#include <iostream>
#include <stdlib.h>

#define DL_SLOWA 20
#define LICZBA_CZUJNIKOW 4
#define ERROR_ALOKACJA printf("error - blad podczas alokacji\n");
#define ERROR_PLIK_OTWARCIE printf("error - nie udalo sie otworzyc podanego pliku\n");
#define ERROR_PLIK_PUSTY printf("error - plik z danymi jest pusty\n");
#define ERROR_SLOWO_WCZYTYWANIE printf("error - blad podczas wczytywania slowa, prosze sprobuj ponownie: ");

struct pomiar {
    unsigned int nrPomiaru;
    unsigned int nrCzujnika;
    char data[DL_SLOWA];
    double temp;
    struct pomiar* nastepny;
};

struct listyCzujnikow {
    struct pomiar** czujniki;
};

void Info() {
    printf("autor: \tMateusz Wloczewski\n");
    printf("data: \t24 mar 2020\n");
    printf("about: \tRozwiazanie wejsciowki na laboratoria nr. 6\n");
    printf("\tProgram wczytan dane czujnikow temperatury z pliku: dane.txt do listy jednokierunkowej.\n");
    printf("\tNastepnie zamknie plik i podzieli liste (poprzez przenoszenie elementow) na mniejsze listy\n");
    printf("\tktore zawiera odczyty odpowiednio z kolejnych czujnikow. Na koniec wypisze liczbe\n");
    printf("\tpomiarow z kazdego z nich, poprosi o nawe pliku wyjsciowego i utworzy dla kazdego czujnika plik\n");
    printf("\t(dodajac indeks to podanej nazwy) zapisujac do niego dane z konkretnego urzadzenia pomiarowego.\n\n");
}

/*
@ brief Funkcja do czyszczenia bufora
*/
void CzyszczenieBufora() {
    while (getchar() != '\n') {}
}

/*
@ brief Funkcja do wczytania slowa
@ param *info - komunikat dla uzytkownika
@ param *slowo - tablica na przechowanie wczytanego slowa
*/
void WczytajSlowo(const char* info, char* slowo) {
    printf("%s: ", info);
    while (scanf_s("%s", slowo, DL_SLOWA) != 1 || getchar() != '\n') {
        CzyszczenieBufora();
        ERROR_SLOWO_WCZYTYWANIE
    }
}

/*
@ brief Funkcja do dodania elementu do listy jednokierunkowej
@ param *in - wskaznik do konkretnego miejsca w plku, ktory zawiera linie obecnie wczytywana do listy
@ ret   *nowy - wskaznik do nowo zaalokowanego elementu listy
*/
struct pomiar* DodajElementListy(FILE* in) {
    struct pomiar* nowy = (struct pomiar*)malloc(sizeof(struct pomiar));
    if (nowy != NULL) {
        nowy->nastepny = NULL;

        unsigned int nrPomiaru;
        unsigned int nrCzujnika;
        char data[DL_SLOWA] = {'\0'};
        double temp;

        fscanf_s(in, "%d", &nrPomiaru);
        if (feof(in)) { // napotkana linia to koniec pliku
            return NULL;
        }

        fscanf_s(in, "%d", &nrCzujnika);
        fscanf_s(in, "%s", data, DL_SLOWA);
        fscanf_s(in, "%lf", &temp);

        nowy->nrPomiaru = nrPomiaru;
        nowy->nrCzujnika = nrCzujnika;
        nowy->temp = temp;
        strcpy_s(nowy->data, DL_SLOWA, data);

        return nowy;
    }
    else {
        ERROR_ALOKACJA
        exit(0);
    }
}

/*
@ brief Funkcja do wczytywania pliku do listy
@ param *in - wskaznik do poczatku otwartego wczesniej pliku z danymi wejsciowymi
@ ret   *glowa - wskaznik do pierwszego elementu listy
*/
struct pomiar* WczytajPlikDoListy(FILE* in) {
    struct pomiar* glowa = NULL;
    struct pomiar* ogon = NULL;
    while (!feof(in)) {
        if (glowa == NULL) {
            glowa = DodajElementListy(in);
            if (glowa != NULL) {
                ogon = glowa;
            }
            else { // jezeli funkcja chce dodac jako pierwszy element null to plik jest pusty
                ERROR_PLIK_PUSTY
                return NULL;
            }
        }
        else {
            ogon->nastepny = DodajElementListy(in);
            if (ogon->nastepny != NULL) {
                ogon = ogon->nastepny;
            }
        }
    }
    return glowa;
}

/*
@ brief Funkcja do dealokacji listy
@ param *glowa - wskaznik do poczatku listys
*/
void DealokujListe(struct pomiar* glowa) {
    struct pomiar* ogon = NULL;
    while (glowa) {
        ogon = glowa->nastepny;
        free(glowa);
        glowa = ogon;
    }
}

/*
@ brief Funkcja do podzialu listy jednokierunkowej na LICZBA_CZUJNIKOW list jednokierunkowych
@ param *lista - wskaznik do glowy listy, ktora dzielimy
@ param *pomiaryCzujnikow - tablica, ktora przechowa liczbe pomiarow z kadego czujnika
@ ret   struct listyCzujnikow - strukturalny typ danych ktory zawiera wskaznik do dynamicznej tablicy,
        przechowujacej glowy list, czyli wskazniki do pierwszych
        elementow kazdej z utoroznych list
*/
struct listyCzujnikow UzupelnijCzujniki(struct pomiar** lista, int* pomiaryCzujnikow) {
    struct pomiar** czujniki = (struct pomiar**)calloc(sizeof(struct pomiar*), LICZBA_CZUJNIKOW);
    struct pomiar** dane = (struct pomiar**)calloc(sizeof(struct pomiar*), LICZBA_CZUJNIKOW);
    if (czujniki != NULL && dane != NULL) {
        while (*lista) {
            struct pomiar* tmp = (*lista)->nastepny;

            int numer = (*lista)->nrCzujnika - 1;
            if (czujniki[numer] == NULL) {
                czujniki[numer] = (*lista);
                dane[numer] = czujniki[numer];
            }
            else {
                dane[numer]->nastepny = (*lista);
                dane[numer] = dane[numer]->nastepny;
            }
            pomiaryCzujnikow[numer] += 1;
            (*lista)->nastepny = NULL;
            (*lista) = tmp;
        }
        free(dane);
        (*lista) = NULL;
        return listyCzujnikow{ czujniki };
    }
    else {
        ERROR_ALOKACJA
        exit(0);
    }
}

/*
@ brief Funkcja do zapisania listy do pliku
@ param *out - wskaznik do poczatku pliku otwartego w trybie w+ (utworz lub zastap plik nowym - do zapisu)
@ param *lista - wskaznik do poczatku zapisywanej listy
*/
void ZapiszListeDoPliku(FILE* out, struct pomiar* lista) {
    while (lista) {
        fprintf(out, "%d %d %s %lf\n", lista->nrPomiaru, lista->nrCzujnika, lista->data, lista->temp);
        lista = lista->nastepny;
    }
}

/*
@ brief Funkcja do dealokowania list zawierajacych dane z kolejnych czujnikow
@ param **czujniki - tablica wskaznikow do kazdej z list
*/
void DealokujCzujniki(struct pomiar** czujniki) {
    for (int i = 0; i < LICZBA_CZUJNIKOW; i++) {
        DealokujListe(czujniki[i]);
    }
    free(czujniki);
}

struct pomiar* OtworzPlik(const char* nazwa) {
    FILE* in;
    if (fopen_s(&in, "test.txt", "r") == 0 && in != NULL) {
        struct pomiar* lista = WczytajPlikDoListy(in);
        fclose(in);
        return lista;
    }
}

void PoliczRekordy(struct pomiar* lista) {
    int liczbaRekordow = 0;
    struct pomiar* ostatni = lista, *pierwszy = lista;
    while (lista) {
        if (liczbaRekordow == 0) {
            pierwszy = lista;
        }
        else {
            ostatni = lista;
        }
        liczbaRekordow++;

        lista = lista->nastepny;
    }
    if (liczbaRekordow != 0) {
        printf("liczba rekordow: %d\n", liczbaRekordow);
        printf("pierwszy rekord: %d %d %s %lf\n", pierwszy->nrPomiaru, pierwszy->nrCzujnika, pierwszy->data, pierwszy->temp);
        printf("ostatni rekord: %d %d %s %lf\n", ostatni->nrPomiaru, ostatni->nrCzujnika, ostatni->data, ostatni->temp);
    }
}

struct pomiar* ZnajdzNajmniejszy(struct pomiar* lista) {
    if (lista == NULL) return NULL; // lista pusta
    else if (lista->nastepny == NULL) return lista; // lista jednoelementowa
    struct pomiar* tmp = lista;
    struct pomiar* wskNajmniejszy = NULL;
    struct pomiar* wskPoprzedzajacy = NULL;
    double najmniejszy = tmp->temp;
    int czyZnaleziono = 0;
    while (tmp) {
        if (tmp->nastepny != NULL && tmp->nastepny->temp < najmniejszy) {
            wskNajmniejszy = tmp->nastepny;
            wskPoprzedzajacy = tmp;
            najmniejszy = tmp->nastepny->temp;
            czyZnaleziono = 1;
        }
        else if (tmp->nastepny == NULL) { // dotarlismy do ostatniego elementu
            if (czyZnaleziono && wskNajmniejszy->nastepny == NULL) {
                return lista;
            }
            else if (czyZnaleziono) {
                wskPoprzedzajacy->nastepny = wskNajmniejszy->nastepny;
                tmp->nastepny = wskNajmniejszy;
                wskNajmniejszy->nastepny = NULL;
                return lista;
            }
            else {
                struct pomiar* zwrot = lista->nastepny;
                tmp->nastepny = lista;
                lista->nastepny = NULL;
                return zwrot;
            }
        }

        tmp = tmp->nastepny;
    }
}

void WypiszListe(struct pomiar* lista) {
    while (lista) {
        printf("%d %d %s %lf\n", lista->nrPomiaru, lista->nrCzujnika, lista->data, lista->temp);
        lista = lista->nastepny;
    }
}

int main() {
    Info();
    FILE* in;
    FILE* out;
    char nazwain[DL_SLOWA];
    char nazwaout[DL_SLOWA];

    int* pomiaryCzujnikow = (int*)calloc(sizeof(int), LICZBA_CZUJNIKOW);
    if (pomiaryCzujnikow == NULL) {
        ERROR_ALOKACJA
        exit(0);
    }

    // wczytywanie pliku do listy dynamicznej
    WczytajSlowo("podaj nazwe pliku wejsciowego", nazwain);
    struct pomiar* lista = OtworzPlik(nazwain);
    struct listyCzujnikow lc;

    printf("WSZYSTKIE POMIARY: \n");
    PoliczRekordy(lista);
    printf("\n");

    lc = UzupelnijCzujniki(&lista, pomiaryCzujnikow);
    for (int i = 0; i < LICZBA_CZUJNIKOW; i++) {
        printf("CZUJNIK NR. %d\n", i + 1);
        PoliczRekordy(lc.czujniki[i]);
        printf("\n");
        lc.czujniki[i] = ZnajdzNajmniejszy(lc.czujniki[i]);
        PoliczRekordy(lc.czujniki[i]);
        printf("\n\n");
    }

    /*
    // zapisywanie pliku
    WczytajSlowo("podaj nazwe pliku wyjsciowego [do nazwy zostanie automatycznie dodany numer czujnika]", nazwaout);
    for (int i = 0; i < LICZBA_CZUJNIKOW; i++) {
        char tmp[DL_SLOWA + 1] = { '\0' };
        char ind[DL_SLOWA] = { '1' + i, '.', 't', 'x', 't', '\0' };
        strcpy_s(tmp, DL_SLOWA + 1, nazwaout);
        strcat_s(tmp, DL_SLOWA + 1, ind);

        if (fopen_s(&out, tmp, "w+") == 0 && out != NULL) {
            ZapiszListeDoPliku(out, lc.czujniki[i]);
            fclose(out);
        }
        else {
            ERROR_PLIK_OTWARCIE
        }
    }
    */
    free(pomiaryCzujnikow);
    DealokujListe(lista);
    DealokujCzujniki(lc.czujniki);

    return 0;
}