ConvertX.hpp

#pragma once
#include <string>

/// @brief Platform-dependent string type used by `ConvertX`.
///
/// Resolves to `std::wstring` when `_UNICODE` is defined; otherwise resolves to
/// `std::string`.
#if _UNICODE
using tstring = std::wstring;
#else
using tstring = std::string;
#endif // _UNICODE

/// @brief Provides unit conversion helpers for supported conversion domains.
///
/// The current interface exposes time and text conversions through the nested
/// `Time` and `Text` helpers. `SmartConvert` selects the appropriate conversion
/// logic based on the supplied unit tags.
class ConvertX
{
public:
	/// @brief Initializes a new `ConvertX` instance.
	ConvertX();

	/// @brief Destroys the `ConvertX` instance.
	~ConvertX();

	/// @brief Identifies the supported unit variants.
	///
	/// Values are grouped by conversion domain using sentinel markers so ranges
	/// can be validated efficiently.
	enum class UnitTag
	{
		/// @brief Start marker for time-based units.
		TIMESTART = 0,

		/// @brief Seconds.
		Seconds = TIMESTART,

		/// @brief Minutes.
		Minutes,

		/// @brief Hours.
		Hours,

		/// @brief Days.
		Days,

		/// @brief Weeks.
		Weeks,

		/// @brief Months.
		///
		/// Uses a fixed 30-day approximation.
		Months,

		/// @brief Years.
		///
		/// Uses a fixed 365-day approximation.
		Years,

		/// @brief Milliseconds.
		Milliseconds,

		/// @brief Microseconds.
		Microseconds,

		/// @brief End marker for time-based units.
		TIMEEND = Microseconds,

		/// @brief Start marker for text-based units.
		TEXTSTART = TIMESTART + 32,

		/// @brief Plain string text.
		String = TEXTSTART,

		/// @brief Unicode code points represented as text.
		CodePoints,

		/// @brief Binary text representation.
		BinaryString,

		/// @brief Octal text representation.
		OctalString,

		/// @brief Hexadecimal text representation.
		HexadecimalString,

		/// @brief End marker for text-based units.
		TEXTEND = HexadecimalString,
	};

	/// @brief Identifies the high-level conversion domain.
	enum class ConversionType
	{
		/// @brief Time conversion.
		Time = 0,

		/// @brief Text conversion.
		Text,

		/// @brief Color conversion.
		Color,

		/// @brief Temperature conversion.
		Temperature,

		/// @brief Data size conversion.
		DataSize,

		/// @brief Pressure conversion.
		Pressure,

		/// @brief Angle conversion.
		Angle,

		/// @brief Length conversion.
		Length,

		/// @brief Area conversion.
		Area,

		/// @brief Speed conversion.
		Speed,

		/// @brief Power conversion.
		Power,

		/// @brief Energy conversion.
		Energy,

		/// @brief Volume conversion.
		Volume,

		/// @brief Weight conversion.
		Weight
	};

	/// @brief Converts a value between two unit tags using the appropriate domain.
	///
	/// @param value The source value to convert.
	/// @param fromType The unit tag describing the source format or unit.
	/// @param toType The unit tag describing the target format or unit.
	/// @return The converted value as a `tstring`.
	tstring SmartConvert(const tstring& value, UnitTag fromType, UnitTag toType);

	/// @brief Determines which conversion domain applies to the supplied unit tags.
	///
	/// @param value The source value to inspect if needed by the implementation.
	/// @param fromType The source unit tag.
	/// @param toType The destination unit tag.
	/// @return The detected `ConversionType`.
	ConversionType DetectConversionType(const tstring& value, UnitTag fromType, UnitTag toType);

	/// @brief Validates whether the supplied unit tags belong to the same supported domain.
	///
	/// @param fromType The source unit tag.
	/// @param toType The destination unit tag.
	/// @return `true` if the conversion is valid; otherwise, `false`.
	bool IsValidUnits(UnitTag fromType, UnitTag toType);

	/// @brief Time conversion helpers using seconds as the canonical base unit.
	struct Time
	{
	public:
		/// @brief Converts a time value between two time units.
		///
		/// @param value The source numeric value.
		/// @param fromType The source time unit.
		/// @param toType The destination time unit.
		/// @return The converted numeric value.
		static double Convert(double value, UnitTag fromType, UnitTag toType);

		/// @brief Converts from seconds to a target time unit.
		struct FromSeconds
		{
		public:
			/// @brief Converts a seconds value to the specified time unit.
			///
			/// @param seconds The value in seconds.
			/// @param toType The destination time unit.
			/// @return The converted numeric value.
			static double Convert(double seconds, UnitTag toType);

			/// @brief Converts seconds to years.
			///
			/// Uses a fixed 365-day year.
			///
			/// @param seconds The value in seconds.
			/// @return The value in years.
			static double ToYears(double seconds);

			/// @brief Converts seconds to months.
			///
			/// Uses a fixed 30-day month.
			///
			/// @param seconds The value in seconds.
			/// @return The value in months.
			static double ToMonths(double seconds);

			/// @brief Converts seconds to weeks.
			///
			/// @param seconds The value in seconds.
			/// @return The value in weeks.
			static double ToWeeks(double seconds);

			/// @brief Converts seconds to days.
			///
			/// @param seconds The value in seconds.
			/// @return The value in days.
			static double ToDays(double seconds);

			/// @brief Converts seconds to hours.
			///
			/// @param seconds The value in seconds.
			/// @return The value in hours.
			static double ToHours(double seconds);

			/// @brief Converts seconds to minutes.
			///
			/// @param seconds The value in seconds.
			/// @return The value in minutes.
			static double ToMinutes(double seconds);

			/// @brief Converts seconds to milliseconds.
			///
			/// @param seconds The value in seconds.
			/// @return The value in milliseconds.
			static double ToMilliseconds(double seconds);

			/// @brief Converts seconds to microseconds.
			///
			/// @param seconds The value in seconds.
			/// @return The value in microseconds.
			static double ToMicroseconds(double seconds);
		};

		/// @brief Converts supported time units to seconds.
		struct ToSeconds
		{
			/// @brief Converts a value from the specified time unit to seconds.
			///
			/// @param value The source numeric value.
			/// @param fromType The source time unit.
			/// @return The value in seconds.
			static double Convert(double value, UnitTag fromType);

			/// @brief Converts years to seconds.
			///
			/// Uses a fixed 365-day year.
			///
			/// @param years The value in years.
			/// @return The value in seconds.
			static double FromYears(double years);

			/// @brief Converts months to seconds.
			///
			/// Uses a fixed 30-day month.
			///
			/// @param months The value in months.
			/// @return The value in seconds.
			static double FromMonths(double months);

			/// @brief Converts weeks to seconds.
			///
			/// @param weeks The value in weeks.
			/// @return The value in seconds.
			static double FromWeeks(double weeks);

			/// @brief Converts days to seconds.
			///
			/// @param days The value in days.
			/// @return The value in seconds.
			static double FromDays(double days);

			/// @brief Converts hours to seconds.
			///
			/// @param hours The value in hours.
			/// @return The value in seconds.
			static double FromHours(double hours);

			/// @brief Converts minutes to seconds.
			///
			/// @param minutes The value in minutes.
			/// @return The value in seconds.
			static double FromMinutes(double minutes);

			/// @brief Converts milliseconds to seconds.
			///
			/// @param milliseconds The value in milliseconds.
			/// @return The value in seconds.
			static double FromMilliseconds(double milliseconds);

			/// @brief Converts microseconds to seconds.
			///
			/// @param microseconds The value in microseconds.
			/// @return The value in seconds.
			static double FromMicroseconds(double microseconds);
		};

		/// @brief Number of seconds in one microsecond.
		constexpr static double SecondsInMicrosecond = 0.000001;

		/// @brief Number of seconds in one millisecond.
		constexpr static double SecondsInMillisecond = 0.001;

		/// @brief Number of seconds in one minute.
		constexpr static double SecondsInMinute = 60.0;

		/// @brief Number of seconds in one hour.
		constexpr static double SecondsInHour = 3600.0;

		/// @brief Number of seconds in one day.
		constexpr static double SecondsInDay = 86400.0;

		/// @brief Number of seconds in one week.
		constexpr static double SecondsInWeek = 604800.0;

		/// @brief Number of seconds in one month.
		///
		/// Uses a fixed 30-day month approximation.
		constexpr static double SecondsInMonth = 2592000.0;

		/// @brief Number of seconds in one year.
		///
		/// Uses a fixed 365-day year approximation.
		constexpr static double SecondsInYear = 31536000.0;
	};

	/// @brief Text conversion helpers using plain string data as the canonical base form.
	struct Text
	{
	public:
		/// @brief Converts text between supported textual representations.
		///
		/// @param value The source text.
		/// @param fromType The source text representation.
		/// @param toType The destination text representation.
		/// @return The converted text.
		static tstring Convert(const tstring& value, UnitTag fromType, UnitTag toType);

		/// @brief Converts from plain string text to other text representations.
		struct FromString
		{
		public:
			/// @brief Converts a plain string to the specified text representation.
			///
			/// @param value The source plain string.
			/// @param toType The destination text representation.
			/// @return The converted text.
			static tstring Convert(const tstring& value, UnitTag toType);

			/// @brief Converts a plain string to a code point representation.
			///
			/// @param value The source plain string.
			/// @return The code point representation.
			static tstring ToCodePoints(const tstring& value);

			/// @brief Converts a plain string to a binary representation.
			///
			/// @param value The source plain string.
			/// @return The binary representation.
			static tstring ToBinaryString(const tstring& value);

			/// @brief Converts a plain string to an octal representation.
			///
			/// @param value The source plain string.
			/// @return The octal representation.
			static tstring ToOctalString(const tstring& value);

			/// @brief Converts a plain string to a hexadecimal representation.
			///
			/// @param value The source plain string.
			/// @return The hexadecimal representation.
			static tstring ToHexadecimalString(const tstring& value);
		};

		/// @brief Converts supported text representations back to plain string text.
		struct ToString
		{
		public:
			/// @brief Converts a text representation to a plain string.
			///
			/// @param value The source text representation.
			/// @param fromType The source text representation type.
			/// @return The decoded plain string.
			static tstring Convert(const tstring& value, UnitTag fromType);

			/// @brief Converts a code point representation to a plain string.
			///
			/// @param value The code point representation.
			/// @return The decoded plain string.
			static tstring FromCodePoints(const tstring& value);

			/// @brief Converts a binary representation to a plain string.
			///
			/// @param value The binary representation.
			/// @return The decoded plain string.
			static tstring FromBinaryString(const tstring& value);

			/// @brief Converts an octal representation to a plain string.
			///
			/// @param value The octal representation.
			/// @return The decoded plain string.
			static tstring FromOctalString(const tstring& value);

			/// @brief Converts a hexadecimal representation to a plain string.
			///
			/// @param value The hexadecimal representation.
			/// @return The decoded plain string.
			static tstring FromHexadecimalString(const tstring& value);
		};
	};

private:

};