/*
 * Copyright 2010-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		John Scipione, jscipione@gmail.com
 *		Clemens Zeidler, haiku@clemens-zeidler.de
 */
#ifndef SAT_GROUP_H
#define SAT_GROUP_H


#include <Rect.h>

#include <AutoDeleter.h>
#include "ObjectList.h"
#include "Referenceable.h"

#include "MagneticBorder.h"

#include "LinearSpec.h"


class SATWindow;
class Tab;
class WindowArea;

typedef BObjectList<SATWindow> SATWindowList;


class Corner {
public:
		enum info_t
		{
			kFree,
			kUsed,
			kNotDockable
		};

		enum position_t
		{
			kLeftTop = 0,
			kRightTop = 1,
			kLeftBottom = 2,
			kRightBottom = 3
		};

						Corner();
		void			Trace() const;

		info_t			status;
		WindowArea*		windowArea;
};


class Crossing : public BReferenceable {
public:
								Crossing(Tab* vertical, Tab* horizontal);
								~Crossing();

			Corner*				GetCorner(Corner::position_t corner) const;
			Corner*				GetOppositeCorner(
									Corner::position_t corner) const;

			Corner*				LeftTopCorner()
									{ return &fCorners[Corner::kLeftTop]; }
			Corner*				RightTopCorner()
									{ return &fCorners[Corner::kRightTop]; }
			Corner*				LeftBottomCorner()
									{ return &fCorners[Corner::kLeftBottom]; }
			Corner*				RightBottomCorner()
									{ return &fCorners[Corner::kRightBottom]; }

			Tab*				VerticalTab() const;
			Tab*				HorizontalTab() const;

			void				Trace() const;
private:
			Corner				fCorners[4];

			BReference<Tab>		fVerticalTab;
			BReference<Tab>		fHorizontalTab;
};


typedef BObjectList<Constraint> ConstraintList;
class SATGroup;

typedef BObjectList<Crossing> CrossingList;


// make all coordinates positive needed for the solver
const float kMakePositiveOffset = 5000;


class Tab : public BReferenceable {
public:
		enum orientation_t
		{
			kVertical,
			kHorizontal
		};

								Tab(SATGroup* group, Variable* variable,
									orientation_t orientation);
								~Tab();

			float				Position() const;
			void				SetPosition(float position);
			orientation_t		Orientation() const;
			Variable*			Var() {	return fVariable.Get(); }

			//! Caller takes ownership of the constraint.
			Constraint*			Connect(Variable* variable);

			BReference<Crossing>	AddCrossing(Tab* tab);
			bool				RemoveCrossing(Crossing* crossing);
			int32				FindCrossingIndex(Tab* tab);
			int32				FindCrossingIndex(float tabPosition);
			Crossing*			FindCrossing(Tab* tab);
			Crossing*			FindCrossing(float tabPosition);

			const CrossingList*	GetCrossingList() const;

	static	int					CompareFunction(const Tab* tab1,
									const Tab* tab2);

private:
			SATGroup*			fGroup;
			ObjectDeleter<Variable>
								fVariable;
			orientation_t		fOrientation;

			CrossingList		fCrossingList;
};


class WindowArea : public BReferenceable {
public:
								WindowArea(Crossing* leftTop,
									Crossing* rightTop, Crossing* leftBottom,
									Crossing* rightBottom);
								~WindowArea();

			bool				Init(SATGroup* group);
			SATGroup*			Group() { return fGroup; }

			void				DoGroupLayout();
			void				UpdateSizeLimits();
			void				UpdateSizeConstaints(const BRect& frame);

	const	SATWindowList&		WindowList() { return fWindowList; }
	const	SATWindowList&		LayerOrder() { return fWindowLayerOrder; }
			bool				MoveWindowToPosition(SATWindow* window,
									int32 index);
			SATWindow*			TopWindow();

			Crossing*			LeftTopCrossing()
									{ return fLeftTopCrossing.Get(); }
			Crossing*			RightTopCrossing()
									{ return fRightTopCrossing.Get(); }
			Crossing*			LeftBottomCrossing()
									{ return fLeftBottomCrossing.Get(); }
			Crossing*			RightBottomCrossing()
									{ return fRightBottomCrossing.Get(); }

			Tab*				LeftTab();
			Tab*				RightTab();
			Tab*				TopTab();
			Tab*				BottomTab();

			Variable*			LeftVar() { return LeftTab()->Var(); }
			Variable*			RightVar() { return RightTab()->Var(); }
			Variable*			TopVar() { return TopTab()->Var(); }
			Variable*			BottomVar() { return BottomTab()->Var(); }

			BRect				Frame();

			bool				PropagateToGroup(SATGroup* group);

			bool				MoveToTopLayer(SATWindow* window);

private:
		friend class SATGroup;
			void				_UninitConstraints();
			void				_UpdateConstraintValues();

			/*! SATGroup adds new windows to the area. */
			bool				_AddWindow(SATWindow* window,
									SATWindow* after = NULL);
			/*! After the last window has been removed the WindowArea delete
			himself and clean up all crossings. */
			bool				_RemoveWindow(SATWindow* window);

	inline	void				_InitCorners();
	inline	void				_CleanupCorners();
	inline	void				_SetToWindowCorner(Corner* corner);
	inline	void				_SetToNeighbourCorner(Corner* neighbour);
	inline	void				_UnsetWindowCorner(Corner* corner);
		//! opponent is the other neighbour of the neighbour
	inline	void				_UnsetNeighbourCorner(Corner* neighbour,
									Corner* opponent);

			// Find crossing by tab position in group and if not exist create
			// it.
			BReference<Crossing>	_CrossingByPosition(Crossing* crossing,
										SATGroup* group);

			void				_MoveToSAT(SATWindow* topWindow);

			BReference<SATGroup>	fGroup;

			SATWindowList		fWindowList;

			SATWindowList		fWindowLayerOrder;

			BReference<Crossing>	fLeftTopCrossing;
			BReference<Crossing>	fRightTopCrossing;
			BReference<Crossing>	fLeftBottomCrossing;
			BReference<Crossing>	fRightBottomCrossing;

			Constraint*			fMinWidthConstraint;
			Constraint*			fMinHeightConstraint;
			Constraint*			fMaxWidthConstraint;
			Constraint*			fMaxHeightConstraint;
			Constraint*			fWidthConstraint;
			Constraint*			fHeightConstraint;

			MagneticBorder		fMagneticBorder;
};


typedef BObjectList<WindowArea> WindowAreaList;
typedef BObjectList<Tab> TabList;

class BMessage;
class StackAndTile;


class SATGroup : public BReferenceable {
public:
		friend class Tab;
		friend class WindowArea;
		friend class GroupCookie;

								SATGroup();
								~SATGroup();

			LinearSpec*			GetLinearSpec() { return fLinearSpec; }

			/*! Create a new WindowArea from the crossing and add the window. */
			bool				AddWindow(SATWindow* window, Tab* left,
									Tab* top, Tab* right, Tab* bottom);
			/*! Add a window to an existing window area. */
			bool				AddWindow(SATWindow* window, WindowArea* area,
									SATWindow* after = NULL);
			/*! If stayBelowMouse is true move the removed window below the
			cursor if necessary. */
			bool				RemoveWindow(SATWindow* window,
									bool stayBelowMouse = true);
			int32				CountItems();
			SATWindow*			WindowAt(int32 index);

			SATWindow*			ActiveWindow() const;
			void				SetActiveWindow(SATWindow* window);

			const WindowAreaList&	GetAreaList() { return fWindowAreaList; }

			/*! \return a sorted tab list. */
			const TabList*		HorizontalTabs();
			const TabList*		VerticalTabs();

			Tab*				FindHorizontalTab(float position);
			Tab*				FindVerticalTab(float position);

			void				WindowAreaRemoved(WindowArea* area);

	static	status_t			RestoreGroup(const BMessage& archive,
									StackAndTile* sat);
			status_t			ArchiveGroup(BMessage& archive);

private:
			BReference<Tab>		_AddHorizontalTab(float position = 0);
			BReference<Tab>		_AddVerticalTab(float position = 0);

			bool				_RemoveHorizontalTab(Tab* tab);
			bool				_RemoveVerticalTab(Tab* tab);

			Tab*				_FindTab(const TabList& list, float position);

			void				_SplitGroupIfNecessary(
									WindowArea* removedArea);
			void				_FillNeighbourList(
									WindowAreaList& neighbourWindows,
									WindowArea* area);
			void				_LeftNeighbours(
									WindowAreaList& neighbourWindows,
									WindowArea* window);
			void				_TopNeighbours(
									WindowAreaList& neighbourWindows,
									WindowArea* window);
			void				_RightNeighbours(
									WindowAreaList& neighbourWindows,
									WindowArea* window);
			void				_BottomNeighbours(
									WindowAreaList& neighbourWindows,
									WindowArea* window);
			bool				_FindConnectedGroup(WindowAreaList& seedList,
									WindowArea* removedArea,
									WindowAreaList& newGroup);
			void				_FollowSeed(WindowArea* area, WindowArea* veto,
									WindowAreaList& seedList,
									WindowAreaList& newGroup);
			void				_SpawnNewGroup(const WindowAreaList& newGroup);

			void				_EnsureGroupIsOnScreen(SATGroup* group);
	inline	void				_CallculateXOffset(BPoint& offset, BRect& frame,
									BRect& screen);
	inline	void				_CallculateYOffset(BPoint& offset, BRect& frame,
									BRect& screen);

protected:
			WindowAreaList		fWindowAreaList;
			SATWindowList		fSATWindowList;

			LinearSpec*			fLinearSpec;

private:
			TabList				fHorizontalTabs;
			bool				fHorizontalTabsSorted;
			TabList				fVerticalTabs;
			bool				fVerticalTabsSorted;

			SATWindow*			fActiveWindow;
};


typedef BObjectList<SATGroup> SATGroupList;

#endif