#include "stringex.h"

#include "Common.h"	// for debug
#include "Logger.h"	// for debug

#ifdef _WIN32

#else

//#ifndef __CYGWIN__
int stricmp(const char * first, const char * last)
{
	int f, l;
	
	do
	{
		f = tolower(*first);
		l = tolower(*last);
		first++;
		last++;
	} while (f && l && f == l);

	//return(f - l);
	return f == l ? 0 : f > l ? 1 : -1;
}

int strnicmp(const char * first, const char * last, unsigned int count)
{
	int f, l;
	
	if (count)
	{
		do
		{
			f = tolower(*first);
			l = tolower(*last);
			first++;
			last++;
		} while (--count && f && l && f == l);
		
		//return(f - l);
		return f == l ? 0 : f > l ? 1 : -1;
	}

	return 0;
}

char * strlwr(char * str)
{
	char * p = str;

	do
	{
		*p = tolower(*p);
		p++;
	} while (*p);

	return(str);
}

char * strupr(char * str)
{
	char * p = str;

	do
	{
		*p = toupper(*p);
		p++;
	} while (*p);

	return(str);
}
//#endif	// __CYGWIN__

#endif

char * gets_hus(char * s, int n)
{
    char * ch = s;
    int k;
 
    while ((k = getchar ()) != '\n')
	{
        if (k == EOF)
		{
            if (ch == s || !feof(stdin)) 
                return NULL;
 
            break;
        }
 
        *ch++ = k;
		if (--n <= 1)
			break;
    }
 
    *ch = '\0';
 
    return s; 
}

char * stristr(char * pszStr, char * pszSearch)
{
	if (pszStr == NULL)
	{
		//HLOG(15, "[TRACE], stristr string is NULL\n");
		return NULL;
	}

	char *cp = pszStr;
	char *s1, *s2;
	int f, l;

	if (!*pszSearch)
		return pszStr;

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)pszSearch;

		f = tolower(*s1);
		l = tolower(*s2);

		while (f && l && !(f-l))
		{
			s1++, s2++;
			f = tolower(*s1);
			l = tolower(*s2);
		}

		if (!*s2)
			return cp;

		cp++;
	}

	return NULL;
}

char * StrIKeyword(char * string, char * strSearch)
{
	char *cp = string;
	char *s1, *s2;
	int f, l;

	if (!*strSearch)
		return string;

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;

		f = tolower(*s1);
		l = tolower(*s2);

		while (f && l && !(f-l))
		{
			s1++, s2++;
			f = tolower(*s1);
			l = tolower(*s2);
		}

		if (*s1 < 0)
		{
			cp++;
			continue;
		}


		//if (!*s2)	// stristr
		if (!*s2 && !isalnum(*s1) && *s1 != '.')	// for com, com.cn
			return cp;

		cp++;
	}

	return NULL;
}

const char * StrNStr(const char * string, const char * strSearch, int nCount)
{
	char *cp = (char *)string;
	char *s1, *s2;
	int f, l, nRemain = nCount, nr2 = nCount;

	if (nCount == 0)
		return NULL;

	if (!*strSearch)
		return((char *)string);

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;

		f = *s1;
		l = *s2;

		if (nCount > 0)
			nr2 = nRemain;

		while (f && l && !(f-l))
		{
			s1++, s2++;
			f = *s1;
			l = *s2;

			if (nCount > 0 && --nr2 < 0)
				return NULL;
		}

		if (!*s2)
			return cp;

		cp++;
		if (nCount > 0 && --nRemain <= 0)
			return NULL;
	}

	return NULL;
}

const char * StrNIStr(const char * string, const char * strSearch, int nCount)
{
	char *cp = (char *)string;
	char *s1, *s2;
	int f, l, nRemain = nCount, nr2 = nCount;

	if (nCount == 0)
		return NULL;

	if (!*strSearch)
		return((char *)string);

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;

		f = tolower(*s1);
		l = tolower(*s2);

		if (nCount > 0)
			nr2 = nRemain;

		while (f && l && !(f-l))
		{
			s1++, s2++;
			f = tolower(*s1);
			l = tolower(*s2);

			if (nCount > 0 && --nr2 < 0)
				return NULL;
		}

		if (!*s2)
			return cp;

		cp++;
		if (nCount > 0 && --nRemain <= 0)
			return NULL;
	}

	return NULL;
}

const char * StrRChr(const char * string, const char * strStart, char ch)
{
	const char * s = strStart;

	if (strStart == NULL || string > s)
		return NULL;

	while (s != string)
	{
		if (*s == ch)
			return s;

		s--;
	}

	return NULL;
}

#if 0
const char * StrNIKeyword(const char * string, const char * strSearch, int nCount)
{
	char *cp = (char *)string;
	char *s1, *s2;
	int f, l, nRemain = nCount, nr2 = nCount;

	if (nCount == 0)
		return NULL;

	if (!*strSearch)
		return((char *)string);

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;

		f = tolower(*s1);
		l = tolower(*s2);

		if (nCount > 0)
			nr2 = nRemain;

		while (f && l && !(f-l))
		{
			s1++, s2++;
			f = tolower(*s1);
			l = tolower(*s2);

			if (nCount > 0 && --nr2 < 0)
				return NULL;
		}

		//if (!*s2)	// StrNIStr
		if (!*s2 && !isalnum(*s1) && *s1 != '.')
			return cp;

		cp++;
		if (nCount > 0 && --nRemain <= 0)
			return NULL;
	}

	return NULL;
}
#endif

const char * StrStrUntilChr(const char * string, const char * strSearch, char chUntil)
{
	char *cp = (char *)string;
	char *s1, *s2;

	if (!*strSearch)
		return ((char *)string);

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;

		if (*s1 == chUntil)
			return NULL;
		
		while (*s1 && *s2 && !(*s1-*s2))
		{
			s1++, s2++;
		}

		if (!*s2)
			return cp;

		cp++;
	}

	return NULL;
}

const char * StrStrUntilStr(const char * string, const char * strSearch, const char * strUntil)
{
	char *cp = (char *)string;
	char *s1, *s2, *s3;

	if (!*strSearch)
		return ((char *)string);

	while (*cp)
	{
		s1 = cp;
		s2 = (char *)strSearch;
		s3 = (char *)strUntil;

		while (*s1 && *s3 && !(*s1-*s3))
		{
			s1++, s3++;
		}

		if (!*s3)
			return NULL;
		
		while (*s1 && *s2 && !(*s1-*s2))
		{
			s1++, s2++;
		}

		if (!*s2)
			return cp;

		cp++;
	}

	return NULL;
}

const char * StrBetweenCpy(const char * pSrc, const char * pszFront, const char * pszRear, char * pDst)
{
	char * pszStart, * pszEnd;

	if ((pszStart = (char *)strstr(pSrc, pszFront)) == NULL)
		return NULL;

	pszStart += strlen(pszFront);

	if ((pszEnd = strstr(pszStart, pszRear)) == NULL)
		return NULL;
	
	strncpy(pDst, pszStart, pszEnd - pszStart);
	pDst[pszEnd - pszStart] = '\0';

	return pszEnd + strlen(pszRear);
}

size_t StrRemoveBetween(char * pszDst, const char * pszSrc, const char * pszFront, const char * pszRear)
{
	char * pszStart, * pszEnd;

	if ((pszStart = (char *)strstr(pszSrc, pszFront)) == NULL)
		return 0;

	pszStart += strlen(pszFront);

	if ((pszEnd = strstr(pszStart, pszRear)) == NULL)
		return 0;

	size_t nFrontSize = pszStart - pszSrc;
	strncpy(pszDst, pszSrc, nFrontSize);
	strcpy(pszDst + nFrontSize, pszEnd);

	return nFrontSize + strlen(pszEnd);
}

int StrCountChar(const char * string, char ch)
{
	int n = 0;
	while (*string)
	{
		if (*string++ == ch)
			n++;
	}
	return n;
}

int StrCountStr(const char * string, const char * strSearch)
{
	int nCount = 0;
	size_t nSrcLength = strlen(string);
	size_t nFindLength = strlen(strSearch);

	char * pszStart = (char *)string;
	char * pszEnd = (char *)string + nSrcLength;
	char * pszTarget;
	while (pszStart < pszEnd)
	{
		while ((pszTarget = strstr(pszStart, strSearch)) != NULL)
		{
			nCount++;
			pszStart = pszTarget + nFindLength;
		}
		pszStart += strlen(pszStart) + 1;
	}

	return nCount;
}

int StrCountRow(const char * string)
{
	int nCount = 0;
	const char * p = string;
	while (*p)
	{
		if (*p++ == '\n')
			nCount++;
	}

	if (nCount == 0)
	{
		p = string;
		while (*p)
		{
			if (*p++ == '\r')
				nCount++;
		}
	}

	if (nCount == 0 && *string != '\0')
		return 1;

	return nCount;
}

char * StrTok(const char * pszSrc, const char * pszDelimit, char * pszTokenBuff)
{
	char * pNext, * pSrcOffset = (char *)pszSrc;

	for (;;)
	{
		pNext = strstr(pSrcOffset, pszDelimit);
		if (pNext == NULL)
		{
			strcpy(pszTokenBuff, pSrcOffset);
			return NULL;
		}
		else if (pNext != pSrcOffset)
			break;

		pSrcOffset += strlen(pszDelimit);
	}

	strncpy(pszTokenBuff, pSrcOffset, pNext - pSrcOffset);
	pszTokenBuff[pNext - pSrcOffset] = '\0';
	
	return pNext + strlen(pszDelimit);
}

// const char pszTest[] = "     123456     ";
// char * psz = (char *)pszTest;
// StrTrim(&psz, strlen(psz), true, true);
// psz --> "123456"
void StrTrim(char ** ppsz, size_t nLength, bool bRemoveFront, bool bRemoveRear)
{
	if (bRemoveFront)
	{
		size_t i;
		for (i = 0; i < nLength; i++)
		{
			if ((*ppsz)[i] == ' ' || (*ppsz)[i] == '\t')
			{
				continue;
			}
			else
			{
				nLength -= i;
				*ppsz = *ppsz + i;
				break;
			}
		}

		if (i == nLength)
		{
			nLength = 0;
			(*ppsz)[0] = '\0';
		}
	}
	
	if (bRemoveRear)
	{
		for (int i = int(nLength - 1); i >= 0; i--)
		{
			if ((*ppsz)[i] == ' ' || (*ppsz)[i] == '\t')
			{
				(*ppsz)[i] = '\0';
				continue;
			}
			else
			{
				break;
			}
		}
	}
}

const char * StrNTrimPtr(const char * pszSrc, int nSrcCount)
{
	int nRemain = nSrcCount;
	for (;;)
	{
		if (*pszSrc == '\0')
			break;
		else if (*pszSrc == ' ' || *pszSrc == '\t')
			pszSrc++;
		else
			break;

		if (nSrcCount > 0 && --nRemain <= 0)
			break;
	}

	return pszSrc;
}

void StrNTrimCpy(char * pszDst, const char * pszSrc, int nSrcCount)
{
	if (nSrcCount == 0)
		return;

	int nRemain = nSrcCount;
	for (;;)
	{
		if (*pszSrc == '\0')
			break;
		else if (*pszSrc == ' ' || *pszSrc == '\t')
			pszSrc++;
		else
			*pszDst++ = *pszSrc++;

		if (nSrcCount > 0 && --nRemain <= 0)
			break;
	}

	*pszDst = '\0';
}

char * StrReadLine(char * pszDst, const char * pszSrc, int nCount)
{
	int i = 0;
	for (; ; i++)
	{
		if (nCount > 0 && i >= nCount)
			break;

		if (pszSrc[i] == '\r' ||
			pszSrc[i] == '\n')
		{
			pszDst[i] = '\0';
			break;
		}
		else if (pszSrc[i] == '\0')
		{
			pszDst[i] = '\0';
			return NULL;
		}
		else
			pszDst[i] = pszSrc[i];
	}

	for (; ; i++)
	{
		if (nCount > 0 && i >= nCount)
			break;

		if (pszSrc[i] != '\r' && pszSrc[i] != '\n' && pszSrc[i] != 0x09)
			break;
	}

	return (char *)pszSrc + i;
}

// return new memory
const char * StrReplace(const char * pszText, const char * pszKeyword, const char * pszReplace, int nMode, int nCount)
{
	if (nCount == 0)
		return NULL;

	const char * (*fnStrStr)(const char *, const char *);
	if (nMode == 0)
		fnStrStr = (const char*(*)(const char*, const char*))strstr;
	else if (nMode == 1)
		fnStrStr = stristr;
	else
		fnStrStr = StrIKeyword;

	int nRepeatCount = nCount;
	size_t nKeywordLength = strlen(pszKeyword);
	const char * pszNext = (const char *)pszText;
	int nKeywordCount = 0;
	for (;;)
	{
		if ((pszNext = fnStrStr(pszNext, pszKeyword)) == NULL)
			break;
		
		nKeywordCount++;

		if (nRepeatCount > -1 && --nRepeatCount == 0)
			break;

		pszNext += nKeywordLength;
	}

	if (nKeywordCount == 0)
		return NULL;

	size_t nReplaceLength = strlen(pszReplace);
	size_t nTextLength = strlen(pszText);
	size_t nNewTextLength = nTextLength + (nReplaceLength - nKeywordLength) * nKeywordCount;
	char * pszNewText = (char *)malloc(nNewTextLength + 1);

	size_t nCopySize;
	size_t nRemainSize = nTextLength;
	char * pszNewTextOffset = pszNewText;
	const char * pszTextOffset = pszText;

	nRepeatCount = nCount;
	for (;;)
	{
		if ((pszNext = fnStrStr(pszTextOffset, pszKeyword)) == NULL)
			break;

		nCopySize = pszNext - pszTextOffset;

		memcpy(pszNewTextOffset, pszTextOffset, nCopySize);
		memcpy(pszNewTextOffset + nCopySize, pszReplace, nReplaceLength);

		pszTextOffset += nCopySize + nKeywordLength;
		pszNewTextOffset += nCopySize + nReplaceLength;

		nRemainSize -= nCopySize + nKeywordLength;

		if (nRepeatCount > -1 && --nRepeatCount == 0)
			break;
	}

	if (nRemainSize > 0)
		memcpy(pszNewTextOffset, pszTextOffset, nRemainSize);

	pszNewText[nNewTextLength] = '\0';
	return pszNewText;
}
	
size_t StrReplace2(char * pszDst, const char * pszText, const char * pszKeyword, const char * pszReplace, int nMode, int nCount)
{
	if (nCount == 0)
		return 0;

	const char * (*fnStrStr)(const char *, const char *);
	if (nMode == 0)
		fnStrStr = (const char*(*)(const char*, const char*))strstr;
	else if (nMode == 1)
		fnStrStr = stristr;
	else
		fnStrStr = StrIKeyword;

	size_t nKeywordLength = strlen(pszKeyword);
	size_t nReplaceLength = strlen(pszReplace);
	size_t nRemainSize = strlen(pszText);
	char * pszNewTextOffset = pszDst;
	const char * pszTextOffset = pszText;
	
	size_t nNewTextLength = 0;
	size_t nCopySize;
	const char * pszNext;

	int nRepeatCount = nCount;
	for (;;)
	{
		if ((pszNext = fnStrStr(pszTextOffset, pszKeyword)) == NULL)
			break;

		nCopySize = pszNext - pszTextOffset;

		memcpy(pszNewTextOffset, pszTextOffset, nCopySize);
		memcpy(pszNewTextOffset + nCopySize, pszReplace, nReplaceLength);

		pszTextOffset += nCopySize + nKeywordLength;
		pszNewTextOffset += nCopySize + nReplaceLength;

		nNewTextLength += nCopySize + nReplaceLength;
		nRemainSize -= nCopySize + nKeywordLength;

		if (nRepeatCount > -1 && --nRepeatCount == 0)
			break;
	}

	if (nNewTextLength == 0)
		return 0;
	
	if (nRemainSize > 0)
	{
		memcpy(pszNewTextOffset, pszTextOffset, nRemainSize);
		nNewTextLength += nRemainSize;
	}

	pszDst[nNewTextLength] = '\0';
	return nNewTextLength;
}

const void * memmem_hus(const void * pMem, size_t nMemSize, const void * pKeymem, size_t nKeymemSize)
{
	const char * p1 = (const char *)pMem;
	const char * p2;
	const void * p3;
	size_t nP2;

	do
	{
		p2 = (const char *)pKeymem;
		nP2 = nKeymemSize;

		while (*p1 != *p2)
		{
			p1++;
			nMemSize--;

			if (nMemSize <= 0)
				return NULL;
		}

		p3 = p1;
		do
		{
			p1++;
			nMemSize--;

			p2++;
			nP2--;

			if (nP2 <= 0)
				return p3;
			else if (*p1 != *p2)
				break;
		} while (nMemSize);
	} while (nMemSize);

	return NULL;
}