/*
 * Copyright 2012, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _SHARED_SOLVER_H
#define _SHARED_SOLVER_H


#include <set>

#include <Archivable.h>
#include <LayoutContext.h>
#include <ObjectList.h>
#include <Referenceable.h>

#include "LinearSpec.h"


class BMessage;

namespace BALM {
	class BALMLayout;
	class Area;
};

using BALM::BALMLayout;
using BALM::Area;


namespace BPrivate {


class SharedSolver : BLayoutContextListener, public BReferenceable,
	   public BArchivable {
public:
								SharedSolver(BMessage* archive);
								SharedSolver();
								~SharedSolver();

			void				Invalidate(bool children);

			LinearSpec*			Solver() const;
			ResultType			Result();

			void				RegisterLayout(BALMLayout* layout);
			void				LayoutLeaving(const BALMLayout* layout);

			ResultType			ValidateMinSize();
			ResultType			ValidateMaxSize();
			ResultType			ValidatePreferredSize();
			ResultType			ValidateLayout(BLayoutContext* context);

			status_t			AddFriendReferences(const BALMLayout* layout,
									BMessage* archive, const char* field);

			status_t			Archive(BMessage* archive, bool deep) const;
			status_t			AllArchived(BMessage* archive) const;
			status_t			AllUnarchived(const BMessage* archive);

	static	BArchivable*		Instantiate(BMessage* archive);

private:
			struct MinSizeValidator;
			struct MaxSizeValidator;
			struct PreferredSizeValidator;

			friend struct MinSizeValidator;
			friend struct MaxSizeValidator;
			friend struct PreferredSizeValidator;


	static	void				_AddConstraintsToSet(Area* area,
									std::set<const Constraint*>& constraints);
	static	status_t			_AddConstraintToArchive(Constraint* constraint,
									BMessage* archive);
			status_t			_InstantiateConstraint(const void* rawData,
									ssize_t numBytes, BUnarchiver& unarchiver);

			void				SetMaxSize(BALM::BALMLayout* layout,
									const BSize& max);
			void				SetMinSize(BALM::BALMLayout* layout,
									const BSize& min);
			void				SetPreferredSize(BALM::BALMLayout* layout,
									const BSize& preferred);

	virtual	void				LayoutContextLeft(BLayoutContext* context);

			void				_UpdateConstraints();
			void				_SetContext(BLayoutContext* context);
			bool				_IsMinSet();
			bool				_IsMaxSet();
			void				_ValidateConstraints();

			template <class Validator>
			void				_Validate(bool& isValid, ResultType& result);


			bool				fConstraintsValid;
			bool				fMinValid;
			bool				fMaxValid;
			bool				fPreferredValid;
			bool				fLayoutValid;

			BLayoutContext*		fLayoutContext;
			BObjectList<BALM::BALMLayout> fLayouts;
			LinearSpec			fLinearSpec;

			ResultType			fMinResult;
			ResultType			fMaxResult;
			ResultType			fPreferredResult;
			ResultType			fLayoutResult;
};


};


using BPrivate::SharedSolver;


#endif