# include <dux/arr>
# include <dux/io>
# include <dux/math>
# include <dux/media>
# include <dux/mem>
# include <dux/seq>
# include <dux/sig>
# include <dux/str>
# include <dux/thrd>
# include <dux/time>

# include <signal.h>

static_assert(sizeof (::dux::uwrd) >= sizeof (void *),"::dux::uwrd must be capable of holding a pointer value");

static_assert(::dux::abs(0x10)  == 0x10);
static_assert(::dux::abs(-0x10) == 0x10);

static_assert(::dux::fac(0x1) == 0x1);
static_assert(::dux::fac(0x2) == 0x2);
static_assert(::dux::fac(0x3) == 0x6);
static_assert(::dux::fac(0x4) == 0x18);

static_assert(::dux::msb(0b1) == 0b1);
static_assert(::dux::msb(0b10) == 0b10);
static_assert(::dux::msb(0b101) == 0b100);
static_assert(::dux::msb(0b1010) == 0b1000);
static_assert(::dux::msb(0b10101) == 0b10000);
static_assert(::dux::msb(0b101010) == 0b100000);

namespace dux::local {
	static auto gotsig {false};
}

static_assert([] {
	auto chk {[] (::dux::sig const _sig0,int const _sig1) {
		return static_cast<int>(_sig0) == _sig1;
	}};
	static_assert(chk(::dux::sig::abrt,  SIGABRT));
	static_assert(chk(::dux::sig::alrm,  SIGALRM));
	static_assert(chk(::dux::sig::bus,   SIGBUS));
	static_assert(chk(::dux::sig::chld,  SIGCHLD));
	static_assert(chk(::dux::sig::cont,  SIGCONT));
	static_assert(chk(::dux::sig::fpe,   SIGFPE));
	static_assert(chk(::dux::sig::hup,   SIGHUP));
	static_assert(chk(::dux::sig::ill,   SIGILL));
	static_assert(chk(::dux::sig::io,    SIGIO));
	static_assert(chk(::dux::sig::intr,  SIGINT));
	static_assert(chk(::dux::sig::kill,  SIGKILL));
	static_assert(chk(::dux::sig::pipe,  SIGPIPE));
	static_assert(chk(::dux::sig::prof,  SIGPROF));
	static_assert(chk(::dux::sig::quit,  SIGQUIT));
	static_assert(chk(::dux::sig::segv,  SIGSEGV));
	static_assert(chk(::dux::sig::stop,  SIGSTOP));
	static_assert(chk(::dux::sig::sys,   SIGSYS));
	static_assert(chk(::dux::sig::term,  SIGTERM));
	static_assert(chk(::dux::sig::trap,  SIGTRAP));
	static_assert(chk(::dux::sig::tstp,  SIGTSTP));
	static_assert(chk(::dux::sig::ttin,  SIGTTIN));
	static_assert(chk(::dux::sig::ttou,  SIGTTOU));
	static_assert(chk(::dux::sig::urg,   SIGURG));
	static_assert(chk(::dux::sig::usr1,  SIGUSR1));
	static_assert(chk(::dux::sig::usr2,  SIGUSR2));
	static_assert(chk(::dux::sig::vtalrm,SIGVTALRM));
	static_assert(chk(::dux::sig::winch, SIGWINCH));
	static_assert(chk(::dux::sig::xcpu,  SIGXCPU));
	static_assert(chk(::dux::sig::xfsz,  SIGXFSZ));
# if defined(SIGPOLL)
	static_assert(chk(::dux::sig::poll,  SIGPOLL));
# endif
# if defined(SIGPWR)
	static_assert(chk(::dux::sig::pwr,   SIGPWR));
# endif
	return true;
}());

extern "C" auto ctest(void const * params) -> void;

extern "C" auto dux_main(::dux::mainparams const * const restrict _params) -> ::dux::stat {
	if (_params->num() == dux_uwrdl(0x0)) {::dux::dbglog("dux :: demo :: No parameters!\n");}
	else {for (auto n {dux_uwrdl(0x0)};n < _params->num();++n) {::dux::dbglog("dux :: demo :: Parameter #%zu: %s\n",n + dux_uwrdl(0x1),_params->param(n).ptr);}}
	{
		constexpr auto estim {dux_uint64l(0x100)};
		::dux::dbglog("Trying to roll two identical 8-bit numbers in a row. Estimated number of tries: " dux_printfuint64 ".\n",estim);
		auto num0 {::dux::rnd<::dux::uint8>()};
		auto num1 {::dux::rnd<::dux::uint8>()};
		for (auto n = dux_uint64l(0x1);;++n) {
			if (num0 == num1) [[unlikely]] {
				::dux::dbglog("Done! Took " dux_printfuint64 " attempts (estimated: " dux_printfuint64 ") to roll the same 8-bit number (" dux_printfuint8 ") two times in a row.\n",n,estim,num0);
				::dux::dbglog("Odds: %f%%",((double)n / (double)estim) * (double)100.0);
				if (n == dux_uint64l(0x45)) {::dux::dbglog(" - Nice!");} /* 69 */
				else if (n == dux_uint64l(0x1)) {::dux::dbglog(" - bruh");}
				::dux::dbglog("\n\nContinuing to the testing stage...\n\n");
				goto test;
			}
			num0 = ::dux::rnd<::dux::uint8>();
			num1 = ::dux::rnd<::dux::uint8>();
		}
	}
test:;
	auto const time = ::dux::gettime();
	::dux::dbglog("Current time: " dux_printfsint64 "\n",time);
	dux_ass("",time >= dux_sint64l(0x5C10DFA4));
	{
		::dux::reseterr();
		auto const ptr {::dux::alloc<char>()};
		dux_ass("Memory allocation failed!",!::dux::haserr());
		::dux::free(ptr);
	}
	{
		constexpr auto val {dux_uint8l(0xC4)};
		dux_ass("",::dux::getbit(val,0x0) == false);
		dux_ass("",::dux::getbit(val,0x1) == false);
		dux_ass("",::dux::getbit(val,0x2) == true);
		dux_ass("",::dux::getbit(val,0x3) == false);
		dux_ass("",::dux::getbit(val,0x4) == false);
		dux_ass("",::dux::getbit(val,0x5) == false);
		dux_ass("",::dux::getbit(val,0x6) == true);
		dux_ass("",::dux::getbit(val,0x7) == true);
	}
	{
		constexpr auto arrsz {dux_uwrdl(0x5)};
		constexpr ::dux::uint16 arr0[] {
			dux_uint16l(0xF),
			dux_uint16l(0x1F),
			dux_uint16l(0x3F),
			dux_uint16l(0x7F),
			dux_uint16l(0xFF),
		};
		auto const arr1 {::dux::alloc<::dux::uint16>(arrsz)};
		::dux::cpy(arr0,arrsz,arr1);
		dux_ass("",arr1[dux_uwrdl(0x0)] == dux_uint16l(0xF));
		dux_ass("",arr1[dux_uwrdl(0x1)] == dux_uint16l(0x1F));
		dux_ass("",arr1[dux_uwrdl(0x2)] == dux_uint16l(0x3F));
		dux_ass("",arr1[dux_uwrdl(0x3)] == dux_uint16l(0x7F));
		dux_ass("",arr1[dux_uwrdl(0x4)] == dux_uint16l(0xFF));
		::dux::free(arr1);
	}
	/*{
		auto * restrict ptr = ::dux::alloc<::dux::uint16>(dux_uwrdl(0x1));
		*ptr = dux_uint16l(0x10);
		dux_ass("",*ptr == dux_uint16l(0x10));
		ptr = ::dux::realloc(ptr,dux_uwrdl(0x2));
		ptr[dux_uwrdl(0x1)] = dux_uint16l(0x20);
		dux_ass("",ptr[dux_uwrdl(0x0)] == dux_uint16l(0x10));
		dux_ass("",ptr[dux_uwrdl(0x1)] == dux_uint16l(0x20));
		::dux::free(ptr);
	}*/ /* Does not work as realloc currently does not support reallocating aligned allocations. */
	{
		constexpr auto arrsz {dux_uwrdl(0x2)};
		::dux::uint64 arr[arrsz];
		::dux::bytefill(arr,arrsz,dux_uint8l(0xFF));
		dux_ass("",arr[dux_uwrdl(0x0)] >= dux_uint64l(0xFFFFFFFFFFFFFFFF));
		::dux::bytefill(arr,arrsz,dux_uint8l(0x7F));
		dux_ass("",arr[dux_uwrdl(0x1)] >= dux_uint64l(0x7F7F7F7F7F7F7F7F));
	}
	{
		::dux::seterr(::dux::errcd::test);
		dux_ass("Testing if the test error was set",::dux::geterr() >::dux::errcd::noerr);
		::dux::reseterr();
	}
	{
		auto x = 0x45;
		auto y = 0x1A4;
		::dux::swp(x,y);
		dux_ass("",x == 0x1A4);
		dux_ass("",y == 0x45);
	}
	{
		::dux::setsighandl(::dux::sig::intr,[](::dux::sig const _sig) {
			dux_ass("",_sig == ::dux::sig::intr);
			::dux::local::gotsig = true;
			return false;
		});
		::dux::raise(::dux::sig::intr);
		dux_ass("",::dux::local::gotsig);
		::dux::setsighandl(::dux::sig::intr,::dux::sighandl::dfl());
	}
	{
		auto handl {[](::dux::sig) {return false;}};
		::dux::setsighandl(::dux::sig::abrt,handl);
		auto goterr {false};
		if (::dux::haserr()) [[unlikely]] {
			goterr = true;
			::dux::reseterr();
		}
		dux_ass("",goterr);
	}
	{
		auto const start {::dux::gettime()};
		::dux::sleep(dux_uint64l(0x2));
		auto const stop {::dux::gettime()};
		dux_ass("",stop - start == dux_uint64l(0x2));
	}
	{
		constexpr auto arrsz {dux_uwrdl(0x8)};
		bool arr[arrsz];
		::dux::plot(arr,arrsz,[](::dux::uwrd const _n) {return ::dux::isprime(_n);});
		dux_ass("",arr[dux_uwrdl(0x0)] == false);
		dux_ass("",arr[dux_uwrdl(0x1)] == false);
		dux_ass("",arr[dux_uwrdl(0x2)] == true);
		dux_ass("",arr[dux_uwrdl(0x3)] == true);
		dux_ass("",arr[dux_uwrdl(0x4)] == false);
		dux_ass("",arr[dux_uwrdl(0x5)] == true);
		dux_ass("",arr[dux_uwrdl(0x6)] == false);
		dux_ass("",arr[dux_uwrdl(0x7)] == true);
	}
	if (::dux::haserr()) [[unlikely]] {
		::dux::dbglog("dux :: \x1B[91mdemo\x1B[0m :: Got error %S!\n",::dux::errcdnm(::dux::geterr()));
		::dux::exit(::dux::stat::err);
	}
	::ctest(_params);
	::dux::onexit([](::dux::stat) {
		::dux::onexit([](::dux::stat) {});
		dux_ass("",::dux::haserr());
		::dux::dbglog("dux :: demo :: All tests passed!\n");
	});
	::dux::exit(::dux::stat::ok);
}