//https://microcontrollerslab.com/esp32-spi-communication-tutorial-arduino/

#include <WiFi.h>
#include "ESP32DMASPISlave.h"
#include <Adafruit_NeoPixel.h> 
//#include <esp32-hal-timer.h>
#define PIN 38 // ESP32-C3 built-in RGB led
//#define LED 2 // ESP32-C3 built-in RGB led

#define NUMPIXELS 1
Adafruit_NeoPixel pixels (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
#define DELAYVAL 500
//Wemos LoLIN32
//#define DSIGNAL 22  //CS3
//ESP32S3 Dev Modul
//#define DSIGNAL 4 //CS3
//ESP32S3 XIAO
//https://wiki.seeedstudio.com/xiao_esp32s3_getting_started/
// GPIO4==4 vagy D3==4 
#define DSIGNAL 4 //CS3

ESP32DMASPI::Slave slave;
uint8_t* spi_slave_tx_buf;
uint8_t* spi_slave_rx_buf;

uint8_t* temp_spi_slave_tx_buf;
uint8_t* temp_spi_slave_rx_buf;

uint8_t flag_SS=0;
int flagtrans = 0;
int StateMachine=0;
int prevStateMachine=0;

hw_timer_t *timer = NULL;

enum Read_Status
{
    Read_DataFromPIC=0x00,
    Read_DataFromPC,
    Read_PC_OK,
    Read_PC_NOK,
    Read_PIC_OK,
    Read_PIC_NOK,
    Read_EMPTY=0xFF
};
enum CMD_Status
{
    CMD_OK=0x01,
    CMD_NOK=0x02,
    CMD_ESPStat=0x09,
    CMD_EMPTY=0xFF
};


/*
//ESP32S3 Dev Modul
//4MByte extFlash
//8MByte IRAM
  #define DSIGNAL 4 //CS3
  printf("SS:%d,\n",SS);     //10
  printf("MISO:%d,\n",MISO); //13
  printf("MOSI:%d,\n",MOSI); //11
  printf("SCK:%d,\n",SCK);   //12
  //Wemos LoLIN32
  #define LED 2
  #define DSIGNAL 22  //CS3
  printf("SS:%d,\n",SS);     //5
  printf("MISO:%d,\n",MISO); //19
  printf("MOSI:%d,\n",MOSI); //23
  printf("SCK:%d,\n",SCK);   //18

  XIAO_ESP32S3
   
   MOSI: 9  arduino->D10
   MISO: 8  arduino->D9
   SCK: 7   arduino->D8
   SS: 44   arduino->D7
*/
byte debug=0;

const char *ssid = "TP-Link_7D0E";
const char *password = "75211301";
const char *host = "192.168.0.100";
const int port = 12345;
IPAddress local_IP(192, 168, 0, 102); //static client IP address
// Set your Gateway IP address
IPAddress gateway(192, 168, 0, 1);
IPAddress subnet(255, 255, 255, 0);
static const uint32_t BUFFER_SIZE = 4108; //8192; //4108//-2048;
bool oksflag=true;
bool alloksflag=false;
bool buffer_empty=true;
byte popflag=0;
byte globlalC=0;
byte HIGHFLag=0;
int InterruptSPI=0;
uint32_t datalength=0;
uint32_t offset=0;
uint32_t preoffset=4;
static const uint32_t FromPC40K_SIZE = 4108*18; 
uint8_t FromPC40K[FromPC40K_SIZE]; 
uint8_t FromBigData4K[4108];

unsigned long previousMillis100 = 0;
unsigned long previousMillis1000 = 0;
unsigned long timetemp = 0;
const long interval100 = 5;   // 100 milliszekundum
const long interval1000 = 1000; // 1000 milliszekundum
unsigned long currentMillis = millis();

bool flag_ReadFromServer = false;
bool flag_ReconnectedToServer = false;
bool flag_ReadFromSerial = false;
bool flag_Pck_CHK=false;
bool flag_SPICommand=false;
bool flag_NextData=false;
bool DataFromPIC=false;
bool flag_inpost=false;


//#define SPI_DEVICE_HALFDUPLEX      (1<<4)  
WiFiClient client;
void OKSn()
{
  String ok = "*OKn*";
        if (client.connected()) {
            client.println(ok);
        }
  Serial.print("*OK*number\n");
}
void OKS()
{
  String ok = "*OK*";
    if (client.connected()) 
    {
      client.println(ok);
    }
  Serial.print("*OK*\n");
}
void NOKS()
{
    String Nok = "*NOK*";
    if (client.connected()) 
    {
      client.println(Nok);
    }
  Serial.print("*NOK*\n");
}
void NOKS2()
{
    String Nok = "*NOK2*";
    if (client.connected()) 
    {
      client.println(Nok);
      SendSPISignalLOW();
      SendSPISignalHIGH();
    }
  Serial.print("*NOK2*\n");
}
void ping(){
  //Szerver bemutatkozása, így folyamatosan látja hogy ha csatlakozik hozzá
  {
    String ok = "Name:ESP_NEW_3";
    if (client.connected()) 
    {
      client.println(ok);

    }
  }
  Serial.println("PING");
}
void set_buffer() {
 /* for (uint32_t i = 0; i < BUFFER_SIZE; i++) 
  {
    spi_slave_tx_buf[i] = (0xFF - i) & 0xFF;
  }*/
  memset(spi_slave_rx_buf, 0xFF, BUFFER_SIZE);
  memset(spi_slave_tx_buf, 0xFF, BUFFER_SIZE);
  memset(temp_spi_slave_rx_buf, 0xFF, BUFFER_SIZE);
  memset(temp_spi_slave_tx_buf, 0xFF, BUFFER_SIZE);

}
void SendSPISignalLOW(){
  digitalWrite(DSIGNAL,LOW);
  //digitalWrite(LED,LOW);
  LED(2,20,2);
}
void SendSPISignalHIGH(){
  digitalWrite(DSIGNAL,HIGH);
  digitalWrite(DSIGNAL,HIGH);
  LED(2,2,20);
}
//uint16_t C_SUM(uint8_t *inputArray, int lenght)
uint16_t C_SUM(String data)  //IRAM_ATTR
{
   //uint16_t inputlenght=((uint16_t)((uint16_t)inputArray[0]<<8)&0xFF00)|(inputArray[1]&0xFF);
   //uint16_t 
   
    //uint8_t inputArray[data.length()*2];
 
     memset(&FromPC40K[0],0xff,FromPC40K_SIZE);
   // memcpy(&inputArray[0],data.c_str(), data.length()-2);//BUFFER_SIZE);//);//udpsize);
    memcpy(&FromPC40K[0],data.c_str(), data.length()-2);//BUFFER_SIZE);//);//udpsize);
   // Serial.println("C_Sum");
   uint16_t inputlenght=FromPC40K[1];
   inputlenght=inputlenght<<8;
   inputlenght=inputlenght|FromPC40K[0];
   if(data.length()>2 && data.length()>=(inputlenght+2))
   {
   uint16_t temp=0;
   //uint16_t judgeX=((uint16_t)((uint16_t)inputArray[inputlenght]<<8)&0xFF00)|(inputArray[inputlenght+1]&0xFF);  
   //uint16_t 
   uint16_t judgeX=FromPC40K[inputlenght+1];
  /* Serial.println("judgeX_0:");
   Serial.println(judgeX);
   Serial.println("judgeX_1:");
   Serial.println(FromPC40K[inputlenght]); */
   judgeX=judgeX<<8;
   judgeX=judgeX|FromPC40K[inputlenght];
   // Serial.println("judgeX:");
   //Serial.println(judgeX); 
        for(uint16_t i=0;i<inputlenght;i++) 
        {
                temp+=FromPC40K[i];

        }
        if((judgeX-temp)==0)
        Serial.println(" FromPC40K_ISOK");
        else
        Serial.println(" FromPC40K_ISNOK");
        return judgeX-temp;
    }
    else
    {
        
        return 1;
    }

}
void  ReadFromServer(){  //IRAM_ATTR
  // Serial.println("\nReadFromServer");
  timetemp=millis();
//Read from server and send to Serial or SPIslave
//int availableBytes = client.available();
  if(client.available())//availableBytes>0) //() 
  {
   //byte buffer[availableBytes];
    //client.read(buffer, availableBytes);
    String data = client.readString();//client.readStringUntil('\n');
    /* for(int i=0; i<data.length();i++)
    Serial.print(data[i],HEX);
    Serial.println();*/
    //if(memcmp(buffer,"*RST*", 5)==0)/
    if(data=="*RST*")
    {
      Serial.println("\nRESET!!!!!!!!!!!!!!!!!!");
      ESP.restart();
    }
    //if(memcmp(buffer,"*hello*", 7)==0)//
    if(data=="*hello*")
    {
      ping();
      SendSPISignalHIGH();
      alloksflag=true;
      globlalC=0;
      oksflag=true;
      buffer_empty=true;
      flag_inpost=false;
      set_buffer();
    }
    else
    {
        //Serial.println("\n1");
        //Serial.print("->>BigData:");
        //Serial.println(data);
        
       
        if(C_SUM(data)==0)// && data.length()>2)
        {
            
            // memset(&temp_spi_slave_tx_buf[0],0xff,BUFFER_SIZE);
            // memcpy(&temp_spi_slave_tx_buf[0],data.c_str(), data.length());//BUFFER_SIZE);//);//udpsize);
           
           //In----> C-SUM
           // memset(&FromPC40K[0],0xff,FromPC40K_SIZE);
            //memcpy(&FromPC40K[0],data.c_str(), data.length()-2);//BUFFER_SIZE);//);//udpsize);
         
            // for(int i;i<data.length();i++)
            // {
            //     Serial.printf("%c",temp_spi_slave_tx_buf[i]);
            // }
            // Serial.println();
            //flag_ReadFromServer=true;
            offset=0;
            preoffset=4;
            flag_NextData=true;
            datalength=data.length()-8;
            //temp_spi_slave_tx_buf[BUFFER_SIZE-2]=0x0D;
            //temp_spi_slave_tx_buf[BUFFER_SIZE-1]=0x0A;
            
        }
        else
        {
            Serial.printf("Nem jo/nem vart packettek\n");
            NOKS();
        }
       
         
          // memcpy(&FromPC40K[0],&buffer[0],BUFFER_SIZE);//
           
           
    }
    Serial.printf("\nData15*4108byte :%d ms\n",millis()-timetemp);
    //return 1;
  }
  else
  {
    ;
    }
    //return 0;
}
void ReconnectedToServer()
{
// Reconnect to server if needed
  if (!client.connected()) 
  {
    Serial.println("Connecting to server...");
    if (client.connect(host, port)) 
    {
      Serial.println("Connected to server");
    }
    else 
    {
      Serial.println("Connection failed");
    }
  }
}

void ReadFromSerial()
{
  // Read from Serial and send to server
  if (Serial.available()) 
  {
    if (client.connected()) 
    {
      String data = Serial.readString();
      if(data[0]=='1')
      {
        SendSPISignalHIGH();
   
         flag_ReadFromServer=false;
                flag_inpost=true;
      } 
      if(data[0]=='0')
      {
        SendSPISignalLOW();
        alloksflag=false;
      }
      client.println(data); 
      OKS(); 
    }
  }
}

void LED(byte R, byte B, byte G)
{
  pixels.begin();
  pixels.clear();
  for(int i=0; i<NUMPIXELS; i++) 
  {
    pixels.setPixelColor(i, pixels.Color (R, B, G));
    pixels.show();
    
  }
}
void SlaveRemained()
{
     if (slave.remained() == 0) {
        //Serial.printf("SPIremainned\n");
       /* spi_slave_tx_buf[167]++;
        spi_slave_tx_buf[170]++;
        spi_slave_tx_buf[171]++;
        spi_slave_tx_buf[172]++;*/
        //slave.queue(spi_slave_rx_buf,spi_slave_tx_buf, BUFFER_SIZE);
        slave.queue(&spi_slave_rx_buf[0],&spi_slave_tx_buf[0], BUFFER_SIZE);
        // Serial.println("SPIrm");
   }
}

bool SPICommand()
{
    //slave.wait(spi_slave_rx_buf, spi_slave_tx_buf, BUFFER_SIZE);
    //SlaveRemained();
    while (slave.available())   //slave.available()) 
    {
   
    //Serial.printf("SPIAvailable\n");
    // show received data
    /*Serial.printf("\n------------------------------\n");
    
     for (size_t i = 0; i < 4108; ++i) {
         printf("%c", spi_slave_tx_buf[i]);
     }
     printf("\n");

    Serial.printf("\n------------------------------\n");*/
    //SendSPISignalHIGH();
      
       memcpy(&temp_spi_slave_rx_buf[0],&spi_slave_rx_buf[0],BUFFER_SIZE);
     
       slave.pop();
      flag_SPICommand=true; 
       // Serial.println("SPIFlag");
    return 1;
    }
  return 0;
}
void setup(){
  Serial.begin(115200);//(256000);
  //pinMode(LED,OUTPUT);
  LED(10,5,2);
  pinMode(DSIGNAL,OUTPUT);
  pinMode(SS,INPUT);
  // to use DMA buffer, use these methods to allocate buffer
  spi_slave_tx_buf = slave.allocDMABuffer(BUFFER_SIZE);
  spi_slave_rx_buf = slave.allocDMABuffer(BUFFER_SIZE);
  temp_spi_slave_tx_buf = slave.allocDMABuffer(BUFFER_SIZE);
  temp_spi_slave_rx_buf = slave.allocDMABuffer(BUFFER_SIZE);
  set_buffer();
  delay(500);
  

    Serial.print("MOSI: ");
  Serial.println(MOSI);
  Serial.print("MISO: ");
  Serial.println(MISO);
  Serial.print("SCK: ");
  Serial.println(SCK);
  Serial.print("SS: ");
  Serial.println(SS);  
  Serial.println();
  Serial.println();
  Serial.println();
  //slave device configuration
  slave.setDataMode(SPI_MODE1);
  slave.setMaxTransferSize(BUFFER_SIZE);
  slave.begin(HSPI);  //ESP32S3-> HSPI Wemos VSPI
  // Connect to Wi-Fi
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  WiFi.setAutoReconnect(true);
  WiFi.config(local_IP,gateway,subnet);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  SendSPISignalHIGH();

}
/*enum Read_Status
{  
    Read_DataFromPIC=0x00,
    Read_DataFromPC,
    Read_PC_OK,
    Read_PC_NOK,
    Read_PIC_OK,
    Read_PIC_NOK,
    Read_EMPTY=0xFF
};


}*/
uint16_t C_SUM2(uint8_t *inputArray)
{
   //uint16_t inputlenght=((uint16_t)((uint16_t)inputArray[0]<<8)&0xFF00)|(inputArray[1]&0xFF);
   uint16_t inputlenght=inputArray[1];
   inputlenght=inputlenght<<8;
   inputlenght=inputlenght|inputArray[0];
   uint16_t temp=0;
   //uint16_t judgeX=((uint16_t)((uint16_t)inputArray[inputlenght]<<8)&0xFF00)|(inputArray[inputlenght+1]&0xFF);  
   uint16_t judgeX=inputArray[inputlenght+1];
   /*Serial.println("judgeX2_0:");
   Serial.println(judgeX);
   Serial.println("judgeX2_1:");
   Serial.println(inputArray[inputlenght]); */
   judgeX=judgeX<<8;
   judgeX=judgeX|inputArray[inputlenght];
   for(uint16_t i=0;i<inputlenght;i++)
   {
        temp+=inputArray[i];
   }

   return judgeX-temp;
}
void PCDataCommand()
{
    
            if(flag_NextData==true)
            {
               // Serial.println("flag_NextData=true!!!!!!!!!!!!!!!!!!:");

            if(datalength!=preoffset)//availableBytes>=preoffset)//
            {
              // Serial.println("datalength=preoffset!!!!!!!!!!!!!!!!!!:");
                //kiszedni a csomag hosszát
                offset=FromPC40K[preoffset]|(FromPC40K[preoffset+1])<<8;
             //   Serial.println("offset:");
             //   Serial.println(offset);
             //   Serial.println("preoffset:");
             //   Serial.println(preoffset);
                memset(&temp_spi_slave_tx_buf[0],0xFF,4106);
                memcpy(&temp_spi_slave_tx_buf[0],&FromPC40K[preoffset],offset+2);//4106);
                
               
                preoffset+=(offset+2);
            //    Serial.println("4Kdata:");
                
                if(C_SUM2(&temp_spi_slave_tx_buf[0])==0)
                   Serial.println("4K ok");
                else 
                   Serial.println("4K Nok");
                /*Serial.print("***");
                   
                for(int i=0;i<offset+2;i++)
                {
                   
                   Serial.printf("%c",temp_spi_slave_tx_buf[i]);
                }
                Serial.println("***");*/
                //Serial.print("AvailableBytes:");
                //Serial.println(availableBytes);
               
               flag_ReadFromServer=true;
               flag_NextData=false;
               
            }
            else
            {
                Serial.println("ElseAga_Idebelep!!!!!!!!!!!!!!!!!!:");
            }
            }
          

}
void IRAM_ATTR callFunctionStateMaschine()
{
   switch (StateMachine){
        case Read_DataFromPIC:
        {
            //SPICommand();
           
            if(flag_SPICommand==true){
                if(temp_spi_slave_rx_buf[0]==CMD_EMPTY && temp_spi_slave_rx_buf[1]==CMD_EMPTY && temp_spi_slave_rx_buf[2]==CMD_EMPTY)
                {
                     //Olvasás volt az ESP32-->PIC32
                        if(debug)Serial.printf("CMD_Olvasas a PIC-tol:\r\n");
                        /* for (size_t i = 0; i < 4108; ++i) 
                        {
                        printf("%c_", spi_slave_tx_buf[i]);
                        }
                        printf("\n");*/
                        //memcpy(&spi_slave_tx_buf[0],&temp_spi_slave_tx_buf[0],BUFFER_SIZE);  
                        SendSPISignalHIGH();
                        SlaveRemained();
                }
                else
                {
                switch(temp_spi_slave_rx_buf[2])
                    {
                         case CMD_ESPStat:
                        {
                            switch (spi_slave_rx_buf[3]){
                                case CMD_OK:{
                                // memset(&spi_slave_rx_buf[0],0xFF,BUFFER_SIZE);
                                    if(debug)Serial.printf("CMD:CMD_Status_OK\r\n");
                                    StateMachine= Read_PIC_OK;
                                   if(datalength<=preoffset)
                                   {
                                   
                                    if(debug)Serial.printf("CMD_ESPStat:datalength<=preoffset:OK\r\n");    
                                    datalength=0;
                                     OKS();
                                   }
                                   else
                                   {
                                    flag_NextData=true;
                                    if(debug)Serial.printf("CMD_ESPStat:datalength<=preoffset:OKnnnnnn\r\n"); 
                                   // OKSn();
                                   }
                                }break;  
                            case CMD_NOK:{
                                    NOKS();
                                    // memset(&spi_slave_rx_buf[0],0xFF,BUFFER_SIZE);
                                    // memcpy(&spi_slave_tx_buf[0],&temp_spi_slave_tx_buf[0],BUFFER_SIZE);
                                    if(debug)Serial.printf("CMD:CMD_Status_NOK\r\n");
                                     memcpy(&spi_slave_tx_buf[0],&temp_spi_slave_tx_buf[0],BUFFER_SIZE);//);//udpsize)
                                    SlaveRemained();
                                    SendSPISignalLOW();
                                    flag_inpost=false;
                                }break;
                            default:
                            {
                                if(debug)Serial.printf("CMD:CMD_Status_CMD_default\r\n");
                                //SendSPISignalHIGH();
                                //SendSPISignalLOW();
                            }
                        //SendSPISignalHIGH();
                            }
                     flag_inpost=false;
                        
                //PIC32 küldött adatot/valamit
                        }
                    default:
                        {
                        if(debug)
                        {
                            Serial.printf("CMD_Iras a PIC-tol:\r\n");
                            for (size_t i = 0; i < 8; ++i) 
                            {
                                printf("%d_", temp_spi_slave_rx_buf[i]);
                            }
                        }
                        }
                    }
                }
                flag_SPICommand=false;
                SendSPISignalHIGH();
               
                StateMachine=Read_DataFromPC;
                if(debug)Serial.printf("callFunctionStateMaschine:Read_DataFromPIC:\r\n");    
                
            }
            else
            {
               // Serial.println("FromPIC");
                StateMachine=Read_DataFromPC;
                delay(10);
            }
 
    case Read_DataFromPC:{
            //ReadFromServer();
             PCDataCommand();
            if(flag_ReadFromServer && flag_inpost==false)
            {
                if(debug)Serial.printf("callFunctionStateMaschine:Read_DataFromPC:\r\n");
                
                memcpy(&spi_slave_tx_buf[0],&temp_spi_slave_tx_buf[0],BUFFER_SIZE);//);//udpsize)
                SlaveRemained();
                flag_ReadFromServer=false;
                flag_inpost=true;
                StateMachine=Read_DataFromPIC;
                SendSPISignalLOW();
        
              
            }
            else
            {
               // Serial.println("FromPC");
                StateMachine=Read_DataFromPIC;
                delay(10);
            }
        }break;
    case Read_PIC_OK:{
            //ReadFromServer();
            OKS();
                StateMachine=Read_DataFromPC;
                flag_inpost=false;
        }break;
    case Read_PIC_NOK:{
            //ReadFromServer();
                NOKS();
                SendSPISignalLOW();
        Serial.println("Read_PIC_NOK");
                flag_inpost=true;
                StateMachine=Read_DataFromPIC;
        }break;
    default:{
       if(debug)Serial.printf("callFunctionStateMaschine:default\r\n");
    }
  }
  /*if(prevStateMachine!=StateMachine)
  {
    if(debug)Serial.printf("StateMachine:_%d_ \r\n",StateMachine);
    prevStateMachine=StateMachine;
  }*/
}
}
void callFunction100(){
  if (currentMillis - previousMillis100 >= interval100){


 
    callFunctionStateMaschine();   

   
    previousMillis100 = currentMillis;
  }
}
void callFunction1000()
{
  if (currentMillis - previousMillis1000 >= interval1000) 
  {
   
   ReconnectedToServer();
    ReadFromSerial();
 
    previousMillis1000 = currentMillis;
  }
}

void loop(){
    callFunction100();
    callFunction1000();
     
    ReadFromServer();
    SPICommand();
  currentMillis = millis();
}