/**
 * 如果是返回1
 * 出錯返回-1
 * */
int str_start_with(const char *src, const char *start) {
  if (src == NULL || start == NULL) return -1;
  int srcLen = strlen(src);
  int startLen = strlen(start);
  if ((srcLen < startLen) || (srcLen == 0 || startLen == 0)) return -1;
  const char *p = start;
  int i = 0
 
;
  while (*p != '\0') {
    if (*p != src[i]) return -1;
    p++;
    i++;
  }
  return 1;
}
//字串轉小寫
char *strlwr(char *str)
{
    if(str == NULL)
        return NULL;
    char *p = str;  
    while(*str!='\0'){  
        *str = tolower(*str);  
        str++;  
    }  
    return p;
}

/**
 * @brief ascll_to_Hex(16進位制字串轉16進位制陣列)
 * @param str 輸入資料(16進位制字串)
 * @param data　輸出資料（16進位制陣列））
 * @param len輸入資料的長度（長度為str/2的長度，即data要輸出的長度）
 
 
*/
void ascll_to_Hex(unsigned char  *str, unsigned char *data,unsigned short len)
{
    unsigned short  i=0;
    for(i =0;i<=len;i++)
    {
        if(str[i*2]>='0' && str[i*2]<='9')
            data[i] =  str[i*2] - '0';
        else if(str[i*2]>='a' && str[i*2]<='f')
            data[i] 
 
=  str[i*2] - 'a'+10;
        else if(str[i*2]>='A' && str[i*2]<='F')
            data[i] =  str[i*2] - 'A'+10;
        else
            return;
        data[i] <<= 4;
        if(str[i+1]>='0' && str[i*2+1]<='9')
            data[i] +=  str[i*2+1] - '0';
        else if(str[i*2+1]>='a' && str[i*2+1]<='f')
            data[i] +=  str[i*2+1] - 'a'+10;
        else if(str[i*2+1]>='A' && str[i*2+1]<='F')
            data[i] +=  str[i*2+1] - 'A'+10;
        else
            return;
    }
}

/**
 * @brief hex_asc hex轉ascii
 * @param hex_buf　輸入資料
 * @param asc_buf　輸出資料
 * @param length　輸入資料的長度
 */
void hex_asc(unsigned char* hex_buf, unsigned char* asc_buf, unsigned short length)
{
    unsigned short i;
    unsigned char byte;

    for (i = 0; i < length; i++)
    {
        byte = hex_buf[i] >> 4;
        if (byte > 9)
        {
            asc_buf[i*2] = 'A' + byte - 10;
        }
        else
        {
            asc_buf[i*2] = '0' + byte;
        }

        byte = hex_buf[i] & 0x0F;
        if (byte > 9)
        {
            asc_buf[i*2+1] = 'A' + byte - 10;
        }
        else
        {
            asc_buf[i*2+1] = '0' + byte;
        }
    }
}

/**
 * @brief asc_int　ascii轉int
 * @param asc_buf
 * @param length
 * @return
 */
u64 asc_int(unsigned char* asc_buf, unsigned short length)
{
    u16 i = 0;
    u64 num = 0;
    u64 tmp = 1;
    tmp = 1;
    if(length  > 19)
        return 0;
    for(i = length; i > 0 ; i--)
    {
        if(asc_buf[i-1]<0x30 || asc_buf[i-1] > 0x39)
            return 0;
        if(i != length)
            tmp = tmp*10;
        num += (asc_buf[i-1]-0x30)*tmp;
    }
    return num;
}

void asc_hex(unsigned char* asc_buf, unsigned char* hex_buf, unsigned int length)
{
    u32 i,j;

    for (i = 0, j = 0; i < length ; i++)
    {
        if (asc_buf[i] >= 'a' && asc_buf[i] <= 'f')
        {
            hex_buf[j] = 10 + (asc_buf[i] - 'a');
        }else if(asc_buf[i] >= 'A' && asc_buf[i] <= 'F')
        {
            hex_buf[j] =10 + (asc_buf[i] - 'A');
        }else if(asc_buf[i] >= '0' && asc_buf[i] <= '9')
        {
            hex_buf[j] = (asc_buf[i] - '0');
        }

        hex_buf[j] <<= 4;
        i++;

        if (asc_buf[i] >= 'a' && asc_buf[i] <= 'f')
        {
            hex_buf[j] |= 10 + (asc_buf[i] - 'a');
        }else if(asc_buf[i] >= 'A' && asc_buf[i] <= 'F')
        {
            hex_buf[j] |=10 + (asc_buf[i] - 'A');
        }else if(asc_buf[i] >= '0' && asc_buf[i] <= '9')
        {
            hex_buf[j] |= (asc_buf[i] - '0');
        }
        j++;
    }
}

//十進位制轉為ASCII碼值
void int_asc(u64 card, unsigned char* asc_buf, unsigned short* length)
{
    int i,j;
    unsigned char byte;
    unsigned char tmp[30];
    i = 0;

    while(1)
    {
        byte = card % 10;
        tmp[i++] = byte;
        if(card<10)
        {
            break;
        }
        card = card / 10;
    }

    *length = i;
    j=0;
    i--;
    for (; i >= 0; i--)
    {
        asc_buf[j++] = tmp[i] + 0x30;
    }
}
u16 count_len(const char *buff,char type)
{
    u16 i;
    if(buff == NULL)
        return 0;

    for(i=0; i<strlen(buff) ;i++)
    {
        if(type == buff[i])
            return i;
    }
    return 0;
    //return count_long_len(buff,type);
}
u16 count_long_len(const char *buff,char type,int buffLen)
{
    u16 i;
    for(i=0; i<buffLen ;i++)
    {
        if(type == buff[i])
            return i;
    }
    return 0;
}
/**
 * @brief 在字串中查詢某個字元出現的次數
 * @param buff 原字串
 * @param subchar  需查詢的子字元
 * @return 返回出現的次數
 */ 
u16 searchCharCount(const char *buff,char subchar)
{
    u16 i;
    if(buff == NULL)
        return 0;
    int count=0;
    for(i=0; i<strlen(buff) ;i++)
    {
        if(subchar == buff[i])
            count++;
    }
    return count;
}
//
/**
 * @brief 查詢字元在字串首次出現的位置
 * @param buff 原字串
 * @param subchar  需查詢的子字元
 * @return 返回首次出現的位置，找不到則返回-1
 */ 
int strsubCharIndexof(const char *buff,char subchar)
{
    u16 i;
    if(buff == NULL)
        return -1;
    int offset=-1;
    for(i=0; i<strlen(buff) ;i++)
    {
        if(subchar == buff[i])
        {
            offset = i;
            break;
        }
    }
    return offset;
}
/**
 * @brief 查詢字元在字串最後出現的位置
 * @param buff 原字串
 * @param subchar  需查詢的子字元
 * @return 返回最後出現的位置，找不到則返回-1
 */ 
int strsubCharLastIndexof(const char *buff,char subchar)
{
    u16 i;
    if(buff == NULL)
        return -1;
    int offset=-1;
    for(i=0; i<strlen(buff) ;i++)
    {
        if(subchar == buff[i])
            offset = i;
    }
    return offset;
}
/**
 * @brief 單個字元替換（所有字元都替換）
 * @param buff 待替換的原字串
 * @param oldchar  需要替換的字元
 * @param oldchar  替換後的字元
 * @return 替換成功返回1，否則為0
 */ 
u8 strreplace(char *buff,char oldchar,char newchar)
{
    u16 i;
    u8 ret = 0;
    if(buff == NULL)
        return 0;
    int offset = 0;
    for(i=0; i<strlen(buff) ;i++)
    {
        if(newchar == 0)
        {
            if(oldchar == buff[i])
            {
                //buff[i] = newchar;
                ret = 1;
            }
            else
            {
                buff[offset++] = buff[i];
            }
        }
        else
        {
            if(oldchar == buff[i])
            {
                buff[i] = newchar;
                ret = 1;
            }
        }
    }
    if(newchar == 0)
    {
        buff[offset++] = 0;//結束字串
    }
    return ret;
    //return count_long_len(buff,type);
}
/**
 * @brief 字串替換（第一次出現時替換）。注意程式碼中有陣列容量512，注意傳入的字串不要大於這個
 * @param buff 待替換的原字串
 * @param oldstr  需要替換的字串
 * @param newstr  替換後的字串
 * @return 替換成功返回1，否則為0
 */ 
u8 strreplace2(char * buff, char * oldstr, char * newstr)
{
    int i, j, k, done, count = 0, gap = 0;
    char temp[512];
    for(i = 0; i < strlen(buff); i += gap){
        if(buff[i] == oldstr[0]){
            done = 0;
            for(j = i, k = 0; k < strlen(oldstr); j++, k++){
                if(buff[j] != oldstr[k]){
                    done = 1;
                    gap = k;
                    break;
                }
            }
            if(done == 0){ // 已找到待替換字串並替換
                for(j = i + strlen(oldstr), k = 0; j < strlen(buff); j++, k++){ // 儲存原字串中剩餘的字元
                    temp[k] = buff[j];
                }
                temp[k] = '\0'; // 將字元陣列變成字串
                for(j = i, k = 0; k < strlen(newstr); j++, k++){ // 字串替換
                    buff[j] = newstr[k];
                    count++;
                }
                for(k = 0; k < strlen(temp); j++, k++){ // 剩餘字串回接
                    buff[j] = temp[k];
                }
                buff[j] = '\0'; // 將字元陣列變成字串
                gap = strlen(oldstr);
            }
        }else{
            gap = 1;
        }
    }
    if(count == 0){
        //printf("Can't find the replaced string!\n");
        return 0;
    }
    return 1;
}

u8 memcpysafe(char *_dest,const char *_src,size_t _n, size_t _destSizeof)
{
    _destSizeof--;
    if(_n > _destSizeof)
        _n = _destSizeof;

    memcpy(_dest,_src,_n);
    _dest[_n]=0x0;//增加結束符
    return 1;
}