/**
 * 日期: 2025-03-08
 * 作者: coffee
 * 描述: 字节栈, 支持数据为8位, 16位, 32位
 * 长度可最大支持到32位, 需定义宏, 默认支持8位长度
 * 使用宏定义定义变量, HBYTE_STACK_DEFINE(name, size)
 */


#ifndef __H_BYTE_STACK_H__
#define __H_BYTE_STACK_H__


#include <stdint.h>


typedef uint8_t HByteType;        // 栈类型
typedef uint32_t HByteDataType;   // 栈数据类型

#ifdef _HBYTE_STACK_LEN_USE32
#define HBYTE_STACK_ERROR (0xffffffff)
typedef uint32_t HByteLenType;
#elif defined(_HBYTE_STACK_LEN_USE16)
#define HBYTE_STACK_ERROR (0xffff)
typedef uint16_t HByteLenType;
#else
#define HBYTE_STACK_ERROR (0xff)
typedef uint8_t HByteLenType;     // 栈长度类型
#endif


/** ================================================================================ **/

enum eHByteStackFlag {
    kHByteStackFlag8        = 0x01, // 数据为8位
    kHByteStackFlag16       = 0x02, // 数据为16位
    kHByteStackFlag32       = 0x04, // 数据为32位

    kHByteStackFlagAllMask  = 0x07, // 栈数据类型掩码

    kHByteStackNeedInit     = 0x80, // 需要初始化
};

typedef struct __attribute__ ((__packed__)) _HByteStackBase {
    uint8_t flag;
    HByteLenType len;
    HByteLenType useLen;
} _HByteStackBase;

typedef struct __attribute__ ((__packed__)) _HByteStack8 {
    _HByteStackBase base;
    uint8_t data[];
} _HByteStack8;

typedef struct __attribute__ ((__packed__)) _HByteStack16 {
    _HByteStackBase base;
    uint16_t data[];
} _HByteStack16;

typedef struct __attribute__ ((__packed__)) _HByteStack32 {
    _HByteStackBase base;
    uint32_t data[];
} _HByteStack32;

// 用于支持多数据类型的宏
#define _HBYTE_STACK_CALC_LEN8(num)     (sizeof(_HByteStack8) + num)
#define _HBYTE_STACK_CALC_LEN16(num)    (sizeof(_HByteStack16) + num * sizeof(uint16_t))
#define _HBYTE_STACK_CALC_LEN32(num)    (sizeof(_HByteStack32) + num * sizeof(uint32_t))
#define _HBYTE_STACK_CALC_LEN(num, type) (_HBYTE_STACK_CALC_LEN##type(num))

// 用于辅助数值初始化
#ifdef _HBYTE_STACK_LEN_USE32
#define _HBYTE_STACK_INIT_SIZE(size)        ((size >> 24) & 0xff), ((size >> 16) & 0xff), ((size >> 8) & 0xff), (size & 0xff)
#define _HBYTE_STACK_INIT_SIZE_INIT(size)   ((size[0] << 24) | (size[1] << 16) | (size[2] << 8) | (size[3] & 0xff))
#elif defined(_HBYTE_STACK_LEN_USE16)
#define _HBYTE_STACK_INIT_SIZE(size)        ((size >> 8) & 0xff), (size & 0xff)
#define _HBYTE_STACK_INIT_SIZE_INIT(size)   ((size[0] << 8) | (size[1] & 0xff))
#else
#define _HBYTE_STACK_INIT_SIZE(size)        (size & 0xff)
#define _HBYTE_STACK_INIT_SIZE_INIT(size)   (size[0] & 0xff)
#endif

// 用于初始化栈数据
#define _HBYTE_STACK_INIT8(size)    { kHByteStackNeedInit | kHByteStackFlag8, _HBYTE_STACK_INIT_SIZE(size), _HBYTE_STACK_INIT_SIZE(0)}
#define _HBYTE_STACK_INIT16(size)   { kHByteStackNeedInit | kHByteStackFlag16, _HBYTE_STACK_INIT_SIZE(size), _HBYTE_STACK_INIT_SIZE(0)}
#define _HBYTE_STACK_INIT32(size)   { kHByteStackNeedInit | kHByteStackFlag32, _HBYTE_STACK_INIT_SIZE(size), _HBYTE_STACK_INIT_SIZE(0)}
#define _HBYTE_STACK_INIT(size, type) _HBYTE_STACK_INIT##type(size)

/** ================================================================================ **/

// 定义字节栈, name: 栈名, size: 栈长度
#define HBYTE_STACK_DEFINE(name, size) HByteType name[_HBYTE_STACK_CALC_LEN(size, 8)] = _HBYTE_STACK_INIT(size, 8)
#define HBYTE_STACK_DEFINE16(name, size) HByteType name[_HBYTE_STACK_CALC_LEN(size, 16)] = _HBYTE_STACK_INIT(size, 16)
#define HBYTE_STACK_DEFINE32(name, size) HByteType name[_HBYTE_STACK_CALC_LEN(size, 32)] = _HBYTE_STACK_INIT(size, 32)

// 声明字节栈, name: 栈名, size: 栈长度
#define HBYTE_STACK_EXTERN(name, size) extern HByteType name[_HBYTE_STACK_CALC_LEN(size, 8)]
#define HBYTE_STACK_EXTERN16(name, size) extern HByteType name[_HBYTE_STACK_CALC_LEN(size, 16)]
#define HBYTE_STACK_EXTERN32(name, size) extern HByteType name[_HBYTE_STACK_CALC_LEN(size, 32)]

// 入栈, 成功返回1, 失败返回 0
uint8_t HByteStackPush(HByteType *stackData, HByteDataType value);

// 出栈, 成功返回出栈数据, 失败返回 HBYTE_STACK_ERROR
HByteDataType HByteStackPop(HByteType *stackData);

// 返回栈顶数据, 失败返回 HBYTE_STACK_ERROR
HByteDataType HByteStackTop(const HByteType *stackData);

// 返回栈长度
HByteLenType HByteStackLen(const HByteType *stackData);

// 返回栈是否为空
uint8_t HByteStackEmpty(const HByteType *stackData);

// 清空栈
void HByteStackClear(HByteType *stackData);

// 从栈顶开始查找, 成功返回位置, 失败返回 HBYTE_STACK_ERROR
HByteLenType HByteStackFind(const HByteType *stackData, HByteDataType value);

// 即当前栈位置
HByteLenType HByteStackGetUseLen(const HByteType *stackData);

// 设置当前栈位置, 设置超过当前栈位置则不修改
void HByteStackSetUseLen(HByteType *stackData, HByteLenType pos);

// 返回栈中指定元素元素个数, 不存在返回0
HByteLenType HByteStackCount(const HByteType *stackData, HByteDataType value);

#endif //__H_BYTE_STACK_H__