/**

 * vim: set ts=4 :

 * =============================================================================

 * SourceMod

 * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * 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/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include <stdlib.h>

#include <ctype.h>

#include <stdarg.h>

#include "sm_stringutil.h"

#include "Logger.h"

#include "PluginSys.h"

#include "Translator.h"

#include "PlayerManager.h"

#define LADJUST			0x00000004		/* left adjustment */

#define ZEROPAD			0x00000080		/* zero (as opposed to blank) pad */

#define UPPERDIGITS		0x00000200		/* make alpha digits uppercase */

#define to_digit(c)		((c) - '0')

#define is_digit(c)		((unsigned)to_digit(c) <= 9)

#define CHECK_ARGS(x) \

	if ((arg+x) > args) { \

		pCtx->ThrowNativeErrorEx(SP_ERROR_PARAM, "String formatted incorrectly - parameter %d (total %d)", arg, args); \

		return 0; \

	}

size_t CorePlayerTranslate(int client, char *buffer, size_t maxlength, const char *phrase, void **params)

{

	Translation pTrans;

	TransError err;

	err = g_pCorePhrases->GetTranslation(phrase, g_Translator.GetClientLanguage(client), &pTrans);

	if (err != Trans_Okay)

	{

		err = g_pCorePhrases->GetTranslation(phrase, g_Translator.GetServerLanguage(), &pTrans);

		if (err != Trans_Okay && g_Translator.GetServerLanguage() != CORELANG_ENGLISH)

		{

			err = g_pCorePhrases->GetTranslation(phrase, CORELANG_ENGLISH, &pTrans);

		}

	}

	if (err != Trans_Okay)

	{

		return UTIL_Format(buffer, maxlength, "%s", phrase);

	}

	return g_Translator.Translate(buffer, maxlength, params, &pTrans);

}

inline bool TryTranslation(CPlugin *pl, const char *key, unsigned int langid, unsigned int langcount, Translation *pTrans)

{

	TransError err = Trans_BadLanguage;

	CPhraseFile *phrfl;

	for (size_t i=0; i<langcount && err!=Trans_Okay; i++)

	{

		phrfl = g_Translator.GetFileByIndex(pl->GetLangFileByIndex(i));

		err = phrfl->GetTranslation(key, langid, pTrans);

	}

	return (err == Trans_Okay) ? true : false;

}

inline void ReorderTranslationParams(const Translation *pTrans, cell_t *params)

{

	cell_t new_params[MAX_TRANSLATE_PARAMS];

	for (unsigned int i = 0; i < pTrans->fmt_count; i++)

	{

		new_params[i] = params[pTrans->fmt_order[i]];

	}

	memcpy(params, new_params, pTrans->fmt_count * sizeof(cell_t));

}

size_t Translate(char *buffer,

				 size_t maxlen,

				 IPluginContext *pCtx,

				 const char *key,

				 cell_t target,

				 const cell_t *params,

				 int *arg,

				 bool *error)

{

	unsigned int langid;

	*error = false;

	Translation pTrans;

	CPlugin *pl = (CPlugin *)g_PluginSys.FindPluginByContext(pCtx->GetContext());

	size_t langcount = pl->GetLangFileCount();

	unsigned int max_params = 0;

try_serverlang:

	if (target == LANG_SERVER)

	{

		langid = g_Translator.GetServerLanguage();

 	}

	else if ((target >= 1) && (target <= g_Players.GetMaxClients()))

	{

		langid = g_Translator.GetClientLanguage(target);

	}

	else

	{

		pCtx->ThrowNativeErrorEx(SP_ERROR_PARAM, "Translation failed: invalid client index %d", target);

		goto error_out;

	}

	if (!TryTranslation(pl, key, langid, langcount, &pTrans))

	{

		if (target != LANG_SERVER && langid != g_Translator.GetServerLanguage())

		{

			target = LANG_SERVER;

			goto try_serverlang;

		}

		else if (langid != LANGUAGE_ENGLISH)

		{

			if (!TryTranslation(pl, key, LANGUAGE_ENGLISH, langcount, &pTrans))

			{

				pCtx->ThrowNativeErrorEx(SP_ERROR_PARAM, "Language phrase \"%s\" not found", key);

				goto error_out;

			}

		}

		else

		{

			pCtx->ThrowNativeErrorEx(SP_ERROR_PARAM, "Language phrase \"%s\" not found", key);

			goto error_out;

		}

	}

	max_params = pTrans.fmt_count;

	if (max_params)

	{

		cell_t new_params[MAX_TRANSLATE_PARAMS];

		/* Check if we're going to over the limit */

		if ((*arg) + (max_params - 1) > (size_t)params[0])

		{

			pCtx->ThrowNativeErrorEx(SP_ERROR_PARAMS_MAX, 

				"Translation string formatted incorrectly - missing at least %d parameters", 

				((*arg + (max_params - 1)) - params[0])

				);

			goto error_out;

		}

		/* If we need to re-order the parameters, do so with a temporary array.

		 * Otherwise, we could run into trouble with continual formats, a la ShowActivity().

		 */

		memcpy(new_params, params, sizeof(cell_t) * (params[0] + 1));

		ReorderTranslationParams(&pTrans, &new_params[*arg]);

		return atcprintf(buffer, maxlen, pTrans.szPhrase, pCtx, new_params, arg);

	}

	else

	{

		return atcprintf(buffer, maxlen, pTrans.szPhrase, pCtx, params, arg);

	}

error_out:

	*error = true;

	return 0;

}

void AddString(char **buf_p, size_t &maxlen, const char *string, int width, int prec)

{

	int size = 0;

	char *buf;

	static char nlstr[] = {'(','n','u','l','l',')','\0'};

	buf = *buf_p;

	if (string == NULL)

	{

		string = nlstr;

		prec = -1;

	}

	if (prec >= 0)

	{

		for (size = 0; size < prec; size++) 

		{

			if (string[size] == '\0')

			{

				break;

			}

		}

	}

	else

	{

		while (string[size++]);

		size--;

	}

	if (size > (int)maxlen)

	{

		size = maxlen;

	}

	maxlen -= size;

	width -= size;

	while (size--)

	{

		*buf++ = *string++;

	}

	while ((width-- > 0) && maxlen)

	{

		*buf++ = ' ';

		maxlen--;

	}

	*buf_p = buf;

}

void AddFloat(char **buf_p, size_t &maxlen, double fval, int width, int prec, int flags)

{

	int digits;					// non-fraction part digits

	double tmp;					// temporary

	char *buf = *buf_p;			// output buffer pointer

	int val;					// temporary

	int sign = 0;				// 0: positive, 1: negative

	int fieldlength;			// for padding

	int significant_digits = 0;	// number of significant digits written

	const int MAX_SIGNIFICANT_DIGITS = 16;

	// default precision

	if (prec < 0)

	{

		prec = 6;

	}

	// get the sign

	if (fval < 0)

	{

		fval = -fval;

		sign = 1;

	}

	// compute whole-part digits count

	digits = (int)log10(fval) + 1;

	// Only print 0.something if 0 < fval < 1

	if (digits < 1)

	{

		digits = 1;

	}

	// compute the field length

	fieldlength = digits + prec + ((prec > 0) ? 1 : 0) + sign;

	// minus sign BEFORE left padding if padding with zeros

	if (sign && maxlen && (flags & ZEROPAD))

	{

		*buf++ = '-';

		maxlen--;

	}

	// right justify if required

	if ((flags & LADJUST) == 0)

	{

		while ((fieldlength < width) && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			width--;

			maxlen--;

		}

	}

	// minus sign AFTER left padding if padding with spaces

	if (sign && maxlen && !(flags & ZEROPAD))

	{

		*buf++ = '-';

		maxlen--;

	}

	// write the whole part

	tmp = pow(10.0, digits-1);

	while ((digits--) && maxlen)

	{

		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)

		{

			*buf++ = '0';

		}

		else

		{

			val = (int)(fval / tmp);

			*buf++ = '0' + val;

			fval -= val * tmp;

			tmp *= 0.1;

		}

		maxlen--;

	}

	// write the fraction part

	if (maxlen)

	{

		*buf++ = '.';

		maxlen--;

	}

	tmp = pow(10.0, prec);

	fval *= tmp;

	while (prec-- && maxlen)

	{

		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)

		{

			*buf++ = '0';

		}

		else

		{

			tmp *= 0.1;

			val = (int)(fval / tmp);

			*buf++ = '0' + val;

			fval -= val * tmp;

		}

		maxlen--;

	}

	// left justify if required

	if (flags & LADJUST)

	{

		while ((fieldlength < width) && maxlen)

		{

			// right-padding only with spaces, ZEROPAD is ignored

			*buf++ = ' ';

			width--;

			maxlen--;

		}

	}

	// update parent's buffer pointer

	*buf_p = buf;

}

void AddUInt(char **buf_p, size_t &maxlen, unsigned int val, int width, int flags)

{

	char text[32];

	int digits;

	char *buf;

	digits = 0;

	do

	{

		text[digits++] = '0' + val % 10;

		val /= 10;

	} while (val);

	buf = *buf_p;

	if (!(flags & LADJUST))

	{

		while (digits < width && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			width--;

			maxlen--;

		}

	}

	while (digits-- && maxlen)

	{

		*buf++ = text[digits];

		width--;

		maxlen--;

	}

	if (flags & LADJUST)

	{

		while (width-- && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			maxlen--;

		}

	}

	*buf_p = buf;

}

void AddInt(char **buf_p, size_t &maxlen, int val, int width, int flags)

{

	char text[32];

	int digits;

	int signedVal;

	char *buf;

	unsigned int unsignedVal;

	digits = 0;

	signedVal = val;

	if (val < 0)

	{

		/* we want the unsigned version */

		unsignedVal = abs(val);

	}

	else

	{

		unsignedVal = val;

	}

	do

	{

		text[digits++] = '0' + unsignedVal % 10;

		unsignedVal /= 10;

	} while (unsignedVal);

	if (signedVal < 0)

	{

		text[digits++] = '-';

	}

	buf = *buf_p;

	if (!(flags & LADJUST))

	{

		while ((digits < width) && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			width--;

			maxlen--;

		}

	}

	while (digits-- && maxlen)

	{

		*buf++ = text[digits];

		width--;

		maxlen--;

	}

	if (flags & LADJUST)

	{

		while (width-- && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			maxlen--;

		}

	}

	*buf_p = buf;

}

void AddHex(char **buf_p, size_t &maxlen, unsigned int val, int width, int flags)

{

	char text[32];

	int digits;

	char *buf;

	char digit;

	int hexadjust;

	if (flags & UPPERDIGITS)

	{

		hexadjust = 'A' - '9' - 1;

	}

	else

	{

		hexadjust = 'a' - '9' - 1;

	}

	digits = 0;

	do 

	{

		digit = ('0' + val % 16);

		if (digit > '9')

		{

			digit += hexadjust;

		}

		text[digits++] = digit;

		val /= 16;

	} while(val);

	buf = *buf_p;

	if (!(flags & LADJUST))

	{

		while (digits < width && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			width--;

			maxlen--;

		}

	}

	while (digits-- && maxlen)

	{

		*buf++ = text[digits];

		width--;

		maxlen--;

	}

	if (flags & LADJUST)

	{

		while (width-- && maxlen)

		{

			*buf++ = (flags & ZEROPAD) ? '0' : ' ';

			maxlen--;

		}

	}

	*buf_p = buf;

}

size_t gnprintf(char *buffer, size_t maxlen, const char *format, void **args)

{

	if (!buffer || !maxlen)

	{

		return 0;

	}

	int arg = 0;

	char *buf_p;

	char ch;

	int flags;

	int width;

	int prec;

	int n;

	char sign;

	const char *fmt;

	size_t llen = maxlen - 1;

	buf_p = buffer;

	fmt = format;

	while (true)

	{

		// run through the format string until we hit a '%' or '\0'

		for (ch = *fmt; llen && ((ch = *fmt) != '\0') && (ch != '%'); fmt++)

		{

			*buf_p++ = ch;

			llen--;

		}

		if ((ch == '\0') || (llen <= 0))

		{

			goto done;

		}

		// skip over the '%'

		fmt++;

		// reset formatting state

		flags = 0;

		width = 0;

		prec = -1;

		sign = '\0';

rflag:

		ch = *fmt++;

reswitch:

		switch(ch)

		{

		case '-':

			{

				flags |= LADJUST;