#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

#define TAG "TEST"
#define RING_BUFFER_SIZE 10

typedef struct {
    void *data;
    size_t capacity;
    size_t size;
    size_t front;
    size_t rear;
} ring_buffer_t;

// Initialize the Ring Buffer
ring_buffer_t* ring_buffer_init(size_t capacity, size_t data_size) {
    ring_buffer_t *buffer = malloc(sizeof(ring_buffer_t));
    if (buffer == NULL) {
        return NULL; // Memory allocation failed
    }
    buffer->data = malloc(capacity * data_size);
    if (buffer->data == NULL) {
        free(buffer);
        return NULL; // Memory allocation failed
    }
    buffer->capacity = capacity;
    buffer->size = 0;
    buffer->front = 0;
    buffer->rear = 0;
    return buffer;
}

// Check if the Ring Buffer is empty
bool ring_buffer_is_empty(ring_buffer_t *buffer) {
    return buffer->size == 0;
}

// Check if the Ring Buffer is full
bool ring_buffer_is_full(ring_buffer_t *buffer) {
    return buffer->size == buffer->capacity;
}

// Write data into the Ring Buffer
bool ring_buffer_write(ring_buffer_t *buffer, void *data, size_t data_size) {
    if (ring_buffer_is_full(buffer)) {
        return false; // Buffer is full
    }
    memcpy((char*)buffer->data + buffer->rear * data_size, data, data_size);
    buffer->rear = (buffer->rear + 1) % buffer->capacity;
    buffer->size++;
    return true;
}

// Read data from the Ring Buffer
bool ring_buffer_read(ring_buffer_t *buffer, void *data, size_t data_size) {
    if (ring_buffer_is_empty(buffer)) {
        return false; // Buffer is empty
    }
    memcpy(data, (char*)buffer->data + buffer->front * data_size, data_size);
    buffer->front = (buffer->front + 1) % buffer->capacity;
    buffer->size--;
    return true;
}

// Free memory allocated for the Ring Buffer
void ring_buffer_free(ring_buffer_t *buffer) {
    free(buffer->data);
    free(buffer);
}

typedef struct 
{
  uint16_t addr:15;
  uint16_t flag:1;
  uint16_t pid;
} sensor_info_t;

typedef struct
{
  sensor_info_t sensor_info;
  float   value;
} sensor_t;

void app_main() {
	sensor_t data;
	sensor_t temp;

	data.sensor_info.addr = 0x0001;
	data.sensor_info.flag = 0;
	data.sensor_info.pid = 0x0056;
	data.value = 27;
	ring_buffer_t *sensor_buffer;
	sensor_buffer = ring_buffer_init (10, sizeof(sensor_t));
	
	ring_buffer_write(sensor_buffer, &data, sizeof(sensor_t));
	
	data.sensor_info.addr = 0x0002;
	data.sensor_info.flag = 1;
	data.sensor_info.pid = 0x0054;
	data.value = 27;
	ring_buffer_write(sensor_buffer, &data, sizeof(sensor_t));
	
	data.sensor_info.addr = 0x0003;
	data.sensor_info.flag = 0;
	data.sensor_info.pid = 0x005b;
	data.value = 27;
	ring_buffer_write(sensor_buffer, &data, sizeof(sensor_t));

	while(!ring_buffer_is_empty(sensor_buffer))
	{
    ring_buffer_read(sensor_buffer, &temp, sizeof(sensor_t));
		printf("addr: 0x%04x, flag: %hu, pid: 0x%04x, value: %0.2f\n", temp.sensor_info.addr, temp.sensor_info.flag, temp.sensor_info.pid, temp.value);
	}
}