#include "fifo.h"
#include "rtthread.h"
#include "stdlib.h"
#include "string.h"


GenericNode* generic_node_create(const void *data, size_t data_size) {
    GenericNode *new_node = (GenericNode*)malloc(sizeof(GenericNode));
    if (!new_node) return NULL;
    
    new_node->data = malloc(data_size);
    if (!new_node->data) {
        free(new_node);
        return NULL;
    }
    
    memcpy(new_node->data, data, data_size);
    new_node->data_size = data_size;
    new_node->next = NULL;
    return new_node;
}


GenericFixedList* generic_list_create(int max_size) {
    GenericFixedList *list = (GenericFixedList*)malloc(sizeof(GenericFixedList));
    if (!list) return NULL;
    
    list->head = NULL;
    list->tail = NULL;
    list->max_size = max_size;
    list->current_size = 0;
    return list;
}

bool generic_list_append(GenericFixedList *list, const void *data, size_t data_size) {
    if (list->max_size == 0) return false;
    
    if (list->current_size == 0) {
        GenericNode *new_node = generic_node_create(data, data_size);
        if (!new_node) return false;
        
        new_node->next = new_node;
        list->head = new_node;
        list->tail = new_node;
        list->current_size = 1;
        return true;
    }
    else if (list->current_size >= list->max_size) {
        if (list->head->data_size != data_size) {

            free(list->head->data);
            list->head->data = malloc(data_size);
            if (!list->head->data) return false;
            list->head->data_size = data_size;
        }
        
        memcpy(list->head->data, data, data_size);
        
        list->tail = list->head;
        list->head = list->head->next;
        return true;
    }
    else {
        GenericNode *new_node = generic_node_create(data, data_size);
        if (!new_node) return false;
        
        new_node->next = list->head;
        list->tail->next = new_node;
        list->tail = new_node;
        list->current_size++;
        return true;
    }
}

void * generic_list_get_index(GenericFixedList *list,uint8_t index)
{
	void *data = NULL;
	GenericNode *p_node = list->head;
	
	if(index < list->current_size)
	{
		int i = 0;
		for(;p_node != list->tail;p_node=p_node->next)
		{
			if(i>= index)
			{
				data = p_node->data;
				break;
			}
			i++;
		}
		if(index == list->current_size-1)
			data = list->tail->data;
	}
	return data;
}

void generic_list_get(GenericFixedList *list,void * data,uint8_t lenth)
{
	if(lenth >= list->current_size)
		lenth = list->current_size;
	if(lenth == 0)
			return;
	
	GenericNode *p_node = list->head;
	int i = 0;
	int p_start = 0;
	for(;;p_node = p_node->next,i++)
	{
		memcpy(data+p_start,p_node->data,p_node->data_size);
		p_start += p_node->data_size;
		if(p_node == list->tail)
		{
			break;
		}
	}
}
void generic_list_clean(GenericFixedList *list)
{
	if (list->current_size > 0) {
			GenericNode *current = list->head;
      GenericNode *next_node = NULL;
			for (int i = 0; i < list->current_size; i++) {
            next_node = current->next;
            free(current->data);
            free(current);
            current = next_node;
      }
	}
	list->head = NULL;
  list->tail = NULL;
  list->current_size = 0;
}


void generic_list_destroy(GenericFixedList *list) {
    if (list->current_size > 0) {
        GenericNode *current = list->head;
        GenericNode *next_node = NULL;
        
        for (int i = 0; i < list->current_size; i++) {
            next_node = current->next;
            free(current->data);
            free(current);
            current = next_node;
        }
    }
		
    free(list);
}


int generic_list_get_count(GenericFixedList *list)
{
	return list->current_size;
}