#include "../pkstn.h"

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

const char *STRNUM_ONE = "1";
const char *STRNUM_ONE_MINUS = "-1";
const char *STRNUM_UNDERFLOW = "-99999999999999999999999999999999";
const char *STRNUM_OVERFLOW = "99999999999999999999999999999999";
const char *STRNUM_UNDERFLOW_FLOAT = "-1.0e9999";
const char *STRNUM_OVERFLOW_FLOAT = "1.0e9999";
const char *STRNUM_INCONVERTIBLE = "junk";

enum STRNUM_TESTS : uint8_t {
	TEST_ONE               = 0x01,
	TEST_ONE_MINUS         = 0x02,
	TEST_UNDERFLOW         = 0x04,
	TEST_OVERFLOW          = 0x08,
	TEST_INCONVERTIBLE     = 0x10,
	TEST_NO_NEG            = TEST_ONE | TEST_OVERFLOW | TEST_INCONVERTIBLE,
	TEST_FLOATS            = TEST_ONE | TEST_ONE_MINUS | TEST_UNDERFLOW | TEST_OVERFLOW,
	TEST_ALL               = 0xFF,
};

template <typename T, enum STRNUM_TESTS t>
void test() {
	enum PK_STN_RES res = {};
	T i = {0};
	if constexpr (t & TEST_ONE) {
		res = pk_stn(&i, STRNUM_ONE);
		std::cout << "pkstn: TEST_ONE res: " << i << "\n";
		if (res != PK_STN_RES_SUCCESS) exit(1);
		if (1 != i) exit(1);
	}
	if constexpr (t & TEST_ONE_MINUS) {
		res = pk_stn(&i, STRNUM_ONE_MINUS);
		std::cout << "pkstn: STRNUM_ONE_MINUS res: " << i << "\n";
		if (res != PK_STN_RES_SUCCESS) exit(1);
		if (T(-1) != i) exit(1);
	}
	if constexpr (t & TEST_UNDERFLOW) {
		const char * str;
		if constexpr(std::is_same<T, float>::value == true || std::is_same<T, double>::value == true) {
			str = STRNUM_UNDERFLOW_FLOAT;
		}	else {
			str = STRNUM_UNDERFLOW;
		}
		res = pk_stn(&i, str);
		std::cout << "pkstn: TEST_UNDERFLOW res: " << i << "\n";
		if constexpr(std::is_unsigned_v<T> == true) {
			if (res != PK_STN_RES_OVERFLOW) exit(1);
		} else {
			if (res != PK_STN_RES_UNDERFLOW) exit(1);
		}
	}
	if constexpr (t & TEST_OVERFLOW) {
		const char * str;
		if constexpr(std::is_same<T, float>::value == true || std::is_same<T, double>::value == true) {
			str = STRNUM_OVERFLOW_FLOAT;
		}	else {
			str = STRNUM_OVERFLOW;
		}
		res = pk_stn(&i, str);
		std::cout << "pkstn: TEST_OVERFLOW res: " << i << "\n";
		if (res != PK_STN_RES_OVERFLOW) exit(1);
	}
	if constexpr (t & TEST_INCONVERTIBLE) {
		res = pk_stn(&i, STRNUM_INCONVERTIBLE);
		std::cout << "pkstn: TEST_INCONVERTIBLE res: " << i << "\n";
		if (res != PK_STN_RES_INCONVERTIBLE) exit(1);
	}
};

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_ALL>();
	}

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

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

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

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

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

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

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

	// 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;
}