/*
 * Copyright © 2008 Dennis Kasprzyk
 * Copyright © 2007 Novell, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without
 * fee, provided that the above copyright notice appear in all copies
 * and that both that copyright notice and this permission notice
 * appear in supporting documentation, and that the name of
 * Dennis Kasprzyk not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior permission.
 * Dennis Kasprzyk makes no representations about the suitability of this
 * software for any purpose. It is provided "as is" without express or
 * implied warranty.
 *
 * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
 * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors: Dennis Kasprzyk <onestone@compiz-fusion.org>
 *          David Reveman <davidr@novell.com>
 */

#ifndef _COMPOPTION_H
#define _COMPOPTION_H

#include <compiz.h>

#include <vector>

class PrivateOption;
class PrivateValue;
class PrivateRestriction;
class CompAction;
class CompMatch;
class CompScreen;

class CompOption {
    public:
	typedef enum {
	    TypeBool,
	    TypeInt,
	    TypeFloat,
	    TypeString,
	    TypeColor,
	    TypeAction,
	    TypeKey,
	    TypeButton,
	    TypeEdge,
	    TypeBell,
	    TypeMatch,
	    TypeList,
	    /* internal use only */
	    TypeUnset
	} Type;

	class Value {
	    public:
		typedef std::vector<Value> Vector;

	    public:
		Value ();
		Value (const Value &);
		Value (const bool b);
		Value (const int i);
		Value (const float f);
		Value (const unsigned short *color);
		Value (const CompString& s);
		Value (const char *s);
		Value (const CompMatch& m);
		Value (const CompAction& a);
		Value (Type type, const Vector& l);
		~Value ();

		Type type () const;

		void set (const bool b);
		void set (const int i);
		void set (const float f);
		void set (const unsigned short *color);
		void set (const CompString& s);
		void set (const char *s);
		void set (const CompMatch& m);
		void set (const CompAction& a);
		void set (Type type, const Vector& l);

		bool               b ();
		int                i ();
		float              f ();
		unsigned short*    c ();
		CompString         s ();
		CompMatch &        match ();
		CompAction &       action ();
		Type               listType ();
		Vector &           list ();

		bool operator== (const Value& val);
		bool operator!= (const Value& val);
		Value & operator= (const Value &val);

		operator bool ();
		operator int ();
		operator float ();
		operator unsigned short * ();
		operator CompString ();
		operator CompMatch & ();
		operator CompAction & ();
		operator CompAction * ();
		operator Type ();
		operator Vector & ();

	    private:
		PrivateValue *priv;
	};

	class Restriction {
	    public:
		Restriction ();
		Restriction (const Restriction &);
		~Restriction ();

		int iMin ();
		int iMax ();
		float fMin ();
		float fMax ();
		float fPrecision ();

		void set (int, int);
		void set (float, float, float);

		bool inRange (int);
		bool inRange (float);

		Restriction & operator= (const Restriction &rest);
	    private:
		PrivateRestriction *priv;
	};

	typedef std::vector<CompOption> Vector;

	class Class {
	    public:
		virtual Vector & getOptions () = 0;

		virtual CompOption * getOption (const CompString &name);

		virtual bool setOption (const CompString &name,
					Value            &value) = 0;
	};

    public:
	CompOption ();
	CompOption (const CompOption &);
	CompOption (CompString name, Type type);
	~CompOption ();

	void setName (CompString name, Type type);

	CompString name ();

	Type type ();
	Value & value ();
	Restriction & rest ();

	bool set (Value &val);
	bool isAction ();

	CompOption & operator= (const CompOption &option);

    public:
	static CompOption * findOption (Vector &options, CompString name,
					unsigned int *index = NULL);

	static bool
	getBoolOptionNamed (const Vector& options,
			    const CompString& name,
			    bool defaultValue = false);

	static int
	getIntOptionNamed (const Vector& options,
			   const CompString& name,
			   int defaultValue = 0);

	static float
	getFloatOptionNamed (const Vector& options,
			     const CompString& name,
			     const float& defaultValue = 0.0);

	static CompString
	getStringOptionNamed (const Vector& options,
			      const CompString& name,
			      const CompString& defaultValue = "");

	static unsigned short *
	getColorOptionNamed (const Vector& options,
			     const CompString& name,
			     unsigned short *defaultValue);

	static CompMatch
	getMatchOptionNamed (const Vector& options,
			     const CompString& name,
			     const CompMatch& defaultValue);

	static CompString typeToString (Type type);

	static bool stringToColor (CompString     color,
				   unsigned short *rgba);

	static CompString colorToString (unsigned short *rgba);


	static bool setOption (CompOption  &o, Value &value);

    private:
	PrivateOption *priv;
};

extern CompOption::Vector noOptions;

#endif