/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#ifndef __WINVAR_H__
#define __WINVAR_H__

static const char* VAR_GUIPREFIX = "gui::";
static const int VAR_GUIPREFIX_LEN = strlen(VAR_GUIPREFIX);

class idWindow;
class idWinVar {
public:
	idWinVar();
	virtual ~idWinVar();

	void SetGuiInfo(idDict* gd, const char* _name);
	const char* GetName() const {
		if (name) {
			if (guiDict && *name == '*') {
				return guiDict->GetString(&name[1]);
			}
			return name;
		}
		return "";
	}
	void SetName(const char* _name) {
		delete[]name;
		name = NULL;
		if (_name) {
			name = new char[strlen(_name) + 1];
			strcpy(name, _name);
		}
	}

	idWinVar& operator=(const idWinVar& other) {
		guiDict = other.guiDict;
		SetName(other.name);
		return *this;
	}

	idDict* GetDict() const { return guiDict; }
	bool NeedsUpdate() { return (guiDict != NULL); }

	virtual void Init(const char* _name, idWindow* win) = 0;
	virtual void Set(const char* val) = 0;
	virtual void Update() = 0;
	virtual const char* c_str() const = 0;
	virtual size_t Size() { size_t sz = (name) ? strlen(name) : 0; return sz + sizeof(*this); }

	virtual void WriteToSaveGame(idFile* savefile) = 0;
	virtual void ReadFromSaveGame(idFile* savefile) = 0;

	virtual float x(void) const = 0;

	void SetEval(bool b) {
		eval = b;
	}
	bool GetEval() {
		return eval;
	}

protected:
	idDict* guiDict;
	char* name;
	bool eval;
};

class idWinBool : public idWinVar {
public:
	idWinBool() : idWinVar() {};
	~idWinBool() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetBool(GetName());
		}
	}
	int	operator==(const bool& other) { return (other == data); }
	bool& operator=(const bool& other) {
		data = other;
		if (guiDict) {
			guiDict->SetBool(GetName(), data);
		}
		return data;
	}
	idWinBool& operator=(const idWinBool& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}

	operator bool() const { return data; }

	virtual void Set(const char* val) {
		data = (atoi(val) != 0);
		if (guiDict) {
			guiDict->SetBool(GetName(), data);
		}
	}

	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetBool(s);
		}
	}

	virtual const char* c_str() const { return va("%i", data); }

	// SaveGames
	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

	virtual float x(void) const { return data ? 1.0f : 0.0f; };

protected:
	bool data;
};

class idWinStr : public idWinVar {
public:
	idWinStr() : idWinVar() {};
	~idWinStr() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetString(GetName());
		}
	}
	int	operator==(const idStr& other) const {
		return (other == data);
	}
	int	operator==(const char* other) const {
		return (data == other);
	}
	idStr& operator=(const idStr& other) {
		data = other;
		if (guiDict) {
			guiDict->Set(GetName(), data);
		}
		return data;
	}
	idWinStr& operator=(const idWinStr& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	operator const char* () const {
		return data.c_str();
	}
	operator const idStr& () const {
		return data;
	}
	int LengthWithoutColors() {
		if (guiDict && name && *name) {
			data = guiDict->GetString(GetName());
		}
		return data.Length();
	}
	int Length() {
		if (guiDict && name && *name) {
			data = guiDict->GetString(GetName());
		}
		return data.Length();
	}
	void RemoveColors() {
		if (guiDict && name && *name) {
			data = guiDict->GetString(GetName());
		}
		//data.RemoveColors();
	}
	virtual const char* c_str() const {
		return data.c_str();
	}

	virtual void Set(const char* val) {
		data = val;
		if (guiDict) {
			guiDict->Set(GetName(), data);
		}
	}

	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetString(s);
		}
	}

	virtual size_t Size() {
		size_t sz = idWinVar::Size();
		return sz + data.Allocated();
	}

	// SaveGames
	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));

		int len = data.Length();
		savefile->Write(&len, sizeof(len));
		if (len > 0) {
			savefile->Write(data.c_str(), len);
		}
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));

		int len;
		savefile->Read(&len, sizeof(len));
		if (len > 0) {
			data.Fill(' ', len);
			savefile->Read(&data[0], len);
		}
	}

	// return wether string is emtpy
	virtual float x(void) const { return data[0] ? 1.0f : 0.0f; };

protected:
	idStr data;
};

class idWinInt : public idWinVar {
public:
	idWinInt() : idWinVar() {};
	~idWinInt() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetInt(GetName());
		}
	}
	int& operator=(const int& other) {
		data = other;
		if (guiDict) {
			guiDict->SetInt(GetName(), data);
		}
		return data;
	}
	idWinInt& operator=(const idWinInt& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	operator int() const {
		return data;
	}
	virtual void Set(const char* val) {
		data = atoi(val);;
		if (guiDict) {
			guiDict->SetInt(GetName(), data);
		}
	}

	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetInt(s);
		}
	}
	virtual const char* c_str() const {
		return va("%i", data);
	}

	// SaveGames
	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

	// no suitable conversion
	virtual float x(void) const { assert(false); return 0.0f; };

protected:
	int data;
};

class idWinFloat : public idWinVar {
public:
#ifdef QUAKE4
	friend class idWinFloatPtr;
#endif

	idWinFloat() : idWinVar() {};
	~idWinFloat() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetFloat(GetName());
		}
	}
	idWinFloat& operator=(const idWinFloat& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	float& operator=(const float& other) {
		data = other;
		if (guiDict) {
			guiDict->SetFloat(GetName(), data);
		}
		return data;
	}
	operator float() const {
		return data;
	}
	virtual void Set(const char* val) {
		data = atof(val);
		if (guiDict) {
			guiDict->SetFloat(GetName(), data);
		}
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetFloat(s);
		}
	}
	virtual const char* c_str() const {
		return va("%f", data);
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

	virtual float x(void) const { return data; };
#ifdef QUAKE4
public:
#else
protected:
#endif
	float data;
};



class idWinRectangle : public idWinVar {
public:
	idWinRectangle() : idWinVar() {};
	~idWinRectangle() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			idVec4 v = guiDict->GetVec4(GetName());
			data.x = v.x;
			data.y = v.y;
			data.w = v.z;
			data.h = v.w;
		}
	}

	int	operator==(const idRectangle& other) const {
		return (other == data);
	}

	idWinRectangle& operator=(const idWinRectangle& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	idRectangle& operator=(const idVec4& other) {
		data = other;
		if (guiDict) {
			guiDict->SetVec4(GetName(), other);
		}
		return data;
	}

	idRectangle& operator=(const idRectangle& other) {
		data = other;
		if (guiDict) {
			idVec4 v = data.ToVec4();
			guiDict->SetVec4(GetName(), v);
		}
		return data;
	}

	operator const idRectangle& () const {
		return data;
	}

	float x() const {
		return data.x;
	}
	float y() const {
		return data.y;
	}
	float w() const {
		return data.w;
	}
	float h() const {
		return data.h;
	}
	float Right() const {
		return data.Right();
	}
	float Bottom() const {
		return data.Bottom();
	}
	idVec4& ToVec4() {
		static idVec4 ret;
		ret = data.ToVec4();
		return ret;
	}
	virtual void Set(const char* val) {
		if (strchr(val, ',')) {
			sscanf(val, "%f,%f,%f,%f", &data.x, &data.y, &data.w, &data.h);
		}
		else {
			sscanf(val, "%f %f %f %f", &data.x, &data.y, &data.w, &data.h);
		}
		if (guiDict) {
			idVec4 v = data.ToVec4();
			guiDict->SetVec4(GetName(), v);
		}
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			idVec4 v = guiDict->GetVec4(s);
			data.x = v.x;
			data.y = v.y;
			data.w = v.z;
			data.h = v.w;
		}
	}

	virtual const char* c_str() const {
		return data.ToVec4().ToString();
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

#ifdef QUAKE4
public:
#else
protected:
#endif
	idRectangle data;
};

class idWinVec2 : public idWinVar {
public:
	idWinVec2() : idWinVar() {};
	~idWinVec2() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetVec2(GetName());
		}
	}
	int	operator==(const idVec2& other) const {
		return (other == data);
	}
	idWinVec2& operator=(const idWinVec2& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}

	idVec2& operator=(const idVec2& other) {
		data = other;
		if (guiDict) {
			guiDict->SetVec2(GetName(), data);
		}
		return data;
	}
	float x() const {
		return data.x;
	}
	float y() const {
		return data.y;
	}
	virtual void Set(const char* val) {
		if (strchr(val, ',')) {
			sscanf(val, "%f,%f", &data.x, &data.y);
		}
		else {
			sscanf(val, "%f %f", &data.x, &data.y);
		}
		if (guiDict) {
			guiDict->SetVec2(GetName(), data);
		}
	}
	operator const idVec2& () const {
		return data;
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetVec2(s);
		}
	}
	virtual const char* c_str() const {
		return data.ToString();
	}
	void Zero() {
		data.Zero();
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

protected:
	idVec2 data;
};

class idWinVec4 : public idWinVar {
#ifdef QUAKE4
	friend class idWinFloatPtr;
#endif

public:
	idWinVec4() : idWinVar() {};
	~idWinVec4() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetVec4(GetName());
		}
	}
	int	operator==(const idVec4& other) const {
		return (other == data);
	}
	idWinVec4& operator=(const idWinVec4& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	idVec4& operator=(const idVec4& other) {
		data = other;
		if (guiDict) {
			guiDict->SetVec4(GetName(), data);
		}
		return data;
	}
	operator const idVec4& () const {
		return data;
	}

	float x() const {
		return data.x;
	}

	float y() const {
		return data.y;
	}

	float z() const {
		return data.z;
	}

	float w() const {
		return data.w;
	}
	virtual void Set(const char* val) {
		if (strchr(val, ',')) {
			sscanf(val, "%f,%f,%f,%f", &data.x, &data.y, &data.z, &data.w);
		}
		else {
			sscanf(val, "%f %f %f %f", &data.x, &data.y, &data.z, &data.w);
		}
		if (guiDict) {
			guiDict->SetVec4(GetName(), data);
		}
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetVec4(s);
		}
	}
	virtual const char* c_str() const {
		return data.ToString();
	}

	void Zero() {
		data.Zero();
		if (guiDict) {
			guiDict->SetVec4(GetName(), data);
		}
	}

	const idVec3& ToVec3() const {
		return data.ToVec3();
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}
#ifdef QUAKE4
	float operator[](int index) const {
		return data[index];
	}

	float& operator[](int index) {
		return data[index];
	}
#endif
protected:
	idVec4 data;
};

class idWinVec3 : public idWinVar {
public:
	idWinVec3() : idWinVar() {};
	~idWinVec3() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinVar::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetVector(GetName());
		}
	}
	int	operator==(const idVec3& other) const {
		return (other == data);
	}
	idWinVec3& operator=(const idWinVec3& other) {
		idWinVar::operator=(other);
		data = other.data;
		return *this;
	}
	idVec3& operator=(const idVec3& other) {
		data = other;
		if (guiDict) {
			guiDict->SetVector(GetName(), data);
		}
		return data;
	}
	operator const idVec3& () const {
		return data;
	}

	float x() const {
		return data.x;
	}

	float y() const {
		return data.y;
	}

	float z() const {
		return data.z;
	}

	virtual void Set(const char* val) {
		sscanf(val, "%f %f %f", &data.x, &data.y, &data.z);
		if (guiDict) {
			guiDict->SetVector(GetName(), data);
		}
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetVector(s);
		}
	}
	virtual const char* c_str() const {
		return data.ToString();
	}

	void Zero() {
		data.Zero();
		if (guiDict) {
			guiDict->SetVector(GetName(), data);
		}
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));
		savefile->Write(&data, sizeof(data));
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));
		savefile->Read(&data, sizeof(data));
	}

protected:
	idVec3 data;
};

class idWinBackground : public idWinStr {
public:
	idWinBackground() : idWinStr() {
		mat = NULL;
	};
	~idWinBackground() {};
	virtual void Init(const char* _name, idWindow* win) {
		idWinStr::Init(_name, win);
		if (guiDict) {
			data = guiDict->GetString(GetName());
		}
	}
	int	operator==(const idStr& other) const {
		return (other == data);
	}
	int	operator==(const char* other) const {
		return (data == other);
	}
	idStr& operator=(const idStr& other) {
		data = other;
		if (guiDict) {
			guiDict->Set(GetName(), data);
		}
		if (mat) {
			if (data == "") {
				(*mat) = NULL;
			}
			else {
				(*mat) = declManager->FindMaterial(data);
			}
		}
		return data;
	}
	idWinBackground& operator=(const idWinBackground& other) {
		idWinVar::operator=(other);
		data = other.data;
		mat = other.mat;
		if (mat) {
			if (data == "") {
				(*mat) = NULL;
			}
			else {
				(*mat) = declManager->FindMaterial(data);
			}
		}
		return *this;
	}
	operator const char* () const {
		return data.c_str();
	}
	operator const idStr& () const {
		return data;
	}
	int Length() {
		if (guiDict) {
			data = guiDict->GetString(GetName());
		}
		return data.Length();
	}
	virtual const char* c_str() const {
		return data.c_str();
	}

	virtual void Set(const char* val) {
		data = val;
		if (guiDict) {
			guiDict->Set(GetName(), data);
		}
		if (mat) {
			if (data == "") {
				(*mat) = NULL;
			}
			else {
				(*mat) = declManager->FindMaterial(data);
			}
		}
	}

	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			data = guiDict->GetString(s);
			if (mat) {
				if (data == "") {
					(*mat) = NULL;
				}
				else {
					(*mat) = declManager->FindMaterial(data);
				}
			}
		}
	}

	virtual size_t Size() {
		size_t sz = idWinVar::Size();
		return sz + data.Allocated();
	}

	void SetMaterialPtr(const idMaterial** m) {
		mat = m;
	}

	virtual void WriteToSaveGame(idFile* savefile) {
		savefile->Write(&eval, sizeof(eval));

		int len = data.Length();
		savefile->Write(&len, sizeof(len));
		if (len > 0) {
			savefile->Write(data.c_str(), len);
		}
	}
	virtual void ReadFromSaveGame(idFile* savefile) {
		savefile->Read(&eval, sizeof(eval));

		int len;
		savefile->Read(&len, sizeof(len));
		if (len > 0) {
			data.Fill(' ', len);
			savefile->Read(&data[0], len);
		}
		if (mat) {
			if (len > 0) {
				(*mat) = declManager->FindMaterial(data);
			}
			else {
				(*mat) = NULL;
			}
		}
	}

protected:
	idStr data;
	const idMaterial** mat;
};

/*
================
idMultiWinVar
multiplexes access to a list if idWinVar*
================
*/
class idMultiWinVar : public idList< idWinVar* > {
public:
	void Set(const char* val);
	void Update(void);
	void SetGuiInfo(idDict* dict);
};



#ifdef QUAKE4
class idWinFloatPtr : public idWinVar {
public:
	idWinFloatPtr() : idWinVar() {};
	~idWinFloatPtr() {};
	virtual void Init(const char* _name, idWindow* win) {

	}

	float& operator=(const float& other) {
		*data = other;
		if (guiDict) {
			guiDict->SetFloat(GetName(), *data);
		}
		return *data;
	}

	void Bind(idWinVec4& ptr, int component)
	{
		switch (component)
		{
		case 0:
			data = &ptr.data[0];
			break;
		case 1:
			data = &ptr.data[1];
			break;
		case 2:
			data = &ptr.data[2];
			break;
		case 3:
			data = &ptr.data[3];
			break;
		}
	}

	virtual void Set(const char* val) {
		*data = atof(val);
		if (guiDict) {
			guiDict->SetFloat(GetName(), *data);
		}
	}
	virtual void Update() {
		const char* s = GetName();
		if (guiDict && s[0] != '\0') {
			*data = guiDict->GetFloat(s);
		}
	}
	virtual const char* c_str() const {
		return va("%f", *data);
	}
	virtual void WriteToSaveGame(idFile* savefile) {}
	virtual void ReadFromSaveGame(idFile* savefile) {}
	virtual float x(void) const { return *data; };
protected:
	float* data;
};
#endif // QUAKE4


#endif /* !__WINVAR_H__ */