/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 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.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWSaveLoad                                                   *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwlib/widestring.cpp            $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 2/06/02 5:27p                                               $*
 *                                                                                             *
 *                    $Revision:: 13                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#pragma warning(disable : 4514)

#include "widestring.h"
#include "win.h"
#include <stdio.h>


///////////////////////////////////////////////////////////////////
//	Static member initialzation
///////////////////////////////////////////////////////////////////

int		WideStringClass::m_UsedTempStringCount	= 0;

FastCriticalSectionClass WideStringClass::m_TempMutex;

WCHAR		WideStringClass::m_NullChar				= 0;
WCHAR *	WideStringClass::m_EmptyString			= &m_NullChar;

//
// A trick to optimize strings that are allocated from the stack and used only temporarily
//
char		WideStringClass::m_TempString1[WideStringClass::MAX_TEMP_BYTES];
char		WideStringClass::m_TempString2[WideStringClass::MAX_TEMP_BYTES];
char		WideStringClass::m_TempString3[WideStringClass::MAX_TEMP_BYTES];
char		WideStringClass::m_TempString4[WideStringClass::MAX_TEMP_BYTES];

WCHAR *	WideStringClass::m_FreeTempPtr[MAX_TEMP_STRING] = {
	reinterpret_cast<WCHAR *> (m_TempString1 + sizeof (WideStringClass::_HEADER)),
	reinterpret_cast<WCHAR *> (m_TempString2 + sizeof (WideStringClass::_HEADER)),
	reinterpret_cast<WCHAR *> (m_TempString3 + sizeof (WideStringClass::_HEADER)),
	reinterpret_cast<WCHAR *> (m_TempString4 + sizeof (WideStringClass::_HEADER))
};

WCHAR *	WideStringClass::m_ResTempPtr[MAX_TEMP_STRING] = {
	NULL,
	NULL,
	NULL,
	NULL
};


///////////////////////////////////////////////////////////////////
//
//	Get_String
//
///////////////////////////////////////////////////////////////////
void
WideStringClass::Get_String (int length, bool is_temp)
{
	if (!is_temp && length <= 1) {
		m_Buffer = m_EmptyString;
	} else {

		WCHAR *string = NULL;

		//
		//	Should we attempt to use a temp buffer for this string?
		//
		if (is_temp && length < MAX_TEMP_LEN && m_UsedTempStringCount < MAX_TEMP_STRING) {

			//
			//	Make sure no one else is requesting a temp pointer
			// at the same time we are.
			//
			FastCriticalSectionClass::LockClass lock(m_TempMutex);

			//
			//	Try to find an available temporary buffer
			//
			for (int index = 0; index < MAX_TEMP_STRING; index ++) {
				if (m_FreeTempPtr[index] != NULL) {
					
					//
					//	Grab this unused buffer for our string
					//
					string					= m_FreeTempPtr[index];
					m_ResTempPtr[index]	= m_FreeTempPtr[index];
					m_FreeTempPtr[index]	= NULL;					
					Set_Buffer_And_Allocated_Length (string, MAX_TEMP_LEN);

					//
					//	Increment the count of used buffers
					//
					m_UsedTempStringCount ++;
					break;
				}
			}
		}

		if (string == NULL) {
			Set_Buffer_And_Allocated_Length (Allocate_Buffer (length), length);
		}
	}

	return ;
}


///////////////////////////////////////////////////////////////////
//
//	Resize
//
///////////////////////////////////////////////////////////////////
void
WideStringClass::Resize (int new_len)
{
	int allocated_len = Get_Allocated_Length ();
	if (new_len > allocated_len) {

		//
		//	Allocate the new buffer and copy the contents of our current
		// string.
		//
		WCHAR *new_buffer = Allocate_Buffer (new_len);
		wcscpy (new_buffer, m_Buffer);

		//
		//	Switch to the new buffer
		//
		Set_Buffer_And_Allocated_Length (new_buffer, new_len);
	}

	return ;
}


///////////////////////////////////////////////////////////////////
//
//	Uninitialised_Grow
//
///////////////////////////////////////////////////////////////////
void
WideStringClass::Uninitialised_Grow (int new_len)
{
	int allocated_len = Get_Allocated_Length ();
	if (new_len > allocated_len) {
		
		//
		//	Switch to a newly allocated buffer
		//
		WCHAR *new_buffer = Allocate_Buffer (new_len);
		Set_Buffer_And_Allocated_Length (new_buffer, new_len);	
	}

	//
	// Whenever this function is called, clear the cached length 
	//
	Store_Length (0);
	return ;
}


///////////////////////////////////////////////////////////////////
//
//	Uninitialised_Grow
//
///////////////////////////////////////////////////////////////////
void
WideStringClass::Free_String (void)
{
	if (m_Buffer != m_EmptyString) {

		//
		//	Check to see if this string was a temporary string
		//
		bool found = false;
		for (int index = 0; index < MAX_TEMP_STRING; index ++) {
			if (m_Buffer == m_ResTempPtr[index]) {
				//
				//	Make sure no one else is modifying a temp pointer
				// at the same time we are.
				//
				FastCriticalSectionClass::LockClass lock(m_TempMutex);
				
				//
				//	Release our hold on this temporary buffer
				//
				m_Buffer[0]				= 0;
				m_FreeTempPtr[index]	= m_Buffer;
				m_ResTempPtr[index]	= 0;
				m_UsedTempStringCount --;
				found = true;
				break;
			}
		}

		//
		//	String wasn't temporary, so free the memory
		//
		if (found == false) {
			char *buffer = ((char *)m_Buffer) - sizeof (WideStringClass::_HEADER);
			delete [] buffer;
		}

		//
		//	Reset the buffer
		//
		m_Buffer = m_EmptyString;
	}

	return ;
}


///////////////////////////////////////////////////////////////////
//
//	Format
//
///////////////////////////////////////////////////////////////////
int _cdecl
WideStringClass::Format_Args (const WCHAR *format, const va_list & arg_list )
{
	if (format == NULL) {
		return 0;
	}

	//
	// Make a guess at the maximum length of the resulting string
	//
	WCHAR temp_buffer[512] = { 0 };

	//
	//	Format the string
	//
	int retval = _vsnwprintf (temp_buffer, 512, format, arg_list);
	
	//
	//	Copy the string into our buffer
	//	
	(*this) = temp_buffer;

	return retval;
}


///////////////////////////////////////////////////////////////////
//
//	Format
//
///////////////////////////////////////////////////////////////////
int _cdecl
WideStringClass::Format (const WCHAR *format, ...)
{
	if (format == NULL) {
		return 0;
	}

	va_list arg_list;
	va_start (arg_list, format);

	//
	// Make a guess at the maximum length of the resulting string
	//
	WCHAR temp_buffer[512] = { 0 };

	//
	//	Format the string
	//
	int retval = _vsnwprintf (temp_buffer, 512, format, arg_list);
	
	//
	//	Copy the string into our buffer
	//	
	(*this) = temp_buffer;

	va_end (arg_list);
	return retval;
}


///////////////////////////////////////////////////////////////////
//
//	Release_Resources
//
///////////////////////////////////////////////////////////////////
void
WideStringClass::Release_Resources (void)
{
	return ;
}

///////////////////////////////////////////////////////////////////
// Convert_From
///////////////////////////////////////////////////////////////////
bool WideStringClass::Convert_From (const char *text)
{
	if (text != NULL) {
		
		int length;

		length = MultiByteToWideChar (CP_ACP, 0, text, -1, NULL, 0);
		if (length > 0) {

			Uninitialised_Grow (length);
			Store_Length (length - 1);

			// Convert.
			MultiByteToWideChar (CP_ACP, 0, text, -1, m_Buffer, length);

			// Success.
			return (true);
		}
   }

	// Failure.
	return (false);
}

///////////////////////////////////////////////////////////////////
// Test if a Unicode string is within the ANSI range. (0 - 255)
///////////////////////////////////////////////////////////////////
bool WideStringClass::Is_ANSI(void)
	{
	if (m_Buffer) {
		for (int index = 0; m_Buffer[index] != 0; index++) {
			unsigned short value = m_Buffer[index];

			if (value > 255) {
				return false;
			}
		}
	}

	return true;
	}