// ConsoleApplication5.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

typedef struct baustein
{
    int hoehe;
    int breite;
    int length;
    int rot;
    int gruen;
    int blau;
} BAUSTEIN;

void eingabeBS(BAUSTEIN *bs);
void ausgabeBS(BAUSTEIN bs);
int compareBS(BAUSTEIN bs1, BAUSTEIN bs2);
void rem(BAUSTEIN *bs, int stelle, int length);
int auswahl();
int getVolume(BAUSTEIN bs);
void compare(int length, BAUSTEIN *lego);
void quicksort(int links, int rechts, BAUSTEIN feld[]);
void speichern(int length, BAUSTEIN *lego);
int read(BAUSTEIN *lego, int length);

int main()
{
    BAUSTEIN *legobausteine;
    legobausteine = (BAUSTEIN*)malloc(1 * sizeof(BAUSTEIN));
    int length = 0;
    int command = 1;
    int chosen;
    while (1)
    {
        system("cls");
        command = auswahl();
        switch (command)
        {
        case 0:
            length++;
            legobausteine = (BAUSTEIN *)realloc(legobausteine, sizeof(BAUSTEIN) * length);
            eingabeBS(&legobausteine[length - 1]);
            break;
        case 1:
            printf("Welches der Elemente von [0; %d[ soll ausgegeben werden: ", length);
            scanf("%d", &chosen);
            if (chosen < 0 || chosen > length - 1)
            {
                printf("Dies ist keine gueltige Eingabe!\n");
                system("pause");
                break;
            }
            ausgabeBS(legobausteine[chosen]);
            break;
        case 2:
            printf("Welches der Elemente von [0; %d[ soll entfernt werden: ", length);
            scanf("%d", &chosen);
            if (chosen < 0 || chosen > length - 1)
            {
                printf("Dies ist keine gueltige Eingabe!\n");
                system("pause");
                break;
            }
            rem(legobausteine, chosen, length);
            length--;
            break;
        case 3:
            compare(length, legobausteine);
            break;
        case 4:
            if (length != 0)
            {
                quicksort(0, length - 1, legobausteine);
            }
            else
            {
                printf("\nEs sind keine Inhalte vorhanden!\n");
                system("pause");
            }
            break;
        case 5:
            speichern(length, legobausteine);
            break;
        case 6:
            length = read(legobausteine, length);
            printf("FINAL: %d", legobausteine[length-1].length);
            system("pause");
            break;
        case 7:
            return 0;
        default:
            printf("Das ist kein gueltiger Befehl!\n");
            system("pause");
            break;
        }
    }
    return 0;
}

void speichern(int length, BAUSTEIN *lego)
{
    FILE *f = fopen("data.txt", "w");

    for (int i = 0; i < length; i++)
    {
        fprintf(f, "%d;%d;%d;%d;%d;%d;", lego[i].hoehe, lego[i].breite, lego[i].length, lego[i].rot, lego[i].gruen, lego[i].blau);
    }
    fprintf(f, "\n");
    fclose(f);
}

int read(BAUSTEIN *lego, int length)
{
    FILE *f;
    f = fopen("data.txt", "r");
    if (f)
    {
        int c;
        char buff[300];
        int counter = 0;
        while ((c = getc(f)) != EOF)
        {
            buff[counter] = c;
            counter++;
        }
        fclose(f);

        char *data;
        data = strtok(buff, "\n");
        printf("Daten: %s", &data[0]);
        int wert = 0;
        char *temp;

        temp = strtok(data, ";");

        while(temp != NULL){
            if(wert % 6 == 0){
                printf("\nReallokiert!\n");
                length++;
                lego = (BAUSTEIN *)realloc(lego, sizeof(BAUSTEIN) * length);
            }
            printf("\n%d", atoi(temp));
            switch(wert % 6){
                case 0:
                    lego[length - 1].hoehe = atoi(temp);
                    printf("Wert hier: %d\n",lego[length-1]);
                case 1:
                    lego[length - 1].breite = atoi(temp);
                case 2:
                    lego[length - 1].length = atoi(temp);
                case 3:
                    lego[length - 1].rot = atoi(temp);
                case 4:
                    lego[length - 1].gruen = atoi(temp);
                case 5:
                    lego[length - 1].blau = atoi(temp);
                }
            temp = strtok(NULL, ";");
            wert++;
        }
    }
    else
    {
        printf("Es sind noch keine Daten vorhanden!");
    }
    return length;
}

void compare(int length, BAUSTEIN *lego)
{
    int eing1, eing2;
    printf("Welche Bausteine sollen miteinander verglichen werden? Waehle 2 Bausteine im Intervall [0; %d[!\n", length);
    printf("Baustein 1: ");
    scanf("%d", &eing1);
    printf("\nBaustein 2: ");
    scanf("%d", &eing2);
    printf("\n");
    if (eing1 < 0 || eing1 >= length || eing2 < 0 || eing2 >= length)
    {
        printf("Mindestens 1 der Bausteine existiert nicht! Bitte taetige eine andere Eingabe!\n");
        system("pause");
        return;
    }
    int vol1, vol2;
    vol1 = getVolume(lego[eing1]);
    vol2 = getVolume(lego[eing2]);
    if (vol1 == vol2)
    {
        printf("Die beiden Bausteine sind gleich gross!\n");
    }
    else if (vol1 < vol2)
    {
        printf("Der 1. Legobaustein ist um %d mm^3 kleiner als der 2.\n", vol2 - vol1);
    }
    else
    {
        printf("Der 1. Legobaustein ist um %d mm^3 groesser als der 2.\n", vol1 - vol2);
    }
    system("pause");
}

void quicksort(int links, int rechts, BAUSTEIN feld[])
{
    int pivot = rechts--;
    BAUSTEIN cache;

    while (links <= rechts)
    {
        if (getVolume(feld[links]) > getVolume(feld[pivot]) && getVolume(feld[rechts]) < getVolume(feld[pivot]))
        {
            cache = feld[links];
            feld[links] = feld[rechts];
            feld[rechts] = cache;
            links++;
            rechts--;
        }
        if (getVolume(feld[links]) <= getVolume(feld[pivot]))
        {
            links++;
        }
        if (getVolume(feld[rechts]) >= getVolume(feld[pivot]))
        {
            rechts--;
        }
    }
    cache = feld[links];
    feld[links] = feld[pivot];
    feld[pivot] = cache;

    if (rechts >= 1)
    {
        quicksort(0, rechts, feld);
    }
    if (pivot - links > 1)
    {
        quicksort(links + 1, pivot, feld);
    }
}

int getVolume(BAUSTEIN bs)
{
    return bs.breite * bs.hoehe * bs.length;
}

int auswahl()
{
    int command = 0;
    char input = 10;
    while (input != 13)
    {
        system("cls");
        printf("Waehle eine Methode aus: (s und w zum navigieren nutzen!)\n");
        if (command == 0)
        {
            printf("\033[32m[0] - Baustein hinzufuegen\n\033[0m");
        }
        else
        {
            printf("[0] - Baustein hinzufuegen\n");
        }
        if (command == 1)
        {
            printf("\033[32m[1] - Baustein anzeigen\n\033[0m");
        }
        else
        {
            printf("[1] - Baustein anzeigen\n");
        }
        if (command == 2)
        {
            printf("\033[32m[2] - Baustein entfernen\n\033[0m");
        }
        else
        {
            printf("[2] - Baustein entfernen\n");
        }
        if (command == 3)
        {
            printf("\033[32m[3] - Baustein vergleichen\n\033[0m");
        }
        else
        {
            printf("[3] - Baustein vergleichen\n");
        }
        if (command == 4)
        {
            printf("\033[32m[4] - Bausteine sortieren\n\033[0m");
        }
        else
        {
            printf("[4] - Bausteine sortieren\n");
        }
        if (command == 5)
        {
            printf("\033[32m[5] - Daten speichern\n\033[0m");
        }
        else
        {
            printf("[5] - Daten speichern\n");
        }
        if (command == 6)
        {
            printf("\033[32m[6] - Daten einlesen\n\033[0m");
        }
        else
        {
            printf("[6] - Daten einlesen\n");
        }
        if (command == 7)
        {
            printf("\033[32m[7] - Programm beenden\n\033[0m");
        }
        else
        {
            printf("[7] - Programm beenden\n");
        }
        input = getch();
        if (input == 'W' || input == 'w')
        {
            if (command > 0)
            {
                command--;
            }
        }
        else if (input == 'S' || input == 's')
        {
            if (command < 7)
            {
                command++;
            }
        }
    }
    return command;
}



void rem(BAUSTEIN *bs, int stelle, int length)
{
    bs[stelle] = bs[length - 1];
    bs = (BAUSTEIN*)realloc(bs, (length - 1) * sizeof(BAUSTEIN));
}

int compareBS(BAUSTEIN bs1, BAUSTEIN bs2)
{
    int vol1 = bs1.hoehe * bs1.length * bs1.breite;
    int vol2 = bs2.hoehe * bs2.length * bs2.breite;

    if (vol1 > vol2)
    {
        return 1;
    }
    else if (vol1 < vol2)
    {
        return 2;
    }
    else
    {
        return 3;
    }
}

void ausgabeBS(BAUSTEIN bs)
{
    printf("Die Hoehe betraegt %d mm\n", bs.hoehe);
    printf("Die Breite betraegt %d mm\n", bs.breite);
    printf("Die length betraegt %d mm\n", bs.length);
    printf("Der Rotwert betraegt %d \n", bs.rot);
    printf("Der Gruenwert betraegt %d \n", bs.gruen);
    printf("Der Blauwert betraegt %d \n", bs.blau);
    system("pause");
}
void eingabeBS(BAUSTEIN *bs)
{
    printf("Gib die Hoehe ein: ");
    scanf("%d", &bs->hoehe);
    printf("Gib die Breite ein: ");
    scanf("%d", &bs->breite);
    printf("Gib die length ein: ");
    scanf("%d", &bs->length);
    printf("Gib den Wert fuer rot ein: ");
    scanf("%d", &bs->rot);
    printf("Gib den Wert fuer gruen ein: ");
    scanf("%d", &bs->gruen);
    printf("Gib den Wert fuer blau ein: ");
    scanf("%d", &bs->blau);
}