// var standard header

// No Copyright
// Created by Paul Robert Stackhouse
// Purpose: to give C++ a universal variable type that can store any of the six standard types within itself.

#ifndef _VAR_
#define _VAR_

#include <yvals_core.h>
#if _STL_COMPILER_PREPROCESSOR
#include <__msvc_filebuf.hpp>
#include <iostream>
#include <cmath>
#include <string>
#include <stdexcept>
#include <list>
#include <map>
#include <ctime>
#include "combine.h"

#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new

_STD_BEGIN

_EXPORT_STD class divide_by_zero : runtime_error {
public:
	using _Mybase = runtime_error;

	explicit divide_by_zero(const string& _Message) : _Mybase(_Message.c_str()) {}

	explicit divide_by_zero(const char* _Message) : _Mybase(_Message) {}

#if !_HAS_EXCEPTIONS
protected:
	void _Doraise() const override { // perform class-specific exception handling
		_RAISE(*this);
	}
#endif // !_HAS_EXCEPTIONS
};

_EXPORT_STD class var {
#define _VAR_ERROR_ false
protected:
	string text, type;
	double value;
	static long long int current;
	map<double, int> version;
	double timeVal;
	void set() {
		if (current == long int()) current = 0;
		timeVal = time(0);
		current++;
		version.insert({ current, timeVal });
	}
	void set(string word) {
		double worth = 0;
		text = word;
		type = "std::string";
		for (int i = 0; i < word.length() && 4 + 3 * i < 94; i++) worth += word[i] * pow(10, -3 * i);
		value = worth;
	}
	void set(char c) {
		text = "" + c;
		type = "char";
		value = c;
	}
	void set(bool b) {
		if (b) text = "\"true\"";
		else text = "\"false\"";
		type = "bool";
		value = b;
	}
	void set(int i) {
		text = to_string(i);
		type = "int";
		value = i;
	}
	void set(float f) {
		text = to_string(f);
		type = "float";
		value = f;
	}
	void set(double d) {
		text = to_string(d);
		type = "double";
		value = d;
	}
public:
// Var-Dependant Object Type Error Code
	class object_type_error : public runtime_error { // base of all runtime-error exceptions
	public:
		using _Mybase = runtime_error;
		explicit object_type_error(const string& _Message) : _Mybase(_Message.c_str()) {}
		explicit object_type_error(const char* _Message) : _Mybase(_Message) {}

#if !_HAS_EXCEPTIONS
	protected:
		void _Doraise() const override { // perform class-specific exception handling
			_RAISE(*this);
		}
#endif // !_HAS_EXCEPTIONS
	};

// Spawner

// Initialization Functions
	var(string word = "") {
		set();
		set(word);
	}
	var(char c) {
		set();
		set(c);
	}
	var(bool b) {
		set();
		set(b);
	}
	var(int i) {
		set();
		set(i);
	}
	var(float f) {
		set();
		set(f);
	}
	var(double d) {
		set();
		set(d);
	}

// Value Return Functions
	string get_type() { return type; }
	int length() { return text.length(); }
	double text_value() {
		object_type_error error("var object is not storing type \"std::string\"\n");
		if (type == "std::string") return value;
#warning "The var type is not a \"std::string\"."
		else throw(error);
	}
	string bool_value() {
		object_type_error error("var object is not storing type \"bool\"\n");
		if (type == "bool") return text;
#warning "the var type is not a \"bool\"."
		else throw(error);
	}
	template <bool first, bool second> bool between(char cBegin, char cEnd) {
		object_type_error error("This var function can only handle \"char\" types.");
		if (type != "char") throw error;
		if (value > cBegin && value < cEnd || first && value == cBegin || second && value == cEnd)
			return true;
		return false;
	}
	long int get_version() {
		return version[timeVal];
	}

// Return Operator Functions
	operator string() { return text; }
	operator char() {
		object_type_error error("var object is not storing type \"char\"\n");
		bool errorVal = (type != "char");
		if (!errorVal) return text[0];
#define _VAR_ERROR_ errorVal;
#if _VAR_ERROR_
#warning "The var type is not a \"char\"."
#endif
		else throw error;
	}
	operator bool() {
		object_type_error error("var object is not storing type \"bool\"\n");
		bool errorVal = (type == "std::string");
		if (!errorVal) return static_cast<bool>(value);
#define _VAR_ERROR_ errorVal;
#if _VAR_ERROR_
#warning "The var type is not a \"std::string\" or a \"bool\"."
#endif
		else throw error;
	}
	operator int() {
		object_type_error error("var object is not storing an integer type\n");
		bool errorVal = (type != "int" && type != "bool" && type != "char");
		if (!errorVal) return static_cast<int>(value);
#define _VAR_ERROR_ errorVal;
#if _VAR_ERROR_
		#warning "The var type is not an \"int\" or a \"bool\" or a \"char\"."
#endif
		else throw error;
	}
	operator float() {
		object_type_error error("var object is not storing a float type\n");
		bool errorVal = (type == "std::string" || type == "double");
		if (!errorVal) return static_cast<float>(value);
#define _VAR_ERROR_ errorVal;
#if _VAR_ERROR_
#warning "The var type is not an \"std::string\" or a \"double\"."
#endif
		if (type != "std::string" || type != "double") return static_cast<float>(value);
		else throw error;
	}
	operator double() { return value; }
	char operator[](int i) {
		out_of_range error("There is no value in your var variable for the specified location.");
		if (i < 0 || i >= text.length()) throw error;
		return text[i];
	}

// Operator Assignment Functions
	var operator=(string word) {
		set(word);
		return *this;
	}
	var operator=(char c) {
		set(c);
		return *this;
	}
	var operator=(bool b) {
		set(b);
		return *this;
	}
	var operator=(int i) {
		set(i);
		return *this;
	}
	var operator=(float f) {
		set(f);
		return *this;
	}
	var operator=(double d) {
		set(d);
		return *this;
	}
	var operator=(var v) { 
		if (v.get_type() == "std::string") {
			string value = v;
			return *this = value;
		}
		if (v.get_type() == "char") {
			char value = v;
			return *this = value;
		}
		if (v.get_type() == "bool") {
			bool value = v;
			return *this = value;
		}
		if (v.get_type() == "int") {
			int value = v;
			return *this = value;
		}
		if (v.get_type() == "float") {
			float value = v;
			return *this = value;
		}
		if (v.get_type() == "double") {
			double value = v;
			return *this = value;
		}
	}
	

// Operator Additional Functions
	friend var operator+(var v, string word) {
		string value = v;
		var read = value + word;
		return read;
	}
	friend var operator+(var v, int i) {
		double worth = v;
		var read = worth + i;
		return read;
	}
	friend var operator+(var v, float f) {
		double value = v;
		var read = value + f;
		return read;
	}
	friend var operator+(var v, double d) {
		double value = v;
		var read = value + d;
		return read;
	}
	friend var operator+(var value, var v) {
		if (value.get_type() != "std::list"
			&& v.get_type() != "std::list") {
			double set = v;
			return value + set;
		}
		string set = v;
		return value + set;
	}
	friend var operator+(string word, var v) {
		string value = v;
		return word + v;
	}
	friend var operator+(int i, var v) { return v + i; }
	friend var operator+(float f, var v) { return v + f; }
	friend var operator+(double d, var v) { return v + d; }

// Operator Subtraction Functions
	friend var operator-(var v, string word) {
		if (word.length() > v.length()) return v;
		var value;
		std::string wordNew = "";
		bool set = false;
		for (int i = 0; i + word.length() < v.length(); i++) {
			bool find = false;
			if (!set) find = true;
			for (int j = i; j - i < v.length() && find && !set; j++) {
				if (v[j] != word[j - i]) find = false;
			}
			if (!find) {
				wordNew += v[i];
			}
			else {
				i += v.length() - 1;
				set = true;
			}
		}
		value = wordNew;
		return value;
	}
	friend var operator-(var v, int i) {
		double value = v;
		var read = value - i;
		return read;
	}
	friend var operator-(var v, float f) {
		double value = v;
		var read = value - f;
		return read;
	}
	friend var operator-(var v, double d) {
		double value = v;
		var read = value - d;
		return read;
	}
	friend var operator-(var value, var v) {
		if (v.get_type() == "std::string") {
			string set = v;
			return value - set;
		}
		double set = v;
		return value - set;
	}
	friend var operator-(string word, var v) {
		var set = word;
		string change = v;
		return set - change;
	}
	friend var operator-(int i, var v) {
		var set = i;
		double change = v;
		return set - change;
	}
	friend var operator-(float f, var v) {
		var set = f;
		double change = v;
		return set - change;
	}
	friend var operator-(double d, var v) {
		var set = d;
		double change = v;
		return set - change;
	}

// Operator Multiplication Functions
	friend var operator*(var v, int i) {
		double value = v;
		return value * i;
	}
	friend var operator*(var v, float f) {
		double value = v;
		return value * f;
	}
	friend var operator*(var v, double d) {
		double value = v;
		return value * d;
	}
	friend var operator*(var value, var v) {
		double set = v;
		return value * set;
	}
	friend var operator*(int i, var v) { return v * i; }
	friend var operator*(float f, var v) { return v * f; }
	friend var operator*(double d, var v) { return v * d; }

// Operator Division Functions
	friend var operator/(var v, int i) {
		divide_by_zero error("The denominator cannot be zero.\n");
		if (i == 0) throw(error);
		double value = v;
		var set = value / i;
		return set;
	}
	friend var operator/(var v, float f) {
		divide_by_zero error("The denominator cannot be zero.\n");
		if (f == 0) throw(error);
		double value = v;
		var set = value / f;
		return set;
	}
	friend var operator/(var v, double d) {
		divide_by_zero error("The denominator cannot be zero.\n");
		if (d == 0) throw(error);
		double value = v;
		var set = value / d;
		return set;
	}
	friend var operator/(var value, var v) {
		double set = v;
		return value / set;
	}
	friend var operator/(int i, var v) {
		var set = i;
		double value = v;
		return set / value;
	}
	friend var operator/(float f, var v) {
		var set = f;
		double value = v;
		return set / value;
	}
	friend var operator/(double d, var v) {
		var set = d;
		double value = v;
		return set / value;
	}

// Operator Exponent Functions
	friend var operator^(var v, int i) {
		double value = v;
		return pow(value, i);
	}
	friend var operator^(var v, float f) {
		double value = v;
		return pow(value, f);
	}
	friend var operator^(var v, double d) {
		double value = v;
		return pow(value, d);
	}
	friend var operator^(var value, var v) {
		double set = v;
		return value + set;
	}
	friend var operator^(int i, var v) {
		var set = i;
		double value = v;
		return set ^ value;
	}
	friend var operator^(float f, var v) {
		var set = f;
		double value = v;
		return set ^ value;
	}
	friend var operator^(double d, var v) {
		var set = d;
		double value = v;
		return set ^ value;
	}

// Other Operator Value Functions
	var operator+=(var v) { return *this + v; }
	var operator-=(var v) { return *this - v; }
	var operator*=(var v) { return *this * v; }
	var operator/=(var v) { return *this / v; }
	var operator^=(var v) { return *this ^ v; }
	var operator++() { return *this += 1; }
	var operator++(int i) { return *this += 1; }
	var operator--() { return *this -= 1; }
	var operator--(int i) { return *this -= 1; }

// Operator Comparison Functions
	var operator<(var v) {
		double compare = v;
		return value < compare;
	}
	var operator<=(var v) {
		double compare = v;
		return value <= compare;
	}
	var operator==(var v) {
		double compare = v;
		return value == compare;
	}
	var operator!=(var v) {
		double compare = v;
		return value != compare;
	}
	var operator>=(var v) {
		double compare = v;
		return value >= compare;
	}
	var operator>(var v) {
		double compare = v;
		return value > compare;
	}

// Friend Operator Functions
	friend istream operator>>(istream &from, var &v) {
		double num;
		float decimal;
		int integer, greatest = 0;
		char letter;
		string word, type;
		if (from.peek() >= '0' && from.peek() <= '9') {
			from >> integer;
			string put = to_string(integer);
			if (put.length() > greatest) {
				type = "int";
				greatest = put.length();
			}
			for (int i = put.length() - 1; i >= 0; i--) from.putback(put[i]);
			from >> decimal;
			put = to_string(decimal);
			if (put.length() > greatest) {
				type = "float";
				greatest = put.length();
			}
			for (int i = put.length() - 1; i >= 0; i--) from.putback(put[i]);
			from >> num;
			put = to_string(num);
			if (put.length() > greatest) {
				type = "double";
				greatest = put.length();
			}
			for (int i = put.length() - 1; i >= 0; i--) from.putback(put[i]);
		}
		if (greatest == 0) {
			greatest = 1;
			type = "char";
		}
		from >> word;
		if (word.length() > greatest) type = "std::string";
		for (int i = word.length() - 1; i >= 0; i--) from.putback(word[i]);
		if (type == "std::string") {
			from >> word;
			v = word;
		}
		else if (type == "int") {
			from >> integer;
			v = integer;
		}
		else if (type == "float") {
			from >> decimal;
			v = decimal;
		}
		else if (type == "double") {
			from >> num;
			v = num;
		}
		else {
			from >> letter;
			v = letter;
		}
	}
	friend ostream operator<<(ostream &to, var &v) {
		if (v.get_type() == "std::string") {
			std::string value = v;
			to << value;
		}
		else if (v.get_type() == "char") {
			char value = v;
			to << value;
		}
		else if (v.get_type() == "bool") {
			std::string value = v;
			to << value;
		}
		else if (v.get_type() == "int") {
			int value = v;
			to << value;
		}
		else if (v.get_type() == "float") {
			float value = v;
			to << value;
		}
		else if (v.get_type() == "double") {
			double value = v;
			to << value;
		}
	}
};

_STD_END

#ifdef _VALUE_SUPPORTS_EXPERIMENTAL_FILESYSTEM
#undef _VALUE_SUPPORTS_EXPERIMENTAL_FILESYSTEM
#endif

#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)
#endif // _STL_COMPILER_REPROCESSOR
#endif // _VAR_