#include <climits>
#include <cstdint>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <limits>
#include <memory>
#include <typeinfo>
#include <zp/mem>
#include <zp/mth>
#include <zp/str>

#if !zp_std_cxx17
#error At least C++17 is required for this test!
#endif

static_assert(::zp::isptr<int>::val                                  == false);
static_assert(::zp::isptr<int                *>::val                 == true);
static_assert(::zp::isptr<int const          *>::val                 == true);
static_assert(::zp::isptr<int volatile       *>::val                 == true);
static_assert(::zp::isptr<int const volatile *>::val                 == true);
static_assert(::zp::isptr<int                * const>::val           == true);
static_assert(::zp::isptr<int const          * const>::val           == true);
static_assert(::zp::isptr<int volatile       * const>::val           == true);
static_assert(::zp::isptr<int const volatile * const>::val           == true);
static_assert(::zp::isptr<int                * volatile>::val        == true);
static_assert(::zp::isptr<int const          * volatile>::val        == true);
static_assert(::zp::isptr<int volatile       * volatile>::val        == true);
static_assert(::zp::isptr<int const volatile * volatile>::val        == true);
static_assert(::zp::isptr<int                * const volatile>::val  == true);
static_assert(::zp::isptr<int const          * const volatile>::val  == true);
static_assert(::zp::isptr<int volatile       * const volatile>::val  == true);
static_assert(::zp::isptr<int const volatile * const volatile>::val  == true);

static_assert(::zp::isref<int>::val                                  == false);
static_assert(::zp::isref<int &>::val               == true);
static_assert(::zp::isref<int const&>::val          == true);
static_assert(::zp::isref<int volatile&>::val       == true);
static_assert(::zp::isref<int const volatile&>::val == true);

static_assert(::zp::typequ<int,int>::val  == true);
static_assert(::zp::typequ<int,int long>::val == false);

static_assert(::zp::typequ<::zp::i8,  ::std::uint8_t>::val  == true);
static_assert(::zp::typequ<::zp::i8s, ::std::int8_t>::val   == true);
static_assert(::zp::typequ<::zp::i01, ::std::uint16_t>::val == true);
static_assert(::zp::typequ<::zp::i01s,::std::int16_t>::val  == true);
static_assert(::zp::typequ<::zp::i02, ::std::uint32_t>::val == true);
static_assert(::zp::typequ<::zp::i02s,::std::int32_t>::val  == true);
static_assert(::zp::typequ<::zp::i04, ::std::uint64_t>::val == true);
static_assert(::zp::typequ<::zp::i04s,::std::int64_t>::val  == true);

static_assert(::zp::typequ<::zp::ptr,   ::std::uintptr_t>::val == true);
static_assert(::zp::typequ<::zp::ptrdif,::std::ptrdiff_t>::val == true);
static_assert(::zp::typequ<::zp::siz,   ::std::size_t>::val    == true);

static_assert(::zp::typequ<::zp::remref<int>::typ,  int>::val == true);
static_assert(::zp::typequ<::zp::remref<int &>::typ,int>::val == true);

static_assert(::zp::typequ<::zp::remptr<int>::typ,                 int>::val == true);
static_assert(::zp::typequ<::zp::remptr<int *>::typ,               int>::val == true);
static_assert(::zp::typequ<::zp::remptr<int * const>::typ,         int>::val == true);
static_assert(::zp::typequ<::zp::remptr<int * volatile>::typ,      int>::val == true);
static_assert(::zp::typequ<::zp::remptr<int * const volatile>::typ,int>::val == true);

static_assert(::zp::typequ<::zp::remcv<int>::typ,               int>::val == true);
static_assert(::zp::typequ<::zp::remcv<int const>::typ,         int>::val == true);
static_assert(::zp::typequ<::zp::remcv<int volatile>::typ,      int>::val == true);
static_assert(::zp::typequ<::zp::remcv<int const volatile>::typ,int>::val == true);

static_assert(::zp::typequ<::zp::sgn<int>::typ,                        int>::val                == true);
static_assert(::zp::typequ<::zp::sgn<int const>::typ,                  int const>::val          == true);
static_assert(::zp::typequ<::zp::sgn<int volatile>::typ,               int volatile>::val       == true);
static_assert(::zp::typequ<::zp::sgn<int const volatile>::typ,         int const volatile>::val == true);
static_assert(::zp::typequ<::zp::sgn<int unsigned>::typ,               int>::val                == true);
static_assert(::zp::typequ<::zp::sgn<int unsigned const>::typ,         int const>::val          == true);
static_assert(::zp::typequ<::zp::sgn<int unsigned volatile>::typ,      int volatile>::val       == true);
static_assert(::zp::typequ<::zp::sgn<int unsigned const volatile>::typ,int const volatile>::val == true);

static_assert(::zp::typequ<::zp::usgn<int unsigned>::typ,               int unsigned>::val                == true);
static_assert(::zp::typequ<::zp::usgn<int unsigned const>::typ,         int unsigned const>::val          == true);
static_assert(::zp::typequ<::zp::usgn<int unsigned volatile>::typ,      int unsigned volatile>::val       == true);
static_assert(::zp::typequ<::zp::usgn<int unsigned const volatile>::typ,int unsigned const volatile>::val == true);
static_assert(::zp::typequ<::zp::usgn<int>::typ,                        int unsigned>::val                == true);
static_assert(::zp::typequ<::zp::usgn<int const>::typ,                  int unsigned const>::val          == true);
static_assert(::zp::typequ<::zp::usgn<int volatile>::typ,               int unsigned volatile>::val       == true);
static_assert(::zp::typequ<::zp::usgn<int const volatile>::typ,         int unsigned const volatile>::val == true);

static_assert(::zp::typequ<::zp::nulptrtyp,::std::nullptr_t>::val == true);

static_assert(::zp::bytelen == CHAR_BIT);

template<typename typtyp> constexpr static auto chktyp() noexcept -> bool {
	using ::zp::inf;
	using ::zp::nan;
	using ::zp::nulptr;
	using ::zp::typequ;

	using typ    = ::zp::typ<typtyp>;
	using numlim = ::std::numeric_limits<typtyp>;

	if constexpr (!typequ<typename ::zp::remcv<typtyp>::typ,bool>::val && !typ::ischr) {static_assert(typ::isint == ::std::is_integral_v<typtyp>);}

	static_assert(typ::isflt == ::std::is_floating_point_v<typtyp>);

	static_assert(nulptr<typtyp>() == nullptr);

	static_assert(typ::hassgn == numlim::is_signed);

	static_assert(typ::min == numlim::lowest());
	static_assert(typ::max == numlim::max());

	if constexpr (typ::isflt) {
		static_assert(inf<typtyp>::val == numlim::infinity());
	}

	return true;
}

template<typename typ> constexpr static auto chktypcv() noexcept -> bool {
	return ::chktyp<typ>() && ::chktyp<typ const>() && ::chktyp<typ volatile>() && ::chktyp<typ const volatile>();
}

static_assert(::chktypcv<bool>()                   == true);
static_assert(::chktypcv<char>()                   == true);
static_assert(::chktypcv<char signed>()            == true);
static_assert(::chktypcv<char unsigned>()          == true);
static_assert(::chktypcv<char16_t>()               == true);
static_assert(::chktypcv<char32_t>()               == true);
static_assert(::chktypcv<::zp::c8>()               == true);
static_assert(::chktypcv<double>()                 == true);
static_assert(::chktypcv<double long>()            == true);
static_assert(::chktypcv<float>()                  == true);
static_assert(::chktypcv<int>()                    == true);
static_assert(::chktypcv<int long>()               == true);
static_assert(::chktypcv<int long long>()          == true);
static_assert(::chktypcv<int long long unsigned>() == true);
static_assert(::chktypcv<int long unsigned>()      == true);
static_assert(::chktypcv<int short>()              == true);
static_assert(::chktypcv<int short unsigned>()     == true);
static_assert(::chktypcv<int unsigned>()           == true);
static_assert(::chktypcv<wchar_t>()                == true);

template<typename ltyp,typename rtyp> static auto cmp(int unsigned & numerr,int long const ln,::zp::i8 const mth,ltyp const& lvalref,rtyp const& rvalref) noexcept {
	char const* const ltypnm = typeid (ltyp).name();
	char const* const rtypnm = typeid (rtyp).name();

	auto const getval = [](auto const& valref) {
		using typ = typename ::zp::remcv<typename ::zp::remref<decltype (valref)>::typ>::typ;

		if constexpr      (::zp::typ<typ>::ischr) {return static_cast<::zp::i02>(valref);}
		else if constexpr (::zp::isptr<typ>::val) {return reinterpret_cast<void *>(valref);}
		else                                      {return valref;}
	};

	auto const lval = getval(lvalref);
	auto const rval = getval(rvalref);

	auto const cmp = [&mth](auto const& lval,auto const& rval) -> bool {
		switch (mth) {
		default:
			::zp::unrch();
		case 0x0u:
			return lval == rval;
		case 0x1u:
			return lval >= rval;
		case 0x2u:
			return lval >  rval;
		case 0x3u:
			return lval <= rval;
		case 0x4u:
			return lval < rval;
		case 0x5u:
			return lval != rval;
		}
	};

	auto const mthstr = [&mth]() -> char const * {
		switch (mth) {
		default:
			::zp::unrch();
		case 0x0u:
			return "==";
		case 0x1u:
			return ">=";
		case 0x2u:
			return ">";
		case 0x3u:
			return "<=";
		case 0x4u:
			return "<";
		case 0x5u:
			return "!=";
		}
	}();

	::std::cout << "  " << ln << ". " << ltypnm << " (" << lval << ") " << mthstr << " " << rtypnm << " (" << rval << ")... ";

	if (!cmp(lval,rval)) {
		::std::cout << "\x1B[38;5;161merror\x1B[0m" << ::std::endl;
		//throw ::std::exception {};
		++numerr;

		return;
	}

	::std::cout <<"\x1B[38;5;77mokay\x1B[0m" << ::std::endl;
}

#define chkeq(lval,rval) (::cmp(numerr,__LINE__,0x0u,(lval),(rval)))
#define chkge(lval,rval) (::cmp(numerr,__LINE__,0x1u,(lval),(rval)))
#define chkgt(lval,rval) (::cmp(numerr,__LINE__,0x2u,(lval),(rval)))
#define chkle(lval,rval) (::cmp(numerr,__LINE__,0x3u,(lval),(rval)))
#define chklt(lval,rval) (::cmp(numerr,__LINE__,0x4u,(lval),(rval)))
#define chkne(lval,rval) (::cmp(numerr,__LINE__,0x5u,(lval),(rval)))

int main() {
	int unsigned numerr = 0x0u;

	auto const tst = [](char const* const tst) noexcept {
		::std::cout <<"\n\x1B[38;5;75mtesting\x1B[0m " << tst <<"\n\n";
	};

	::std::cout <<"zp " <<::zp::ver.api <<"." <<::zp::ver.ext <<", run-time test\n";

	try {
		[&] {
			tst("optionals");

			::zp::opt<::zp::i8s> opt = ::zp::nulopt;

			chkeq(opt.chk(),false);

			auto const fun = [](char const* msg) -> void {
				::std::cout << msg << ::std::endl;

				::std::abort();
			};

			opt = -0x45;

			chkeq(opt.chk(),true);
			chkeq(opt.exp(fun,"expectation failed"),-0x45);

			::zp::opt<::zp::i8s> const optasg = opt;

			chkeq(optasg.chk(),true);
			chkeq(optasg.exp(fun,"expectation failed"),-0x45);
		}();

		[&] {
			tst("results");

			auto res = ::zp::res<::zp::i8s,::zp::i8s>::err(0x45);

			chkeq(res.chk(),false);
			chkeq(res.geterr(),0x45);

			res = ::zp::res<::zp::i8s,::zp::i8s>::oky(-0x45);

			auto const fun = [](char const* msg) -> void {
				::std::cout << msg << ::std::endl;

				::std::abort();
			};

			chkeq(res.chk(),true);
			chkeq(res.exp(fun,"expectation failed"),-0x45);

			class nopod0 {
			public:
				char val;

				nopod0() noexcept : val('\x00') {}
				nopod0(char const* const str) noexcept : val(str[0x0]) {}
			
				~nopod0() noexcept(false) {}
			};

			class nopod1 {
			public:
				int val;

				nopod1() noexcept : val(0x0) {}
				nopod1(int const val) noexcept : val(0x0-val) {}

				~nopod1() noexcept(false) {}
			};

			auto resnopod = ::zp::res<nopod0,nopod1>::oky("Hallo");

			chkeq(resnopod.chk(),true);
			chkeq(resnopod.getoky().val,'H');

			resnopod = ::zp::res<nopod0,nopod1>::err(0x4);

			chkeq(resnopod.chk(),false);
			chkeq(resnopod.geterr().val,-0x4);
		}();

		[&] {
			tst("special numbers");

			::zp::f02 f02;
			::zp::f04 f04;

			chkeq(sizeof (f02),0x4u);
			chkeq(sizeof (f04),0x8u);

			f02 = ::zp::nan<::zp::f02>::val;
			f04 = ::zp::nan<::zp::f04>::val;

			chkeq(::zp::isnan(f02),true);
			chkeq(::zp::isnan(f04),true);

			f02 = ::zp::inf<::zp::f02>::val;
			f04 = ::zp::inf<::zp::f04>::val;

			chkgt(f02,::zp::typ<::zp::f02>::max);
			chkgt(f04,::zp::typ<::zp::f04>::max);
		}();

		[&] {
			tst("mathematics");
		}();

		[&] {
			tst("vectors");

		/*	::zp::vec2<int> const lvec2 = {
				+0x1,
				-0x3,
			};
			::zp::vec2<int> const rvec2 = {
				+0x2,
				-0x4,
			};
			chkeq(::zp::dot2(lvec2,rvec2),0xE);

			::zp::vec3<int> const lvec3 = {
				.x = +0x1,
				.y = -0x3,
				.z = +0x5,
			};
			::zp::vec3<int> const rvec3 = {
				.x = +0x2,
				.y = -0x4,
				.z = +0x6,
			};
			chkeq(::zp::dot(lvec3,rvec3),0x2C);

			::zp::vec4<int> const lvec4 = {
				.x = +0x1,
				.y = -0x3,
				.z = +0x5,
				.w = -0x7,
			};
			::zp::vec4<int> const rvec4 = {
				.x = +0x2,
				.y = -0x4,
				.z = +0x6,
				.w = -0x8,
			};
			chkeq(::zp::dot(lvec4,rvec4),0x64);

			auto const avec2 = ::zp::vadd(lvec2,rvec2);
			auto const svec2 = ::zp::vsub(lvec2,rvec2);
			chkeq(avec2.x,+0x3);
			chkeq(avec2.y,-0x7);
			chkeq(svec2.x,-0x1);
			chkeq(svec2.y,+0x1);*/
		}();

		[&] {
			tst("memory sequences");

			::zp::i04 filbuf;

			chkeq(::zp::memfil(&filbuf,0xFFu,0x8u),reinterpret_cast<char unsigned *>(&filbuf)+0x8u);
			chkeq(::zp::memfil(&filbuf,0x7Fu,0x4u),reinterpret_cast<char unsigned *>(&filbuf)+0x4u);
			chkeq(::zp::memfil(&filbuf,0x3Fu,0x2u),reinterpret_cast<char unsigned *>(&filbuf)+0x2u);
			chkeq(::zp::memfil(&filbuf,0x1Fu,0x1u),reinterpret_cast<char unsigned *>(&filbuf)+0x1u);

			chkeq(filbuf,0xFFFFFFFF7F7F3F1Fu);

			::zp::i04 cpybuf;
			::zp::memcpy(&cpybuf,&filbuf,0x8u);

			chkeq(cpybuf,filbuf);

			chkeq(::zp::memsrh(&cpybuf,0x1Fu,0x8u),reinterpret_cast<char unsigned *>(&cpybuf));
		}();

		[&] {
			tst("strings");

			char     str[]   = "Hello there!";
			wchar_t  wstr[]  = L"Hello there!";
			char32_t str02[] = U"Hello there!";

			::zp::siz const len   = ::zp_strlen(  str);
			::zp::siz const wlen  = ::zp_wstrlen( wstr);
			::zp::siz const len02 = ::zp_utf32len(str02);

			chkeq(len,  0xCu);
			chkeq(wlen, 0xCu);
			chkeq(len02,0xCu);

			auto const buf   = new char[    len];
			auto const wbuf  = new wchar_t[ wlen];
			auto const buf02 = new char32_t[len02];

			chkeq(::zp_strcpy(  buf,  str),  len);
			chkeq(::zp_wstrcpy( wbuf, wstr), wlen);
			chkeq(::zp_utf32cpy(buf02,str02),len02);

			delete[] buf;
			delete[] wbuf;
			delete[] buf02;
		}();

		[&] {
			tst("UTF-8");

			char32_t const src[] = U"\U0001F480";

			::zp::siz const buf8len = ::zp_utf8enclen(src);
			chkeq(buf8len,0x4u);
			
			::zp::c8 * buf8 = new ::zp::c8[buf8len+0x1];

			::zp_utf8enc(buf8,src);

			chkeq(buf8[0x0],0xF0u);
			chkeq(buf8[0x1],0x9Fu);
			chkeq(buf8[0x2],0x92u);
			chkeq(buf8[0x3],0x80u);
			chkeq(buf8[0x4],0x00u);

			::zp::siz const buf02len = ::zp_utf8declen(buf8);
			chkeq(buf02len,0x1u);

			char32_t * buf02 = new char32_t[buf02len+0x1];

			::zp_utf8dec(buf02,buf8);

			chkeq(buf02[0x0],0x1F480u);
			chkeq(buf02[0x1],0x0u);

			delete[] buf8;
			delete[] buf02;
		}();

		[&] {
			tst("UTF-16");

			char32_t const src[] = U"\U0001F480\u00F0";

			::zp::siz const buf01len = ::zp_utf16enclen(src);
			chkeq(buf01len,0x3u);
			
			char16_t * buf01 = new char16_t[buf01len+0x1];

			::zp_utf16enc(buf01,src);

			chkeq(buf01[0x0],0xD83Du);
			chkeq(buf01[0x1],0xDC80u);
			chkeq(buf01[0x2],0x00F0u);
			chkeq(buf01[0x3],0x0000u);

			::zp::siz const buf02len = ::zp_utf16declen(buf01);
			chkeq(buf02len,0x2u);

			char32_t * buf02 = new char32_t[buf02len+0x1];

			::zp_utf16dec(buf02,buf01);

			chkeq(buf02[0x0],0x1F480u);
			chkeq(buf02[0x1],0xF0u);
			chkeq(buf02[0x2],0x0u);

			delete[] buf01;
			delete[] buf02;
		}();

#if false
		[&] {
			tst("boxes");

			::zp::box<::zp::i8s,::std::allocator<::zp::i8s>> box0 = 0x4;

			chkeq(*box0,0x4);

			::zp::box<::zp::i8s,::std::allocator<::zp::i8s>> const box1 = 0x0-box1;

			chkeq(*box1,-0x4);
		}();
#endif

		[&] {
			tst("arrays");

			::zp::arr<::zp::i8,::std::allocator<::zp::i8>> arr(0x8u);

			chkeq(arr.len(),0x8u);

			arr[0x0] = 0x7Fu;
			arr[0x1] = 0x3Fu;
			arr[0x2] = 0x1Fu;
			arr[0x3] = 0x0Fu;
			arr[0x4] = 0x07u;
			arr[0x5] = 0x03u;
			arr[0x6] = 0x01u;
			arr[0x7] = 0x00u;

			::zp::i8 prv = 0xFFu;
			for (::zp::i8 const val : arr) {
				chkeq(val,static_cast<::zp::i8>(prv>>0x1u));
				prv = val;
			}

			arr.fil(0xFFu);

			for (::zp::i8 const val : arr) {
				chkeq(val,0xFFu);
			}
		}();
	}
	catch (::std::exception const&) {
		return EXIT_FAILURE;
	}

	::std::cout <<"\nDone \u2212 " <<numerr <<" error(s)\n";

	return numerr ? EXIT_FAILURE : EXIT_SUCCESS;
}