/*
 * Copyright 2013, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "CharacterStyle.h"


CharacterStyle::CharacterStyle()
	:
	fStyleData(new CharacterStyleData(), true)
{
}


CharacterStyle::CharacterStyle(const CharacterStyle& other)
	:
	fStyleData(other.fStyleData)
{
}


CharacterStyle&
CharacterStyle::operator=(const CharacterStyle& other)
{
	if (this == &other)
		return *this;

	fStyleData = other.fStyleData;
	return *this;
}


bool
CharacterStyle::operator==(const CharacterStyle& other) const
{
	if (this == &other)
		return true;

	if (fStyleData == other.fStyleData)
		return true;

	if (fStyleData.IsSet() && other.fStyleData.IsSet())
		return *fStyleData == *other.fStyleData;

	return false;
}


bool
CharacterStyle::operator!=(const CharacterStyle& other) const
{
	return !(*this == other);
}


bool
CharacterStyle::SetFont(const BFont& font)
{
	CharacterStyleDataRef data = fStyleData->SetFont(font);
	if (data == fStyleData)
		return data->Font() == font;

	fStyleData = data;
	return true;
}


const BFont&
CharacterStyle::Font() const
{
	return fStyleData->Font();
}


bool
CharacterStyle::SetFontSize(float size)
{
	BFont font(Font());
	font.SetSize(size);
	return SetFont(font);
}


float
CharacterStyle::FontSize() const
{
	return Font().Size();
}


bool
CharacterStyle::SetBold(bool bold)
{
	uint16 face = Font().Face();
	if ((bold && (face & B_BOLD_FACE) != 0)
		|| (!bold && (face & B_BOLD_FACE) == 0)) {
		return true;
	}

	uint16 neededFace = face;
	if (bold) {
		neededFace |= B_BOLD_FACE;
		neededFace &= ~B_REGULAR_FACE;
	} else {
		neededFace &= ~B_BOLD_FACE;
		if (neededFace == 0)
			neededFace |= B_REGULAR_FACE;
	}

	return SetFont(_FindFontForFace(neededFace));
}


bool
CharacterStyle::IsBold() const
{
	return (Font().Face() & B_BOLD_FACE) != 0;
}


bool
CharacterStyle::SetItalic(bool italic)
{
	uint16 face = Font().Face();
	if ((italic && (face & B_ITALIC_FACE) != 0)
		|| (!italic && (face & B_ITALIC_FACE) == 0)) {
		return true;
	}

	uint16 neededFace = face;
	if (italic) {
		neededFace |= B_ITALIC_FACE;
		neededFace &= ~B_REGULAR_FACE;
	} else {
		neededFace &= ~B_ITALIC_FACE;
		if (neededFace == 0)
			neededFace |= B_REGULAR_FACE;
	}

	return SetFont(_FindFontForFace(neededFace));
}


bool
CharacterStyle::IsItalic() const
{
	return (Font().Face() & B_ITALIC_FACE) != 0;
}


bool
CharacterStyle::SetAscent(float ascent)
{
	CharacterStyleDataRef data = fStyleData->SetAscent(ascent);
	if (data == fStyleData)
		return data->Ascent() == ascent;

	fStyleData = data;
	return true;
}


float
CharacterStyle::Ascent() const
{
	return fStyleData->Ascent();
}


bool
CharacterStyle::SetDescent(float descent)
{
	CharacterStyleDataRef data = fStyleData->SetDescent(descent);
	if (data == fStyleData)
		return data->Descent() == descent;

	fStyleData = data;
	return true;
}


float
CharacterStyle::Descent() const
{
	return fStyleData->Descent();
}


bool
CharacterStyle::SetWidth(float width)
{
	CharacterStyleDataRef data = fStyleData->SetWidth(width);
	if (data == fStyleData)
		return data->Width() == width;

	fStyleData = data;
	return true;
}


float
CharacterStyle::Width() const
{
	return fStyleData->Width();
}


bool
CharacterStyle::SetGlyphSpacing(float spacing)
{
	CharacterStyleDataRef data = fStyleData->SetGlyphSpacing(spacing);
	if (data == fStyleData)
		return data->GlyphSpacing() == spacing;

	fStyleData = data;
	return true;
}


float
CharacterStyle::GlyphSpacing() const
{
	return fStyleData->GlyphSpacing();
}


bool
CharacterStyle::SetForegroundColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	return SetForegroundColor((rgb_color){ r, g, b, a });
}


bool
CharacterStyle::SetForegroundColor(color_which which)
{
	CharacterStyleDataRef data = fStyleData->SetForegroundColor(which);
	if (data == fStyleData)
		return data->WhichForegroundColor() == which;

	fStyleData = data;
	return true;
}


bool
CharacterStyle::SetForegroundColor(rgb_color color)
{
	CharacterStyleDataRef data = fStyleData->SetForegroundColor(color);
	if (data == fStyleData)
		return data->ForegroundColor() == color;

	fStyleData = data;
	return true;
}


rgb_color
CharacterStyle::ForegroundColor() const
{
	return fStyleData->ForegroundColor();
}


color_which
CharacterStyle::WhichForegroundColor() const
{
	return fStyleData->WhichForegroundColor();
}


bool
CharacterStyle::SetBackgroundColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	return SetBackgroundColor((rgb_color){ r, g, b, a });
}


bool
CharacterStyle::SetBackgroundColor(color_which which)
{
	CharacterStyleDataRef data = fStyleData->SetBackgroundColor(which);
	if (data == fStyleData)
		return data->WhichBackgroundColor() == which;

	fStyleData = data;
	return true;
}


bool
CharacterStyle::SetBackgroundColor(rgb_color color)
{
	CharacterStyleDataRef data = fStyleData->SetBackgroundColor(color);
	if (data == fStyleData)
		return data->BackgroundColor() == color;

	fStyleData = data;
	return true;
}


rgb_color
CharacterStyle::BackgroundColor() const
{
	return fStyleData->BackgroundColor();
}


color_which
CharacterStyle::WhichBackgroundColor() const
{
	return fStyleData->WhichBackgroundColor();
}


bool
CharacterStyle::SetStrikeOutColor(color_which which)
{
	CharacterStyleDataRef data = fStyleData->SetStrikeOutColor(which);
	if (data == fStyleData)
		return data->WhichStrikeOutColor() == which;

	fStyleData = data;
	return true;
}


bool
CharacterStyle::SetStrikeOutColor(rgb_color color)
{
	CharacterStyleDataRef data = fStyleData->SetStrikeOutColor(color);
	if (data == fStyleData)
		return data->StrikeOutColor() == color;

	fStyleData = data;
	return true;
}


rgb_color
CharacterStyle::StrikeOutColor() const
{
	return fStyleData->StrikeOutColor();
}


color_which
CharacterStyle::WhichStrikeOutColor() const
{
	return fStyleData->WhichStrikeOutColor();
}


bool
CharacterStyle::SetUnderlineColor(color_which which)
{
	CharacterStyleDataRef data = fStyleData->SetUnderlineColor(which);
	if (data == fStyleData)
		return data->WhichUnderlineColor() == which;

	fStyleData = data;
	return true;
}


bool
CharacterStyle::SetUnderlineColor(rgb_color color)
{
	CharacterStyleDataRef data = fStyleData->SetUnderlineColor(color);
	if (data == fStyleData)
		return data->UnderlineColor() == color;

	fStyleData = data;
	return true;
}


rgb_color
CharacterStyle::UnderlineColor() const
{
	return fStyleData->UnderlineColor();
}


color_which
CharacterStyle::WhichUnderlineColor() const
{
	return fStyleData->WhichUnderlineColor();
}


bool
CharacterStyle::SetStrikeOut(uint8 strikeOut)
{
	CharacterStyleDataRef data = fStyleData->SetStrikeOut(strikeOut);
	if (data == fStyleData)
		return data->StrikeOut() == strikeOut;

	fStyleData = data;
	return true;
}


uint8
CharacterStyle::StrikeOut() const
{
	return fStyleData->StrikeOut();
}


bool
CharacterStyle::SetUnderline(uint8 underline)
{
#if 1
	uint16 face = Font().Face();
	if ((underline && (face & B_UNDERSCORE_FACE) != 0)
		|| (!underline && (face & B_UNDERSCORE_FACE) == 0)) {
		return true;
	}

	uint16 neededFace = face;
	if (underline) {
		neededFace |= B_UNDERSCORE_FACE;
		neededFace &= ~B_REGULAR_FACE;
	} else {
		neededFace &= ~B_UNDERSCORE_FACE;
		if (neededFace == 0)
			neededFace |= B_REGULAR_FACE;
	}

	return SetFont(_FindFontForFace(neededFace));
#else
	// TODO: re-enable this instead of using B_UNDERSCORE_FACE when TextDocumentView actually
	// implements drawing the fancy underline styles. Until then, we can at least get simple
	// underlines.
	CharacterStyleDataRef data = fStyleData->SetUnderline(underline);
	if (data == fStyleData)
		return data->Underline() == underline;

	fStyleData = data;
	return true;
#endif
}


uint8
CharacterStyle::Underline() const
{
	return fStyleData->Underline();
}


// #pragma mark - private


BFont
CharacterStyle::_FindFontForFace(uint16 face) const
{
	BFont font(Font());
	font.SetFamilyAndFace(NULL, face);

	return font;
}