/*

"Spam Filter"-Plugin for Miranda IM

Copyright 2003-2006 Heiko Herkenrath

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program ("SpamFilter-License.txt"); if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/


// -- Includes
#include "common.h"


// -----------------------------------------


/*
int SubStringExistsInStringCount(const TCHAR* pszStr, const TCHAR* pszSubString, BOOL bCaseSensitive)
{
	int iSubStrLen;
	char* pszOcc;
	int iReturn;

	if (!pszSubString) return 0;

	pszOcc = pszStr;
	iCount = 0;
	iSubStrLen = lstrlen(pszSubString);
	while ((pszOcc = bCaseSensitive?StrStr(pszOcc, pszOldSubStr):StrStrI(pszOcc, pszOldSubStr)) != NULL)
	{
		iCount++;
		pszOcc = pszOcc+iSubStrLen;
	}

	return iCount;
}
*/


WCHAR* RemoveSubStr(WCHAR* pszStr, int iPos, int iSubStrLen)
{
	if (!pszStr) return NULL;
	if ((iPos > 0) && (iSubStrLen > 0) && (iPos < lstrlen(pszStr)))
		MoveMemory(&pszStr[iPos], &pszStr[iPos+iSubStrLen], (lstrlen(&pszStr[iPos])+1)*sizeof(WCHAR));
	return pszStr;
}

/*
BOOL HasSubStr(const TCHAR* pszStr, int iPos, const TCHAR* pszSubStr);
{
	TCHAR* pszPos;

	if (!pszSubStr || !pszStr || (iPos >= lstrlen(pszStr))) return FALSE;

	// Test for suffix
	if (iPos < 0)
		return ((lstrlen(pszStr) <= lstrlen(pszSubStr)) || (StrCmp(pszStr+lstrlen(pszStr)-lstrlen(pszSubStr), pszSubStr) != 0));
	else
		return (StrCmpN(&pszStr[iPos], pszSubStr, lstrlen(pszSubStr)) != 0))
}
*/

WCHAR* InsertSubStr(WCHAR* pszStr, int cchMaxSize, int iPos, const WCHAR* pszSubStr)
{
	int iSubStrLen;

	if (!pszStr) return NULL;
	if (!pszSubStr || (iPos < 0) || (iPos >= lstrlen(pszStr))) return pszStr;
	iSubStrLen = lstrlen(pszSubStr);
	if ((cchMaxSize > 0) && ((iSubStrLen+lstrlen(pszStr)+1) > cchMaxSize))
		return pszStr;
	MoveMemory(&pszStr[iPos+iSubStrLen], &pszStr[iPos], (lstrlen(&pszStr[iPos])+1)*sizeof(WCHAR));
	CopyMemory(&pszStr[iPos], pszSubStr, iSubStrLen*sizeof(WCHAR)); // no terminating zero
	return pszStr;
}


WCHAR* ReplaceSubStringWithString(const WCHAR* pszStr, const WCHAR* pszOldSubStr, const WCHAR* pszNewSubStr, BOOL bCaseSensitive, BOOL bAlsoSearchNewString, BOOL* pbSthReplaced)
{
	// returned TCHAR* needs to be mir_free()'d
	// returns NULL on error
	
	int iOldSubStrLen, iNewSubStrLen;
	int iPos;
	WCHAR* pszOcc;
	WCHAR* pszReturn;
	WCHAR* pszReturnBuf;

	if (pbSthReplaced) *pbSthReplaced = FALSE;
	if (!pszStr) return NULL;
	if (!pszOldSubStr) {
		*pbSthReplaced = TRUE;
		return mir_wstrdup(pszStr);
	}

	iOldSubStrLen = (int)lstrlen(pszOldSubStr);
	iNewSubStrLen = pszNewSubStr?(int)lstrlen(pszNewSubStr):0;

	// Make sure that no infinite loop occurs (on str in new one)
	if (bAlsoSearchNewString && pszNewSubStr)
		if (bCaseSensitive?StrStr(pszNewSubStr, pszOldSubStr):StrStrI(pszNewSubStr, pszOldSubStr))
			bAlsoSearchNewString = FALSE;

	pszReturn = mir_wstrdup(pszStr);
	if (!pszReturn) return NULL;
	
	pszOcc = pszReturn;
	while ((pszOcc = bCaseSensitive?StrStr(pszOcc, pszOldSubStr):StrStrI(pszOcc, pszOldSubStr)) != NULL)
	{
		// Reallocate more memory (memory block might get moved)
		if (iNewSubStrLen > iOldSubStrLen)
		{
			pszReturnBuf = pszReturn;
			pszReturn = (WCHAR*)mir_realloc(pszReturnBuf, (lstrlen(pszReturn)+iNewSubStrLen-iOldSubStrLen+1)*sizeof(WCHAR));
			if (!pszReturn) {
				mir_free(pszReturnBuf);
				return NULL;
			}
		}

		iPos = pszOcc-pszReturn;
		RemoveSubStr(pszReturn, iPos, iOldSubStrLen);
		if (pszNewSubStr) InsertSubStr(pszReturn, 0, iPos, pszNewSubStr);

		// Get new start position for search
		if (!bAlsoSearchNewString)
			pszOcc = &pszReturn[iPos+iNewSubStrLen];

		if (pbSthReplaced) *pbSthReplaced = TRUE;
	}

	// Correct memory allocation (if less needed)
	if (iNewSubStrLen < iOldSubStrLen)
	{
		pszReturnBuf = pszReturn;
		pszReturn = (WCHAR*)mir_realloc(pszReturnBuf, (lstrlen(pszReturn)+1)*sizeof(WCHAR));
		if (!pszReturn) pszReturn = pszReturnBuf;
	}

	return pszReturn;
}


BOOL ReplaceSubStringWithStringBuf(WCHAR* pszStr, int cchMaxSize, const WCHAR* pszOldSubStr, const WCHAR* pszNewSubStr, BOOL bCaseSensitive, BOOL bAlsoSearchNewString)
{
	int iOldSubStrLen, iNewSubStrLen;
	int iPos;
	WCHAR* pszOcc;
	BOOL bSthReplaced;

	if (!pszStr) return FALSE;
	if (!pszOldSubStr || (cchMaxSize <= 0)) return TRUE;

	iOldSubStrLen = (int)lstrlen(pszOldSubStr);
	iNewSubStrLen = pszNewSubStr?(int)lstrlen(pszNewSubStr):0;

	// Make sure that no infinite loop occurs (on str in new one)
	if (bAlsoSearchNewString && pszNewSubStr)
		if (bCaseSensitive?StrStr(pszNewSubStr, pszOldSubStr):StrStrI(pszNewSubStr, pszOldSubStr))
			bAlsoSearchNewString = FALSE;
	
	pszOcc = pszStr;
	bSthReplaced = FALSE;
	while ((pszOcc = bCaseSensitive?StrStr(pszOcc, pszOldSubStr):StrStrI(pszOcc, pszOldSubStr)) != NULL)
	{
		if (cchMaxSize < lstrlen(pszStr)+iNewSubStrLen-iOldSubStrLen+1);
			break;

		iPos = pszOcc-pszStr;
		RemoveSubStr(pszStr, iPos, iOldSubStrLen);
		if (pszNewSubStr) InsertSubStr(pszStr, 0, iPos, pszNewSubStr);

		// Get new start position for search
		if (!bAlsoSearchNewString)
			pszOcc = &pszStr[iPos+iNewSubStrLen];

		bSthReplaced = TRUE;
	}

	return bSthReplaced;
}


WCHAR* ReplaceSubStringWithStringMultiple(const WCHAR* pszStr, STRINGLIST* pslFromTo, BOOL bCaseSensitive, BOOL bAlsoSearchNewString, BOOL* pbSthReplaced)
{
	WCHAR* pszReplaced;
	WCHAR* pszStrBuf;
	int i;
	BOOL bSthReplacedBuf;

	if (pbSthReplaced) *pbSthReplaced = FALSE;
	if (!pszStr) return NULL;
	pszStrBuf = mir_wstrdup(pszStr);
	if (pszStrBuf && pslFromTo)
		for (i=SL_MIN_POS; i<SLGetMaxPos(pslFromTo); i+=2)
		{
			pszReplaced = ReplaceSubStringWithString(pszStrBuf, SLGetItem(pslFromTo, i), SLGetItem(pslFromTo, i+1), bCaseSensitive, bAlsoSearchNewString, &bSthReplacedBuf);
			if (!pszReplaced) continue;
			if (pszStrBuf) mir_free(pszStrBuf);
			pszStrBuf = pszReplaced;
			if (pbSthReplaced && bSthReplacedBuf) *pbSthReplaced = TRUE;
		}

	return pszStrBuf;
}


BOOL ReplaceSubStringWithStringMultipleBuf(WCHAR* pszStr, int cchMaxSize, STRINGLIST* pslFromTo, BOOL bCaseSensitive, BOOL bAlsoSearchNewString)
{
	int i;
	BOOL bSthReplaced;

	if (!pszStr) return FALSE;
	if (!pslFromTo) return TRUE;

	bSthReplaced = FALSE;
	for (i=SL_MIN_POS; i<SLGetMaxPos(pslFromTo); i+=2)
		if (ReplaceSubStringWithStringBuf(pszStr, cchMaxSize, SLGetItem(pslFromTo, i), SLGetItem(pslFromTo, i+1), bCaseSensitive, bAlsoSearchNewString))
			bSthReplaced = TRUE;

	return bSthReplaced;
}


WCHAR* InsertSubStrEveryNChars(const WCHAR* pszStr, int iDist, const WCHAR* pszSubStr, BOOL bAlsoDoFirst, BOOL bAlsoDoLast)
{
	// returned char needs to be mir_free()'d
	// returns NULL on error

	int iSubStrLen;
	int iLoops;
	WCHAR* pszReturn;
	int i;

	if (!pszStr) return NULL;
	if (iDist <= 0) return mir_wstrdup(pszStr);

	iSubStrLen = pszSubStr?lstrlen(pszSubStr):0;
	iLoops = (int)(lstrlen(pszStr)/iDist);
	if ((iLoops == (int)(lstrlen(pszStr)/iDist)) && !bAlsoDoLast) iLoops--;
	if (bAlsoDoFirst) iLoops++;

	pszReturn = (WCHAR*)mir_alloc((lstrlen(pszStr)+(iLoops*iSubStrLen)+1)*sizeof(WCHAR));
	if (!pszReturn) return NULL;
	mir_sntprintf(pszReturn, lstrlen(pszStr)+(iLoops*iSubStrLen)+1, _T("%s"), pszStr);

	if (iSubStrLen > 0)
		for (i=0; i<iLoops; i++) // FIX ME: use NextChar() instead
			InsertSubStr(pszReturn, 0, (bAlsoDoFirst?0:iDist)+(i*(iSubStrLen+iDist)), pszSubStr);

	return pszReturn;
}


BOOL RemoveWhiteSpaces(WCHAR* pszStr, BOOL bReplaceWithSpaces, BOOL bAlsoUnneededSpaces)
{
	BOOL bReturn = FALSE;

	if (!pszStr) return bReturn;

	if (StrTrim(pszStr, _T("\r\n\t"))) bReturn = TRUE;
	if (ReplaceSubStringWithStringBuf(pszStr, 0, _T("\r\n"), bReplaceWithSpaces?_T(" "):_T(""), TRUE, FALSE)) bReturn = TRUE;
	if (ReplaceSubStringWithStringBuf(pszStr, 0, _T("\r"), bReplaceWithSpaces?_T(" "):_T(""), TRUE, FALSE)) bReturn = TRUE;
	if (ReplaceSubStringWithStringBuf(pszStr, 0, _T("\n"), bReplaceWithSpaces?_T(" "):_T(""), TRUE, FALSE)) bReturn = TRUE;
	if (ReplaceSubStringWithStringBuf(pszStr, 0, _T("\t"), bReplaceWithSpaces?_T(" "):_T(""), TRUE, FALSE)) bReturn = TRUE;
	
	if (bAlsoUnneededSpaces)
	{
		if (StrTrim(pszStr, _T(" "))) bReturn = TRUE;
		if (ReplaceSubStringWithStringBuf(pszStr, 0, _T("  "), _T(" "), TRUE, TRUE)) bReturn = TRUE;
	}

	return bReturn;
}


BOOL GetRandomString(WCHAR* pszStr, int cchSize)
{
	static BOOL bRandInited = FALSE;
	const WCHAR* pszChars = TranslateT("abcdefghkmnpqrstuvwxyz23456789ABCDEFGHJKLMNPQRSTUVWXYZ23456789"); // misunderstandable chars were removed (l=I=1, O=0=o, i=j)
	int i;
	
	if (!pszChars || !pszStr || (cchSize < 1)) return FALSE;
	
	// Initialize random seed
	if (!bRandInited)
	{
		srand((unsigned int)(GetTickCount()+time(NULL))); // very random
		bRandInited = TRUE;
	}
	
	for (i=0; i<(cchSize-1); i++)
		pszStr[i] = pszChars[(rand()*lstrlen(pszChars))/RAND_MAX]; // % operator is not a good choice

	pszStr[cchSize-1] = _T('\0');
	return TRUE;
}