#include "cheat_func.h"

HighScore _highscore_table[5][5]; // 4 difficulty-settings (+ network); top 5

static const StringID _endgame_perf_titles[] = {

	STR_0213_BUSINESSMAN,

	STR_0213_BUSINESSMAN,

	STR_0213_BUSINESSMAN,

	STR_0213_BUSINESSMAN,

	STR_0213_BUSINESSMAN,

	STR_0214_ENTREPRENEUR,

	STR_0214_ENTREPRENEUR,

	STR_0215_INDUSTRIALIST,

	STR_0215_INDUSTRIALIST,

	STR_0216_CAPITALIST,

	STR_0216_CAPITALIST,

	STR_0217_MAGNATE,

	STR_0217_MAGNATE,

	STR_0218_MOGUL,

	STR_0218_MOGUL,

	STR_0219_TYCOON_OF_THE_CENTURY

};

StringID EndGameGetPerformanceTitleFromValue(uint value)

{

	value = minu(value / 64, lengthof(_endgame_perf_titles) - 1);

	return _endgame_perf_titles[value];

}

/** Save the highscore for the company */

int8 SaveHighScoreValue(const Company *c)

{

	HighScore *hs = _highscore_table[_settings_game.difficulty.diff_level];

	uint i;

	uint16 score = c->old_economy[0].performance_history;

	/* Exclude cheaters from the honour of being in the highscore table */

	if (CheatHasBeenUsed()) return -1;

	for (i = 0; i < lengthof(_highscore_table[0]); i++) {

		/* You are in the TOP5. Move all values one down and save us there */

		if (hs[i].score <= score) {

			/* move all elements one down starting from the replaced one */

			memmove(&hs[i + 1], &hs[i], sizeof(HighScore) * (lengthof(_highscore_table[0]) - i - 1));

			SetDParam(0, c->index);

			SetDParam(1, c->index);

			GetString(hs[i].company, STR_HIGHSCORE_NAME, lastof(hs[i].company)); // get manager/company name string

			hs[i].score = score;

			hs[i].title = EndGameGetPerformanceTitleFromValue(score);

			return i;

		}

	}

	return -1; // too bad; we did not make it into the top5

}

/** Sort all companies given their performance */

static int CDECL HighScoreSorter(const Company* const *a, const Company* const *b)

{

	return (*b)->old_economy[0].performance_history - (*a)->old_economy[0].performance_history;

}

/* Save the highscores in a network game when it has ended */

#define LAST_HS_ITEM lengthof(_highscore_table) - 1

int8 SaveHighScoreValueNetwork()

{

	const Company *c;

	const Company *cl[MAX_COMPANIES];

	uint count = 0;

	int8 company = -1;

	/* Sort all active companies with the highest score first */

	FOR_ALL_COMPANIES(c) cl[count++] = c;

	GSortT(cl, count, &HighScoreSorter);

	{

		uint i;

		memset(_highscore_table[LAST_HS_ITEM], 0, sizeof(_highscore_table[0]));

		/* Copy over Top5 companies */

		for (i = 0; i < lengthof(_highscore_table[LAST_HS_ITEM]) && i < count; i++) {

			HighScore* hs = &_highscore_table[LAST_HS_ITEM][i];

			SetDParam(0, cl[i]->index);

			SetDParam(1, cl[i]->index);

			GetString(hs->company, STR_HIGHSCORE_NAME, lastof(hs->company)); // get manager/company name string

			hs->score = cl[i]->old_economy[0].performance_history;

			hs->title = EndGameGetPerformanceTitleFromValue(hs->score);

			/* get the ranking of the local company */

			if (cl[i]->index == _local_company) company = i;

		}

	}

	/* Add top5 companys to highscore table */

	return company;

}

/** Save HighScore table to file */

void SaveToHighScore()

{

	FILE *fp = fopen(_highscore_file, "wb");

	if (fp != NULL) {

		uint i;

		HighScore *hs;

		for (i = 0; i < LAST_HS_ITEM; i++) { // don't save network highscores

			for (hs = _highscore_table[i]; hs != endof(_highscore_table[i]); hs++) {

				/* First character is a command character, so strlen will fail on that */

				byte length = min(sizeof(hs->company), StrEmpty(hs->company) ? 0 : (int)strlen(&hs->company[1]) + 1);

				if (fwrite(&length, sizeof(length), 1, fp)       != 1 || // write away string length

						fwrite(hs->company, length, 1, fp)           >  1 || // Yes... could be 0 bytes too

						fwrite(&hs->score, sizeof(hs->score), 1, fp) != 1 ||

						fwrite("  ", 2, 1, fp)                       != 1) { // XXX - placeholder for hs->title, not saved anymore; compatibility

					DEBUG(misc, 1, "Could not save highscore.");

					i = LAST_HS_ITEM;

					break;

				}

			}

		}

		fclose(fp);

	}

}

/** Initialize the highscore table to 0 and if any file exists, load in values */

void LoadFromHighScore()

{

	FILE *fp = fopen(_highscore_file, "rb");

	memset(_highscore_table, 0, sizeof(_highscore_table));

	if (fp != NULL) {

		uint i;

		HighScore *hs;

		for (i = 0; i < LAST_HS_ITEM; i++) { // don't load network highscores

			for (hs = _highscore_table[i]; hs != endof(_highscore_table[i]); hs++) {

				byte length;

				if (fread(&length, sizeof(length), 1, fp)       !=  1 ||

						fread(hs->company, length, 1, fp)           >   1 || // Yes... could be 0 bytes too

						fread(&hs->score, sizeof(hs->score), 1, fp) !=  1 ||

						fseek(fp, 2, SEEK_CUR)                      == -1) { // XXX - placeholder for hs->title, not saved anymore; compatibility

					DEBUG(misc, 1, "Highscore corrupted");

					i = LAST_HS_ITEM;

					break;

				}

				*lastof(hs->company) = '\0';

				hs->title = EndGameGetPerformanceTitleFromValue(hs->score);

			}

		}

		fclose(fp);

	}

}

struct HighScore {

	char company[100];

	StringID title; ///< NOSAVE, has troubles with changing string-numbers.

	uint16 score;   ///< do NOT change type, will break hs.dat

};

extern HighScore _highscore_table[5][5]; // 4 difficulty-settings (+ network); top 5

void SaveToHighScore();

void LoadFromHighScore();

int8 SaveHighScoreValue(const Company *c);

int8 SaveHighScoreValueNetwork();

#include "openttd.h"

/********** HIGHSCORE and ENDGAME windows */

extern StringID EndGameGetPerformanceTitleFromValue(uint value);

struct EndGameHighScoreBaseWindow : Window

{

	uint32 background_img;

	int8 rank;

	EndGameHighScoreBaseWindow(const WindowDesc *desc) : Window(desc)

	{

	}

	/* Always draw a maximized window and within there the centered background */

	void SetupHighScoreEndWindow(uint *x, uint *y)

	{

		/* resize window to "full-screen" */

		this->width = _screen.width;

		this->height = _screen.height;

		this->widget[0].right = this->width - 1;

		this->widget[0].bottom = this->height - 1;

		this->DrawWidgets();

		/* Center Highscore/Endscreen background */

		*x = max(0, (_screen.width  / 2) - (640 / 2));

		*y = max(0, (_screen.height / 2) - (480 / 2));

		for (uint i = 0; i < 10; i++) { // the image is split into 10 50px high parts

			DrawSprite(this->background_img + i, PAL_NONE, *x, *y + (i * 50));

		}

	}

	virtual void OnClick(Point pt, int widget)

	{

		delete this;

	}

};

/** End game window shown at the end of the game */

struct EndGameWindow : EndGameHighScoreBaseWindow {

	EndGameWindow(const WindowDesc *desc) : EndGameHighScoreBaseWindow(desc)

	{

		/* Pause in single-player to have a look at the highscore at your own leisure */

		if (!_networking) DoCommandP(0, 1, 0, CMD_PAUSE);

		this->background_img = SPR_TYCOON_IMG1_BEGIN;

		if (_local_company != COMPANY_SPECTATOR) {

			const Company *c = GetCompany(_local_company);

			if (c->old_economy[0].performance_history == SCORE_MAX) {

				this->background_img = SPR_TYCOON_IMG2_BEGIN;

			}

		}

		/* In a network game show the endscores of the custom difficulty 'network' which is the last one

		 * as well as generate a TOP5 of that game, and not an all-time top5. */

		if (_networking) {

			this->window_number = lengthof(_highscore_table) - 1;

			this->rank = SaveHighScoreValueNetwork();

		} else {

			/* in single player _local company is always valid */

			const Company *c = GetCompany(_local_company);

			this->window_number = _settings_game.difficulty.diff_level;

			this->rank = SaveHighScoreValue(c);

		}

		MarkWholeScreenDirty();

	}

	~EndGameWindow()

	{

		if (!_networking) DoCommandP(0, 0, 0, CMD_PAUSE); // unpause

		ShowHighscoreTable(this->window_number, this->rank);

	}

	virtual void OnPaint()

	{

		const Company *c;

		uint x, y;

		this->SetupHighScoreEndWindow(&x, &y);

		if (!IsValidCompanyID(_local_company)) return;

		c = GetCompany(_local_company);

		/* We need to get performance from last year because the image is shown

		 * at the start of the new year when these things have already been copied */

		if (this->background_img == SPR_TYCOON_IMG2_BEGIN) { // Tycoon of the century \o/

			SetDParam(0, c->index);

			SetDParam(1, c->index);

			SetDParam(2, EndGameGetPerformanceTitleFromValue(c->old_economy[0].performance_history));

			DrawStringMultiCenter(x + (640 / 2), y + 107, STR_021C_OF_ACHIEVES_STATUS, 640);

		} else {

			SetDParam(0, c->index);

			SetDParam(1, EndGameGetPerformanceTitleFromValue(c->old_economy[0].performance_history));

			DrawStringMultiCenter(x + (640 / 2), y + 157, STR_021B_ACHIEVES_STATUS, 640);

		}

	}

};

struct HighScoreWindow : EndGameHighScoreBaseWindow

{

	HighScoreWindow(const WindowDesc *desc, int difficulty, int8 ranking) : EndGameHighScoreBaseWindow(desc)

	{

		/* pause game to show the chart */

		if (!_networking) DoCommandP(0, 1, 0, CMD_PAUSE);

		/* Close all always on-top windows to get a clean screen */

		if (_game_mode != GM_MENU) HideVitalWindows();

		MarkWholeScreenDirty();

		this->window_number = difficulty; // show highscore chart for difficulty...

		this->background_img = SPR_HIGHSCORE_CHART_BEGIN; // which background to show

		this->rank = ranking;

	}

	~HighScoreWindow()

	{

		if (_game_mode != GM_MENU) ShowVitalWindows();

		if (!_networking) DoCommandP(0, 0, 0, CMD_PAUSE); // unpause

	}

	virtual void OnPaint()

	{

		const HighScore *hs = _highscore_table[this->window_number];

		uint x, y;

		this->SetupHighScoreEndWindow(&x, &y);

		SetDParam(0, ORIGINAL_END_YEAR);

		SetDParam(1, this->window_number + STR_6801_EASY);

		DrawStringMultiCenter(x + (640 / 2), y + 62, !_networking ? STR_0211_TOP_COMPANIES_WHO_REACHED : STR_TOP_COMPANIES_NETWORK_GAME, 500);

		/* Draw Highscore peepz */

		for (uint8 i = 0; i < lengthof(_highscore_table[0]); i++) {

			SetDParam(0, i + 1);

			DrawString(x + 40, y + 140 + (i * 55), STR_0212, TC_BLACK);

			if (hs[i].company[0] != '\0') {

				TextColour colour = (this->rank == i) ? TC_RED : TC_BLACK; // draw new highscore in red

				DoDrawString(hs[i].company, x + 71, y + 140 + (i * 55), colour);

				SetDParam(0, hs[i].title);

				SetDParam(1, hs[i].score);

				DrawString(x + 71, y + 160 + (i * 55), STR_HIGHSCORE_STATS, colour);

			}

		}

	}

};

static const Widget _highscore_widgets[] = {

{      WWT_PANEL, RESIZE_NONE,  COLOUR_END, 0, 640, 0, 480, 0x0, STR_NULL},

{   WIDGETS_END},

};

static const WindowDesc _highscore_desc = {

	0, 0, 641, 481, 641, 481,

	WC_HIGHSCORE, WC_NONE,

	0,

	_highscore_widgets,

};

static const WindowDesc _endgame_desc = {

	0, 0, 641, 481, 641, 481,

	WC_ENDSCREEN, WC_NONE,

	0,

	_highscore_widgets,

};

/** Show the highscore table for a given difficulty. When called from

 * endgame ranking is set to the top5 element that was newly added

 * and is thus highlighted */

void ShowHighscoreTable(int difficulty, int8 ranking)

{

	DeleteWindowByClass(WC_HIGHSCORE);

	new HighScoreWindow(&_highscore_desc, difficulty, ranking);

}

/** Show the endgame victory screen in 2050. Update the new highscore

 * if it was high enough */

void ShowEndGameChart()

{

	/* Dedicated server doesn't need the highscore window */

	if (_network_dedicated) return;

	HideVitalWindows();

	DeleteWindowByClass(WC_ENDSCREEN);

	new EndGameWindow(&_endgame_desc);

}

void ShowHighscoreTable(int difficulty, int8 rank);