/*
 * Copyright 2009-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		DarkWyrm, bpmagic@columbus.rr.com
 *		Adrien Destugues, pulkomandy@gmail.com
 *		John Scipione, jscipione@gmail.com
 */


/*! Decorator resembling Windows 95 */


#include "WinDecorator.h"

#include <new>
#include <stdio.h>

#include <Point.h>
#include <Rect.h>
#include <View.h>

#include "DesktopSettings.h"
#include "DrawingEngine.h"
#include "PatternHandler.h"
#include "RGBColor.h"


//#define DEBUG_DECORATOR
#ifdef DEBUG_DECORATOR
#	define STRACE(x) printf x
#else
#	define STRACE(x) ;
#endif


WinDecorAddOn::WinDecorAddOn(image_id id, const char* name)
	:
	DecorAddOn(id, name)
{
}


Decorator*
WinDecorAddOn::_AllocateDecorator(DesktopSettings& settings, BRect rect,
	Desktop* desktop)
{
	return new (std::nothrow)WinDecorator(settings, rect, desktop);
}


WinDecorator::WinDecorator(DesktopSettings& settings, BRect frame,
	Desktop* desktop)
	:
	SATDecorator(settings, frame, desktop),
	// common colors to both focus and non focus state
	fFrameHighColor((rgb_color){ 255, 255, 255, 255 }),
	fFrameMidColor((rgb_color){ 216, 216, 216, 255 }),
	fFrameLowColor((rgb_color){ 110, 110, 110, 255 }),
	fFrameLowerColor((rgb_color){ 0, 0, 0, 255 }),

	// state based colors
	fFocusTabColor(settings.UIColor(B_WINDOW_TAB_COLOR)),
	fFocusTextColor(settings.UIColor(B_WINDOW_TEXT_COLOR)),
	fNonFocusTabColor(settings.UIColor(B_WINDOW_INACTIVE_TAB_COLOR)),
	fNonFocusTextColor(settings.UIColor(B_WINDOW_INACTIVE_TEXT_COLOR))
{
	STRACE(("WinDecorator:\n"));
	STRACE(("\tFrame (%.1f,%.1f,%.1f,%.1f)\n",
		frame.left, frame.top, frame.right, frame.bottom));
}


WinDecorator::~WinDecorator()
{
	STRACE(("~WinDecorator()\n"));
}


/*!	\brief Updates the decorator in the rectangular area \a updateRect.

	Updates all areas which intersect the frame and tab.

	\param updateRect The rectangular area to update.
*/
void
WinDecorator::Draw(BRect updateRect)
{
	STRACE(("WinDecorator::Draw(BRect updateRect): "));
	updateRect.PrintToStream();

	// We need to draw a few things: the tab, the resize knob, the borders,
	// and the buttons
	fDrawingEngine->SetDrawState(&fDrawState);

	_DrawFrame(updateRect & fBorderRect);
	_DrawTabs(updateRect & fTitleBarRect);
}


//! Forces a complete decorator update
void
WinDecorator::Draw()
{
	STRACE(("WinDecorator: Draw()"));

	// Easy way to draw everything - no worries about drawing only certain
	// things
	fDrawingEngine->SetDrawState(&fDrawState);

	_DrawFrame(fBorderRect);
	_DrawTabs(fTitleBarRect);
}


// TODO : add GetSizeLimits


Decorator::Region
WinDecorator::RegionAt(BPoint where, int32& tabIndex) const
{
	tabIndex = -1;

	for (int32 i = 0; i < fTabList.CountItems(); i++) {
		Decorator::Tab* tab = fTabList.ItemAt(i);
		if (tab->minimizeRect.Contains(where)) {
			tabIndex = i;
			return REGION_MINIMIZE_BUTTON;
		}
	}
	// Let the base class version identify hits of the buttons and the tab.
	Region region = Decorator::RegionAt(where, tabIndex);
	if (region != REGION_NONE)
		return region;

	// check the resize corner
	if (fTopTab->look == B_DOCUMENT_WINDOW_LOOK && fResizeRect.Contains(where))
		return REGION_RIGHT_BOTTOM_CORNER;

	// hit-test the borders
	if (!(fTopTab->flags & B_NOT_RESIZABLE)
		&& (fTopTab->look == B_TITLED_WINDOW_LOOK
			|| fTopTab->look == B_FLOATING_WINDOW_LOOK
			|| fTopTab->look == B_MODAL_WINDOW_LOOK)
		&& fBorderRect.Contains(where) && !fFrame.Contains(where)) {
		return REGION_BOTTOM_BORDER;
			// TODO Determine the actual border!
	}

	return REGION_NONE;
}


bool
WinDecorator::SetRegionHighlight(Region region, uint8 highlight,
	BRegion* dirty, int32 tabIndex)
{
	Decorator::Tab* tab
		= static_cast<Decorator::Tab*>(_TabAt(tabIndex));
	if (tab != NULL) {
		tab->isHighlighted = highlight != 0;
		// Invalidate the bitmap caches for the close/minimize/zoom button
		// when the highlight changes.
		switch (region) {
			case REGION_CLOSE_BUTTON:
				if (highlight != RegionHighlight(region))
					memset(&tab->closeBitmaps, 0, sizeof(tab->closeBitmaps));
				break;
			case REGION_MINIMIZE_BUTTON:
				if (highlight != RegionHighlight(region)) {
					memset(&tab->minimizeBitmaps, 0,
						sizeof(tab->minimizeBitmaps));
				}
				break;
			case REGION_ZOOM_BUTTON:
				if (highlight != RegionHighlight(region))
					memset(&tab->zoomBitmaps, 0, sizeof(tab->zoomBitmaps));
				break;
			default:
				break;
		}
	}

	return Decorator::SetRegionHighlight(region, highlight, dirty, tabIndex);
}


void
WinDecorator::_DoLayout()
{
	STRACE(("WinDecorator()::_DoLayout()\n"));

	bool hasTab = false;

	fBorderRect = fFrame;
	switch ((int)fTopTab->look) {
		case B_MODAL_WINDOW_LOOK:
			fBorderWidth = 4;
			break;

		case B_TITLED_WINDOW_LOOK:
		case B_DOCUMENT_WINDOW_LOOK:
			hasTab = true;
			fBorderWidth = 4;
			break;
		case B_FLOATING_WINDOW_LOOK:
			fBorderWidth = 0;
			hasTab = true;
			break;

		case B_BORDERED_WINDOW_LOOK:
			fBorderWidth = 1;
			break;

		default:
			fBorderWidth = 0;
			break;
	}

	fBorderRect.InsetBy(-fBorderWidth, -fBorderWidth);

	if (hasTab) {
		font_height fontHeight;
		fDrawState.Font().GetHeight(fontHeight);

		float tabSize = ceilf(fontHeight.ascent + fontHeight.descent + 4.0);

		if (tabSize < 20)
			tabSize = 20;
		fBorderRect.top -= tabSize;

		fTitleBarRect.Set(fFrame.left - 1,
			fFrame.top - tabSize,
			((fFrame.right - fFrame.left) < 32.0 ?
				fFrame.left + 32.0 : fFrame.right) + 1,
			fFrame.top - 1);

		for (int32 i = 0; i < fTabList.CountItems(); i++) {
			Decorator::Tab* tab = fTabList.ItemAt(i);

			tab->tabRect = fTitleBarRect;

			const float buttonsInset = 3;

			tab->zoomRect = tab->tabRect;
			tab->zoomRect.top += buttonsInset;
			tab->zoomRect.right -= buttonsInset;
			tab->zoomRect.bottom -= buttonsInset;
			tab->zoomRect.left = tab->zoomRect.right - tabSize + buttonsInset;

			tab->closeRect = tab->zoomRect;
			tab->zoomRect.OffsetBy(0 - tab->zoomRect.Width() - 3, 0);

			tab->minimizeRect = tab->zoomRect;
			tab->minimizeRect.OffsetBy(0 - tab->zoomRect.Width() - 1, 0);
		}
	} else {
		for (int32 i = 0; i < fTabList.CountItems(); i++) {
			Decorator::Tab* tab = fTabList.ItemAt(i);

			tab->tabRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->closeRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->zoomRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->minimizeRect.Set(0.0, 0.0, -1.0, -1.0);
		}
	}
}


void
WinDecorator::_DrawFrame(BRect rect)
{
	if (fTopTab->look == B_NO_BORDER_WINDOW_LOOK)
		return;

	if (fBorderRect == fFrame)
		return;

	BRect r = fBorderRect;

	fDrawingEngine->SetHighColor(fFrameLowerColor);
	fDrawingEngine->StrokeRect(r);

	if (fTopTab->look == B_BORDERED_WINDOW_LOOK)
		return;

	BPoint pt;

	pt = r.RightTop();
	pt.x--;
	fDrawingEngine->StrokeLine(r.LeftTop(), pt, fFrameMidColor);
	pt = r.LeftBottom();
	pt.y--;
	fDrawingEngine->StrokeLine(r.LeftTop(), pt, fFrameMidColor);

	fDrawingEngine->StrokeLine(r.RightTop(), r.RightBottom(), fFrameLowerColor);
	fDrawingEngine->StrokeLine(r.LeftBottom(), r.RightBottom(), fFrameLowerColor);

	r.InsetBy(1, 1);
	pt = r.RightTop();
	pt.x--;
	fDrawingEngine->StrokeLine(r.LeftTop(),pt,fFrameHighColor);
	pt = r.LeftBottom();
	pt.y--;
	fDrawingEngine->StrokeLine(r.LeftTop(),pt,fFrameHighColor);

	fDrawingEngine->StrokeLine(r.RightTop(), r.RightBottom(), fFrameLowColor);
	fDrawingEngine->StrokeLine(r.LeftBottom(), r.RightBottom(), fFrameLowColor);

	r.InsetBy(1, 1);
	fDrawingEngine->StrokeRect(r, fFrameMidColor);
	r.InsetBy(1, 1);
	fDrawingEngine->StrokeRect(r, fFrameMidColor);
}


/*!	\brief Actually draws the tab

	This function is called when the tab itself needs drawn. Other items,
	like the window title or buttons, should not be drawn here.

	\param tab The \a tab to update.
	\param rect The area of the \a tab to update.
*/
void
WinDecorator::_DrawTab(Decorator::Tab* tab, BRect rect)
{
	const BRect& tabRect = tab->tabRect;

	// If a window has a tab, this will draw it and any buttons in it.
	if (!tabRect.IsValid() || !rect.Intersects(tabRect)
		|| fTopTab->look == B_NO_BORDER_WINDOW_LOOK) {
		return;
	}

	fDrawingEngine->FillRect(tabRect & rect, fTabColor);

	_DrawTitle(tab, tabRect);

	// Draw the buttons if we're supposed to
	// TODO : we should still draw the buttons if they are disabled, but grey them out
	_DrawButtons(tab, rect);
}


/*!	\brief Actually draws the title

	The main tasks for this function are to ensure that the decorator draws
	the title only in its own area and drawing the title itself.
	Using B_OP_COPY for drawing the title is recommended because of the marked
	performance hit of the other drawing modes, but it is not a requirement.

	\param tab The \a tab to update.
	\param rect area of the title to update.
*/
void
WinDecorator::_DrawTitle(Decorator::Tab* tab, BRect rect)
{
	const BRect& tabRect = tab->tabRect;
	const BRect& minimizeRect = tab->minimizeRect;
	const BRect& zoomRect = tab->zoomRect;
	const BRect& closeRect = tab->closeRect;

	fDrawingEngine->SetHighColor(fTextColor);
	fDrawingEngine->SetLowColor(IsFocus(tab)
		? fFocusTabColor : fNonFocusTabColor);

	tab->truncatedTitle = Title(tab);
	fDrawState.Font().TruncateString(&tab->truncatedTitle, B_TRUNCATE_END,
		((minimizeRect.IsValid() ? minimizeRect.left :
			zoomRect.IsValid() ? zoomRect.left :
			closeRect.IsValid() ? closeRect.left : tabRect.right) - 5)
		- (tabRect.left + 5));
	tab->truncatedTitleLength = tab->truncatedTitle.Length();
	fDrawingEngine->SetFont(fDrawState.Font());

	font_height fontHeight;
	fDrawState.Font().GetHeight(fontHeight);

	BPoint titlePos;
	titlePos.x = tabRect.left + 5;
	titlePos.y = floorf(((tabRect.top + 2.0) + tabRect.bottom
			+ fontHeight.ascent + fontHeight.descent) / 2.0
			- fontHeight.descent + 0.5);

	fDrawingEngine->DrawString(tab->truncatedTitle, tab->truncatedTitleLength,
		titlePos);
}


void
WinDecorator::_DrawButtons(Decorator::Tab* tab, const BRect& invalid)
{
	if ((tab->flags & B_NOT_MINIMIZABLE) == 0
		&& invalid.Intersects(tab->minimizeRect)) {
		_DrawMinimize(tab, false, tab->minimizeRect);
	}
	if ((tab->flags & B_NOT_ZOOMABLE) == 0
		&& invalid.Intersects(tab->zoomRect)) {
		_DrawZoom(tab, false, tab->zoomRect);
	}
	if ((tab->flags & B_NOT_CLOSABLE) == 0
		&& invalid.Intersects(tab->closeRect)) {
		_DrawClose(tab, false, tab->closeRect);
	}
}


/*!
	\brief Actually draws the minimize button

	Unless a subclass has a particularly large button, it is probably
	unnecessary to check the update rectangle.

	\param tab The \a tab to update.
	\param direct Draw without double buffering.
	\param rect The area of the button to update.
*/
void
WinDecorator::_DrawMinimize(Decorator::Tab* tab, bool direct, BRect rect)
{
	// Just like DrawZoom, but for a Minimize button
	_DrawBeveledRect(rect, tab->minimizePressed);

	fDrawingEngine->SetHighColor(fTextColor);
	BRect minimizeBox(rect.left + 5, rect.bottom - 4, rect.right - 5,
		rect.bottom - 3);
	if (true)
		minimizeBox.OffsetBy(1, 1);

	fDrawingEngine->SetHighColor(RGBColor(0, 0, 0));
	fDrawingEngine->StrokeRect(minimizeBox);
}


/*!	\brief Actually draws the zoom button

	Unless a subclass has a particularly large button, it is probably
	unnecessary to check the update rectangle.

	\param tab The \a tab to update.
	\param direct Draw without double buffering.
	\param rect The area of the button to update.
*/
void
WinDecorator::_DrawZoom(Decorator::Tab* tab, bool direct, BRect rect)
{
	_DrawBeveledRect(rect, tab->zoomPressed);

	// Draw the Zoom box

	BRect zoomBox(rect);
	zoomBox.InsetBy(2, 2);
	zoomBox.InsetBy(1, 0);
	zoomBox.bottom--;
	zoomBox.right--;

	if (true)
		zoomBox.OffsetBy(1, 1);

	fDrawingEngine->SetHighColor(RGBColor(0,0,0));
	fDrawingEngine->StrokeRect(zoomBox);
	zoomBox.InsetBy(1, 1);
	fDrawingEngine->StrokeLine(zoomBox.LeftTop(), zoomBox.RightTop());
}


/*!	\brief Actually draws the close button

	Unless a subclass has a particularly large button, it is probably
	unnecessary to check the update rectangle.

	\param tab The \a tab to update.
	\param direct Draw without double buffering.
	\param rect The area of the button to update.
*/
void
WinDecorator::_DrawClose(Decorator::Tab* tab, bool direct, BRect rect)
{
	STRACE(("_DrawClose(%f, %f, %f, %f)\n", rect.left, rect.top, rect.right,
		rect.bottom));

	// Just like DrawZoom, but for a close button
	_DrawBeveledRect(rect, tab->closePressed);

	// Draw the X

	BRect closeBox(rect);
	closeBox.InsetBy(4, 4);
	closeBox.right--;
	closeBox.top--;

	if (true)
		closeBox.OffsetBy(1, 1);

	fDrawingEngine->SetHighColor(RGBColor(0, 0, 0));
	fDrawingEngine->StrokeLine(closeBox.LeftTop(), closeBox.RightBottom());
	fDrawingEngine->StrokeLine(closeBox.RightTop(), closeBox.LeftBottom());
	closeBox.OffsetBy(1, 0);
	fDrawingEngine->StrokeLine(closeBox.LeftTop(), closeBox.RightBottom());
	fDrawingEngine->StrokeLine(closeBox.RightTop(), closeBox.LeftBottom());
}


void
WinDecorator::_SetTitle(Decorator::Tab* tab, const char* string,
	BRegion* updateRegion)
{
	// TODO we could be much smarter about the update region

	BRect rect = TabRect(tab);

	if (updateRegion == NULL)
		return;

	BRect updatedRect = TabRect(tab);
	if (rect.left > updatedRect.left)
		rect.left = updatedRect.left;
	if (rect.right < updatedRect.right)
		rect.right = updatedRect.right;

	updateRegion->Include(rect);
}


void
WinDecorator::_SetFocus(Decorator::Tab* tab)
{
	// TODO stub

	// SetFocus() performs necessary duties for color swapping and
	// other things when a window is deactivated or activated.

	if (IsFocus(tab)) {
		fTabColor = fFocusTabColor;
		fTextColor = fFocusTextColor;
	} else {
		fTabColor = fNonFocusTabColor;
		fTextColor = fNonFocusTextColor;
	}
}


void
WinDecorator::_MoveBy(BPoint offset)
{
	// Move all tab rectangles over
	for (int32 i = 0; i < fTabList.CountItems(); i++) {
		Decorator::Tab* tab = fTabList.ItemAt(i);

		tab->zoomRect.OffsetBy(offset);
		tab->closeRect.OffsetBy(offset);
		tab->minimizeRect.OffsetBy(offset);
		tab->tabRect.OffsetBy(offset);
	}

	// Move all internal rectangles over
	fFrame.OffsetBy(offset);
	fTitleBarRect.OffsetBy(offset);
	fResizeRect.OffsetBy(offset);
	fBorderRect.OffsetBy(offset);
}


void
WinDecorator::_ResizeBy(BPoint offset, BRegion* dirty)
{
	// Move all internal rectangles the appropriate amount
	fFrame.right += offset.x;
	fFrame.bottom += offset.y;
	fTitleBarRect.right += offset.x;
	fTitleBarRect.bottom += offset.y;
	fResizeRect.OffsetBy(offset);
	fBorderRect.right += offset.x;
	fBorderRect.bottom += offset.y;

	for (int32 i = 0; i < fTabList.CountItems(); i++) {
		Decorator::Tab* tab = fTabList.ItemAt(i);

		tab->tabRect.right += offset.x;
		if (dirty != NULL)
			dirty->Include(tab->tabRect);
		//tab->zoomRect.right += offset.x;
		//tab->closeRect.right += offset.x;
		//tab->minimizeRect.right += offset.x;
	}
	if (dirty != NULL)
		dirty->Include(fBorderRect);

	// TODO probably some other layouting stuff here
	_DoLayout();
}


// TODO : _SetSettings


Decorator::Tab*
WinDecorator::_AllocateNewTab()
{
	Decorator::Tab* tab = new(std::nothrow) Decorator::Tab;
	if (tab == NULL)
		return NULL;

	// Set appropriate colors based on the current focus value. In this case,
	// each decorator defaults to not having the focus.
	_SetFocus(tab);
	return tab;
}


bool
WinDecorator::_AddTab(DesktopSettings& settings, int32 index,
	BRegion* updateRegion)
{
	_UpdateFont(settings);

	_DoLayout();
	if (updateRegion != NULL)
		updateRegion->Include(fTitleBarRect);

	return true;
}


bool
WinDecorator::_RemoveTab(int32 index, BRegion* updateRegion)
{
	BRect oldTitle = fTitleBarRect;
	_DoLayout();
	if (updateRegion != NULL) {
		updateRegion->Include(oldTitle);
		updateRegion->Include(fTitleBarRect);
	}
	return true;
}


bool
WinDecorator::_MoveTab(int32 from, int32 to, bool isMoving,
	BRegion* updateRegion)
{
	// TODO stub
	return false;
}


void
WinDecorator::_GetFootprint(BRegion* region)
{
	// This function calculates the decorator's footprint in coordinates
	// relative to the view. This is most often used to set a Window
	// object's visible region.
	if (region == NULL)
		return;

	region->MakeEmpty();

	if (fTopTab->look == B_NO_BORDER_WINDOW_LOOK)
		return;

	region->Set(fBorderRect);
	for (int32 i = 0; i < fTabList.CountItems(); i++) {
		Decorator::Tab* tab = fTabList.ItemAt(i);
		region->Include(tab->tabRect);
	}
	region->Exclude(fFrame);
}


void
WinDecorator::_UpdateFont(DesktopSettings& settings)
{
	ServerFont font;
	if (fTopTab->look == B_FLOATING_WINDOW_LOOK)
		settings.GetDefaultPlainFont(font);
	else
		settings.GetDefaultBoldFont(font);

	font.SetFlags(B_FORCE_ANTIALIASING);
	font.SetSpacing(B_STRING_SPACING);
	fDrawState.SetFont(font);
}


void
WinDecorator::_DrawBeveledRect(BRect r, bool down)
{
	RGBColor higher;
	RGBColor high;
	RGBColor mid;
	RGBColor low;
	RGBColor lower;

	if (down) {
		lower.SetColor(255,255,255);
		low.SetColor(216,216,216);
		mid.SetColor(192,192,192);
		high.SetColor(128,128,128);
		higher.SetColor(0,0,0);
	} else {
		higher.SetColor(255,255,255);
		high.SetColor(216,216,216);
		mid.SetColor(192,192,192);
		low.SetColor(128,128,128);
		lower.SetColor(0,0,0);
	}

	BRect rect(r);
	BPoint point;

	// Top highlight
	fDrawingEngine->SetHighColor(higher);
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop());

	// Left highlight
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftBottom());

	// Right shading
	point = rect.RightTop();
	point.y++;
	fDrawingEngine->StrokeLine(point, rect.RightBottom(), lower);

	// Bottom shading
	point = rect.LeftBottom();
	point.x++;
	fDrawingEngine->StrokeLine(point, rect.RightBottom(), lower);

	rect.InsetBy(1,1);
	fDrawingEngine->SetHighColor(high);
	// Top inside highlight
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop());

	// Left inside highlight
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftBottom());

	// Right inside shading
	point = rect.RightTop();
	point.y++;
	fDrawingEngine->StrokeLine(point, rect.RightBottom(), low);

	// Bottom inside shading
	point = rect.LeftBottom();
	point.x++;
	fDrawingEngine->StrokeLine(point, rect.RightBottom(), low);

	rect.InsetBy(1,1);

	fDrawingEngine->FillRect(rect, mid);
}


// #pragma mark - DecorAddOn


extern "C" DecorAddOn*
instantiate_decor_addon(image_id id, const char* name)
{
	return new (std::nothrow)WinDecorAddOn(id, name);
}