/*==================================================================================================================
                    Copyright(c) 2012 ORIGIN.
                             Unpublished - All rights reserved
====================================================================================================================
File description:
    Filename: string_utils.c
    Module  : Common module.

        This file includes some operations of the string.

====================================================================================================================
Date                Name             Description of Change
3-Feb-2015		Ray li    Initialize creation
$HISTORY$
===================================================================================================================*/
#ifndef _cplusplus
#ifndef _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_DEPRECATE
#endif
#endif

//#include <tc/tc_util.h>
//#include <itk/mem.h>
//#include <stdlib.h>
//#include <ctype.h>
#include "string_utils.h"
#include <io.h>

void Split( string strArg, string spliter, vector<string> &ans )
{
	ans.clear();
	size_t index0;
	string one_arg;
	if ( strArg.find_first_not_of(' ') == string::npos )
		strArg = "";
	while( strArg.size()>0 )
	{
		index0 = strArg.find(spliter);
		//printf("  index0:%d", (int)index0);
		if( index0 != string::npos )
		{
			if (index0 == 0) {
				strArg = strArg.substr(index0 + spliter.size());
				ans.push_back("");
			}
			else{
				one_arg = strArg.substr(0, index0);
				strArg = strArg.substr(index0 + spliter.size());
				ans.push_back(one_arg);
			}
		}
		else
		{
			ans.push_back( strArg );
			break;
		}
	}
}
/*void Split(string strArg, char spliter, vector<string> &ans)
{
	ans.clear();
	size_t index0 = 0;
	string one_arg;
	if (strArg.find_first_not_of(' ') == string::npos)
		strArg = "";
	while (strArg.size() > 0)
	{
		index0 = strArg.find_first_of(spliter);
		if (index0 != string::npos)
		{
			one_arg = strArg.substr(0, index0);
			strArg = strArg.substr(index0 + 1);
			ans.push_back(one_arg);
		}
		else
		{
			ans.push_back(strArg);
			break;
		}
	}
}*/
char* GSTR_clone( char **dst, const char *src )
{
    char *retVal = NULL;
    int  srcLen  = 0;
    
    *dst = NULL;
    if (src == NULL)
        return NULL;

    srcLen = (int)tc_strlen( src ) + 1;
    *dst   = (char*)MEM_alloc( srcLen * sizeof(char) );
    retVal = tc_strncpy( *dst, src, srcLen );
    (*dst)[srcLen - 1] = '\0';

    return retVal;
}

char* GSTR_copy( char *dst, const char *src, int dstSize )
{
    char *retVal = tc_strncpy( dst, src, dstSize );
    dst[dstSize - 1] = '\0';
    return retVal;
}

char* GSTR_int_to_string( char **dst, int value )
{
    char strVal[128 + 1];

    *dst = NULL;
    memset( strVal, 0, sizeof(strVal)/sizeof(char) );
    sprintf( strVal, "%d", value );

    return GSTR_clone( dst, strVal );
}

void GSTR_format_int_to_string( char *dst, int digitNum, int value )
{
    char sNum[WSO_desc_size_c + 1];
    sprintf( sNum, "%%0%dd", digitNum );
    sprintf( dst, sNum, value );
}

void GSTR_format_string( const char *dst, int m, const char *fill_char, char **out )
{
	char sNum[WSO_name_size_c + 1] = {0};
	char sNew[WSO_name_size_c + 1] = {0};
	sprintf( sNum, "%%%d.%ds", m, m );
	sprintf( sNew, sNum, dst );
	STRNG_replace_str( sNew, " ", fill_char, out );
}


char* GSTR_string_append( const char *s1, const char *s2 )
{
    char *s = NULL;
    if (s1 == NULL || s2 == NULL)
    {
        GSTR_clone(&s, s1 == NULL ? (s2 == NULL ? "" : s2) : s1 );
    }
    else
    {
        int size = (int)tc_strlen(s1) + (int)tc_strlen(s2) + 1;
        s = (char *)MEM_alloc( size );
        tc_strcpy( s, s1 );
        tc_strcat( s, s2 );
        s[size - 1] = '\0';
    }
    return s;
}

logical GSTR_is_float(const char *str)
{
    logical isfloat = true;
    char *pStr = (char *)str;
    logical hasPositive = false;
    logical hasMinus    = false;
    logical hasDot      = false;

    if (str == NULL)
        return false;

    while (*pStr != '\0' && isfloat == true)
    {
        if ( (*pStr >= '0' && *pStr <= '9'))
        {
            //continue;
        }
        else if ( *pStr == '+' )
        {
            isfloat = (hasPositive ? false : (hasPositive = true));
        }
        else if ( *pStr == '-' )
        {
            isfloat = (hasMinus ? false : (hasMinus = true));
        }
        else if ( *pStr == '.' )
        {
            isfloat = (hasDot ? false : (hasDot = true));
        }
        else
            isfloat = false;

        pStr ++;
    }
    return isfloat;
}

logical GSTR_is_number(const char *str)
{
	logical is_number = true;
	char *pStr = (char *)str;
	if (str == NULL)
		return false;

	while (*pStr != '\0')
	{
		if ( !( (*pStr >= '0' && *pStr <= '9') || *pStr == '-' ) )
		{
			is_number = false;
			break;
		}
		pStr ++;
	}
	return is_number;
}

logical GSTR_is_ascii(char ch)
{
    return ((unsigned int)ch) < 128;
}

int GSTR_trim_l( char *str, char s )
{
    int count     = 0;
    char *pointer = str, *poffset = NULL;
    if (str == NULL || str[0] == '\0')
        return 0;

    while ( *pointer != '\0' )
    {
        if ( *pointer != s )
        {
            break;
        }
        count++;
        pointer++;
    }
    if (count == 0)
        return 0;

    poffset = str + count;
    pointer = str;
    while ( *poffset != '\0' )
    {
        *pointer = *poffset;
        pointer ++;
        poffset ++;
    }
    *pointer = '\0';

    return count;
}

int GSTR_trim_r( char *str, char s )
{
    int count = 0;
    char *pointer = NULL;
    if (str == NULL || str[0] == '\0')
        return 0;

    pointer = str + ((int) strlen(str) - 1);

    while ( pointer != str )
    {
        if ( *pointer != s )
        {
            break;
        }

        *pointer = '\0';

        count++;
        pointer--;
    }

    return count;
}

void GSTR_trim_float( char *floatValue )
{
    if ( !IS_EMPTY(floatValue) && tc_strstr(floatValue, ".") != NULL )
    {
        int len = 0;
        GSTR_trim_r(floatValue, '0');
        len = (int)tc_strlen(floatValue);
        if (floatValue[ len - 1 ] == '.')
            floatValue[ len - 1 ] = '\0';
    }
}

int contains(const char *parent, char target) {
	for (int i = 0; i < strlen(parent); i++) {
		if (parent[i] == target)
			return i;
	}
	return -1;
}
bool contains1(char **array, char *str) {
	//printf("containsA:%d==%d", sizeof(array), sizeof(array[0]));
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++) {
		//printf("  containsA:%s==%s\n", array[i], str);
		if (strcmp(array[i], str) == 0)
			return true;
	}
	return false;
}
bool contains2(char **array, int len, const char *str) {
	printf("containsB:%d", len);
	for (int i = 0; i < len; i++) {
		printf("  containsB:%s==%s\n", array[i], str);
		if (strcmp(array[i], str) == 0)
			return true;
	}
	return false;
}
bool contains3(vector<string> array, const char *str) {
	printf("contains3:%d", array.size());
	for (int i = 0; i < array.size(); i++) {
		printf("  contains3:%s==%s\n", array[i].c_str(), str);
		if (strcmp(array[i].c_str(), "null") == 0) {
			if (strcmp("", str) == 0)
				return true;
		}else if (strcmp(array[i].c_str(), str) == 0)
			return true;
	}
	return false;
}
string replace(string str, string s1, string s2) {
	int pos;
	pos = str.find(s1);
	while (pos != -1) {
		// str.length()求字符的长度，注意str必须是string类型
		str.replace(pos, string(s1).length(), s2);
		pos = str.find(s1);
	}
	return str;
}

string GbkToUtf8(const char *src_str) {
	int len = MultiByteToWideChar(CP_ACP, 0, src_str, -1, NULL, 0);
	wchar_t* wstr = new wchar_t[len + 1];
	memset(wstr, 0, len + 1);
	MultiByteToWideChar(CP_ACP, 0, src_str, -1, wstr, len);
	len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
	char* str = new char[len + 1];
	memset(str, 0, len + 1);
	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
	string strTemp = str;
	if (wstr) delete[] wstr;
	if (str) delete[] str;
	return strTemp;
}
string stringToUTF8(const std::string  str)
{
	int nwLen = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);

	wchar_t * pwBuf = new wchar_t[nwLen + 1];//一定要加1，不然会出现尾巴
	ZeroMemory(pwBuf, nwLen * 2 + 2);

	::MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.length(), pwBuf, nwLen);

	int nLen = ::WideCharToMultiByte(CP_UTF8, 0, pwBuf, -1, NULL, NULL, NULL, NULL);

	char * pBuf = new char[nLen + 1];
	ZeroMemory(pBuf, nLen + 1);

	::WideCharToMultiByte(CP_UTF8, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);

	std::string retStr(pBuf);

	delete[]pwBuf;
	delete[]pBuf;

	pwBuf = NULL;
	pBuf = NULL;

	return retStr;
}

string Utf8ToGbk(const char *src_str) {
	int len = MultiByteToWideChar(CP_UTF8, 0, src_str, -1, NULL, 0);
	wchar_t* wszGBK = new wchar_t[len + 1];
	memset(wszGBK, 0, len * 2 + 2);
	MultiByteToWideChar(CP_UTF8, 0, src_str, -1, wszGBK, len);
	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
	char* szGBK = new char[len + 1];
	memset(szGBK, 0, len + 1);
	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
	string strTemp(szGBK);
	if (wszGBK) delete[] wszGBK;
	if (szGBK) delete[] szGBK;
	return strTemp;
}
void createDir(){
	string folderPath = "";
	folderPath = getenv("TEMP");
	folderPath.append("\\tmplog");
	if (!access(folderPath.c_str(), 0))
	{
		printf("存在此路径");
	}
	else
	{
		string command = "mkdir -p ";
		command = command.append(folderPath);
		try
		{
			system(command.c_str());
		}
		catch (...)
		{

		}
	}
}