ona/source/coral/utf8.zig

const debug = @import("./debug.zig");

const io = @import("./io.zig");

const math = @import("./math.zig");

const std = @import("std");

///
///
///
pub const DecimalFormat = struct {
	delimiter: []const u8 = "",
	positive_prefix: enum {none, plus, space} = .none,
};

///
///
///
pub const HexadecimalFormat = struct {
	delimiter: []const u8 = "",
	positive_prefix: enum {none, plus, space} = .none,
	casing: enum {lower, upper} = .lower,
};

///
/// Errors that may occur during any kind of utf8-encoded parsing.
///
pub const ParseError = error {
	BadSyntax,
};

///
/// Errors that may occur during any kind of utf8-encoded printing.
///
pub const PrintError = error {
	PrintFailed,
	PrintIncomplete,
};

///
///
///
pub fn parse_decimal(comptime Decimal: type, utf8: []const u8, format: DecimalFormat) !Decimal {
	if (utf8.len == 0) {
		return error.BadSyntax;
	}

	switch (@typeInfo(Decimal)) {
		.Int => |int| {
			var has_sign = switch (utf8[0]) {
				'-', '+', ' ' => true,
				else => false,
			};

			var result = @as(Decimal, 0);

			for (@boolToInt(has_sign) .. utf8.len) |index| {
				const radix = 10;
				const code = utf8[index];

				switch (code) {
					'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => {
						result = try math.checked_add(
							try math.checked_mul(result, radix),
							try math.checked_sub(code, '0'));
					},

					else => {
						if (format.delimiter.len == 0 or !io.equals(format.delimiter, utf8[index ..])) {
							return error.BadSyntax;
						}
					},
				}
			}

			switch (int.signedness) {
				.signed => {
					return result * @as(Decimal, if (has_sign and utf8[0] == '-') -1 else 1);
				},

				.unsigned => {
					if (has_sign and utf8[0] == '-') {
						return error.OutOfMemory;
					}

					return result;
				},
			}
		},

		.Float => {
			// ""
			if (utf8.len == 0) {
				return error.BadSyntax;
			}

			var has_sign = switch (utf8[0]) {
				'-', '+', ' ' => true,
				else => false,
			};

			// "-"
			if (has_sign and utf8.len == 1) {
				return error.BadSyntax;
			}

			const sign_offset = @boolToInt(has_sign);
			var has_decimal = utf8[sign_offset] == '.';

			// "-."
			if (has_decimal and (utf8.len == 2)) {
				return error.BadSyntax;
			}

			var result = @as(Decimal, 0);
			var factor = @as(Decimal, if (has_sign and utf8[0] == '-') -1 else 1);

			for (utf8[0 .. (sign_offset + @boolToInt(has_decimal))]) |code| switch (code) {
				'.' => {
					if (has_decimal) return error.BadSyntax;

					has_decimal = true;
				},

				'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => {
					if (has_decimal) factor /= 10.0;

					result = ((result * 10.0) + @intToFloat(Decimal, code - '0'));
				},

				else => return error.BadSyntax,
			};

			return result * factor;
		},

		else => @compileError("`" ++ @typeName(Decimal) ++ "` cannot be formatted as a decimal string"),
	}
}

///
/// Attempts to print `utf8` to `writer`.
///
/// The function returns [PrintError] if the write failed to complete partially or entirely.
///
pub fn print(writer: io.Writer, utf8: []const u8) PrintError!void {
	if ((writer.invoke(utf8) orelse return error.PrintFailed) != utf8.len) {
		return error.PrintIncomplete;
	}
}

///
///
///
pub fn print_formatted(writer: io.Writer, comptime format: []const u8, arguments: anytype) PrintError!void {
	switch (@typeInfo(@TypeOf(arguments))) {
		.Struct => |arguments_struct| {
			comptime var arg_index = 0;
			comptime var head = 0;
			comptime var tail = 0;

			inline while (tail < format.len) : (tail += 1) {
				if (format[tail] == '{') {
					if (tail > format.len) {
						@compileError("expected an idenifier after opening `{`");
					}

					tail += 1;

					switch (format[tail]) {
						'{' => {
							try print(writer, format[head .. (tail - 1)]);

							tail += 1;
							head = tail;
						},

						'}' => {
							if (!arguments_struct.is_tuple) {
								@compileError("all format specifiers must be named when using a named struct");
							}

							try print(writer, arguments[arg_index]);

							arg_index += 1;
							tail += 1;
							head = tail;
						},

						else => {
							if (arguments_struct.is_tuple) {
								@compileError("format specifiers cannot be named when using a tuple struct");
							}

							try print(writer, format[head .. (tail - 1)]);

							head = tail;
							tail += 1;

							if (tail >= format.len) {
								@compileError("expected closing `}` or another `{` after opening `{`");
							}

							debug.assert(tail < format.len);

							inline while (format[tail] != '}') {
								tail += 1;

								debug.assert(tail < format.len);
							}

							try print_value(writer, @field(arguments, format[head .. tail]));

							tail += 1;
							head = tail;
						}
					}
				}
			}
		},

		else => @compileError("`arguments` must be a struct type"),
	}
}

///
///
///
pub fn print_decimal(writer: io.Writer, value: anytype, format: DecimalFormat) PrintError!void {
	if (value == 0) {
		return print(writer, switch (format.positive_prefix) {
			.none => "0",
			.plus => "+0",
			.space => " 0",
		});
	}

	switch (@typeInfo(@TypeOf(value))) {
		.Int => |int| {
			const radix = 10;
			var buffer = [_]u8{0} ** (1 + math.max(int.bits, 1));
			var buffer_start = buffer.len - 1;

			{
				var decomposable_value = value;

				while (decomposable_value != 0) : (buffer_start -= 1) {
					buffer[buffer_start] = @intCast(u8, (decomposable_value % radix) + '0');
					decomposable_value = (decomposable_value / radix);
				}
			}

			if (int.signedness == .unsigned and value < 0) {
				buffer[buffer_start] = '-';
			} else {
				switch (format.positive_prefix) {
					.none => buffer_start += 1,
					.plus => buffer[buffer_start] = '+',
					.space => buffer[buffer_start] = ' ',
				}
			}

			try print(writer, buffer[buffer_start ..]);
		},

		else => @compileError("`arguments` must be a struct type"),
	}
}

pub fn print_hexadecimal(writer: io.Writer, value: anytype, format: HexadecimalFormat) PrintError!void {
	// TODO: Implement.
	_ = writer;
	_ = value;
	_ = format;

	unreachable;
}

noinline fn print_value(writer: io.Writer, value: anytype) PrintError!void {
	const Value = @TypeOf(value);

	return switch (@typeInfo(Value)) {
		.Int => print_decimal(writer, value, .{}),
		.Float => print_decimal(writer, value, .{}),

		.Pointer => |pointer| switch (pointer.size) {
			.One, .Many, .C => print_hexadecimal(writer, @ptrToInt(value), .{}),
			.Slice => if (pointer.child == u8) print(writer, value) else @compileError(unformattableMessage(Value)),
		},

		else => @compileError(unformattableMessage(Value)),
	};
}

fn unformattableMessage(comptime Value: type) []const u8 {
	return "`" ++ @typeName(Value) ++ "` are not formattable";
}