/*
 * Copyright 2001-2006, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		DarkWyrm <bpmagic@columbus.rr.com>
 */


#include "RGBColor.h"
#include "SystemPalette.h"

#include <stdio.h>
#include <stdlib.h>


/*!
	\brief An approximation of 31/255, which is needed for converting from 32-bit
		colors to 16-bit and 15-bit.
*/
#define RATIO_8_TO_5_BIT .121568627451

/*!
	\brief An approximation of 63/255, which is needed for converting from 32-bit
		colors to 16-bit.
*/
#define RATIO_8_TO_6_BIT .247058823529

/*!
	\brief An approximation of 255/31, which is needed for converting from 16-bit
		and 15-bit colors to 32-bit.
*/
#define RATIO_5_TO_8_BIT 8.22580645161

/*!
	\brief An approximation of 255/63, which is needed for converting from 16-bit
		colors to 32-bit.
*/
#define RATIO_6_TO_8_BIT 4.04761904762

#if 0
/*!
	\brief Function for easy conversion of 16-bit colors to 32-bit
	\param col Pointer to an rgb_color.
	\param color RGB16 color

	This function will do nothing if passed a NULL 32-bit color.
*/
void
SetRGBColor16(rgb_color *col,uint16 color)
{
	if(!col)
		return;

	uint16 r16,g16,b16;

	// alpha's the easy part
	col->alpha=0;

	r16= (color >> 11) & 31;
	g16= (color >> 5) & 63;
	b16= color & 31;

	col->red=uint8(r16 * RATIO_5_TO_8_BIT);
	col->green=uint8(g16 * RATIO_6_TO_8_BIT);
	col->blue=uint8(b16 * RATIO_5_TO_8_BIT);
}
#endif

/*!
	\brief Finds the index of the closest matching color in a rgb_color palette array
	\param palette Array of 256 rgb_color objects
	\param color Color to match
	\return Index of the closest matching color

	Note that passing a NULL palette will always return 0 and passing an array of less
	than 256 rgb_colors will cause a crash.
*/
static uint8
FindClosestColor(const rgb_color *palette, rgb_color color)
{
	if (!palette)
		return 0;

	uint16 cindex = 0, cdelta = 765, delta = 765;

	for (uint16 i = 0; i < 256; i++) {
		const rgb_color *c = &(palette[i]);
		delta = abs(c->red-color.red) + abs(c->green-color.green)
			+ abs(c->blue-color.blue);

		if (delta == 0) {
			cindex = i;
			break;
		}

		if (delta < cdelta) {
			cindex = i;
			cdelta = delta;
		}
	}

	return (uint8)cindex;
}


/*!
	\brief Constructs a RGBA15 color which best matches a given 32-bit color
	\param color Color to match
	\return The closest matching color's value

	Format is ARGB, 1:5:5:5
*/
static uint16
FindClosestColor15(rgb_color color)
{
	uint16 r16 = uint16(color.red * RATIO_8_TO_5_BIT);
	uint16 g16 = uint16(color.green * RATIO_8_TO_5_BIT);
	uint16 b16 = uint16(color.blue * RATIO_8_TO_5_BIT);

	// start with alpha value
	uint16 color16 = color.alpha > 127 ? 0x8000 : 0;

	color16 |= r16 << 10;
	color16 |= g16 << 5;
	color16 |= b16;

	return color16;
}


/*!
	\brief Constructs a RGB16 color which best matches a given 32-bit color
	\param color Color to match
	\return The closest matching color's value

	Format is RGB, 5:6:5
*/
static uint16
FindClosestColor16(rgb_color color)
{
	uint16 r16 = uint16(color.red * RATIO_8_TO_5_BIT);
	uint16 g16 = uint16(color.green * RATIO_8_TO_6_BIT);
	uint16 b16 = uint16(color.blue * RATIO_8_TO_5_BIT);

	uint16 color16 = r16 << 11;
	color16 |= g16 << 5;
	color16 |= b16;

	return color16;
}


//	#pragma mark -


/*!
	\brief Create an RGBColor from specified values
	\param red red
	\param green green
	\param blue blue
	\param alpha alpha, defaults to 255
*/
RGBColor::RGBColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	SetColor(r,g,b,a);
}


/*!
	\brief Create an RGBColor from specified values
	\param red red
	\param green green
	\param blue blue
	\param alpha alpha, defaults to 255
*/
RGBColor::RGBColor(int r, int g, int b, int a)
{
	SetColor(r, g, b, a);
}


/*!
	\brief Create an RGBColor from an rgb_color
	\param color color to initialize from
*/
RGBColor::RGBColor(const rgb_color &color)
{
	SetColor(color);
}

#if 0
/*!
	\brief Create an RGBColor from a 16-bit RGBA color
	\param color color to initialize from
*/
RGBColor::RGBColor(uint16 color)
{
	SetColor(color);
}
#endif

/*!
	\brief Create an RGBColor from an index color
	\param color color to initialize from
*/
RGBColor::RGBColor(uint8 color)
{
	SetColor(color);
}


/*!
	\brief Copy Contructor
	\param color color to initialize from
*/
RGBColor::RGBColor(const RGBColor &color)
{
	fColor32 = color.fColor32;
	fColor16 = color.fColor16;
	fColor15 = color.fColor15;
	fColor8 = color.fColor8;
	fUpdate8 = color.fUpdate8;
	fUpdate15 = color.fUpdate15;
	fUpdate16 = color.fUpdate16;
}


/*!
	\brief Create an RGBColor with the values(0,0,0,0)
*/
RGBColor::RGBColor()
{
	SetColor(0, 0, 0, 0);
}


/*!
	\brief Returns the color as the closest 8-bit color in the palette
	\return The palette index for the current color
*/
uint8
RGBColor::GetColor8() const
{
	if (fUpdate8) {
		fColor8 = FindClosestColor(SystemPalette(), fColor32);
		fUpdate8 = false;
	}

	return fColor8;
}


/*!
	\brief Returns the color as the closest 15-bit color
	\return 15-bit value of the current color plus 1-bit alpha
*/
uint16
RGBColor::GetColor15() const
{
	if (fUpdate15) {
		fColor15 = FindClosestColor15(fColor32);
		fUpdate15 = false;
	}

	return fColor15;
}


/*!
	\brief Returns the color as the closest 16-bit color
	\return 16-bit value of the current color
*/
uint16
RGBColor::GetColor16() const
{
	if (fUpdate16) {
		fColor16 = FindClosestColor16(fColor32);
		fUpdate16 = false;
	}

	return fColor16;
}


/*!
	\brief Returns the color as a 32-bit color
	\return current color, including alpha
*/
rgb_color
RGBColor::GetColor32() const
{
	return fColor32;
}


/*!
	\brief Set the object to specified values
	\param red red
	\param green green
	\param blue blue
	\param alpha alpha, defaults to 255
*/
void
RGBColor::SetColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	fColor32.red = r;
	fColor32.green = g;
	fColor32.blue = b;
	fColor32.alpha = a;

	fUpdate8 = fUpdate15 = fUpdate16 = true;
}


/*!
	\brief Set the object to specified values
	\param red red
	\param green green
	\param blue blue
	\param alpha alpha, defaults to 255
*/
void
RGBColor::SetColor(int r, int g, int b, int a)
{
	fColor32.red = (uint8)r;
	fColor32.green = (uint8)g;
	fColor32.blue = (uint8)b;
	fColor32.alpha = (uint8)a;

	fUpdate8 = fUpdate15 = fUpdate16 = true;
}

#if 0
/*!
	\brief Set the object to specified value
	\param col16 color to copy
*/
void
RGBColor::SetColor(uint16 col16)
{
	fColor16 = col16;
	SetRGBColor(&fColor32, col16);

	fUpdate8 = true;
	fUpdate15 = true;
	fUpdate16 = false;
}
#endif


/*!
	\brief Set the object to specified index in the palette
	\param col8 color to copy
*/
void
RGBColor::SetColor(uint8 col8)
{
	fColor8 = col8;
	fColor32 = SystemPalette()[col8];

	fUpdate8 = false;
	fUpdate15 = true;
	fUpdate16 = true;
}


/*!
	\brief Set the object to specified color
	\param color color to copy
*/
void
RGBColor::SetColor(const rgb_color &color)
{
	fColor32 = color;
	fUpdate8 = fUpdate15 = fUpdate16 = true;
}


/*!
	\brief Set the object to specified color
	\param color color to copy
*/
void
RGBColor::SetColor(const RGBColor &color)
{
	fColor32 = color.fColor32;
	fColor16 = color.fColor16;
	fColor15 = color.fColor15;
	fColor8 = color.fColor8;
	fUpdate8 = color.fUpdate8;
	fUpdate15 = color.fUpdate15;
	fUpdate16 = color.fUpdate16;
}


/*!
	\brief Set the object to specified color
	\param color color to copy
*/
const RGBColor&
RGBColor::operator=(const RGBColor &color)
{
	fColor32 = color.fColor32;
	fColor16 = color.fColor16;
	fColor15 = color.fColor15;
	fColor8 = color.fColor8;
	fUpdate8 = color.fUpdate8;
	fUpdate15 = color.fUpdate15;
	fUpdate16 = color.fUpdate16;

	return *this;
}


/*!
	\brief Set the object to specified color
	\param color color to copy
*/
const RGBColor&
RGBColor::operator=(const rgb_color &color)
{
	fColor32 = color;
	fUpdate8 = fUpdate15 = fUpdate16 = true;

	return *this;
}


/*!
	\brief Prints the 32-bit values of the color to standard out
*/
void
RGBColor::PrintToStream(void) const
{
	printf("RGBColor(%u,%u,%u,%u)\n",
		fColor32.red, fColor32.green, fColor32.blue, fColor32.alpha);
}


/*!
	\brief Overloaded comaparison
	\return true if all color elements are exactly equal
*/
bool
RGBColor::operator==(const rgb_color &color) const
{
	return fColor32.red == color.red
		&& fColor32.green == color.green
		&& fColor32.blue == color.blue
		&& fColor32.alpha == color.alpha;
}


/*!
	\brief Overloaded comaparison
	\return true if all color elements are exactly equal
*/
bool
RGBColor::operator==(const RGBColor &color) const
{
	return fColor32.red == color.fColor32.red
		&& fColor32.green == color.fColor32.green
		&& fColor32.blue == color.fColor32.blue
		&& fColor32.alpha == color.fColor32.alpha;
}


bool
RGBColor::operator!=(const rgb_color &color) const
{
	return fColor32.red != color.red
		|| fColor32.green != color.green
		|| fColor32.blue != color.blue
		|| fColor32.alpha != color.alpha;
}


bool
RGBColor::operator!=(const RGBColor &color) const
{
	return fColor32.red != color.fColor32.red
		|| fColor32.green != color.fColor32.green
		|| fColor32.blue != color.fColor32.blue
		|| fColor32.alpha != color.fColor32.alpha;
}


bool
RGBColor::IsTransparentMagic() const
{
	// TODO: validate this for B_CMAP8 for example
	return *this == B_TRANSPARENT_COLOR;
}