#define TASK_SIZE_BYTES 8192u  

/* Task Handlers */
TaskHandle_t Task_C0_Init_handle = NULL;
TaskHandle_t Task_C0_handle = NULL;
TaskHandle_t Task_C1_Init_handle = NULL;
TaskHandle_t Task_AsyncEvents_C1_handle = NULL;

/* Task Counters */
static bool init_flag_C0 = false;
static bool init_flag_C1 = false;
static volatile uint64_t  cnt_C0 = 0;
static volatile uint64_t  cnt_AsyncEvents_C1 = 0;

/* Semaphores */
SemaphoreHandle_t xInitSemaphore_C0;
SemaphoreHandle_t xInitSemaphore_C1;

/* Cores */
typedef enum {
    ESP_CORE_0 = 0u,
    ESP_CORE_1
} Cores;

/* Task info struct */
typedef struct
{
    void (*taskFunction)(void*);
    const char* taskName;
    uint32_t stackSize;
    void* params;
    UBaseType_t priority;
    TaskHandle_t* handle;
    Cores core;
} TaskDefinition;

/* Tasks list */
TaskDefinition taskList[] = {
    /* Core 0 timed tasks */
    { Task_C0_Init,        "Task_C0_Init",        TASK_SIZE_BYTES, NULL, 20, &Task_C0_Init_handle,        ESP_CORE_0 },
    { Task_C0_2s,          "Task_C0",             TASK_SIZE_BYTES, NULL, 10, &Task_C0_handle,             ESP_CORE_0 },
    /* Core 1 timed tasks */
    { Task_C1_Init,        "Task_C1_Init",        TASK_SIZE_BYTES, NULL, 20, &Task_C1_Init_handle,        ESP_CORE_1 },
    /* Event driven tasks */
    { Task_AsyncEvents_C1, "Task_AsyncEvents_C1", TASK_SIZE_BYTES, NULL, 20, &Task_AsyncEvents_C1_handle, ESP_CORE_1}
};

/* Task & OS Function Prototypes */
void Task_C0_Init(void *pvParameters);
void Task_C0(void *pvParameters);
void Task_C1_Init(void *pvParameters);
void Task_AsyncEvents_C1(void *pvParameters);

void OS_CreateTask(void (*taskInterface)(void *), const char* taskName, uint32_t stackSize,
                   void* taskParams, UBaseType_t priority, TaskHandle_t* taskHandler, Cores core);
void OS_ValidateTaskCreation(BaseType_t xReturned, const char* taskName);
void OS_InitOS();





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

void loop() 
{
    // put your main code here, to run repeatedly:
    delay(10); // this speeds up the simulation
}


/* ----- Task interfaces ----- */
void Task_C0_Init(void *pvParameters)
{

}

void Task_C0(void *pvParameters)
{

}

void Task_C1_Init(void *pvParameters)
{

}

void Task_AsyncEvents_C1(void *pvParameters)
{

}

/* ----- OS functions ----- */


/*
 *  OS_CreateTask: Wrapper to xTaskCreatePinnedToCore
 */
void OS_CreateTask(void (*taskInterface)(void *),
                   const char* taskName,
                   uint32_t stackSize,
                   void* taskParams,
                   UBaseType_t priority,
                   TaskHandle_t* taskHandler,
                   Cores core)
{
    /* Set initial flag to false */
    BaseType_t xReturned = pdFAIL;

    /* Create task */
    xReturned = xTaskCreatePinnedToCore(
          taskInterface,
          taskName,
          stackSize,
          taskParams,
          priority,
          taskHandler,
          static_cast<BaseType_t>(core)
    )

    /* Task created successfully */
    if (xReturned == pdPASS) break;  

}

/*
 *  OS_InitOS: Creates task semaphores and tasks
 */
void OS_InitOS()
{
      /* Create semaphore for core 0 */
      xInitSemaphore_C0 = xSemaphoreCreateBinary();
      if (xInitSemaphore_C0 == NULL)
      {
          while(1);
      }

      /* Create semaphore for core 1 */
      xInitSemaphore_C1 = xSemaphoreCreateBinary();
      if (xInitSemaphore_C1 == NULL)
      {
          while(1);
      }

      /* Create tasks */
      const uint8_t numTasks = sizeof(taskList) / sizeof(taskList[0]);
      for (uint8_t i = 0; i < numTasks; ++i)
      {
          OS_CreateTasks(taskList[i].taskFunction,
                        taskList[i].taskName,
                        taskList[i].stackSize,
                        taskList[i].params,
                        taskList[i].priority,
                        taskList[i].handle,
                        taskList[i].core);
      }

}