#include <HVector.h>
#include <string.h>

static void InitVector(HVectorType *vector) {
    if ((vector[0] & kHVectorNeedInit) == 0) {
        return ;
    }

    _HVectorBase *base = (_HVectorBase *)vector;
    base->flag &= ~kHVectorNeedInit;
    uint8_t *len = (uint8_t *)&base->len;
    base->len = _HVECTOR_INIT_SIZE_INIT(len);
    len = (uint8_t *)&base->useLen;
    base->useLen = _HVECTOR_INIT_SIZE_INIT(len);
}

static uint8_t GetVectorType(const HVectorType *vector) {
    InitVector((HVectorType *)vector);
    const _HVectorBase *base = (const _HVectorBase *)vector;
    return base->flag & kHVectorFlagAllMask;
}

static HVectorLenType GetVectorTypeSize(const HVectorType *vector) {
    switch(GetVectorType(vector)) {
        case kHVectorFlag8: return sizeof(uint8_t); break;
        case kHVectorFlag16: return sizeof(uint16_t); break;
        case kHVectorFlag32: return sizeof(uint32_t); break;
    }

    return 0;
}

static HVectorDataType GetVectorData(const HVectorType *vector, HVectorLenType pos) {
    switch(GetVectorType(vector)) {
        case kHVectorFlag8: return ((const _HVector8 *)vector)->data[pos]; break;
        case kHVectorFlag16: return ((const _HVector16 *)vector)->data[pos]; break;
        case kHVectorFlag32: return ((const _HVector32 *)vector)->data[pos]; break;
    }

    return HVECTOR_ERROR;
}

static void SetVectorData(HVectorType *vector, HVectorLenType pos, HVectorDataType data) {
    switch(GetVectorType(vector)) {
        case kHVectorFlag8: ((_HVector8 *)vector)->data[pos] = (uint8_t)data; break;
        case kHVectorFlag16: ((_HVector16 *)vector)->data[pos] = (uint16_t)data; break;
        case kHVectorFlag32: ((_HVector32 *)vector)->data[pos] = (uint32_t)data; break;
    }
}

static HVectorLenType GetVectorLen(const HVectorType *vector) {
    const _HVectorBase *base = (const _HVectorBase *)vector;
    InitVector((HVectorType *)vector);
    return base->len;
}

static HVectorLenType GetVectorUseLen(const HVectorType *vector) {
    const _HVectorBase *base = (const _HVectorBase *)vector;
    InitVector((HVectorType *)vector);
    return base->useLen;
}

static HVectorLenType GetVectorByteLen(const HVectorType *vector) {
    return GetVectorTypeSize(vector) * ((const _HVectorBase *)vector)->len;
}

static HVectorLenType GetVectorByteUseLen(const HVectorType *vector) {
    return GetVectorTypeSize(vector) * ((const _HVectorBase *)vector)->useLen;
}

static void *GetVectorDataBytePtr(HVectorType *vector, HVectorLenType bytePos) {
    if (bytePos >= GetVectorByteLen(vector)) {
        return NULL;
    }

    return ((_HVector8 *)vector)->data + bytePos;
}

static void *GetVectorDataPtr(HVectorType *vector, HVectorLenType pos) {
    return GetVectorDataBytePtr(vector, pos * GetVectorTypeSize(vector));
}

static void SetVectorUseLen(HVectorType *vector, HVectorLenType len) {
    _HVectorBase *base = (_HVectorBase *)vector;
    InitVector((HVectorType *)vector);
    base->useLen = len;
}


uint8_t HVectorAddData(HVectorType *vector, HVectorDataType data) {
    HVectorLenType len = GetVectorUseLen(vector);
    if (len >= GetVectorLen(vector)) {
        return 0;
    }

    SetVectorData(vector, len, data);
    SetVectorUseLen(vector, len + 1);
    return 1;
}

void HVectorAddBytes(HVectorType *vector, const uint8_t *datas, HVectorLenType byteLen) {
    HVectorLenType useLen = GetVectorUseLen(vector);
    HVectorLenType maxLen = GetVectorByteLen(vector) - useLen;
    HVectorLenType typeSize = GetVectorTypeSize(vector);
    if (byteLen > maxLen) {
        byteLen = maxLen;
    }

    if (byteLen == 0) {
        return;
    }

    uint8_t *dest = (uint8_t *)GetVectorDataBytePtr(vector, GetVectorByteUseLen(vector));
    memcpy(dest, datas, byteLen);
    SetVectorUseLen(vector, useLen + (byteLen + typeSize - 1) / typeSize);
}

void HVectorAddDatas(HVectorType *vector, const void *datas, HVectorLenType byteLen) {
    HVectorAddBytes(vector, (const uint8_t *)datas, byteLen * GetVectorTypeSize(vector));
}

// 获取数据, 失败返回 HVECTOR_ERROR
HVectorDataType HVectorGetData(HVectorType *vector, HVectorLenType index) {
    return GetVectorData(vector, index);
}

// 超出位置返回NULL, 数据长度是根据字节长度
void *HVectorGetByteDataPtr(HVectorType *vector, HVectorLenType pos) {
    return GetVectorDataBytePtr(vector, pos);
}

void *HVectorGetDataPtr(HVectorType *vector, HVectorLenType pos) {
    return GetVectorDataPtr(vector, pos);
}

HVectorLenType HVectorGetLen(HVectorType *vector) {
    return GetVectorLen(vector);
}

HVectorLenType HVectorGetByteLen(HVectorType *vector) {
    return GetVectorByteLen(vector);
}

HVectorLenType HVectorGetUseLen(HVectorType *vector) {
    return GetVectorUseLen(vector);
}

HVectorLenType HVectorGetUseByteLen(HVectorType *vector) {
    return GetVectorByteUseLen(vector);
}

void HVectorClear(HVectorType *vector) {
    SetVectorUseLen(vector, 0);
}

void HVectorSetUseLen(HVectorType *vector, HVectorLenType len) {
    if (len >= GetVectorUseLen(vector)) {
        return;
    }

    SetVectorUseLen(vector, len);
}

// 查找数据, 返回索引, 不存在返回 HVECTOR_ERROR
HVectorLenType HVectorFindData(HVectorType *vector, HVectorDataType data) {
    for (HVectorLenType i = 0; i < GetVectorUseLen(vector); ++i) {
        if (GetVectorData(vector, i) == data) {
            return i;
        }
    }

    return HVECTOR_ERROR;
}

uint8_t HVectorEmpty(HVectorType *vector) {
    return GetVectorUseLen(vector) == 0;
}

void HVectorRemoveData(HVectorType *vector, HVectorLenType index, HVectorLenType len) {
    if (index >= GetVectorUseLen(vector)) {
        return;
    }

    if (index + len > GetVectorUseLen(vector)) {
        SetVectorUseLen(vector, index);
        return;
    }

    void *src = GetVectorDataPtr(vector, index + len);
    void *dest = GetVectorDataPtr(vector, index);
    memcpy(dest, src, (GetVectorUseLen(vector) - index - len) * GetVectorTypeSize(vector));
    SetVectorUseLen(vector, GetVectorUseLen(vector) - len);
}