/* See LICENSE file for copyright and license details. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "../grapheme.h"
#include "util.h"

static const struct {
	char *arr;             /* UTF-8 byte sequence */
	size_t len;            /* length of UTF-8 byte sequence */
	size_t exp_len;        /* expected length returned */
	uint_least32_t exp_cp; /* expected codepoint returned */
} dec_test[] = {
	{
		/* empty sequence
	         * [ ] ->
	         * INVALID
	         */
		.arr = NULL,
		.len = 0,
		.exp_len = 0,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid lead byte
	         * [ 11111101 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xFD },
		.len = 1,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* valid 1-byte sequence
	         * [ 00000001 ] ->
	         * 0000001
	         */
		.arr = (char *)(unsigned char[]) { 0x01 },
		.len = 1,
		.exp_len = 1,
		.exp_cp = 0x1,
	},
	{
		/* valid 2-byte sequence
	         * [ 11000011 10111111 ] ->
	         * 00011111111
	         */
		.arr = (char *)(unsigned char[]) { 0xC3, 0xBF },
		.len = 2,
		.exp_len = 2,
		.exp_cp = 0xFF,
	},
	{
		/* invalid 2-byte sequence (second byte missing)
	         * [ 11000011 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xC3 },
		.len = 1,
		.exp_len = 2,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 2-byte sequence (second byte malformed)
	         * [ 11000011 11111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xC3, 0xFF },
		.len = 2,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 2-byte sequence (overlong encoded)
	         * [ 11000001 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xC1, 0xBF },
		.len = 2,
		.exp_len = 2,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* valid 3-byte sequence
	         * [ 11100000 10111111 10111111 ] ->
	         * 0000111111111111
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0xBF, 0xBF },
		.len = 3,
		.exp_len = 3,
		.exp_cp = 0xFFF,
	},
	{
		/* invalid 3-byte sequence (second byte missing)
	         * [ 11100000 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0 },
		.len = 1,
		.exp_len = 3,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (second byte malformed)
	         * [ 11100000 01111111 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0x7F, 0xBF },
		.len = 3,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (short string, second byte malformed)
	         * [ 11100000 01111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0x7F },
		.len = 2,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (third byte missing)
	         * [ 11100000 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0xBF },
		.len = 2,
		.exp_len = 3,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (third byte malformed)
	         * [ 11100000 10111111 01111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0xBF, 0x7F },
		.len = 3,
		.exp_len = 2,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (overlong encoded)
	         * [ 11100000 10011111 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xE0, 0x9F, 0xBF },
		.len = 3,
		.exp_len = 3,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 3-byte sequence (UTF-16 surrogate half)
	         * [ 11101101 10100000 10000000 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xED, 0xA0, 0x80 },
		.len = 3,
		.exp_len = 3,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* valid 4-byte sequence
	         * [ 11110011 10111111 10111111 10111111 ] ->
	         * 011111111111111111111
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF, 0xBF, 0xBF },
		.len = 4,
		.exp_len = 4,
		.exp_cp = UINT32_C(0xFFFFF),
	},
	{
		/* invalid 4-byte sequence (second byte missing)
	         * [ 11110011 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3 },
		.len = 1,
		.exp_len = 4,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (second byte malformed)
	         * [ 11110011 01111111 10111111 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0x7F, 0xBF, 0xBF },
		.len = 4,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (short string 1, second byte
	         * malformed) [ 11110011 011111111 ] -> INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0x7F },
		.len = 2,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (short string 2, second byte
	         * malformed) [ 11110011 011111111 10111111 ] -> INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0x7F, 0xBF },
		.len = 3,
		.exp_len = 1,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},

	{
		/* invalid 4-byte sequence (third byte missing)
	         * [ 11110011 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF },
		.len = 2,
		.exp_len = 4,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (third byte malformed)
	         * [ 11110011 10111111 01111111 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF, 0x7F, 0xBF },
		.len = 4,
		.exp_len = 2,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (short string, third byte malformed)
	         * [ 11110011 10111111 01111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF, 0x7F },
		.len = 3,
		.exp_len = 2,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (fourth byte missing)
	         * [ 11110011 10111111 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF, 0xBF },
		.len = 3,
		.exp_len = 4,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (fourth byte malformed)
	         * [ 11110011 10111111 10111111 01111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF3, 0xBF, 0xBF, 0x7F },
		.len = 4,
		.exp_len = 3,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (overlong encoded)
	         * [ 11110000 10000000 10000001 10111111 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF0, 0x80, 0x81, 0xBF },
		.len = 4,
		.exp_len = 4,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
	{
		/* invalid 4-byte sequence (UTF-16-unrepresentable)
	         * [ 11110100 10010000 10000000 10000000 ] ->
	         * INVALID
	         */
		.arr = (char *)(unsigned char[]) { 0xF4, 0x90, 0x80, 0x80 },
		.len = 4,
		.exp_len = 4,
		.exp_cp = GRAPHEME_INVALID_CODEPOINT,
	},
};

int
main(int argc, char *argv[])
{
	size_t i, failed;

	(void)argc;

	/* UTF-8 decoder test */
	for (i = 0, failed = 0; i < LEN(dec_test); i++) {
		size_t len;
		uint_least32_t cp;

		len = grapheme_decode_utf8(dec_test[i].arr, dec_test[i].len,
		                           &cp);

		if (len != dec_test[i].exp_len || cp != dec_test[i].exp_cp) {
			fprintf(stderr,
			        "%s: Failed test %zu: "
			        "Expected (%zx,%u), but got (%zx,%u).\n",
			        argv[0], i, dec_test[i].exp_len,
			        dec_test[i].exp_cp, len, cp);
			failed++;
		}
	}
	printf("%s: %zu/%zu unit tests passed.\n", argv[0],
	       LEN(dec_test) - failed, LEN(dec_test));

	return (failed > 0) ? 1 : 0;
}