#include <stdint.h>
#include <stddef.h>
#include <assert.h>

#include "curves.h"

static void
test_hil_xy_from_d()
{
	uint32_t x, y;

	hil_xy_from_d(0, &x, &y);
	assert(x == 0 && y == 0);

	hil_xy_from_d(1, &x, &y);
	assert(x == 1 && y == 0);

	hil_xy_from_d(2, &x, &y);
	assert(x == 1 && y == 1);

	hil_xy_from_d(3, &x, &y);
	assert(x == 0 && y == 1);

	hil_xy_from_d(4, &x, &y);
	assert(x == 0 && y == 2);

	hil_xy_from_d(5, &x, &y);
	assert(x == 0 && y == 3);

	hil_xy_from_d(6, &x, &y);
	assert(x == 1 && y == 3);

	hil_xy_from_d(7, &x, &y);
	assert(x == 1 && y == 2);

	hil_xy_from_d(8, &x, &y);
	assert(x == 2 && y == 2);

	hil_xy_from_d(9, &x, &y);
	assert(x == 2 && y == 3);

	hil_xy_from_d(10, &x, &y);
	assert(x == 3 && y == 3);

	hil_xy_from_d(11, &x, &y);
	assert(x == 3 && y == 2);

	hil_xy_from_d(12, &x, &y);
	assert(x == 3 && y == 1);

	hil_xy_from_d(13, &x, &y);
	assert(x == 2 && y == 1);

	hil_xy_from_d(14, &x, &y);
	assert(x == 2 && y == 0);

	hil_xy_from_d(15, &x, &y);
	assert(x == 3 && y == 0);


	hil_xy_from_d(10, &x, &y);
	assert(x == 3 && y == 3);

	hil_xy_from_d(21, &x, &y);
	assert(x == 7 && y == 0);

	hil_xy_from_d(63, &x, &y);
	assert(x == 0 && y == 7);

	hil_xy_from_d(4095, &x, &y);
	assert(x == 63 && y == 0);

	hil_xy_from_d(4067, &x, &y);
	assert(x == 58 && y == 3);
}

static void
test_hil_d_from_xy()
{
	assert(hil_d_from_xy(0, 0) == 0);
	assert(hil_d_from_xy(1, 0) == 1);
	assert(hil_d_from_xy(1, 1) == 2);
	assert(hil_d_from_xy(0, 1) == 3);
	assert(hil_d_from_xy(0, 2) == 4);
	assert(hil_d_from_xy(0, 3) == 5);
	assert(hil_d_from_xy(1, 3) == 6);
	assert(hil_d_from_xy(1, 2) == 7);
	assert(hil_d_from_xy(2, 2) == 8);
	assert(hil_d_from_xy(2, 3) == 9);
	assert(hil_d_from_xy(3, 3) == 10);
	assert(hil_d_from_xy(3, 2) == 11);
	assert(hil_d_from_xy(3, 1) == 12);
	assert(hil_d_from_xy(2, 1) == 13);
	assert(hil_d_from_xy(2, 0) == 14);
	assert(hil_d_from_xy(3, 0) == 15);

	assert(hil_d_from_xy(3, 3) == 10);
	assert(hil_d_from_xy(7, 0) == 21);
	assert(hil_d_from_xy(0, 7) == 63);
	assert(hil_d_from_xy(63, 0) == 4095);
	assert(hil_d_from_xy(58, 3) == 4067);
}

static void
test_hil_inv(size_t nmax)
{
	size_t n, y, x;
	for (n = 0; n <= nmax; n++) {
		for (y = 0; y < n; y++) {
			for (x = 0; x < n; x++) {
				uint32_t tx, ty;
				uint32_t d = hil_d_from_xy(x, y);
				hil_xy_from_d(d, &tx, &ty);
				assert(tx == x && ty == y);
			}
		}
	}
}

static void
test_hil_inv2(size_t nmax)
{
	size_t n, y, x;
	for (n = 0; n <= nmax; n++) {
		for (y = 0; y < n; y++) {
			for (x = 0; x < n; x++) {
				uint32_t tx, ty;
				uint32_t d = hil_d_from_xy2(x, y);
				hil_xy_from_d(d, &tx, &ty);
				assert(tx == x && ty == y);
			}
		}
	}
}

static void
test_hil_inv3(size_t nmax)
{
	size_t n, y, x;
	for (n = 0; n <= nmax; n++) {
		for (y = 0; y < n; y++) {
			for (x = 0; x < n; x++) {
				uint32_t tx, ty;
				uint32_t d = hil_d_from_xy3(x, y);
				hil_xy_from_d(d, &tx, &ty);
				assert(tx == x && ty == y);
			}
		}
	}
}

static void
test_mor_xy_from_z()
{
	uint32_t x, y;

	mor_xy_from_z(0, &x, &y);
	assert(x == 0 && y == 0);

	mor_xy_from_z(1, &x, &y);
	assert(x == 1 && y == 0);

	mor_xy_from_z(2, &x, &y);
	assert(x == 0 && y == 1);

	mor_xy_from_z(3, &x, &y);
	assert(x == 1 && y == 1);

	mor_xy_from_z(4, &x, &y);
	assert(x == 2 && y == 0);

	mor_xy_from_z(5, &x, &y);
	assert(x == 3 && y == 0);

	mor_xy_from_z(6, &x, &y);
	assert(x == 2 && y == 1);

	mor_xy_from_z(7, &x, &y);
	assert(x == 3 && y == 1);

	mor_xy_from_z(8, &x, &y);
	assert(x == 0 && y == 2);

	mor_xy_from_z(9, &x, &y);
	assert(x == 1 && y == 2);

	mor_xy_from_z(10, &x, &y);
	assert(x == 0 && y == 3);

	mor_xy_from_z(11, &x, &y);
	assert(x == 1 && y == 3);

	mor_xy_from_z(12, &x, &y);
	assert(x == 2 && y == 2);

	mor_xy_from_z(13, &x, &y);
	assert(x == 3 && y == 2);

	mor_xy_from_z(14, &x, &y);
	assert(x == 2 && y == 3);

	mor_xy_from_z(15, &x, &y);
	assert(x == 3 && y == 3);
}

static void
test_mor_z_from_xy()
{
	assert(mor_z_from_xy(0, 0) == 0);
	assert(mor_z_from_xy(1, 0) == 1);
	assert(mor_z_from_xy(1, 1) == 3);
	assert(mor_z_from_xy(0, 1) == 2);
	assert(mor_z_from_xy(0, 2) == 8);
	assert(mor_z_from_xy(0, 3) == 10);
	assert(mor_z_from_xy(1, 3) == 11);
	assert(mor_z_from_xy(1, 2) == 9);
	assert(mor_z_from_xy(2, 2) == 12);
	assert(mor_z_from_xy(2, 3) == 14);
	assert(mor_z_from_xy(3, 3) == 15);
	assert(mor_z_from_xy(3, 2) == 13);
	assert(mor_z_from_xy(3, 1) == 7);
	assert(mor_z_from_xy(2, 1) == 6);
	assert(mor_z_from_xy(2, 0) == 4);
	assert(mor_z_from_xy(3, 0) == 5);
}

static void
test_mor_inv(size_t nmax)
{
	size_t n, y, x;
	for (n = 0; n <= nmax; n++) {
		for (y = 0; y < n; y++) {
			for (x = 0; x < n; x++) {
				uint32_t tx, ty;
				uint32_t z = mor_z_from_xy(x, y);
				mor_xy_from_z(z, &tx, &ty);
				assert(tx == x && ty == y);
			}
		}
	}
}

int
main()
{
	test_hil_xy_from_d();
	test_hil_d_from_xy();
	test_hil_inv(113);
	test_hil_inv2(113);
	test_hil_inv3(113);

	test_mor_z_from_xy();
	test_mor_xy_from_z();
	test_mor_inv(113);

	return 0;
}