//+------------------------------------------------------------------+
//|                                                      Reciber.mqh |
//|                                   Copyright 2026,Niquel Mendoza. |
//|                          https://www.mql5.com/en/users/nique_372 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026,Niquel Mendoza."
#property link      "https://www.mql5.com/en/users/nique_372"
#property strict

#ifndef AIDATATASKRUNNER_BACKEND_API_API_MQH
#define AIDATATASKRUNNER_BACKEND_API_API_MQH


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "Protocol\\Def.mqh"

//--- Frontend:
// Generacion de datos (aqui tambien va el backend pero como interfaz)
#include "..\\..\\UI\\DataGenerationTab\\Base.mqh"

//---
//#define AIDATATASKRUNER_API_DEBUG


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// Esta clase se encarga de procesar las llamadas que se le hacen
// Aplicarlas y sincronizar el frontend
class CAiDataTaskRunnerApiReciber : public CLoggerBase
 {
private:
  ITaskRunerAi*      m_backend;
  CTaskRunerAiTabDGenMain* m_fronted;
  const long         m_chart_id;

public:
                     CAiDataTaskRunnerApiReciber(void) : m_chart_id(ChartID()) {}
                    ~CAiDataTaskRunnerApiReciber(void) {}

  //---
  void               SetDataGeneration(ITaskRunerAi* backend, CTaskRunerAiTabDGenMain* fronted);
  bool               Init();
  void               Deinit();


  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam);
 };


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CAiDataTaskRunnerApiReciber::Init()
 {
  const string file_name = AIDATATASKRUNER_API_GLOBAL_IDS_FOLDER + ::StringFormat("%I64d.bin", m_chart_id);
  ::ResetLastError();
  const int fh = FileOpen(file_name, FILE_WRITE | FILE_BIN);
  if(fh == INVALID_HANDLE)
   {
    LogError(StringFormat("Fallo al registrar chart id = %I64d, err=%d", m_chart_id, ::GetLastError()), FUNCION_ACTUAL);
    return false;
   }
  FileClose(fh);
  return true;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAiDataTaskRunnerApiReciber::Deinit()
 {
  const string file_name = AIDATATASKRUNER_API_GLOBAL_IDS_FOLDER + StringFormat("%I64d.bin", m_chart_id);
  FileDelete(file_name);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAiDataTaskRunnerApiReciber::SetDataGeneration(ITaskRunerAi* backend, CTaskRunerAiTabDGenMain* fronted)
 {
  m_backend = backend;
  m_fronted = fronted;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAiDataTaskRunnerApiReciber::ChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
 {
//---
  if(id == CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
   {
    //---
    // De entrada: (api recibe datos)
    // lparam= Chart id de donde se envia (de que chart id se envia)
    // dparam= Id del evento (como id de la funcion) que se desea correr
    // sparam= IdCall\"Parametros

    //---
    // De salida: (api responde al que le envio datos)
    // lparam=evento respondiido
    // dparam=fallo\exito
    // sparam=info (empaquetada)

    //---
#ifdef AIDATATASKRUNER_API_DEBUG
    PRINT_EVENT(h, id, lparam, dparam, sparam)
#endif // AIDATATASKRUNER_API_DEBUG

    //---
    const uint8_t event_id = uint8_t(dparam);

    //---
    static string id_call, val;
    if(!AiDataTaskRunnerDesempaquetar(sparam, id_call, val))
     {
      LogError("Formato invalido de empauqetacion de api (val recibido de tlgm)", FUNCION_ACTUAL);
      return;
     }

    //---
    switch(event_id)
     {
      case 0: // AIDATATASKRUNER_API_ADD_TASK_TO_TABLE
       {
        //---
        static string arr[TASKTESTER_VALUES];
        if(StringSplit(val, AIDATATASKRUNER_API_SEPARATOR_PARAM, arr) != TASKTESTER_VALUES)
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_ADD_TASK_TO_TABLE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, "Invalid format"));
          return;
         }

        //---
        static TaskTester task;
        task.Assing(arr);
        const bool ok = m_backend.AddDirectTask(task);

        //---
        if(ok)
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_ADD_TASK_TO_TABLE
                             , AIDATATASKRUNER_API_RES_EXITO, AiDataTaskRunnerEmpaquetar(id_call, "Task added successfully"));
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_ADD_TASK_TO_TABLE,
                             AIDATATASKRUNER_API_RES_FALLO, AiDataTaskRunnerEmpaquetar(id_call, m_backend.m_last_error_msg));
         }


        //---
        break;
       }

      //---
      case 1: // AIDATATASKRUNER_API_SAVE_TASK_IN_FILE
       {
        //---
        static string arr[2];
        if(StringSplit(val, AIDATATASKRUNER_API_SEPARATOR_PARAM, arr) != 2)
         {
          LogError("Fallo al parsear val, para añadir nueva tarea, formato invalido\nse debe de separar con | y en los valores no tener el carcter |", FUNCION_ACTUAL);
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_SAVE_TASK_IN_FILE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, "Invalid format, use | for separate bool parameter and file name"));
          return;
         }


        //---
        if(!m_backend.SaveAllTaskInFile(arr[1], bool(int(arr[0])))) // Añadimos internamente
         {
          const string str = StringFormat("Failed to save tasks to file = %s, last error:\n%s", val, m_backend.m_last_error_msg);
          LogError(str, FUNCION_ACTUAL);
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_SAVE_TASK_IN_FILE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, str));
          return;
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_SAVE_TASK_IN_FILE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Successfully saving all tasks to file %s, in %s base folder", arr[1])));
         }

        //---
        break;
       }


      //---
      case 2: // AIDATATASKRUNER_API_LOAD_TASK_IN_FILE
       {
        //---
        if(!m_backend.SetTastByFile(val)) // Añadimos internamente
         {
          const string str = StringFormat("Failed to load tasks from file = %s", val);
          LogError(str, FUNCION_ACTUAL);
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_LOAD_TASK_IN_FILE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, str));
         }
        else
         {
          m_fronted.SincronizeFrontendOfBackend(TASKRUNERAIDGENMAIN_FLAG_TABLE); // sincronizamos la tabla con los elementos del backend
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_LOAD_TASK_IN_FILE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, "Tasks loaded successfully"));
         }

        //---
        break;
       }

      //---
      case 3: // AIDATATASKRUNER_API_TASK_TOTAL
       {
        //---
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_TASK_TOTAL, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, string(m_backend.TaskSize())));

        //---
        break;
       }

      //---
      case 4: // AIDATATASKRUNER_API_GET_TASK_BY_INDEX
       {
        //---
        const int index = int(val);
        if(index < 0 || index >= m_backend.TaskSize())
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_GET_TASK_BY_INDEX,
                             AIDATATASKRUNER_API_RES_FALLO, AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Invalid index acces = %d ", index)));
          break;
         }

        //---
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_GET_TASK_BY_INDEX, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, string(m_backend.GetTaskByIndex(index).ToStringFile())));

        //---
        break;
       }

      case 5: // AIDATATASKRUNER_API_CLEAN_ALL_TASK_OF_TABLE
       {
        const bool ok = m_fronted.CleanAllTask();
        if(ok)
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_CLEAN_ALL_TASK_OF_TABLE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, "All tasks cleaned"));
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_CLEAN_ALL_TASK_OF_TABLE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, "No tasks to clean"));
         }
        break;
       }

      case 6: // AIDATATASKRUNER_API_EXECUTE_ALL_TASK_OF_TABLE
       {
        int arr[];
        const bool ok = m_fronted.RunAllTask(arr);
        if(ok)
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_EXECUTE_ALL_TASK_OF_TABLE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Task run: [%s]", ArrayToString(arr, ","))));
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_EXECUTE_ALL_TASK_OF_TABLE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, "No pending tasks"));
         }
        break;
       }

      //---
      case 7: // AIDATATASKRUNER_API_LOAD_CONFIG_IN_FILE
       {
        const bool ok = m_backend.LoadConfig(val);
        if(ok)
         {
          m_fronted.SincronizeFrontendOfBackend(TASKRUNERAIDGENMAIN_FLAG_CONFIG);
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_LOAD_CONFIG_IN_FILE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, "Config loaded successfully"));
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_LOAD_CONFIG_IN_FILE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Failed: %s", m_backend.m_last_error_msg)));
         }
        break;
       }

      //---
      case 8: // AIDATATASKRUNER_API_SAVE_CONFIG_IN_FILE
       {
        const bool ok = m_backend.SaveConfig(val);
        if(ok)
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_SAVE_CONFIG_IN_FILE, AIDATATASKRUNER_API_RES_EXITO,
                             AiDataTaskRunnerEmpaquetar(id_call, "Config saved successfully"));
         }
        else
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                             AIDATATASKRUNER_API_SAVE_CONFIG_IN_FILE, AIDATATASKRUNER_API_RES_FALLO,
                             AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Failed: %s", m_backend.m_last_error_msg)));
         }
        break;
       }

      //---
      case 9: // AIDATATASKRUNER_API_MAIN_FOLDER
       {
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_MAIN_FOLDER, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, AIDATATASKRUNER_BASE_FOLDER));
        break;
       }

      //---
      case 10: // AIDATATASKRUNER_API_TASK_FOLDER
       {
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_TASK_FOLDER, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, AIDATATASKRUNER_PATH_TASK));
        break;
       }

      //---
      case 11: // AIDATATASKRUNER_API_IS_IN_COMMON_FOLDER
       {
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_IS_IN_COMMON_FOLDER, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, g_aidatatask_runner_config_g.comon_flag ? "1" : "0"));
        break;
       }

      //---
      case AIDATATASKRUNER_API_GET_TASK_STATUS:
       {
        //---
        const int index = int(val);
        if(index < 0 || index >= m_backend.TaskSize())
         {
          ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_GET_TASK_STATUS,
                             AIDATATASKRUNER_API_RES_FALLO, AiDataTaskRunnerEmpaquetar(id_call, StringFormat("Invalid index acces = %d ", index)));
          break;
         }

        //---
        ::EventChartCustom(lparam, AIDATATASKRUNER_API_ON_PARAM_CHANGE, AIDATATASKRUNER_API_GET_TASK_STATUS, AIDATATASKRUNER_API_RES_EXITO,
                           AiDataTaskRunnerEmpaquetar(id_call, string(int(m_backend.GetTaskStatus(index)))));

        break;
       }

      //---
      default:
        break;
     }
   }
 }
//+------------------------------------------------------------------+
#endif // AIDATATASKRUNNER_BACKEND_API_API_MQH