#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#include <string.h>
#include <pthread.h>  // 添加线程互斥锁支持
#include "JZring.h"

typedef struct T_JZring
{
    U8_t *buffer;   // 缓冲区指针
    U32_t size;     // 缓冲区总容量
    U32_t head;     // 写入位置（下一个可写位置）
    U32_t tail;     // 读取位置（下一个可读位置）
    U32_t count;    // 当前数据量
    pthread_mutex_t mutex;  // 互斥锁保护共享资源
} T_JZring;

// 初始化环形缓冲区
T_JZsdkReturnCode JZring_Init(T_JZringHandle *ring, U8_t *buffer, U32_t size)
{
    if (!ring || !buffer || size == 0) 
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)malloc(sizeof(T_JZring));
    if (!r) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 初始化互斥锁
    if (pthread_mutex_init(&r->mutex, NULL) != 0) {
        free(r);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    r->buffer = buffer;
    r->size = size;
    r->head = 0;
    r->tail = 0;
    r->count = 0;

    *ring = (T_JZringHandle)r;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 获取缓冲区总容量
T_JZsdkReturnCode JZring_GetSize(T_JZringHandle ring, U32_t *size)
{
    if (!ring || !size) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    *size = r->size;
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 获取当前数据量
T_JZsdkReturnCode JZring_GetDataCount(T_JZringHandle ring, U32_t *count)
{
    if (!ring || !count) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    *count = r->count;
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 从环形缓冲区读取数据
T_JZsdkReturnCode JZring_Read(T_JZringHandle ring, U8_t *data, U32_t size, U32_t *readSize)
{
    if (!ring || !data || !readSize) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    *readSize = 0;
    
    pthread_mutex_lock(&r->mutex);
    
    if (r->count == 0 || size == 0) {
        pthread_mutex_unlock(&r->mutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    // 计算实际可读数量
    U32_t bytes_to_read = (size > r->count) ? r->count : size;
    *readSize = bytes_to_read;
    
    // 计算连续可读空间（可能被尾部分割）
    U32_t contig = r->size - r->tail;
    if (bytes_to_read <= contig) {
        memcpy(data, r->buffer + r->tail, bytes_to_read);
    } else {
        memcpy(data, r->buffer + r->tail, contig);
        memcpy(data + contig, r->buffer, bytes_to_read - contig);
    }
    
    // 更新读指针和数据计数
    r->tail = (r->tail + bytes_to_read) % r->size;
    r->count -= bytes_to_read;
    
    pthread_mutex_unlock(&r->mutex);
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 写入数据到环形缓冲区
T_JZsdkReturnCode JZring_Write(T_JZringHandle ring, const U8_t *data, U32_t size)
{
    if (!ring || !data) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    if (size == 0) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);

    // 直接检查可用空间
    if (size > (r->size - r->count)) 
    {
        pthread_mutex_unlock(&r->mutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_BUFFER_SIZE_NOT_ENOUGH;
    }

    // 计算连续可写空间（可能被尾部分割）
    U32_t contig = r->size - r->head;
    if (size <= contig) {
        memcpy(r->buffer + r->head, data, size);
    } else {
        memcpy(r->buffer + r->head, data, contig);
        memcpy(r->buffer, data + contig, size - contig);
    }
    
    // 更新写指针和数据计数
    r->head = (r->head + size) % r->size;
    r->count += size;
    
    pthread_mutex_unlock(&r->mutex);
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 获取空闲空间
T_JZsdkReturnCode JZring_GetFreeSpace(T_JZringHandle ring, U32_t *size)
{
    if (!ring || !size) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    *size = r->size - r->count;
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 检查缓冲区是否为空
T_JZsdkReturnCode JZring_IsEmpty(T_JZringHandle ring, bool *isEmpty)
{
    if (!ring || !isEmpty) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    *isEmpty = (r->count == 0);
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 检查缓冲区是否已满
T_JZsdkReturnCode JZring_IsFull(T_JZringHandle ring, bool *isFull)
{
    if (!ring || !isFull) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    *isFull = (r->count == r->size);
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 重置环形缓冲区
T_JZsdkReturnCode JZring_Reset(T_JZringHandle ring)
{    
    if (!ring) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    T_JZring *r = (T_JZring*)ring;
    
    pthread_mutex_lock(&r->mutex);
    r->head = 0;
    r->tail = 0;
    r->count = 0;
    pthread_mutex_unlock(&r->mutex);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 反初始化环形缓冲区
T_JZsdkReturnCode JZring_DeInit(T_JZringHandle ring)
{
    if (!ring) {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    T_JZring *r = (T_JZring*)ring;
    
    // 销毁互斥锁
    pthread_mutex_destroy(&r->mutex);
    
    // 释放管理结构体
    free(r);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}