//********************************************************************************************************************
// 
//
// 
// 
//
//
//********************************************************************************************************************

#include <Arduino_JSON.h>
#include "painlessMesh.h"

#define   MESH_PREFIX     "ESP_Root"
#define   MESH_PASSWORD   "ESP_Root"
#define   MESH_PORT       5555

//********************************************************************************************************************
//
// O B I E K T Y
//
//********************************************************************************************************************

Scheduler userScheduler; 
painlessMesh  mesh;

JSONVar JSON_msg;

//********************************************************************************************************************
//
// P R O T O T Y P Y
//
//********************************************************************************************************************

void sendMessage(); 
void getTime();              // poproś o czas NTP z MESH-ROOT   HH:MM:SS
void getTimeHM();            // poproś o czas NTP z MESH-ROOT   HH:MM
void getDate();              // poproś o datę NTP z MESH-ROOT   DD.MM.YYYY
void getDatePL();            // poproś o datę NTP z MESH-ROOT   DD miesiac YYYY
void getRoot();              // poproś ROOT kto tu rządzi

//********************************************************************************************************************
//
//    T A S K   O B I E K T Y
//
//********************************************************************************************************************

Task taskgetTime ( TASK_SECOND * 60, TASK_FOREVER, &getTime );
Task taskgetTimeHM ( TASK_SECOND * 60, TASK_FOREVER, &getTimeHM );
Task taskgetDate ( TASK_SECOND * 90, TASK_FOREVER, &getDate );
Task taskgetDatePL ( TASK_SECOND * 90, TASK_FOREVER, &getDatePL );
Task taskgetRoot ( TASK_SECOND * 90, TASK_FOREVER, &getRoot );


//********************************************************************************************************************
//
//    S T R U K T U R Y
//
//********************************************************************************************************************

struct ZEGAR
{
    String    SformatowanyCzas    = "";     // czas HH:MM:SS
    String    SformatowanyCzasHM  = "";     // czas HH:MM
    String    SformatowanaData    = "";     // data DD.MM.RRRR
    String    SformatowanaDataPL  = "";     // data DD miesiac RRRR
}
zegar;

String root = "";

//*********************************************************************************************************************
//
//    T A S K   F U N K C J E
//
//*********************************************************************************************************************

void getTime()
{ 
    String msg;
    msg = "{\"ID\":2229645491,\"CODE\":1001}";           // msg do wysłania (kod 1001) - ządanie czasu    
    mesh.sendBroadcast( msg );                           // wyślij żądanie do serwera
    taskgetTime.setInterval( TASK_SECOND * 60 );         // wykonuj co 60 sekund
}

void getTimeHM()
{ 
    String msg;
    msg = "{\"ID\":2229645491,\"CODE\":1002}";           // msg do wysłania (kod 1002) - ządanie czasu    
    mesh.sendBroadcast( msg );                           // wyślij żądanie do serwera
    taskgetTime.setInterval( TASK_SECOND * 59 );         // wykonuj co 60 sekund
}

void getDate()
{ 
    String msg;    
    msg = "{\"ID\":2229645491,\"CODE\":1011}";           // msg do wysłania (kod 1002) - żadanie daty
    mesh.sendBroadcast( msg );                           // wyślij żądanie do serwera
    taskgetDate.setInterval( TASK_SECOND * 600 );        // wykonuj co godzinę
}

void getDatePL()
{ 
    String msg;    
    msg = "{\"ID\":2229645491,\"CODE\":1012}";           // msg do wysłania (kod 1002) - żadanie daty
    mesh.sendBroadcast( msg );                           // wyślij żądanie do serwera
    taskgetDate.setInterval( TASK_SECOND * 90 );         // wykonuj co 
}

void getRoot()
{ 
    String msg;    
    msg = "{\"ID\":2229645491,\"CODE\":0000}";           // msg do wysłania (kod 0000) - pytanie do ROOT
    mesh.sendBroadcast( msg );                           // wyślij żądanie do serwera
    taskgetDate.setInterval( TASK_SECOND * 120 );         // wykonuj co 
}




//*********************************************************************************************************************
//
//    M E S H - receiver Callback
//
//*********************************************************************************************************************

void receivedCallback( uint32_t from, String &msg ) 
{
    Serial.printf("\n[ESP] [otrzymałem od] %u [wiadomość JSON] %s", from, msg.c_str());
    
    JSON_msg = JSON.parse(msg); 
    int code = JSON_msg["CODE"];

    switch(code)
    {
        case  0000  :   root = JSON_msg["ROOT"];
                        Serial.printf("\n[ESP] [ROOT MSG] = %s", root.c_str());
                        Serial.printf(" [Moje ID] %u", from );
                        break;

        case  1001  :   zegar.SformatowanyCzas = JSON_msg["CZAS"];  
                        Serial.printf("\n[ESP] [struct ZEGAR -> zegar.SformatowanyCzas] = %s", zegar.SformatowanyCzas.c_str());
                        break;

        case  1002  :   zegar.SformatowanyCzasHM = JSON_msg["CZAS"];  
                        Serial.printf("\n[ESP] [struct ZEGAR -> zegar.SformatowanyCzas] = %s", zegar.SformatowanyCzasHM.c_str());
                        break;

        case  1011  :   zegar.SformatowanaData = JSON_msg["DATA"];  
                        Serial.printf("\n[ESP] [struct ZEGAR -> zegar.SformatowanaData] = %s", zegar.SformatowanaData.c_str());
                        break;

        case  1012  :   zegar.SformatowanaDataPL = JSON_msg["DATA"];  
                        Serial.printf("\n[ESP] [struct ZEGAR -> zegar.SformatowanaDataPL] = %s", zegar.SformatowanaDataPL.c_str());
                        break;                

        default     :   Serial.printf("\n[ESP] [otrzymałem od] %u [niezidentyfikowano] %s\n", from, msg.c_str()); break;
    }
}

//*********************************************************************************************************************
//
//    M E S H - cknewConnectionCallback
//
//*********************************************************************************************************************

void newConnectionCallback(uint32_t nodeId) 
{
    Serial.printf("\n[ESP] [Serwer ID] = %u", nodeId);
}

//*********************************************************************************************************************
//
//    M E S H - changedConnectionCallback
//
//*********************************************************************************************************************

void changedConnectionCallback() 
{
    Serial.printf("\n[ESP] zmieniam połączenie");
}

//*********************************************************************************************************************
//
//    M E S H - nodeTimeAdjustedCallback
//
//*********************************************************************************************************************

void nodeTimeAdjustedCallback(int32_t offset) 
{
    Serial.printf("\n[ESP] [Skorygowany czas] %u. Offsetowy = %d", mesh.getNodeTime(),offset);
}

//*********************************************************************************************************************
//
//    S E T U P
//
//*********************************************************************************************************************

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

    //mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); 
    //mesh.setDebugMsgTypes( ERROR | STARTUP );  

    mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT );
    mesh.onReceive(&receivedCallback);
    mesh.onNewConnection(&newConnectionCallback);
    mesh.onChangedConnections(&changedConnectionCallback);
    mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

    userScheduler.addTask( taskgetTime );
    userScheduler.addTask( taskgetTimeHM );
    userScheduler.addTask( taskgetDate );
    userScheduler.addTask( taskgetDatePL );
    userScheduler.addTask( taskgetRoot );

    taskgetTime.enable();
    taskgetTimeHM.enable();
    taskgetDate.enable();
    taskgetDatePL.enable();
    taskgetRoot.enable();
}

//*********************************************************************************************************************
//
//    L O O P
//
//*********************************************************************************************************************

void loop() 
{
    mesh.update();
}