// Copyright (c) 2020 Lv Decai, Shenzhen, China.
// Filename: StringUtility.cpp
// Version: 1.0
// Release date: 2020年10月11日
// License: MIT (http://opensource.org/licenses/MIT)

#include "StdAfx.h"
#include <atlbase.h>
#include <locale.h>
#include "StringUtility.h"

NAMESPACE_BEGIN;

// 判断一个字符串是否数字字符串
BOOL StringUtility::IsNumeric(PCSTR sInput, BOOL bIncludeDecimal, BOOL bIncludeSign)
{
	if (sInput == NULL || *sInput == '0円')
	{
		return FALSE;
	}

	BOOL bDigit = FALSE;
	BOOL bDecimalPoint = FALSE;
	BOOL bSign = FALSE;

	while (*sInput != '0円')
	{
		if (*sInput >= '0' && *sInput <= '9')
		{
			bDigit = TRUE;
		}
		else if (*sInput == '.')
		{
			if (bIncludeDecimal && bDigit && !bDecimalPoint)
			{
				bDecimalPoint = TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else if (*sInput == '+' || *sInput == '-')
		{
			if (bIncludeSign && !bDigit && !bSign)
			{
				bSign = TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else
		{
			return FALSE;
		}

		sInput++;
	}

	if ((bDecimalPoint || bSign) && !bDigit)
	{
		return FALSE;
	}

	return TRUE;
}

// 判断一个字符串是否数字字符串
BOOL StringUtility::IsNumeric(PCWSTR sInput, BOOL bIncludeDecimal, BOOL bIncludeSign)
{
	if (sInput == NULL || *sInput == L'0円')
	{
		return FALSE;
	}

	BOOL bDigit = FALSE;
	BOOL bDecimalPoint = FALSE;
	BOOL bSign = FALSE;

	while (*sInput != L'0円')
	{
		if (*sInput >= L'0' && *sInput <= L'9')
		{
			bDigit = TRUE;
		}
		else if (*sInput == L'.')
		{
			if (bIncludeDecimal && bDigit && !bDecimalPoint)
			{
				bDecimalPoint = TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else if (*sInput == L'+' || *sInput == L'-')
		{
			if (bIncludeSign && !bDigit && !bSign)
			{
				bSign = TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else
		{
			return FALSE;
		}

		sInput++;
	}

	if ((bDecimalPoint || bSign) && !bDigit)
	{
		return FALSE;
	}

	return TRUE;
}

// 判断一个字符串是否十六进制数字字符串
BOOL StringUtility::IsHex(PCSTR sInput)
{
	if (!ValidString(sInput))
	{
		return FALSE;
	}

	while (*sInput != '0円')
	{
		char Char = *sInput;

		if (!('0' <= Char && Char <= '9')
			&& !('A' <= Char && Char <= 'F')
			&& !('a' <= Char && Char <= 'f'))
		{
			return FALSE;
		}

		sInput++;
	}

	return TRUE;
}

// 判断一个字符串是否十六进制数字字符串
BOOL StringUtility::IsHex(PCWSTR sInput)
{
	if (!ValidString(sInput))
	{
		return FALSE;
	}

	while (*sInput != L'0円')
	{
		WCHAR Char = *sInput;

		if (!(L'0' <= Char && Char <= L'9')
			&& !(L'A' <= Char && Char <= L'F')
			&& !(L'a' <= Char && Char <= L'f'))
		{
			return FALSE;
		}

		sInput++;
	}

	return TRUE;
}

// 判断一个字符串是否为 IP 地址
BOOL StringUtility::IsIpAddress(PCSTR sIp)
{
	return IsIpAddress(CA2W(sIp));
}

// 判断一个字符串是否为 IP 地址
BOOL StringUtility::IsIpAddress(PCWSTR sIp)
{
	list<CString> lstPieces;

	if (Split(CW2T(sIp), lstPieces, _T(".")) != 4)
	{
		return FALSE;
	}

	for (CString& sNumber : lstPieces)
	{
		if (!IsNumeric(sNumber, FALSE, FALSE))
		{
			return FALSE;
		}

		int iNumber = _ttoi(sNumber);

		if (iNumber < 0 || iNumber > 255)
		{
			return FALSE;
		}
	}

	return TRUE;
}

// 从字符串表加载指定的字符串资源
CString StringUtility::GetStringResource(UINT iResourceId, PCTSTR sDefault)
{
	CString sResource;

	if (sResource.LoadString(iResourceId))
	{
		return sResource;
	}
	else
	{
		return sDefault;
	}
}

// 切分字符串
size_t StringUtility::Split(PCTSTR sSource, list<CString>& lstDest, PCTSTR sDivision, BOOL bIncludeNullString)
{
	lstDest.clear();

	if (sSource == NULL || sDivision == NULL)
	{
		return lstDest.size();
	}

	if (sSource[0] == _T('0円'))
	{
		if (bIncludeNullString)
		{
			lstDest.push_back(sSource);
		}

		return lstDest.size();
	}

	if (sDivision[0] == _T('0円'))
	{
		if (bIncludeNullString)
		{
			lstDest.push_back(_T(""));
		}

		while (*sSource != _T('0円'))
		{
			lstDest.push_back(CString(*sSource));
			sSource++;
		}

		if (bIncludeNullString)
		{
			lstDest.push_back(_T(""));
		}

		return lstDest.size();
	}

	CString sSourceCopy(sSource);
	int iStartPosition = 0;
	int iDevisionLength = (int) _tcslen(sDivision);

	if (iDevisionLength < 1)
	{
		iDevisionLength = 1;
	}

	while (TRUE)
	{
		int iFoundPosition = sSourceCopy.Find(sDivision, iStartPosition);

		if (iFoundPosition == -1)
		{
			break;
		}

		if (iFoundPosition > iStartPosition)
		{
			lstDest.push_back(sSourceCopy.Mid(iStartPosition, iFoundPosition - iStartPosition));
		}
		else if (bIncludeNullString)
		{
			lstDest.push_back(_T(""));
		}

		iStartPosition = iFoundPosition + iDevisionLength;
	}

	if (iStartPosition < sSourceCopy.GetLength())
	{
		lstDest.push_back(sSourceCopy.Mid(iStartPosition));
	}
	else if (bIncludeNullString)
	{
		lstDest.push_back(_T(""));
	}

	return lstDest.size();
}

// 切分字符串
size_t StringUtility::Split(PCTSTR sSource, vector<CString>& vecDest, PCTSTR sDivision, BOOL bIncludeNullString)
{
	list<CString> lstDest;
	Split(sSource, lstDest, sDivision, bIncludeNullString);

	vecDest.clear();
	vecDest.reserve(lstDest.size());

	for (CString& sDest : lstDest)
	{
		vecDest.push_back(sDest);
	}

	return vecDest.size();
}

// 切分字符串
size_t StringUtility::Split(PCSTR sSource, list<string>& lstDest, PCSTR sDivision, BOOL bIncludeNullString)
{
	lstDest.clear();

	if (sSource == NULL || sDivision == NULL)
	{
		return lstDest.size();
	}

	if (sSource[0] == '0円')
	{
		if (bIncludeNullString)
		{
			lstDest.push_back(sSource);
		}

		return lstDest.size();
	}

	if (sDivision[0] == '0円')
	{
		if (bIncludeNullString)
		{
			lstDest.push_back("");
		}

		while (*sSource != '0円')
		{
			lstDest.push_back(string(sSource, 1));
			sSource++;
		}

		if (bIncludeNullString)
		{
			lstDest.push_back("");
		}

		return lstDest.size();
	}

	string sSourceCopy(sSource);

	lstDest.clear();

	string::size_type iPosition = sSourceCopy.find(sDivision);
	while (iPosition != string::npos)
	{
		if (iPosition == 0 && bIncludeNullString)
		{
			lstDest.push_back(string(""));
		}
		else if (iPosition > 0)
		{
			lstDest.push_back(sSourceCopy.substr(0, iPosition));
		}

		sSourceCopy = sSourceCopy.substr(iPosition + 1);

		iPosition = sSourceCopy.find(sDivision);
	}

	if (!sSourceCopy.empty() || bIncludeNullString)
	{
		lstDest.push_back(sSourceCopy);
	}

	return lstDest.size();
}

// 切分字符串
size_t StringUtility::Split(PCSTR sSource, vector<string>& vecDest, PCSTR sDivision, BOOL bIncludeNullString)
{
	list<string> lstDest;
	Split(sSource, lstDest, sDivision, bIncludeNullString);

	vecDest.clear();
	vecDest.reserve(lstDest.size());

	for (string& sDest : lstDest)
	{
		vecDest.push_back(sDest);
	}

	return vecDest.size();
}

// 拼接字符串
CString StringUtility::Join(const vector<CString>& vecStr, PCTSTR sDivision)
{
	CString sResult;

	for (auto& sPiece : vecStr)
	{
		if (!sResult.IsEmpty())
		{
			sResult += sDivision;
		}

		sResult += sPiece;
	}

	return sResult;
}

// 拼接字符串
CString StringUtility::Join(const list<CString>& lstStr, PCTSTR sDivision)
{
	CString sResult;

	for (auto& sPiece : lstStr)
	{
		if (!sResult.IsEmpty())
		{
			sResult += sDivision;
		}

		sResult += sPiece;
	}

	return sResult;
}

// 字符串格式化
CStringA StringUtility::Format(PCSTR sFormat, ...)
{
	if (!ValidString(sFormat))
	{
		return "";
	}

	CStringA sResult;

	va_list args;
	va_start(args, sFormat);
	sResult.FormatV(sFormat, args);
	va_end(args);

	return sResult;
}

// 字符串格式化
CStringW StringUtility::Format(PCWSTR sFormat, ...)
{
	if (!ValidString(sFormat))
	{
		return L"";
	}

	CStringW sResult;

	va_list args;
	va_start(args, sFormat);
	sResult.FormatV(sFormat, args);
	va_end(args);

	return sResult;
}

// 在一个字符串中查找位于指定子字符串之间的内容
CStringA StringUtility::GetSubString(PCSTR sIn, int iStartPos, PCSTR sPrifix, PCSTR sSufix)
{
	sIn += iStartPos;

	if (ValidString(sPrifix))
	{
		sIn = strstr(sIn, sPrifix);

		if (sIn == NULL)
		{
			return "";
		}

		sIn += strlen(sPrifix);
	}

	if (!ValidString(sSufix))
	{
		return sIn;
	}

	PCSTR sEnd = strstr(sIn, sSufix);
	if (sEnd == NULL)
	{
		return "";
	}

	CStringA sOut(sIn, (int) (sEnd - sIn));

	return sOut;
}

// 在一个字符串中查找位于指定子字符串之间的内容
CStringW StringUtility::GetSubString(PCWSTR sIn, int iStartPos, PCWSTR sPrifix, PCWSTR sSufix)
{
	sIn += iStartPos;

	if (ValidString(sPrifix))
	{
		sIn = wcsstr(sIn, sPrifix);

		if (sIn == NULL)
		{
			return L"";
		}

		sIn += wcslen(sPrifix);
	}

	if (!ValidString(sSufix))
	{
		return sIn;
	}

	PCWSTR sEnd = wcsstr(sIn, sSufix);
	if (sEnd == NULL)
	{
		return L"";
	}

	CStringW sOut(sIn, (int) (sEnd - sIn));

	return sOut;
}

// 判断字符串是否以指定的子串开头
BOOL StringUtility::StartsWith(CString sSource, CString sSub)
{
	return sSource.Find(sSub) == 0;
}

// 判断字符串是否以指定的子串结尾
BOOL StringUtility::EndsWith(CString sSource, CString sSub)
{
	return sSource.Find(sSub, sSource.GetLength() - sSub.GetLength()) != -1;
}

// 获取环境变量值
CString StringUtility::GetEnvironmentVariable(CString sName)
{
	CString sValue;
	DWORD iBufferSize = 1024;

	while (TRUE)
	{
		DWORD iLength = ::GetEnvironmentVariable(_T("Path"), sValue.GetBuffer(iBufferSize), iBufferSize);

		sValue.ReleaseBuffer();

		if (iLength <= iBufferSize)
		{
			break;
		}

		iBufferSize = iLength;
	}

	return sValue;
}

// 设置环境变量值
BOOL StringUtility::SetEnvironmentVariable(CString sName, CString sValue)
{
	return ::SetEnvironmentVariable(sName, sValue);
}

NAMESPACE_END;