#ifndef __ARRAY_H
#define __ARRAY_H

#ifdef ARRAY_ENABLE

#include "CH58x_common.h"
//#include "stdbool.h"
#include "stdlib.h"
#include "string.h"

#ifndef FreePtr
#define FreePtr(ptr)    \
    do                  \
    {                   \
        if (ptr!=NULL)  \
        {               \
            free(ptr);  \
            ptr = NULL; \
        }               \
    } while (0)
#endif

#define Array_DefSize 256
typedef struct {
    bool type; // true: 动态数组, false: 静态数组
    uint8_t *Data;
    uint8_t ElemBytes; // The number of bytes a piece of data occupies.
    int Size;
    int Cap;
} Array_t;

/*动态数组初始化*/
// void Array_Init(Array_t *array, int cap, uint8_t elm_bytes); //暂时不建议使用
void Array_InitStatic(Array_t *array, int cap, uint8_t elm_bytes, uint8_t *buff);

#define Array_Initialize(array, buf, buff) Array_InitStatic(array,cap,1,buff)
// 注意这个宏前面的if一定要加花括号
#define Array_Create(arrayName, cap)    \
    uint8_t arrayName##_buff[cap]={0};  \
    Array_t arrayName;                  \
    Array_InitStatic(&arrayName, cap, 1, arrayName##_buff)

/*动态数组销毁*/
void Array_Destroy(Array_t *array);
/*给动态数组添加一个数组*/
bool Array_AddArray(Array_t *array, const uint8_t *value, int size);

bool Array_AddArrayUint8(Array_t *array, uint8_t value, int index);
/*给动态数组指定位置插入一组数据*/
bool Array_Insert(Array_t *array, uint8_t *value, int size, int index);
/*给动态数组指定位置删除一组数据*/
bool Array_Remove(Array_t *array, int start, int end);
/*获取动态数组的元素个数*/
#define Array_GetSize(array) ((array)->Size)
/*获取动态数组可容纳的元素个数*/
#define Array_GetCap(array) ((array)->Cap)
/*获取动态数组中一个元素所占字节*/
#define Array_GetElemBytes(array) ((array)->ElemBytes)
/*获取动态数组总共占的字节数*/
#define Array_GetAllSize(array) ((array)->Size * (array)->ElemBytes)
/*获取动态数组总共能容纳的字节数*/
#define Array_GetAllCap(array) ((array)->Cap * (array)->ElemBytes)
/*获取动态数组指定位置的指针
 * 用法：
 * uint16_t *p = NULL;
 * Array_PopPtr(&Arr, p);
 * */
#define Array_GetPtr(arr, index) ((void *)((arr)->Data + (index) * (arr)->ElemBytes))
/*获取动态数组指定位置的结构体（该接口用于动态数组中存储的是64位数据或者结构体的情况）
 * 用法：
 * Test_t st = {0};//Test_t是一个结构体
 *  Array_PopPtr(&Arr, &st);
 */
#define Array_GetStruct(arr, index, ptr) memcpy(ptr, Array_GetPtr(arr, index), Array_GetElemBytes(arr))

/*给动态数组指push数据*/
#define Array_Push(array, data)                                                       \
    do                                                                                \
    {                                                                                 \
        for (int arraypush__i = 0; arraypush__i < (array)->ElemBytes; arraypush__i++) \
        {                                                                             \
            uint8_t array__push__val = ((data) >> (arraypush__i * 8)) & 0xff;         \
            Array_AddArrayUint8(array, array__push__val, arraypush__i);               \
        }                                                                             \
        (array)->Size++;                                                              \
    } while (0)
/*给动态数组push一个数组*/
#define Array_PushArray(array, value, size) Array_AddArray(array, (uint8_t *)(value), size)
/*给动态数组push一个结构体*/
#define Array_PushStruct(array, value) Array_PushArray(array, &(value), 1)
/*获取指定位置的数据*/
#define Array_GetVal(arr, index)                                               \
    ({                                                                         \
        uint32_t array__get__val = 0;                                          \
        uint8_t array_elm_bytes = (arr)->ElemBytes;                            \
        int mindex = (index)*array_elm_bytes;                                  \
        for (uint8_t i = 0; i < array_elm_bytes; i++)                          \
        {                                                                      \
            array__get__val |= ((uint32_t)(arr)->Data[mindex + i]) << (i * 8); \
        }                                                                      \
        (array__get__val);                                                     \
    })
/*获取该数组的数据并存入并返回给buff指针，并返回数组元素个数*/
// #define Array_GetArrayPtr(array, buff)                   \
//     ({                                                   \
//         int array__all__size = Array_GetAllSize(array);  \
//         (buff) = malloc(array__all__size);               \
//         memcpy((buff), (array)->Data, array__all__size); \
//         ((array)->Size);                                 \
//     })
/*pop一个数据*/
#define Array_PopVal(array)                                \
    ({                                                     \
        uint32_t array__pop__val = Array_GetVal(array, 0); \
        Array_Remove(array, 0, 1);                         \
        (array__pop__val);                                 \
    })
/*pop一个指针*/
#define Array_PopPtr(arr, ptr)                        \
    do                                                \
    {                                                 \
        uint8_t array__elm__bytes = (arr)->ElemBytes; \
        memcpy(ptr, (arr)->Data, array__elm__bytes);  \
        Array_Remove(arr, 0, 1);                      \
    } while (0)
/*pop一个结构体*/
#define Array_PopStruct Array_PopPtr
/*清空一个动态数组*/
#define Array_Clear(arr) (arr)->Size = 0

#endif // ARRAY_ENABLE
#endif