#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"
#include "murax.h"

#include <cstddef>

#include <initializer_list>
#include <cstdio>

#define mainTIMER_PERIOD_MS (1 / portTICK_PERIOD_MS) // Ustawienie okresu timera na 1 sekundę
#define QUEUE_LENGTH 5
#define QUEUE_ITEM_SIZE sizeof(uint32_t)

extern "C" {
    void vApplicationMallocFailedHook(void);
    void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName);
}

/*-----------------------------------------------------------*/

// Deklaracja funkcji dla zadania i callbacku timera
static void hungryTask(void *pvParameters);
static void timerCallback(TimerHandle_t xTimer);

// Globalna kolejka
static QueueHandle_t xQueue;

/*-----------------------------------------------------------*/



// Modern C++ aproach
// ---
class TimeR {

public:
    static inline  uint32_t readValue() {
        return ptr->VALUE;
    }

private:
        static const Timer_Reg* ptr ;
};

const Timer_Reg* TimeR::ptr = reinterpret_cast<const Timer_Reg*>(0xF0020040);


void test (std::initializer_list<int> vals) {
    int  buffer[50];

    for (auto p = vals.begin(); p != vals.end(); ++p) {

        int * i = buffer;
        *i++ = *p;
        //        sprintf(buffer, "%d\n", *p);
        // printf("%s", buffer);
    }

}

#include <vector>

int main(void) {

std::vector<int> numbers;

    // Dodawanie elementów do wektora
    for (int i = 0; i < 10; ++i) {
        numbers.push_back(i);
    }

    // Wypisywanie elementów wektora
    char buffer[100];
    sprintf(buffer, "Elements in the vector: ");

    for (int number : numbers) {
        sprintf(buffer, "%d ", number);
    }
    sprintf(buffer, "\n");

    test({1,2,3,4,5});
    
	xQueue = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); // Tworzenie kolejki
    if (xQueue == NULL) {
        return -1; // Błąd podczas tworzenia kolejki
    }

    TimerHandle_t xCheckTimer = NULL;

   /*
    // Inicjalizacja timera
    xCheckTimer = xTimerCreate("CheckTimer",
                               mainTIMER_PERIOD_MS,
                               pdTRUE,
                               (void *)0,
                               timerCallback);
    */

    // Start timera
    if (xCheckTimer != NULL) {
        xTimerStart(xCheckTimer, 0);
    }

    // Tworzenie zadania hungryTask
    xTaskCreate(hungryTask, "Hungry Task", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);

    // Uruchomienie planisty
    vTaskStartScheduler();

    // Teoretycznie nigdy nie powinniśmy tu dotrzeć
    for (;;);
    return 0;
}

/*-----------------------------------------------------------*/

// Definicja funkcji callback timera
static void timerCallback(TimerHandle_t xTimer) {
    uint32_t ulValueToSend = 1; // Przykładowa wartość do wysłania
    xQueueSendFromISR(xQueue, &ulValueToSend, NULL);
}

// Definicja zadania
static void hungryTask(void *pvParameters) {
    uint32_t ulReceivedValue;
    for (;;) {
    //    if (xQueueReceive(xQueue, &ulReceivedValue, portMAX_DELAY) == pdPASS) {
            //printf("hungry\n"); // Drukowanie, gdy odbierzemy wartość z kolejki
    //    }
    }
}

/*-----------------------------------------------------------*/

void vApplicationMallocFailedHook(void) {
    for (;;);
}

void vApplicationIdleHook(void) {
    // Można tu umieścić kod wykonywany w stanie bezczynności
}

void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName) {
    for (;;);
}