/*
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifndef ALPHA_LINUX_CXX
#  include <cstring> 
#endif
#include "files/U7file.h" 
#include "palette.h"
#include "ibuf8.h"
#include "utils.h"
#include "fnames.h"
#include "gamewin.h"

#include "SDL_timer.h"

#ifndef UNDER_CE
using std::memcpy;
using std::memset;
using std::size_t;
using std::string;
#endif

Palette::Palette()
	: win(Game_window::get_instance()->get_win()), 
	    palette(-1), brightness(100), 
	    faded_out(false), fades_enabled(true), max_val(63)
    	{
	}

Palette::~Palette()
	{
	}
	
/*
 *	Fade the current palette in or out.
 *	Note:  If pal_num != -1, the current palette is set to it.
 */

void Palette::fade
	(
	int cycles,			// Length of fade.
	int inout,			// 1 to fade in, 0 to fade to black.
	int pal_num			// 0-11, or -1 for current.
	)
	{
	  if (pal_num == -1) pal_num = palette;
	  load(PALETTES_FLX, pal_num);
	  if(inout)
		fade_in(cycles);
	  else
		fade_out(cycles);
	  faded_out = !inout;		// Be sure to set flag.
	}

/*
 *	Flash the current palette red.
 */

void Palette::flash_red
	(
	)
	{
	int savepal = palette;
	set(PALETTE_RED);		// Palette 8 is the red one.
	win->show();
	SDL_Delay(100);
	set(savepal);
	Game_window::get_instance()->set_painted();
	}

/*
 *	Read in a palette.
 */

void Palette::set
	(
	int pal_num,			// 0-11, or -1 to leave unchanged.
	int new_brightness,		// New percentage, or -1.
	bool repaint
	)
	{
	if ((palette == pal_num || pal_num == -1) &&
		(brightness == new_brightness || new_brightness == -1))
		return;			// Already set.
	if (pal_num != -1)
		palette = pal_num;	// Store #.
	if (new_brightness > 0)
		brightness = new_brightness;
	if (faded_out)
		return;			// In the black.
	
	load(PALETTES_FLX, palette);	// could throw!
	set_brightness(brightness);
	apply(repaint);
	}

void Palette::apply(bool repaint)
{
	win->set_palette(pal1, max_val, brightness);
	if (repaint)
		win->show();
}

/*
 *	Returns 0 if file not found.
 */
void Palette::load(const char *fname, int index, const char *xfname, int xindex)
	{
	size_t len;
	char *buf = 0;
	if (std::strncmp(fname, "<STATIC>/", sizeof("<STATIC>/") - 1) == 0 &&
					is_system_path_defined("<PATCH>"))
		{			// Check in "patch" dir. first.
		string pname("<PATCH>/");
		pname += fname + sizeof("<STATIC>/") - 1;
		U7object pal(pname.c_str(), index);
		try {
			buf = pal.retrieve(len);
		}
		catch (exult_exception& e) {
			buf = 0;
		}
		}
	if (!buf)			// Not in patch.
		{
		U7object pal(fname, index);
		buf = pal.retrieve(len);// this may throw an exception
		}
	if(len==768) {	// Simple palette
		if (xindex >= 0) {	// Get xform table.
			U7object xform(xfname, xindex);
			unsigned char *xbuf = 0;
			size_t xlen;
			try {
#if 0	/* +++++TESTING */
				xbuf = new unsigned char[256];
				Game_window *gwin = 
					Game_window::get_instance();
				memcpy(xbuf, gwin->get_xform(11 - xindex - 1),
									256);
#else
				xbuf = (unsigned char *) xform.retrieve( xlen);
#endif
				for (int i = 0; i < 256; i++) {
					int ix = xbuf[i];
					pal1[3*i] = buf[3*ix];
					pal1[3*i+1] = buf[3*ix+1];
					pal1[3*i+2] = buf[3*ix+2];
				}
			}
			catch( const std::exception & err ) {
				xindex = -1;
			}
			delete [] xbuf;
		}
		if (xindex < 0)		// Set the first palette
			memcpy(pal1,buf,768);
		memset(pal2,0,768);	// The second one is black
	} else {			// Double palette
		for(int i=0; i<768; i++) {
			pal1[i]=buf[i*2];
			pal2[i]=buf[i*2+1];
		}
	}
	delete [] buf;
	}
/*void Palette::load(const char *fname, int index, const char *xfname, int xindex)
	{
	U7object pal(fname, index);
	size_t len;
	char *buf;
	pal.retrieve(&buf, len);	// this may throw an exception
	if(len==768) {	// Simple palette
		if (xindex >= 0)	// Get xform table.
			{
			U7object xform(xfname, xindex);
			unsigned char *xbuf; size_t xlen;
			if (!xform.retrieve(&xbuf, xlen))
				xindex = -1;
			else
				for (int i = 0; i < 256; i++)
					{
					int ix = xbuf[i];
					pal1[3*i] = buf[3*ix];
					pal1[3*i+1] = buf[3*ix+1];
					pal1[3*i+2] = buf[3*ix+2];
					}
			delete [] xbuf;
			}
		if (xindex < 0)		// Set the first palette
			memcpy(pal1,buf,768);
		memset(pal2,0,768);	// The second one is black
	} else {			// Double palette
		for(int i=0; i<768; i++) {
			pal1[i]=buf[i*2];
			pal2[i]=buf[i*2+1];
		}
	}
	delete [] buf;
	}
*/
	
void Palette::set_brightness(int bright)
	{
		brightness = bright;
	}
	
void Palette::fade_in(int cycles)
{
	if (fades_enabled)
	{
		unsigned char fade_pal[768];
		unsigned int ticks = SDL_GetTicks() + 20;
		for (int i = 0; i <= cycles; i++)
		{
			for(int c=0; c < 768; c++)
				fade_pal[c] = ((pal1[c]-pal2[c])*i)/cycles+pal2[c];
			win->set_palette(fade_pal, max_val, brightness);
			// Frame skipping on slow systems
			if (i == cycles || ticks >= SDL_GetTicks() ||
			    !Game_window::get_instance()->get_frame_skipping())
				win->show();
			while (ticks >= SDL_GetTicks())
				;
			ticks += 20;
		}
	}
	else
	{
		win->set_palette(pal1, max_val, brightness);
		win->show();
	}
}

void Palette::fade_out(int cycles)
{
	if (fades_enabled)
	{
		unsigned char fade_pal[768];
		unsigned int ticks = SDL_GetTicks() + 20;
		for (int i = cycles; i >= 0; i--)
		{
			for(int c=0; c < 768; c++)
				fade_pal[c] = ((pal1[c]-pal2[c])*i)/cycles+pal2[c];
			win->set_palette(fade_pal, max_val, brightness);
			// Frame skipping on slow systems
			if (i == 0 || ticks >= SDL_GetTicks() ||
			   !Game_window::get_instance()->get_frame_skipping())
				win->show();
			while (ticks >= SDL_GetTicks())
				;
			ticks += 20;
		}
	}
	else
	{
		win->set_palette(pal2, max_val, brightness);
		win->show();
	}
//Messes up sleep.	        win->set_palette(pal1, max_val, brightness);
}

//	Find index (0-255) of closest color (r,g,b < 64).
int Palette::find_color(int r, int g, int b) {
	int best_index = -1;
	long best_distance = 0xfffffff;
					// But don't search rotating colors.
	for (int i = 0; i < 0xe0; i++) {
					// Get deltas.
		long dr = r - pal1[3*i], dg = g - pal1[3*i + 1], 
							db = b - pal1[3*i + 2];
					// Figure distance-squared.
		long dist = dr*dr + dg*dg + db*db;
		if (dist < best_distance) {	// Better than prev?
			best_index = i;
			best_distance = dist;
		}
	}
	return best_index;
}

/*
 *	Create a translucency table for this palette seen through a given
 *	color.  (Based on a www.gamedev.net article by Jesse Towner.)
 */

void Palette::create_trans_table
	(
					// Color to blend with:
	unsigned char br, unsigned bg, unsigned bb,
	int alpha,			// 0-255, applied to 'blend' color.
	unsigned char *table		// 256 indices are stored here.
	)
	{
	for (int i = 0; i < 256; i++)
		{
		int newr = ((int) br * alpha)/255 + 
				((int) pal1[i*3] * (255 - alpha))/255;
		int newg = ((int) bg * alpha)/255 + 
				((int) pal1[i*3 + 1] * (255 - alpha))/255;
		int newb = ((int) bb * alpha)/255 + 
				((int) pal1[i*3 + 2] * (255 - alpha))/255;
		table[i] = find_color(newr, newg, newb);
		}
	}

void Palette::show() {
	for (int x = 0; x < 16; x++) {
		for (int y = 0; y < 16; y++) {
			win->fill8(y*16+x, 8, 8, x*8, y*8);
		}
	} 
}

void Palette::set_color(int nr, int r, int g, int b) {
	pal1[nr*3] = r;
	pal1[nr*3+1] = g;
	pal1[nr*3+2] = b;
}

void Palette::set_palette(unsigned char palnew[768]) {
	memcpy(pal1,palnew,768);
	memset(pal2,0,768);
}

void Palette::set_max_val(int max)
{
	max_val = max;
}

int Palette::get_max_val()
{
	return max_val;
}