//////////////////////////////////////////////////////////////////////////
#include "StringTools.h"
#include "Utf8_16.h"
#include <stdarg.h>
namespace  strtools
{
//转义字符为  \\,
// I: ptr  		*ptr是要检索的 字符串开始地址，执行后*ptr指向分隔符之后的地址
// I: Delimiters	分割字符集合开始地址，默认是TAB,SPACE
// O: ret		分割后字符串存放缓冲区（大小由调用时候充分考虑）
// 返回值		没有意义
// 补充		【‘，“】等字符包围的分隔符忽略
int wcstokEx(wchar_t* *ptr,wchar_t* Delimiters, wchar_t* ret){
	bool bEscape=false;
	bool bSingleQuotation=false;
	bool bDoubleQuotation=false;
	int i=-1;
	int l=-1;
	TCHAR ch;
	wchar_t* scan;
	wchar_t* end;
	wchar_t* next;
	if (ptr){
		for(scan=*ptr;*scan==' '||*scan=='\t';scan++){};
		l=wcslen(scan);
		if (l==0){
			*ptr=NULL;
			if (ret)
				*ret=L'\0';
			return(0);
		}
		if(wcschr(Delimiters,*scan)){
			*ptr=scan+1;
			if (ret)
				*ret=L'\0';
			return (0);
		}
		if(*scan==L'\''){
			ch=L'\'';
		}else if(*scan==L'"'){
			ch=L'"';
		}else{
			ch=L'\0';
		}
		if(ch){
			scan++;
			for(next=scan;(*next!=L'\0'&&*next!=ch)||(bEscape&&*next==ch);next++)
			{
				if(*next==L'\\'&&!bEscape)
					bEscape=true;
				else
					bEscape=false;
			}
		}else{
			next=scan;
		}
		for(;*next!=L'\0'&&(!wcschr(Delimiters,*next));next++){};
		if (*next){
			*ptr=next+1;
		}else{
			*ptr=NULL;
		}
		for(;wcschr(L" \t",*(next-1));next--){};
		if(ch&&*(next-1)==ch){
			next--;
		}
		end=next;
		//i=next-scan;
		bEscape=false;
		if (ret){
			for(next=scan;next<end;next++)
			{
				if(*next==L'\\'&&!bEscape){
					bEscape=true;
				}else{
					*ret++=*next;
					bEscape=false;
				}
			}
			*ret=L'\0';
		}

	}
	return i;
}

// I: str  		要分割的字符串
// I: Delimiters	分割字符集合开始地址，默认是TAB,SPACE
// 返回值		分割之后的字符串
//------------------------------------------------
// 开始 字符【‘/“】时候连续一样的字符【‘/“】时候表示转义，如下
//  ''abc'	'123'   	=>	[][abc']
//  'a'bc'	'123'   	=>	[a][bc']
//  'a''bc'	'123'	=>	[a'bc][123]
//  'a'''bc'	'123'	=>	[a'][bc']
std::wstring subwcs(std::wstring &str, std::wstring Delimiters){

	std::wstring strRet;
	std::wstring strOrg;
	strRet=L"";
	strtools::trim(str);
	//str.TrimLeft();
	//str.TrimRight();
	if (!str.empty()){

		bool transferred_meaning=false;
		bool bSingleQuotation=false;
		bool bDoubleQuotation=false;

		std::wstring::iterator it=str.begin();
		if(*it==L'\''){
			bSingleQuotation=true;
		}else if(*it==L'"'){
			bDoubleQuotation=true;
		}else{
			strRet+=*it;
		}
		++it;

		for(; it!=str.end(); ++it){
			if(*it==L'\''){
				if(bSingleQuotation && !transferred_meaning){
					transferred_meaning=true;
				}else if(bDoubleQuotation &&transferred_meaning){
					break;
				}else{
					// *it=='
					transferred_meaning=false;
					strRet+=*it;
				}
			}else if(*it==L'"'){
				if(bDoubleQuotation && !transferred_meaning){
					transferred_meaning=true;
				}else if(bSingleQuotation && transferred_meaning){
					break;
				}else{
					// *it=="
					transferred_meaning=false;
					strRet+=*it;
				}
			}else{
				if((bSingleQuotation||bDoubleQuotation)&&transferred_meaning){
					break;
				}else if(!bSingleQuotation&&!bDoubleQuotation&&( wcschr(Delimiters.c_str(),*it))){
					break;
				}else{
					strRet+=*it;
				}
				transferred_meaning=false;
			}

		}
		str.erase(str.begin(),it);
	}
	return strRet;
}

// I: str  		要分割的字符串
// I: substr		读取的一行
// 返回值		空字符：flase,有字符：true
//------------------------------------------------
// 读取一行，根据  CR[\r] LF[\n]  分割字符串
bool readwcs(std::wstring & str,std::wstring & substr){
	 //const wchar_t * bb=(const)str;
	 // int i;

	//wchar_t* b=(wchar_t *)bb;
	// int Length;
	bool back;
	//str.LockBuffer();
	//std::wstring backstr;
	if (!str.empty()){
		//Length=str.size();

		//i=str.Find(0x0A,0);
		std::size_t pos=str.find_first_of(L"\r\n",0);
		//if(i>0){
		if(pos!=std::string::npos){
			substr=str.substr(0,pos);
			std::size_t next=str.find_first_not_of(L"\r\n",pos);
			if(next!=std::string::npos){
				str.erase(0,next);
			}else{
				str.clear();
			}
		}else{
			substr=str;
			str.clear();
		}

		back=true;
		//substr=backstr;

	}else{
		back=false;
	}
	return back;
}

// I: str  		要分割的字符串
// O: n		n
// O: m		m
//------------------------------------------------
// return 0		{n}
//  return 1		{,m}
//  return 2		{n,m}   {n,}
//  return 3		{}
long wcs2int(std::wstring& str,int & n, int& m )
{
	if(str.size()>0){
		int pos=str.find(L',',0);
		if (pos<0) {			//褰搟n} return n
			n=wcstol(str.c_str(), NULL, 0);
			m=n;
			return 0;
		}else if(pos==0){		//褰搟,n} return 0,
			n=0;
			m=wcstol(str.substr(1).c_str(), NULL, 0);
			return 1;
		}else{				//褰搟n,m} return n,
			n=wcstol(str.substr(0, pos).c_str(), NULL, 0);
			m=wcstol(str.substr(pos+1).c_str(), NULL, 0);
			return 2;
		}
	}else{
		n=0;
		m=0;
		return 3;
	}
}


std::wstring MStrToWStr(std::string& str,int len){
	//CCode   euc_code;
	if (-1 == len)
		len=str.size();
	
	Utf16_Read convert;
	
	int length=convert.convert(str.c_str(), len,false);
	return std::wstring(reinterpret_cast<const wchar_t*>(convert.getNewBuf()), length/2);

}
std::string WStrToMStr(std::wstring& str,int len){
	//CCode   euc_code;
	if (-1 == len)
		len=str.size();
	int needLength = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)str.c_str(), len, NULL, 0, NULL, NULL);
	// char  multibyte[needLength];
	char *ansi_buf=new char[needLength+1];
	memset(ansi_buf, 0x00, needLength + 1);
	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)str.c_str(), len, ansi_buf, needLength, NULL, NULL);
	std::string  ret(ansi_buf, needLength);
	delete [] ansi_buf;
	return ret;
}

std::wstring Format(const wchar_t * sFormat, ...)
{

	//整形
	static wchar_t szText[16000];
	va_list argList;
	va_start(argList, sFormat);
	int ret = _vsnwprintf(szText, _countof(szText), sFormat, argList);
	std::wstring	sMsg(szText);

	va_end(argList);
	return  sMsg;
}


}