/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

/*
 * This code is based on the original source code of Lord Avalot d'Argent version 1.3.
 * Copyright (c) 1994-1995 Mike, Mark and Thomas Thurman.
 */

#include "graph.h"
/*#include "Crt.h"*/

namespace Avalanche {

struct scoretype {
	varying_string<39> name;
	word score;
};

struct ratetype {
	varying_string<10> rank;
	word lowest;
};

struct tabletype {
	array<1, 12, scoretype> a;
	byte light;
};

const array<1, 9, ratetype> ratings = {
	{	{"Rubbish",    0},
		{"Beginner",   1},
		{"Poor",       10},
		{"Average",    30},
		{"Fair",       50},
		{"Not bad",    70},
		{"Good",       100},
		{"Great",      200},
		{"Fantastic!", 330}
	}
};

integer gd, gm;
tabletype table;

byte ratingname(word x) {
	byte fv;
	byte ratingname_result;
	for (fv = 9; fv >= 1; fv --)
		if (x >= ratings[fv].lowest) {
			ratingname_result = fv;
			return ratingname_result;
		}    /* bad style */
	return ratingname_result;
}

void title();

const string message = "A v a l o t  :  H i g h - S c o r e s";


static void sayfast(integer x, integer y) {
	integer anchor;
	byte fv;
	anchor = -296;
	for (fv = 1; fv <= length(message); fv ++) {
		if (message[fv - 1] != '\40')  outtextxy(x + anchor, y - 8, message[fv - 1]);
		anchor += 16;
	}
}

void title() {
	const array<0, 6, byte> shades =
	{{blue, lightgray, darkgray, blue, lightblue, blue, darkgray}};
	byte x;
	integer len;

	settextstyle(0, 0, 2); /*settextjustify(1,1);*/
	len = textheight(message);
	for (x = 6; x >= 0; x --) {
		setcolor(shades[x]);
		sayfast(320 - x * 2, 20 - x);
		if (x > 0) {
			sayfast(320 + x * 2, 20 - x);
			sayfast(320 + x * 2, 20 + x);
			sayfast(320 - x * 2, 20 + x);
		}
	}
}

void newtable() {
	const array<1, 12, varying_string<15> > names = {
		{
			"Mike", "Liz", "Thomas", "Mark", "Mandy", "Andrew", "Lucy Tryphena", "",
			"Thanks to all", "who helped...", "", "Have fun!"
		}
	};
	byte fv;
	fillchar(table, sizeof(table), '\261');
	for (fv = 1; fv <= 12; fv ++) {
		scoretype &with = table.a[fv];
		with.name = names[fv];
		with.score = 193 - fv * 16;
	}
	table.light = 1;
}

string strf(longint x) {         /* From Gyro. Delete when integrated. */
	string q;
	string strf_result;
	str(x, q);
	strf_result = q;
	return strf_result;
}

void sparkle(integer x, integer y, string z) {
	setcolor(cyan);
	outtextxy(x - 1, y - 1, z);
	setcolor(blue);
	outtextxy(x + 1, y + 1, z);
	setcolor(white);
	outtextxy(x  , y  , z);
}

void drawtable() {
	byte fv, last, now;
	setfillstyle(1, 8);
	bar(0, 40, 105, 58);
	bar(110, 40, 400, 58);
	bar(405, 40, 490, 58);
	bar(495, 40, 640, 58);
	bar(5, 60, 105, 181);
	bar(110, 60, 400, 181);
	bar(405, 60, 490, 181);
	bar(495, 60, 635, 181);
	bar(0, 185, 640, 190);
	setcolor(lightred);
	settextstyle(0, 0, 1);
	settextjustify(0, 0);
	outtextxy(45, 55, "Number:");
	outtextxy(120, 55, "Name:");
	outtextxy(420, 55, "Score:");
	outtextxy(500, 55, "Rating:");
	setcolor(white);
	last = 177;
	for (fv = 1; fv <= 12; fv ++) {
		scoretype &with = table.a[fv];
		settextjustify(righttext, bottomtext);
		sparkle(100, 60 + fv * 10, strf(fv) + '.');
		sparkle(455, 60 + fv * 10, strf(with.score));
		if (fv == table.light)  sparkle(70, 60 + fv * 10, string("ออ") + '\20');

		settextjustify(lefttext, bottomtext);
		sparkle(120, 60 + fv * 10, with.name);
		now = ratingname(with.score);
		if (now != last)
			sparkle(510, 60 + fv * 10, ratings[ratingname(with.score)].rank);
		else
			sparkle(517, 57 + fv * 10, ",,");
		last = now;
	}
}

void message1(string x) {
	setfillstyle(1, 8);
	bar(0, 190, 640, 200);
	settextjustify(1, 1);
	sparkle(320, 195, x);
}

void sorthst() {
	byte fv;
	boolean ok;
	scoretype temp;
	do {
		ok = true;
		for (fv = 1; fv <= 11; fv ++)
			if (table.a[fv].score < table.a[fv + 1].score) {
				temp = table.a[fv];
				table.a[fv] = table.a[fv + 1];
				table.a[fv + 1] = temp; /* swap 'em */
				table.light = fv; /* must be- that's the only unsorted one */
				ok = false; /* So, we try again. */
			}
	} while (!ok);
}

void entername();
static integer x, y;


static void cursor(byte col) {
	setcolor(col);
	outtextxy(x, y, "?");
}

void entername() {
	varying_string<34> i;
	char r;
	integer counter;
	byte flash;

	y = 60 + table.light * 10;
	i = "";
	settextjustify(2, 0);
	counter = 999;
	flash = 0;
	do {
		x = 128 + length(i) * 8;
		do {
			counter += 1;
			if (counter == 1000) {
				cursor(4 + flash * 10);
				flash = 1 - flash;
				counter = 0;
			}
			delay(1);
		} while (!keypressed());
		cursor(8);
		sound(17177);
		r = readkey();
		nosound;
		if (r == '\10')  {
			if (i[0] > '\0')  {
				bar(x - 17, y - 10, x - 8, y);
				i[0] -= 1;
				sparkle(x - 16, y, i[length(i)]);
			}
		} else {
			if ((i[0] < '\42') && (r != '\15'))  {
				sparkle(x, y, r);
				i = i + r;
			}
		}
		counter = 999;
	} while (!(r == '\15'));
}

void newscore(word sc) {
	{
		scoretype &with = table.a[12];
		if (sc > with.score) {
			with.name = "";
			with.score = sc;
			table.light = 10;
			sorthst();
			drawtable();
			message1("Well done! Please enter your name, then press Return...");
			entername();
		} else drawtable();
	} /* too low for score */
	message1("Press Space to continue...");
	do {
	} while (!(keypressed() && (readkey() == '\40')));
}

int main(int argc, const char *argv[]) {
	pio_initialize(argc, argv);
	gd = 3;
	gm = 0;
	initgraph(gd, gm, "");
	title();
	newtable();
	newscore(/*177*/0);
	return EXIT_SUCCESS;
}

} // End of namespace Avalanche.