#define PK_IMPL_STN

#include "../pkstn.h"
#include "../pktst.h"

#include <cstring>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <type_traits>

const char *STRNUM_NIL = "";
const char *STRNUM_ZED = "0";
const char *STRNUM_ONE = "1";
const char *STRNUM_ONE_MINUS = "-1";
const char *STRNUM_UNDERFLOW = "-99999999999999999999999999999999";
const char *STRNUM_OVERFLOW = "99999999999999999999999999999999";
const char *STRNUM_FLOAT_NIL = "";
const char *STRNUM_FLOAT_ZED = "0.0";
const char *STRNUM_FLOAT_ONE = "15.0";
const char *STRNUM_FLOAT_ONE_MINUS = "-15.0";
const char *STRNUM_UNDERFLOW_FLOAT = "-1.0e9999";
const char *STRNUM_OVERFLOW_FLOAT = "1.0e9999";
const char *STRNUM_INCONVERTIBLE = "junk";

#define VAL_SCALAR_ZED 0
#define VAL_SCALAR_ONE 1
#define VAL_SCALAR_ONE_MINUS -1
#define VAL_FLOATING_ZED 0.0
#define VAL_FLOATING_ONE 0x1.ep+3
#define VAL_FLOATING_ONE_MINUS -0x1.ep+3

enum STRNUM_TESTS : uint32_t {
	TEST_SCALAR_NIL               = 0x00000001,
	TEST_SCALAR_ZED               = 0x00000002,
	TEST_SCALAR_ONE               = 0x00000004,
	TEST_SCALAR_ONE_MINUS         = 0x00000008,
	TEST_SCALAR_UNDERFLOW         = 0x00000010,
	TEST_SCALAR_OVERFLOW          = 0x00000020,
	TEST_FLOATING_NIL             = 0x00000100,
	TEST_FLOATING_ZED             = 0x00000200,
	TEST_FLOATING_ONE             = 0x00000400,
	TEST_FLOATING_ONE_MINUS       = 0x00000800,
	TEST_FLOATING_UNDERFLOW       = 0x00001000,
	TEST_FLOATING_OVERFLOW        = 0x00002000,
	TEST_INCONVERTIBLE            = 0x00010000,
	TEST_BOOL                     = 0x000100F7,
	TEST_SCALAR                   = 0x000100FF,
	TEST_FLOATS                   = 0x0001FF00,
	TEST_ALL                      = 0xFFFFFFFF,
};

template <typename T, enum STRNUM_TESTS t>
void test() {
	char *s;
	enum PK_STN_RES res = {};
	T i = {1};
	if constexpr (t & TEST_SCALAR_NIL) {
		res = pk_stn(&i, STRNUM_NIL, &s);
		std::cout << "pkstn: TEST_SCALAR_NIL res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_NIL, s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
	}
	if constexpr (t & TEST_FLOATING_NIL) {
		res = pk_stn(&i, STRNUM_FLOAT_NIL, &s);
		std::cout << "pkstn: TEST_FLOATING_NIL res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_NIL, s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
	}
	if constexpr (t & TEST_SCALAR_ZED) {
		res = pk_stn(&i, STRNUM_ZED, &s);
		std::cout << "pkstn: TEST_SCALAR_ZED res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ZED + strlen(STRNUM_ZED), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ZED), i);
	}
	if constexpr (t & TEST_FLOATING_ZED) {
		res = pk_stn(&i, STRNUM_FLOAT_ZED, &s);
		std::cout << "pkstn: TEST_FLOATING_ZED res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ZED + strlen(STRNUM_FLOAT_ZED), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
		PK_TEST_ASSERT_EQ_EXIT(T(VAL_FLOATING_ZED), i);
	}
	if constexpr (t & TEST_SCALAR_ONE) {
		res = pk_stn(&i, STRNUM_ONE, &s);
		std::cout << "pkstn: TEST_SCALAR_ONE res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ONE + strlen(STRNUM_ONE), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ONE), i);
	}
	if constexpr (t & TEST_FLOATING_ONE) {
		res = pk_stn(&i, STRNUM_FLOAT_ONE, &s);
		std::cout << "pkstn: TEST_FLOATING_ONE res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ONE + strlen(STRNUM_FLOAT_ONE), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
		PK_TEST_ASSERT_EQ_EXIT(T(VAL_FLOATING_ONE), i);
	}
	if constexpr (t & TEST_SCALAR_ONE_MINUS) {
		res = pk_stn(&i, STRNUM_ONE_MINUS, &s);
		std::cout << "pkstn: TEST_SCALAR_ONE_MINUS res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ONE_MINUS + strlen(STRNUM_ONE_MINUS), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ONE_MINUS), i);
	}
	if constexpr (t & TEST_FLOATING_ONE_MINUS) {
		res = pk_stn(&i, STRNUM_FLOAT_ONE_MINUS, &s);
		std::cout << "pkstn: TEST_FLOATING_ONE_MINUS res: " << i << "\n";
		if (s != STRNUM_FLOAT_ONE_MINUS + strlen(STRNUM_FLOAT_ONE_MINUS)) exit(1);
		if (res != PK_STN_RES_SUCCESS) exit(1);
		if (T(VAL_FLOATING_ONE_MINUS) != i) exit(1);
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ONE_MINUS + strlen(STRNUM_FLOAT_ONE_MINUS), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
	}
	if constexpr (t & TEST_SCALAR_UNDERFLOW) {
		res = pk_stn(&i, STRNUM_UNDERFLOW, &s);
		std::cout << "pkstn: TEST_SCALAR_UNDERFLOW res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_UNDERFLOW + strlen(STRNUM_UNDERFLOW), s);
		if constexpr(std::is_unsigned_v<T> == true) {
			PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
		} else {
			PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_UNDERFLOW, res);
		}
	}
	if constexpr (t & TEST_FLOATING_UNDERFLOW) {
		res = pk_stn(&i, STRNUM_UNDERFLOW_FLOAT, &s);
		std::cout << "pkstn: TEST_FLOATING_UNDERFLOW res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_UNDERFLOW_FLOAT + strlen(STRNUM_UNDERFLOW_FLOAT), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_UNDERFLOW, res);
	}
	if constexpr (t & TEST_SCALAR_OVERFLOW) {
		res = pk_stn(&i, STRNUM_OVERFLOW, &s);
		std::cout << "pkstn: TEST_SCALAR_OVERFLOW res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_OVERFLOW + strlen(STRNUM_OVERFLOW), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
	}
	if constexpr (t & TEST_FLOATING_OVERFLOW) {
		res = pk_stn(&i, STRNUM_OVERFLOW_FLOAT, &s);
		std::cout << "pkstn: TEST_FLOATING_OVERFLOW res: " << i << "\n";
		PK_TEST_ASSERT_EQ_EXIT(STRNUM_OVERFLOW_FLOAT + strlen(STRNUM_OVERFLOW_FLOAT), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
	}
	if constexpr (t & TEST_INCONVERTIBLE) {
		res = pk_stn(&i, STRNUM_INCONVERTIBLE, &s);
		std::cout << "pkstn: TEST_INCONVERTIBLE res: " << i << "\n";
		PK_TEST_ASSERT_NEQ_EXIT(STRNUM_INCONVERTIBLE + strlen(STRNUM_INCONVERTIBLE), s);
		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
	}
};

int main(int argc, char *argv[])
{
	(void)argc;
	(void)argv;
	fprintf(stdout, "\n");

	// stn_int64_t
	{
		fprintf(stdout, "\npkstn: starting int64_t\n");
		test<int64_t, TEST_SCALAR>();
	}

	// stn_uint64_t
	{
		fprintf(stdout, "\npkstn: starting uint64_t\n");
		test<uint64_t, TEST_SCALAR>(); }

	// stn_int32_t
	{
		fprintf(stdout, "\npkstn: starting int32_t\n");
		test<int32_t, TEST_SCALAR>();
	}

	// stn_uint32_t
	{
		fprintf(stdout, "\npkstn: starting uint32_t\n");
		test<uint32_t, TEST_SCALAR>();
	}

	// stn_int16_t
	{
		fprintf(stdout, "\npkstn: starting int16_t\n");
		test<int16_t, TEST_SCALAR>();
	}

	// stn_uint16_t
	{
		fprintf(stdout, "\npkstn: starting uint16_t\n");
		test<uint16_t, TEST_SCALAR>();
	}

	// stn_int8_t
	{
		fprintf(stdout, "\npkstn: starting int8_t\n");
		test<int8_t, TEST_SCALAR>();
	}

	// stn_uint8_t
	{
		fprintf(stdout, "\npkstn: starting uint8_t\n");
		test<uint8_t, TEST_SCALAR>();
	}

	// bool
	{
		fprintf(stdout, "\npkstn: starting bool\n");
		test<bool, TEST_BOOL>();
	}

	// stn_float
	{
		fprintf(stdout, "\npkstn: starting float\n");
		test<float, TEST_FLOATS>();
	}

	// stn_double
	{
		fprintf(stdout, "\npkstn: starting double\n");
		test<double, TEST_FLOATS>();
	}

	return 0;
}