#include <freertos/FreeRTOS.h>
#include <stdio.h>
#include <driver/gpio.h>
#include <freertos/task.h>
#include <freertos/semphr.h>
#include <esp_system.h>
#include "sdkconfig.h"
#include <time.h>
/* Kernel includes. */
#include "freertos/queue.h"	/* RTOS queue related API prototypes. */
#include "freertos/timers.h" /* Software timer related API prototypes. */
#include <stdlib.h>
#include <stdarg.h>
// Definieren Sie die Struktur für die Komponenten
int komponentenArray[]= {50, 30, 40, 40, 30, 20};
typedef struct
{
    int gewicht;
} Komponente;

// Definieren Sie die Struktur für das Rezept
typedef struct
{
    Komponente komponenten[6];
} Rezept;

// Definieren Sie die Struktur für die Waage
typedef struct
{
    Komponente komponenten[3];
} Waage;

// Definieren Sie die Struktur für den Mischer
typedef struct
{
    Komponente komponenten[6];
    int trockenMischZeit;
    int nassMischZeit;
    int entleerZeit;
} Mischer;

// Definieren Sie die Semaphoren
SemaphoreHandle_t xSemaphore;

// Definieren Sie die Warteschlangen
QueueHandle_t xQueue1, xQueue2;



// Funktion zum Entleeren der Waage
void entleerenWaage(Komponente komponente)
{

    Serial.println("Entleeren der Waage: Gewicht = ");
    Serial.print(komponente.gewicht);

}

// Funktion zum Befüllen des Mischers
void befuellenMischer(Komponente komponente)
{

    Serial.println("Befüllen des Mischers: Gewicht = ");
    Serial.print(komponente.gewicht);

}

// Funktion zum Entleeren des Mischers
void entleerenMischer(Mischer *mischer)
{
    // Schritte zum Öffnen des Ablaufventils / der Entleerklappe (abhängig von Ihrer Hardware)
    // ...

    // Logik zum Entleeren des Mischers (Beispiel: serielle Ausgabe)
    Serial.println("Entleeren des Mischers\n");

    // Schritte zum Schließen des Ablaufventils / der Entleerklappe (abhängig von Ihrer Hardware)
    // ...
}


// Keyboard-Task
// Keyboard-Task
void keyboardTask(void *pvParameters)
{
    char c;
    Rezept rezept;

    for (;;)
    {
        // Warten auf eine Eingabe
        c = getchar();

        switch (c)
        {
        case 'e':
            // Lesen Sie das Rezept aus der Datei
            for (int i = 0; i < 6; i++)
            {
                rezept.komponenten[i].gewicht = komponentenArray[i];
            }
            // Senden Sie das Rezept an die Wagentasks
            xQueueSend(xQueue1, &rezept, portMAX_DELAY);
            xQueueSend(xQueue2, &rezept, portMAX_DELAY);
            break;

        case 's':
            // Starten Sie die Anlage
            xSemaphoreGive(xSemaphore);
            break;

        default:
            break;
        }
    }
}

// Wagentasks
void waagenTask(void *pvParameters)
{
    Rezept rezept;
    Waage waage;

    for (;;)
    {
        // Warten auf das Rezept
        xQueueReceive(xQueue1, &rezept, portMAX_DELAY);

        // Befüllen Sie die Waage mit den Komponenten aus dem Rezept
        for (int i = 0; i < 3; i++)
        {
            waage.komponenten[i] = rezept.komponenten[i];
        }

        // Warten auf den Start der Anlage
        xSemaphoreTake(xSemaphore, 1);

        // Entleeren Sie die Waage in den Mischer
        for (int i = 0; i < 3; i++)
        {
            // Implementieren Sie die Logik zum Entleeren der Waage
            entleerenWaage(waage.komponenten[i]);

        }
    }
}

// Mischertask
void mischerTask(void *pvParameters)
{
    Mischer mischer;

    for (;;)
    {
        // Warten auf den Start der Anlage
        xSemaphoreTake(xSemaphore, 1);

        // Befüllen Sie den Mischer mit den Komponenten von den Waagen
        for (int i = 0; i < 6; i++)
        {
            // Implementieren Sie die Logik zum Befüllen des Mischers
            befuellenMischer(mischer.komponenten[i]);

        }

        // Starten Sie den Mischprozess
        for (int i = 0; i < 3; i++)
        {
            switch (i)
            {
            case 0:
                // Trockenmischzeit
                vTaskDelay(pdMS_TO_TICKS(mischer.trockenMischZeit * 1000));
                break;
            case 1:
                // Nassmischzeit mit Wasserzugabe
                vTaskDelay(pdMS_TO_TICKS(mischer.nassMischZeit * 1000));
                break;
            case 2:
                // Trockenmischzeit
                vTaskDelay(pdMS_TO_TICKS(mischer.trockenMischZeit * 1000));
                break;
            default:
                break;
            }
        }

        // Entleeren Sie den Mischer
        // Implementieren Sie die Logik zum Entleeren des Mischers
          entleerenMischer(&mischer);

    }
}

// UI-Task
void uiTask(void *pvParameters)
{
    Mischer mischer;

    for (;;)
    {
        // Warten auf den Start der Anlage
        xSemaphoreTake(xSemaphore, portMAX_DELAY);

        // Anzeigen des aktuellen Mischprozesses und der verbleibenden Zeit
        for (int i = 0; i < 3; i++)
        {
            switch (i)
            {
            case 0:
                Serial.println("Trockenmischzeit: %d Sekunden\n");
                Serial.print(mischer.trockenMischZeit);
                vTaskDelay(pdMS_TO_TICKS(mischer.trockenMischZeit * 1000));
                break;
            case 1:
                Serial.println("Nassmischzeit mit Wasserzugabe: %d Sekunden\n");
                Serial.print(mischer.nassMischZeit);
                vTaskDelay(pdMS_TO_TICKS(mischer.nassMischZeit * 1000));
                break;
            case 2:
                Serial.println("Trockenmischzeit: %d Sekunden\n");
                Serial.print(mischer.trockenMischZeit);
                vTaskDelay(pdMS_TO_TICKS(mischer.trockenMischZeit * 1000));
                break;
            default:
                break;
            }
        }

        // Anzeigen der Entleerzeit des Mischers
        Serial.println("Entleerzeit des Mischers: %d Sekunden\n");
        Serial.print(mischer.entleerZeit);
    }
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.println("Hello, ESP32!");

    // Erstellen Sie die Semaphoren
    vSemaphoreCreateBinary(xSemaphore);

    // Erstellen Sie die Warteschlangen
    xQueue1 = xQueueCreate(10, sizeof(Komponente));
    xQueue2 = xQueueCreate(10, sizeof(Komponente));

    // Erstellen Sie die Tasks
    xTaskCreate(keyboardTask, "KeyboardTask", 1000, NULL, 1, NULL);
    xTaskCreate(waagenTask, "WaagenTask1", 1000, NULL, 1, NULL);
    xTaskCreate(waagenTask, "WaagenTask2", 1000, NULL, 1, NULL);
    xTaskCreate(mischerTask, "MischerTask", 1000, NULL, 1, NULL);
    xTaskCreate(uiTask, "UITask", 1000, NULL, 1, NULL);

    // Starten Sie den Scheduler
    vTaskStartScheduler();

    // Wenn alle Aufgaben gelöscht sind, wird der Programmfluss hier fortgesetzt.
    for (;;)
        ;
}
void loop() {
  // put your main code here, to run repeatedly:
  delay(1000); // this speeds up the simulation
}