#include "stdint.h"
#include <stdarg.h>
#include "stdbool.h"
#include "string.h"
#include "stdio.h"

#include "sys_common.h"
#include "sys_log.h"

#define  MAX_BUF 128

int HAL_Vsnprintf(char *buffer, int n, const char *format, va_list ap)
{
    return vsnprintf((char *)buffer, n, (const char *)format, ap);
}

int HAL_Sprintf(char *buf, const char *fmt, ...)
{
    va_list ap;
    int rv;
    va_start(ap, fmt);
    rv = vsnprintf((char *)buf, MAX_BUF, (const char *)fmt, ap);
    va_end(ap);
    return rv;
}

int8_t *SYS_Strcpy(int8_t *dst, const int8_t *src)
{
    return (int8_t *)strncpy((char *)dst, (const char *)src, strlen((const char *)src));
}

int8_t *SYS_Strstr(const int8_t *haystack, const int8_t *needle)
{
    return (int8_t *)strstr((const char *)haystack, (const char *)needle);
}

int8_t *SYS_Strcat(int8_t *dst, const int8_t *src)
{
    return (int8_t *)strcat((char *)dst, (const char *)src);
}

#define MAX_TRAS_BUF 1536
uint8_t *SYS_Hex2str(uint8_t *hex, int len)
{
    int i;
    char szTmp[5];
    static uint8_t g_log_buff[MAX_TRAS_BUF + 1];
    len = len > MAX_TRAS_BUF / 2 ? MAX_TRAS_BUF / 2 : len;
    memset(g_log_buff, 0, MAX_TRAS_BUF + 1);
    for (i = 0; i < len; i++)
    {
        sprintf(szTmp, "%02X", (uint8_t)hex[i]);
        memcpy(&g_log_buff[i * 2], szTmp, 2);
    }
    g_log_buff[MAX_TRAS_BUF] = '\0';
    return g_log_buff;
}

uint8_t *SYS_Str2hex(uint8_t *src, int len)
{
    uint8_t hb;
    uint8_t lb;
		int i,j;
	
    static uint8_t dest[64];
    if (len > 64)
    {
        DLOG_E("Str2Hex length is too large !!!");
        return NULL;
    }

    memset((char *)dest, 0, 64);

    if (len % 2 != 0)
    {
        DLOG_E("Str2Hex length is not right !!!");
        return NULL;
    }

    for (i = 0, j = 0; i < len; i++)
    {
        hb = src[i];
        if (hb >= 'A' && hb <= 'F')
        {
            hb = hb - 'A' + 10;
        }
        else if (hb >= '0' && hb <= '9')
        {
            hb = hb - '0';
        }
        else if (hb == 0x0d || hb == 0x0a)
        {
            hb = 0;
        }
        else
        {
            DLOG_E("Str2Hex data[%d] not right 1 !!!", hb);
        }

        i++;
        lb = src[i];
        if (lb >= 'A' && lb <= 'F')
        {
            lb = lb - 'A' + 10;
        }
        else if (lb >= '0' && lb <= '9')
        {
            lb = lb - '0';
        }
        else if (lb == 0x0d || lb == 0x0a)
        {
            lb = 0;
        }
        else
        {
            DLOG_E("Str2Hex data[%d] not right 2 !!!", hb);
        }

        dest[j++] = (hb << 4) | (lb);
    }
    return dest;
}

void small_big_transfer32(uint32_t *data)
{
    uint8_t *p_data = (uint8_t *)data;
    uint8_t a = p_data[0];
    uint8_t b = p_data[1];
    uint8_t c = p_data[2];
    uint8_t d = p_data[3];
    p_data[0] = d;
    p_data[1] = c;
    p_data[2] = b;
    p_data[3] = a;
}

void small_big_transfer16(uint16_t *data)
{
    uint8_t *p_data = (uint8_t *)data;
    uint8_t a = p_data[0];
    uint8_t b = p_data[1];
    p_data[0] = b;
    p_data[1] = a;
}

uint8_t SYS_CheckStrLen(const char* buf, const char* key, uint8_t len)
{
    uint8_t err = 1;
    uint8_t *start = (uint8_t* )buf;
    uint8_t *end = strstr(buf, key);
    if (len == end - start)
    {
        err = 0;
    }
    else
    {
        err = 1;
    }

    return err;
}