#include <stdint.h>
#include <HardwareSerial.h>

#include <ArduinoJson.h>


HardwareSerial mySerial(1); // UART1
 // UART1: RX na GPIO18
//         TX na GPIO17

//http://wiki.fluidnc.com/en/hardware/ESP32-S3_Pin_Reference

static const BaseType_t pro_cpu = 0;
static const BaseType_t app_cpu = 1;


int mydata = 0; 
int mydataZ = 9999999;

uint8_t dataRequested = 0x00;
uint8_t errdataRequested = 0x01;
uint8_t sendingData = 0;
uint8_t receivedData = 0;

String jsonStringGlass;
String jsonStringStation;
String jsonStringInfo;


const char* glass0[] = {"rum", "vodka", "whiskey", "", "brandy", "cola"};
uint8_t volumes0[] = {80, 70, 40, 0, 30, 150};

const char* glass1[] = {"jack", "bourbon", "scotch", "rye", "cognac", "armagnac"};
uint8_t volumes1[] = {40, 35, 30, 25, 20, 15};

const char* glass2[] = {"jack", "bourbon", "scotch", "rye", "cognac", "armagnac"};
uint8_t volumes2[] = {40, 35, 30, 25, 20, 15};

const char* glass3[] = {"", "water", "milk", "cream", "coffee", "tea"};
uint8_t volumes3[] = {0, 50, 45, 40, 35, 30};

const char* glass4[] = {"gin", "vermouth", "campari", "bitters", "anisette", "chartreuse"};
uint8_t volumes4[] = {35, 30, 25, 20, 15, 10};

const char* glass5[] = {"cole", "pepsi", "sprite", "fanta", "ginger ale", "root beer"};
uint8_t volumes5[] = {30, 25, 20, 15, 10, 5};

String ingredientOnStation0 = "cola";
String ingredientOnStation1 = "rum";
String ingredientOnStation2 = "whiskey";
String ingredientOnStation3 = "vodka";
String ingredientOnStation4 = "gin";
String ingredientOnStation5 = "tonic";

//Constants
static const uint8_t StandByMode = 1;
static const uint8_t StopMode = 2;
static const uint8_t CheckMode = 3;
static const uint8_t PouringMode = 4;
static const uint8_t ServiseMode = 5;

uint8_t mode = 1;

///////// MODES /////////
bool start = false;
bool stop = false;  
bool check = false;
bool service = false;
bool standBy = true;

bool openValveOnPosition0 = false;
bool openValveOnPosition1 = false;
bool openValveOnPosition2 = false;
bool openValveOnPosition3 = false;
bool openValveOnPosition4 = false;
bool openValveOnPosition5 = false;

bool position_0_check;
bool position_1_check;
bool position_2_check;
bool position_3_check;
bool position_4_check;
bool position_5_check;
bool pouringDone;



//////////////////////////////////// FUNCTION ///////////////////////////////////////////////////

void updateValvesStatus() {

  uint8_t currentOpenValveOnPosition_0 = openValveOnPosition0;
  uint8_t currentOpenValveOnPosition_1 = openValveOnPosition1;
  uint8_t currentOpenValveOnPosition_2 = openValveOnPosition2;
  uint8_t currentOpenValveOnPosition_3 = openValveOnPosition3;
  uint8_t currentOpenValveOnPosition_4 = openValveOnPosition4;
  uint8_t currentOpenValveOnPosition_5 = openValveOnPosition5;

  openValveOnPosition0 = currentOpenValveOnPosition_5;
  openValveOnPosition1 = currentOpenValveOnPosition_0;
  openValveOnPosition2 = currentOpenValveOnPosition_1;
  openValveOnPosition3 = currentOpenValveOnPosition_2;
  openValveOnPosition4 = currentOpenValveOnPosition_3;
  openValveOnPosition5 = currentOpenValveOnPosition_4;
}


void createGlassJSON(){

  // Vytvoření dokumentu
  StaticJsonDocument<1300> doc; // Nastavení dostatečné velikosti

  // Vytvoření hlavního objektu "glasses"
  JsonObject glasses = doc.createNestedObject("glasses");

  // --- POSITION 0 ---
  JsonArray position_0 = glasses.createNestedArray("position_0");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_0.createNestedObject();
      obj["name"] = glass0[i];
      obj["volume"] = volumes0[i];
  }

  // --- POSITION 1 ---
  JsonArray position_1 = glasses.createNestedArray("position_1");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_1.createNestedObject();
      obj["name"] = glass1[i];
      obj["volume"] = volumes1[i];
  }

  // --- POSITION 2 ---
  JsonArray position_2 = glasses.createNestedArray("position_2");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_2.createNestedObject();
      obj["name"] = glass2[i];
      obj["volume"] = volumes2[i];
  }

  // --- POSITION 3 ---
  JsonArray position_3 = glasses.createNestedArray("position_3");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_3.createNestedObject();
      obj["name"] = glass3[i];
      obj["volume"] = volumes3[i];
  }

  // --- POSITION 4 ---
  JsonArray position_4 = glasses.createNestedArray("position_4");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_4.createNestedObject();
      obj["name"] = glass4[i];
      obj["volume"] = volumes4[i];
  }

  // --- POSITION 5 ---
  JsonArray position_5 = glasses.createNestedArray("position_5");
  for (uint8_t i = 0; i < 6; i++) {
      JsonObject obj = position_5.createNestedObject();
      obj["name"] = glass5[i];
      obj["volume"] = volumes5[i];
  }

  // --- Serializace a výpis JSONu ---
  serializeJson(doc, jsonStringGlass);
  Serial.println("Zpráva pro odeslání: ");
  Serial.println(jsonStringGlass);
}


void createStationJSON(){
  StaticJsonDocument<256> doc;
  JsonArray drinkOnStation = doc.createNestedArray("drinkOnStation");

  JsonObject stationObj = drinkOnStation.createNestedObject();
  stationObj["station_1"] = ingredientOnStation0;
  stationObj["station_2"] = ingredientOnStation1;
  stationObj["station_3"] = ingredientOnStation2;
  stationObj["station_4"] = ingredientOnStation3;
  stationObj["station_5"] = ingredientOnStation4;
  stationObj["station_6"] = ingredientOnStation5;

  // --- Serializace a výpis JSONu ---
  serializeJson(doc, jsonStringStation);
  Serial.println("Zpráva pro odeslání: ");
  Serial.println(jsonStringStation);
}

void createInfoJSON(){
  StaticJsonDocument<256> doc;
  JsonArray info = doc.createNestedArray("info");
  
  JsonObject infoObj = info.createNestedObject();
  infoObj["start"] = start;
  infoObj["stop"] = stop;
  infoObj["check"] = check;
  infoObj["service"] = service;
  infoObj["standBy"] = standBy;
  
  infoObj["openValveOnPosition0"] = openValveOnPosition0;
  infoObj["openValveOnPosition1"] = openValveOnPosition1;
  infoObj["openValveOnPosition2"] = openValveOnPosition2;
  infoObj["openValveOnPosition3"] = openValveOnPosition3;
  infoObj["openValveOnPosition4"] = openValveOnPosition4;
  infoObj["openValveOnPosition5"] = openValveOnPosition5;
  
  // --- Serializace a výpis JSONu ---
  serializeJson(doc, jsonStringInfo);
  Serial.println("Zpráva pro odeslání: ");
  Serial.println(jsonStringInfo);
}


void processIncommingMess(JsonObject info) {
  position_0_check = info["position_0_check"];
  position_1_check = info["position_1_check"];
  position_2_check = info["position_2_check"];
  position_3_check = info["position_3_check"];
  position_4_check = info["position_4_check"];
  position_5_check = info["position_5_check"];
  pouringDone = info["pouringDone"];

  Serial.println("Position Checks: ");
  Serial.print("Position 0: "); Serial.println(position_0_check);
  Serial.print("Position 1: "); Serial.println(position_1_check);
  Serial.print("Position 2: "); Serial.println(position_2_check);
  Serial.print("Position 3: "); Serial.println(position_3_check);
  Serial.print("Position 4: "); Serial.println(position_4_check);
  Serial.print("Position 5: "); Serial.println(position_5_check);
  Serial.print("Pouring Done: "); Serial.println(pouringDone);
}

void receiveDataFromESP32() {                 // Je třeba ošetřit buffer a čtení čerstvých zpráv only
  if (mySerial.available() > 0) {
    String receivedData = mySerial.readStringUntil('\n');
    Serial.print("Received: ");
    Serial.println(receivedData);
    Serial.println("");
    
    StaticJsonDocument<256> doc;
    DeserializationError error = deserializeJson(doc, receivedData);
    if (!error) {
      JsonObject obj = doc.as<JsonObject>();
      processIncommingMess(obj);
    } else {
      Serial.println("Failed to parse JSON");
    }
  }
}

void sentDataToESP32(String mess){

  mySerial.println(mess);

}


//////////////////////////////////// SETUP ///////////////////////////////////////////////////
void setup() {
  Serial.begin(115200);

  mySerial.begin(9600, SERIAL_8N1, 18, 17); // UART1: RX na GPIO18, TX na GPIO17
  

  Serial.println("UART RX Buffer Test - Připraven");

  xTaskCreatePinnedToCore(ReceivingTask, "Receive", 10000, NULL, 1, NULL, pro_cpu);

  xTaskCreatePinnedToCore(SendingTask, "Send", 10000, NULL, 1, NULL, app_cpu);

  vTaskDelete(NULL); //vypne loop

}


//////////////////////////////////// TASKS ///////////////////////////////////////////////////
void ReceivingTask(void *parameter) {

  Serial.print("----------------------------- ReceivingTask běží na jádru: ");
  Serial.println(xPortGetCoreID());

  while(1){

    receiveDataFromESP32();

    vTaskDelay(100 / portTICK_PERIOD_MS); // Čekání 1 sekundu
  }
}


void SendingTask(void *parameter) {

  Serial.print("----------------------------- SendingTask běží na jádru: ");
  Serial.println(xPortGetCoreID());

  while(1){

  createGlassJSON();
  sentDataToESP32(jsonStringGlass);
  delay(10000);


  createStationJSON();
  sentDataToESP32(jsonStringStation);
  delay(10000);


  createInfoJSON();
  sentDataToESP32(jsonStringInfo);
  delay(10000);

  vTaskDelay(100 / portTICK_PERIOD_MS); // Čekání 1 sekundu
  }
}

//////////////////////////////////// LOOP (NOT USED) ///////////////////////////////////////////////////
void loop() {
  // Execution should never get here
}