#include <utility>
#include <iostream>
#include <termios.h>
#include <concepts>
#include <mutex>
#include <memory>
//
// Created by imper on 6/12/21.
//
#ifndef LOG_CONSOLE
#define LOG_CONSOLE

struct check_for_unary_minus
{
	template <typename U, typename = decltype(-std::declval<U>())>
	static constexpr std::true_type perform(U&& u)
	{
		return { };
	}
	
	static constexpr std::false_type perform(...)
	{
		return { };
	}
};

struct check_for_less
{
	template <typename U, typename = decltype(std::declval<const U&>() < std::declval<const U&>())>
	static constexpr std::true_type perform(U&& u)
	{
		return { };
	}
	
	static constexpr std::false_type perform(...)
	{
		return { };
	}
};

template <typename char_t>
concept character = std::is_same_v<char_t, char> || std::is_same_v<char_t, wchar_t>;

template <typename arithmetic_t>
concept arithmetic = std::is_arithmetic_v<arithmetic_t>;

template <template <typename> typename string_t, typename T>
concept string_type = std::is_same_v<string_t<T>, std::basic_string<T>>;

template <typename Smart>
using remove_smart = typename Smart::element_type;

template <character char_t>
static constexpr size_t static_strlen(const char_t* str)
{
	size_t size(0);
	for (; *str; ++str) ++size;
	return size;
}

#define l_location std::pair<const char*, std::pair<const char*, int>>(__FILE__, {__func__, __LINE__})

namespace color
{
	static constexpr const char* reset = "\033[0m";
	static constexpr const char* bold = "\033[1m";
	static constexpr const char* faint = "\033[2m";
	[[deprecated]] static constexpr const char* light = faint;
	static constexpr const char* italic = "\033[3m";
	static constexpr const char* underlined = "\033[4m";
	static constexpr const char* blinking = "\033[5m";
	static constexpr const char* default_bg = "\033[7m";
	static constexpr const char* strikeout = "\033[9m";
	static constexpr const char* black = "\033[30m";
	static constexpr const char* red = "\033[31m";
	static constexpr const char* green = "\033[32m";
	static constexpr const char* yellow = "\033[33m";
	static constexpr const char* blue = "\033[34m";
	static constexpr const char* purple = "\033[35m";
	static constexpr const char* aqua = "\033[36m";
	static constexpr const char* white = "\033[37m";
	static constexpr const char* black_bg = "\033[40m";
	static constexpr const char* red_bg = "\033[41m";
	static constexpr const char* green_bg = "\033[42m";
	static constexpr const char* yellow_bg = "\033[43m";
	static constexpr const char* blue_bg = "\033[44m";
	static constexpr const char* purple_bg = "\033[45m";
	static constexpr const char* aqua_bg = "\033[46m";
	static constexpr const char* white_bg = "\033[47m";
}

static constexpr const char* terminal_control_char = "\033[";

namespace move
{
	static constexpr const char* up = "\033[1A";
	static constexpr const char* down = "\033[1B";
	static constexpr const char* forward = "\033[1C";
	static constexpr const char* backward = "\033[1D";
}

namespace clear
{
	static constexpr const char* to_the_top = "\033[1J";
	static constexpr const char* all = "\033[2J";
}

namespace position
{
	static constexpr const char* save = "\033[s";
	static constexpr const char* restore = "\033[u";
}

namespace _detail_::log_console
{
	extern struct termios* stdin_defaults;
	extern struct termios* stdout_defaults;
	extern struct termios* stderr_defaults;
}

class log_console
{
public:
	using state_change_function = void (*)(log_console& logger);
	
	template <typename T>
	using val_set_function = void (*)(log_console& logger, T val);
	
	enum l_flags : unsigned long
	{
		l_lock, l_unlock, l_flush, l_endl, l_locendl, l_endent, l_color, l_nocolor, l_nlarrow, l_nonlarrow
	};
	
	struct l_special_flag
	{
		unsigned long val;
	};
	
	static constexpr const l_special_flag l_localtime = {0xff};
	
	
	inline log_console(int output_stream_socket) : output_stream(::fdopen(output_stream_socket, "wb"))
	{ }
	
	inline log_console(FILE* output_stream) : output_stream(output_stream)
	{ }
	
	inline ~log_console()
	{
		::fclose(output_stream);
	}
	
	template <template <typename> typename S, typename T>
	requires string_type<S, T>
	inline void print(const S<T>& str) const
	{
		::fwrite(str.c_str(), sizeof(T), str.size(), output_stream);
	}
	
	template <character char_t>
	inline void print(const char_t* str) const
	{
		::fwrite(str, sizeof(char_t), static_strlen(str), output_stream);
	}
	
	template <template <typename> typename Container, typename T>
	inline void print(const Container<T>& container) const
	{
		::fwrite(container.data(), sizeof(T), container.size(), output_stream);
	}
	
	template <character char_t>
	inline void print(char_t _char) const
	{
		::fwrite(&_char, sizeof(_char), 1, output_stream);
	}
	
	inline void flush()
	{
		::fflush(output_stream);
	}
	
	template <typename num_t>
	inline static constexpr num_t abs(num_t num);
	
	template <std::integral int_t>
	inline static constexpr std::string& integral_to_string(int_t value, int base);
	
	inline static const char* get_time(bool color = true);
	
	static inline void set_base(log_console& logger, int base)
	{
		logger.base = base;
	}
	
	static inline void hex(log_console& logger)
	{
		logger.base = 16;
	}
	
	static inline void dec(log_console& logger)
	{
		logger.base = 10;
	}
	
	static inline void oct(log_console& logger)
	{
		logger.base = 8;
	}
	
	static inline void tetra(log_console& logger)
	{
		logger.base = 4;
	}
	
	static inline void bin(log_console& logger)
	{
		logger.base = 2;
	}
	
	static inline void flush(log_console& logger)
	{
		logger.flush();
	}
	
	inline void lock()
	{
		mutex.lock();
	}
	
	inline void unlock()
	{
		mutex.unlock();
	}
	
	static inline void setting_stdin();
	
	static inline void setting_stdout();
	
	static inline void setting_stderr();
	
	static inline void reset_all();
	
	static constexpr const char* color_int_t = color::blue;
	static constexpr const char* color_float_t = color::aqua;
	static constexpr const char* color_l_location = "\033[35m\033[2m";
	static constexpr const char* color_l_location_separator = "\033[33m\033[2m";
	static constexpr const char* color_l_time = "\033[35m\033[2m";
	static constexpr const char* color_l_time_separator = "\033[33m\033[2m";
	static constexpr const char* color_bool_true = color::green;
	static constexpr const char* color_bool_false = color::red;
	static constexpr const char* log_arrow = "+--> ";
	
	inline static void on(log_console& logger)
	{ logger.is_logging_on = true; }
	
	inline static void off(log_console& logger)
	{ logger.is_logging_on = false; }

private:
	friend inline log_console& operator<<(log_console& logger, log_console::state_change_function state_change_function);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::state_change_function state_change_function);
	
	template <typename T>
	friend inline const std::pair<log_console&, log_console::val_set_function<T>>& operator<<(
			log_console& logger, log_console::val_set_function<T> val_set_function);
	
	template <typename T>
	friend inline const std::pair<log_console&, log_console::val_set_function<T>>& operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::val_set_function<T> val_set_function);
	
	template <typename T>
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, log_console::val_set_function<T>>> logger, T val);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			log_console& logger, const std::remove_cvref_t<decltype(l_location)>& location);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const decltype(l_location)& location);
	
	friend inline log_console& operator<<(log_console& logger, const std::string& str);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const std::string& str);
	
	friend inline log_console& operator<<(log_console& logger, const std::wstring& str);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const std::wstring& str);
	
	friend inline log_console& operator<<(log_console& logger, const char* str);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const char* str);
	
	friend inline log_console& operator<<(log_console& logger, const void* ptr);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const void* ptr);
	
	friend inline log_console& operator<<(log_console& logger, bool boolean);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, bool boolean);
	
	friend inline log_console& operator<<(log_console& logger, log_console::l_flags flag);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::l_flags flag);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			log_console& logger, log_console::l_special_flag flag);
	
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::l_special_flag flag);
	
	template <arithmetic num_t>
	friend inline log_console& operator<<(log_console& logger, num_t num);
	
	template <arithmetic num_t>
	friend inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
			std::shared_ptr<std::pair<log_console&, std::true_type>> logger, num_t num);
	
	static constexpr const char* base_max_str = "0123456789abcdefghijklmnopqrstuvwxyz";
	static constexpr const size_t base_max = static_strlen(base_max_str);
	std::recursive_mutex mutex;
	FILE* output_stream;
	bool is_logging_on = true;
	bool time = false;
	bool location = false;
	unsigned base = 10;
	bool colorful = true;
	bool enablearrow = true;
};

template <typename num_t>
inline constexpr num_t log_console::abs(num_t num)
{
	static_assert(check_for_less::perform(num), "can't find less operator for passed object type");
	static_assert(check_for_unary_minus::perform(num), "can't find unary minus operator for passed object type");
	if (num < 0)
	{
		return -num;
	}
	else
	{
		return num;
	}
}

template <std::integral int_t>
inline constexpr std::string& log_console::integral_to_string(int_t value, int base)
{
	auto* result = new std::string;
	if (base > 0 && base <= base_max)
	{
		bool negative = value < 0;
		while (value != 0)
		{
			int remainder = log_console::abs(value % base);
			value /= base;
			result->insert(result->begin(), log_console::base_max_str[remainder]);
		}
		
		if (negative)
		{
			result->insert(result->begin(), '-');
		}
		
		if (result->empty()) *result = "0";
	}
	else
	{
		*result = "<invalid_base>";
	}
	return *result;
}

inline const char* log_console::get_time(bool color)
{
	time_t tm = ::time(nullptr);
	struct tm* tinfo = ::localtime(&tm);
	auto* time = new char[128];
	auto* res = new char[128];
	size_t size = ::strftime(time, 127, (std::string((color ? "\033[35m" : "")) + "%a %d.%m.%Y %H:%M:%S").c_str(), tinfo);
	time[size] = 0;
	struct timespec ts{ };
	timespec_get(&ts, TIME_UTC);
	size = sprintf(res, "%s %ldms %s", time, ts.tv_nsec / 1000000, "\033[0m\t");
	res[size] = 0;
	return res;
}

inline void log_console::setting_stdin()
{
	if (_detail_::log_console::stdin_defaults == nullptr)
	{ _detail_::log_console::stdin_defaults = new termios; }
	::tcgetattr(0, _detail_::log_console::stdin_defaults);
	struct termios settings = *_detail_::log_console::stdin_defaults;
	settings.c_lflag &= (~ICANON);
	settings.c_lflag &= (~ECHO);
	settings.c_cc[VTIME] = 0;
	settings.c_cc[VMIN] = 1;
	::tcsetattr(0, TCSANOW, &settings);
}

inline void log_console::setting_stdout()
{
	if (_detail_::log_console::stdout_defaults == nullptr)
	{ _detail_::log_console::stdout_defaults = new termios; }
	::tcgetattr(1, _detail_::log_console::stdout_defaults);
	struct termios settings = *_detail_::log_console::stdout_defaults;
	settings.c_lflag &= (~ICANON);
	settings.c_lflag &= (~ECHO);
	settings.c_cc[VTIME] = 0;
	settings.c_cc[VMIN] = 1;
	::tcsetattr(1, TCSANOW, &settings);
}

inline void log_console::setting_stderr()
{
	if (_detail_::log_console::stderr_defaults == nullptr)
	{ _detail_::log_console::stderr_defaults = new termios; }
	::tcgetattr(2, _detail_::log_console::stderr_defaults);
	struct termios settings = *_detail_::log_console::stderr_defaults;
	settings.c_lflag &= (~ICANON);
	settings.c_lflag &= (~ECHO);
	settings.c_cc[VTIME] = 0;
	settings.c_cc[VMIN] = 1;
	::tcsetattr(2, TCSANOW, &settings);
}

inline void log_console::reset_all()
{
	if (_detail_::log_console::stdin_defaults != nullptr)
	{
		::tcsetattr(0, TCSANOW, _detail_::log_console::stdin_defaults);
		_detail_::log_console::stdin_defaults = nullptr;
	}
	if (_detail_::log_console::stdout_defaults != nullptr)
	{
		::tcsetattr(1, TCSANOW, _detail_::log_console::stdout_defaults);
		_detail_::log_console::stdout_defaults = nullptr;
	}
	if (_detail_::log_console::stderr_defaults != nullptr)
	{
		::tcsetattr(1, TCSANOW, _detail_::log_console::stderr_defaults);
		_detail_::log_console::stderr_defaults = nullptr;
	}
}

// static operators

inline log_console& operator<<(log_console& logger, log_console::state_change_function state_change_function)
{
	logger.time = false;
	logger.location = false;
	state_change_function(logger);
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::state_change_function state_change_function)
{
	logger->first.time = false;
	logger->first.location = false;
	state_change_function(logger->first);
	return logger;
}

template <typename T>
inline const std::pair<log_console&, log_console::val_set_function<T>>& operator<<(
		log_console& logger, log_console::val_set_function<T> val_set_function)
{
	logger.time = false;
	logger.location = false;
	return std::make_shared<remove_smart<decltype(operator<<(logger, val_set_function))>>(logger, std::true_type());
}

template <typename T>
inline const std::pair<log_console&, log_console::val_set_function<T>>& operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::val_set_function<T> val_set_function)
{
	logger->first.time = false;
	logger->first.location = false;
	return std::make_shared<remove_smart<decltype(operator<<(logger, val_set_function))>>(logger->first, val_set_function);
}

template <typename T>
inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, log_console::val_set_function<T>>> logger, T val)
{
	logger->first.time = false;
	logger->first.location = false;
	logger->second(logger.first, val);
	return std::make_shared<remove_smart<decltype(operator<<(logger, val))>>(logger.first, std::true_type());
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		log_console& logger, const std::remove_cvref_t<decltype(l_location)>& location)
{
	if (logger.is_logging_on)
	{
		if (logger.colorful)
		{
			logger.print((logger.location ? std::string() : std::string("\n")) + log_console::color_l_location + location.first +
						 log_console::color_l_location_separator + "::" + log_console::color_l_location + location.second.first +
						 log_console::color_l_location_separator + "::" + log_console::color_l_location + std::to_string(location.second.second) +
						 color::reset + "\n+--> "
			);
		}
		else
		{
			logger.print((logger.location ? std::string() : std::string("\n")) + location.first + "::" + location.second.first +
						 "::" + std::to_string(location.second.second) + "\n+--> "
			);
		}
		logger.time = false;
		logger.location = true;
	}
	return std::make_shared<remove_smart<decltype(operator<<(logger, l_location))>>(logger, std::true_type());
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const decltype(l_location)& location)
{
	if (logger->first.is_logging_on)
	{
		if (logger->first.colorful)
		{
			logger->first.print((logger->first.time ? std::string() : std::string("\n")) + log_console::color_l_location + location.first +
								log_console::color_l_location_separator + "::" + log_console::color_l_location + location.second.first + "()" +
								log_console::color_l_location_separator + "::" + log_console::color_l_location +
								std::to_string(location.second.second) +
								color::reset + "\n+--> "
			);
		}
		else
		{
			logger->first.print((logger->first.time ? std::string() : std::string("\n")) + location.first + "::" + location.second.first + "()" +
								"::" + std::to_string(location.second.second) + "\n+--> "
			);
		}
		logger->first.time = false;
		logger->first.location = true;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, const std::string& str)
{
	if (logger.is_logging_on)
	{
		logger.print(str);
		logger.time = false;
		logger.location = false;
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const std::string& str)
{
	if (logger->first.is_logging_on)
	{
		if (logger->first.enablearrow)
		{
			std::string copy;
			for (auto& i: str)
			{
				copy += i;
				if (i == '\n')
					copy += log_console::log_arrow;
			}
			logger->first.print(copy);
		}
		else
		{
			logger->first.print(str);
		}
		logger->first.time = false;
		logger->first.location = false;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, const std::wstring& str)
{
	if (logger.is_logging_on)
	{
		logger.print(str);
		logger.time = false;
		logger.location = false;
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const std::wstring& str)
{
	if (logger->first.is_logging_on)
	{
		if (logger->first.enablearrow)
		{
			std::string copy;
			for (auto& i: str)
			{
				copy += i;
				if (i == '\n')
					copy += log_console::log_arrow;
			}
			logger->first.print(copy);
		}
		else
		{
			logger->first.print(str);
		}
		logger->first.time = false;
		logger->first.location = false;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, const char* str)
{
	if (logger.is_logging_on)
	{
		logger.print(str);
		logger.time = false;
		logger.location = false;
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const char* str)
{
	if (logger->first.is_logging_on)
	{
		if (logger->first.enablearrow)
		{
			std::string copy;
			for (; *str; ++str)
			{
				copy += *str;
				if (*str == '\n')
				{ copy += log_console::log_arrow; }
			}
			logger->first.print(copy);
		}
		else
		{
			logger->first.print(str);
		}
		logger->first.time = false;
		logger->first.location = false;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, const void* ptr)
{
	if (logger.is_logging_on)
	{
		logger.print(color::reset);
		logger.print(color::yellow_bg);
		logger.print(color::bold);
		logger.print(color::black);
		logger.print("0x");
		logger.print(log_console::integral_to_string(reinterpret_cast<unsigned long>(ptr), 0x10));
		logger.print(color::reset);
		logger.time = false;
		logger.location = false;
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, const void* ptr)
{
	if (logger->first.is_logging_on)
	{
		logger->first.print(color::reset);
		logger->first.print(color::yellow_bg);
		logger->first.print(color::bold);
		logger->first.print(color::black);
		logger->first.print("0x");
		logger->first.print(log_console::integral_to_string(reinterpret_cast<unsigned long>(ptr), 0x10));
		logger->first.print(color::reset);
		logger->first.time = false;
		logger->first.location = false;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, bool boolean)
{
	if (logger.is_logging_on)
	{
		if (logger.colorful)
		{
			logger.print(
					(boolean ? std::string(log_console::color_bool_true) + " true" : std::string(log_console::color_bool_false) + " false")
					+ color::reset
			);
		}
		else
		{
			logger.print(boolean ? " true" : " false");
		}
		logger.time = false;
		logger.location = false;
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, bool boolean)
{
	if (logger->first.is_logging_on)
	{
		if (logger->first.colorful)
		{
			logger->first
				  .print((boolean ? std::string(log_console::color_bool_true) + " true" : std::string(log_console::color_bool_false) + " false")
						 + color::reset
				  );
		}
		else
		{
			logger->first.print(boolean ? " true" : " false");
		}
		logger->first.time = false;
		logger->first.location = false;
	}
	return logger;
}

inline log_console& operator<<(log_console& logger, log_console::l_flags flag)
{
	if (logger.is_logging_on)
	{
		switch (flag)
		{
			case log_console::l_flags::l_lock:
				logger.lock();
				break;
			case log_console::l_flags::l_unlock:
				logger.unlock();
				break;
			case log_console::l_flags::l_flush:
				logger.flush();
				break;
			case log_console::l_flags::l_endl:
				logger.print("\n");
				logger.flush();
				break;
			case log_console::l_flags::l_locendl:
				logger.print("\n");
				logger.print(log_console::log_arrow);
				logger.flush();
				break;
			case log_console::l_flags::l_endent:
				logger.print("\n");
				logger.flush();
				logger.unlock();
				break;
			case log_console::l_flags::l_color:
				logger.colorful = true;
				break;
			case log_console::l_flags::l_nocolor:
				logger.colorful = false;
				break;
			case log_console::l_flags::l_nlarrow:
				logger.enablearrow = true;
				break;
			case log_console::l_flags::l_nonlarrow:
				logger.enablearrow = false;
				break;
		}
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::l_flags flag)
{
	if (logger->first.is_logging_on)
	{
		switch (flag)
		{
			case log_console::l_flags::l_lock:
				logger->first.lock();
				break;
			case log_console::l_flags::l_unlock:
				logger->first.unlock();
				break;
			case log_console::l_flags::l_flush:
				logger->first.flush();
				break;
			case log_console::l_flags::l_endl:
				logger->first.print("\n");
				logger->first.flush();
				break;
			case log_console::l_flags::l_locendl:
				logger->first.print("\n");
				logger->first.print(log_console::log_arrow);
				logger->first.flush();
				break;
			case log_console::l_flags::l_endent:
				logger->first.print("\n");
				logger->first.flush();
				logger->first.unlock();
				break;
			case log_console::l_flags::l_color:
				logger->first.colorful = true;
				break;
			case log_console::l_flags::l_nocolor:
				logger->first.colorful = false;
				break;
			case log_console::l_flags::l_nlarrow:
				logger->first.enablearrow = true;
				break;
			case log_console::l_flags::l_nonlarrow:
				logger->first.enablearrow = false;
				break;
		}
	}
	return logger;
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		log_console& logger, log_console::l_special_flag flag)
{
	if (logger.is_logging_on)
	{
		if (flag.val == log_console::l_localtime.val)
		{
			auto time = log_console::get_time(logger.colorful);
			logger.print(time);
			logger.time = true;
			logger.location = false;
		}
	}
	return std::make_shared<remove_smart<decltype(operator<<(logger, flag))>>(logger, std::true_type());
}

inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, log_console::l_special_flag flag)
{
	if (logger->first.is_logging_on)
	{
		if (flag.val == log_console::l_localtime.val)
		{
			auto time = log_console::get_time(logger->first.colorful);
			logger->first.print(time);
			logger->first.time = true;
			logger->first.location = false;
		}
	}
	return logger;
}

template <arithmetic num_t>
inline log_console& operator<<(log_console& logger, num_t num)
{
	if (logger.is_logging_on)
	{
		logger.time = false;
		logger.location = false;
		
		if constexpr(std::is_same_v<num_t, char> || std::is_same_v<num_t, wchar_t>)
		{
			logger.print(num);
		}
		else if constexpr(std::is_integral_v<num_t>)
		{
			if (logger.colorful)
				logger.print(log_console::color_int_t + log_console::integral_to_string(num, logger.base) + color::reset);
			else
				logger.print(log_console::integral_to_string(num, logger.base));
		}
		else if constexpr(std::is_floating_point_v<num_t>)
		{
			if (logger.colorful)
				logger.print(log_console::color_float_t + std::to_string(num) + color::reset);
			else
				logger.print(std::to_string(num));
		}
		else
		{
			logger.print(num);
		}
	}
	return logger;
}

template <arithmetic num_t>
inline std::shared_ptr<std::pair<log_console&, std::true_type>> operator<<(
		std::shared_ptr<std::pair<log_console&, std::true_type>> logger, num_t num)
{
	if (logger->first.is_logging_on)
	{
		logger->first.time = false;
		logger->first.location = false;
		
		if constexpr(std::is_same_v<num_t, char>)
		{
			logger->first.print(num);
		}
		else if constexpr(std::is_integral_v<num_t>)
		{
			if (logger->first.colorful)
				logger->first.print(log_console::color_int_t + log_console::integral_to_string(num, logger->first.base) + color::reset);
			else
				logger->first.print(log_console::integral_to_string(num, logger->first.base));
		}
		else if constexpr(std::is_floating_point_v<num_t>)
		{
			if (logger->first.colorful)
				logger->first.print(log_console::color_float_t + std::to_string(num) + color::reset);
			else
				logger->first.print(std::to_string(num));
		}
	}
	return logger;
}

#endif //LOG_CONSOLE