#ifndef __GUT_VARIABLE_HXX
#define __GUT_VARIABLE_HXX

#include <string>


namespace gut
{
const size_t 		gut::VARTEMP_SIZE 		= 32;
const char * const	gut::VARNULL_STRING		= "";

typedef enum {
	VAR_TYPE_NULL,
	VAR_TYPE_INT,
	VAR_TYPE_FLOAT,
	VAR_TYPE_STRING,
} var_type_e;

class variable {
private:
	var_type_e			m_type;
	union {
		long 			var_int;
		float			var_float;
		std::string 	*var_string;
	} m_value;
	
	mutable char *m_temp_string;    // work space
	
public:
	variable(void);
	variable(const variable &rhs);
	~variable(void);
	
	bool is_int(void) const;
	bool is_float(void) const;
	bool is_string(void) const;
	var_type_e get_type(void) const;
	void set_int(long value);
	void set_float(float value);
	void set_string(const char *value);
	long get_int(void) const;
	float get_float(void) const;
	const char *get_string(void) const;

	inline operator bool()
	{
		return get_int() != 0;
	}

	inline variable operator =(const variable &rhs)
	{
		switch (rhs.m_type) {
		case VAR_TYPE_INT:
			set_int(rhs.m_value.var_int);
			break;
		case VAR_TYPE_FLOAT:
			set_float(rhs.m_value.var_float);
			break;
		case VAR_TYPE_STRING:
			set_string(rhs.m_value.var_string->c_str());
			break;
		default:
			m_value = rhs.m_value;
			break;
		}
		m_type = rhs.m_type;

		return *this;
	}
	
	inline variable operator ==(const variable &rhs) const
	{
		variable var;
		
		if (get_int() == rhs.get_int()) {
			var.set_int(1);
		} else {
			var.set_int(0);
		}
		
		return var;
	}
	
	inline variable operator !=(const variable &rhs) const
	{
		variable var;
		
		if (get_int() == rhs.get_int()) {
			var.set_int(0);
		} else {
			var.set_int(1);
		}
		
		return var;
	}
	
	inline variable operator <(const variable &rhs) const
	{
		variable var;

		if (get_int() < rhs.get_int()) {
			var.set_int(1);
		} else {
			var.set_int(0);
		}
		
		return var;
	}

	inline variable operator >(const variable &rhs) const
	{
		variable var;

		if (get_int() > rhs.get_int()) {
			var.set_int(1);
		} else {
			var.set_int(0);
		}

		return var;
	}
	
	inline variable operator <=(const variable &rhs) const
	{
		variable var;
		int lint = get_int(), rint = rhs.get_int();
		
		if (lint < rint || lint == rint) {
			var.set_int(1);
		} else {
			var.set_int(0);
		}
		
		return var;
	}

	inline variable operator >=(const variable &rhs) const
	{
		variable var;
		int lint = get_int(), rint = rhs.get_int();

		if (lint > rint || lint == rint) {
			var.set_int(1);
		} else {
			var.set_int(0);
		}

		return var;
	}

	inline variable operator +(const variable &rhs) const
	{
		variable var;
		var_type_e rtype = rhs.get_type();
		
		if (is_float() || rhs.is_float()) {
			var.set_float(get_float() + rhs.get_float());
		} else {
			var.set_int(get_int() + rhs.get_int());
		}
		
		return var;
	}

	inline variable operator -(const variable &rhs) const
	{
		variable var;
		var_type_e rtype = rhs.get_type();

		if (is_float() || rhs.is_float()) {
			var.set_float(get_float() - rhs.get_float());
		} else {
			var.set_int(get_int() - rhs.get_int());
		}

		return var;
	}

	inline variable operator *(const variable &rhs) const
	{
		variable var;
		var_type_e rtype = rhs.get_type();

		if (is_float() || rhs.is_float()) {
			var.set_float(get_float() *rhs.get_float());
		} else {
			var.set_int(get_int() * rhs.get_int());
		}

		return var;
	}

	inline variable operator /(const variable &rhs) const
	{
		variable var;
		var_type_e rtype = rhs.get_type();

		if (is_float() || rhs.is_float()) {
			float rhfloat = rhs.get_float();

			if (rhfloat == 0.0) {
				var.set_float(0.0);
			} else {
				var.set_float(get_float() / rhfloat);
			}
		} else {
			int rhint = rhs.get_int();
			
			if (rhint == 0) {
				var.set_int(0);
			} else {
				var.set_int(get_int() / rhs.get_int());
			}
		}

		return var;
	}

	inline variable operator %(const variable &rhs) const
	{
		variable var;
		var_type_e rtype = rhs.get_type();
		int rhint = rhs.get_int();

		if (rhint == 0) {
			var.set_int(0);
		} else {
			var.set_int(get_int() % rhs.get_int());
		}

		return var;
	}

	inline variable operator |(const variable &rhs) const
	{
		variable var;
		
		var.set_int(get_int() | rhs.get_int());
	
		return var;
	}

	inline variable operator &(const variable &rhs) const
	{
		variable var;

		var.set_int(get_int() & rhs.get_int());

		return var;
	}

	inline variable operator ^(const variable &rhs) const
	{
		variable var;

		var.set_int(get_int() ^ rhs.get_int());

		return var;
	}

	inline variable operator ~(void) const
	{
		variable var;

		var.set_int(~get_int());

		return var;
	}

	inline variable operator !(void) const
	{
		variable var;

		if (get_int() != 0) {
			var.set_int(0);
		} else {
			var.set_int(1);
		}
		
		return var;
	}
};

}	// namespace gut

#endif	// __GUT_VARIABLE_HPP