#include <c_ArrayQueue.h>

#define DEFAULT_INIT_CAPACITY   4

c_err_t c_ArrayQueue_Init(c_ArrayQueue_t* self, c_size_t item_size, c_size_t capacity, c_Allocator_t* allocator) {
    if (!self || item_size == 0) return C_ERR_PARAM;

    self->allocator = (allocator != NULL) ? *allocator : c_DefaultAllocator;
    self->item_size = item_size;
    self->size = 0;
    self->head = 0;
    self->tail = 0;
    self->capacity = (capacity > 0) ? capacity : DEFAULT_INIT_CAPACITY;

    self->array = c_Allocator_Alloc(&self->allocator, self->capacity * item_size);
    if (!self->array) return C_ERR_NOMEM;

    return C_ERR_OK;
}

void c_ArrayQueue_Destroy(c_ArrayQueue_t* self) {
    if (!self) return;
    if (self->array) {
        c_Allocator_Free(&self->allocator, self->array);
        self->array = NULL;
    }
    self->size = 0;
    self->capacity = 0;
    self->head = 0;
    self->tail = 0;
}

c_err_t c_ArrayQueue_Resize(c_ArrayQueue_t* self, c_size_t new_capacity) {
    if (!self || new_capacity < self->size) return C_ERR_PARAM; // 不允许缩容到比当前已有元素还小

    if (new_capacity == self->capacity) return C_ERR_OK;

    const c_size_t new_bytes = new_capacity * self->item_size;

    // 1. 先用 Alloc 申请一块干净、独立的全新目标缓冲区
    void* new_array = c_Allocator_Alloc(&self->allocator, new_bytes);
    if (!new_array) return C_ERR_NOMEM;

    // 2. 此时旧缓冲区 self->array 100% 安全存活，可以放心读取并执行平整化导出
    if (self->size > 0 && self->array) {
        uint8_t* dst = (uint8_t*)new_array;
        const uint8_t* src = (const uint8_t*)self->array;

        if (self->head < self->tail) {
            // 情况 A: 数据是连续的，没有发生回绕
            memcpy(dst, src + (self->head * self->item_size), self->size * self->item_size);
        } else {
            // 情况 B: 数据发生了回绕，精准分两段导出到新阵列
            const c_size_t first_part_len = self->capacity - self->head;
            const c_size_t second_part_len = self->tail;

            memcpy(dst, src + (self->head * self->item_size), first_part_len * self->item_size);
            memcpy(dst + (first_part_len * self->item_size), src, second_part_len * self->item_size);
        }
    }

    // 3. 数据安全倒腾完毕后，显式手工释放旧空间（因为我们第一步用的是 Alloc 而不是 Realloc）
    if (self->array) {
        c_Allocator_Free(&self->allocator, self->array);
    }

    // 4. 更新队列控制头状态
    self->array = new_array;
    self->capacity = new_capacity;
    self->head = 0;
    self->tail = self->size; // 经过平整化铺平，新尾部直接等于已有大小

    return C_ERR_OK;
}


// 内部自动扩容
C_STATIC_FORCE_INLINE
bool c_ArrayQueue_EnsureCapacity(c_ArrayQueue_t* self) {
    if (self->size < self->capacity) return true;
    c_size_t new_capacity = self->capacity * 2;
    return c_ArrayQueue_Resize(self, new_capacity) == C_ERR_OK;
}

// 入队 (O(1) 性能，自动触发扩容)
c_err_t c_ArrayQueue_Enqueue(c_ArrayQueue_t* self, const void* item) {
    if (!self || !item) return C_ERR_PARAM;
    if (!c_ArrayQueue_EnsureCapacity(self)) return C_ERR_NOMEM;

    // 计算尾部插入点并拷贝数据
    uint8_t* target = (uint8_t*)self->array + (self->tail * self->item_size);
    memcpy(target, item, self->item_size);

    // 环形推进 tail 指针
    self->tail = (self->tail + 1) % self->capacity;
    self->size++;

    return C_SUCCESS;
}

// 出队 (O(1) 性能，零内存移动开销)
c_err_t c_ArrayQueue_Dequeue(c_ArrayQueue_t* self, void* out_item) {
    if (!self || self->size == 0) return C_ERR_PARAM;

    // 找到队头数据源
    uint8_t* source = (uint8_t*)self->array + (self->head * self->item_size);
    if (out_item) {
        memcpy(out_item, source, self->item_size);
    }

    // 环形推进 head 指针
    self->head = (self->head + 1) % self->capacity;
    self->size--;

    return C_SUCCESS;
}

// 查看队头元素（不移除）
void* c_ArrayQueue_Peek(const c_ArrayQueue_t* self) {
    if (!self || self->size == 0) return NULL;
    return (uint8_t*)self->array + (self->head * self->item_size);
}