/***************************************************************************************************
 * 
 * Helper functions that serve general purposes.
 * 
 * Authors:
 *   $(LINK2 mailto:Marco.Leise@gmx.de, Marco Leise)
 * 
 * Copyright:
 *   © 2017-2023 $(LINK2 mailto:Marco.Leise@gmx.de, Marco Leise), $(LINK2 mailto:etienne@cimons.com, Etienne Cimon)
 * 
 * License:
 *   $(LINK2 https://mit-license.org/, GNU General Public License 3.0)
 * 
 **************************************************************************************************/
module fast.internal.helpers;

import std.traits;
import fast.internal.sysdef;

static void function(string) nothrow @safe logInfo;
static void function(string) nothrow @safe logError;

static enum isX86 = false;
static enum isAMD64 = false;
private enum 一META一PROGRAMMING一;

// 2.071 fixed visibility rules, so we need to roll our own staticIota.
static if (__VERSION__ >= 2071)
{
	import std.meta : AliasSeq;

	template staticIota(int beg, int end)
	{
		static if (beg + 1 >= end)
		{
			static if (beg >= end)
			{
				alias staticIota = AliasSeq!();
			}
			else
			{
				alias staticIota = AliasSeq!(+beg);
			}
		}
		else
		{
			enum mid = beg + (end - beg) / 2;
			alias staticIota = AliasSeq!(staticIota!(beg, mid), staticIota!(mid, end));
		}
	}
}
else
{
	import std.typecons : staticIota;
}

/**
 * For any integral type, returns the unsigned type of the same bit-width.
 */
template UnsignedOf(I) if (isIntegral!I)
{
	static if (isUnsigned!I)
		alias UnsignedOf = I;
	else static if (is(I == long))
		alias UnsignedOf = ulong;
	else static if (is(I == int))
		alias UnsignedOf = uint;
	else static if (is(I == short))
		alias UnsignedOf = ushort;
	else static if (is(I == byte))
		alias UnsignedOf = ubyte;
	else
		static assert(0, "Not implemented");
}

/**
 * Generates a mixin string for repeating code. It can be used to unroll variadic arguments.
 * A format string is instantiated a certain number times with an incrementing parameter.
 * The results are then concatenated using an optional joiner.
 *
 * Params:
 *   length = Number of elements you want to join. It is passed into format() as an incrementing number from [0 .. count$(RPAREN).
 *   fmt = The format string to apply on each instanciation. Use %1d$ to refer to the current index multiple times when necessary.
 *   joiner = Optional string that will be placed between instances. It could be a space or an arithmetic operation.
 *
 * Returns:
 *   The combined elements as a mixin string.
 *
 * See_Also:
 *   $(LINK2 http://forum.dlang.org/thread/vqfvihyezbmwcjkmpzin@forum.dlang.org, A simple way to do compile time loop unrolling)
 */
enum ctfeJoin(size_t length)(in string fmt, in string joiner = null)
{
	import std.range : iota;
	import std.algorithm : map;

	// BUG: Cannot use, join(), as it "cannot access the nested function 'ctfeJoin'".
	string result;
	foreach (inst; map!(i => format(fmt, i))(iota(length)))
	{
		if (result && joiner)
			result ~= joiner;
		result ~= inst;
	}
	return result;
}

enum getUDA(alias sym, T)()
{
	foreach (uda; __traits(getAttributes, sym))
		static if (is(typeof(uda) == T))
			return uda;
	return T.init;
}

private enum 一BIT一OPERATIONS一;

static import core.bitop;

alias bsr = core.bitop.bsr;
alias bsf = core.bitop.bsf;

/*******************************************************************************
 * 
 * Count leading zeroes.
 *
 * Params:
 *   u = the unsigned value to scan
 *
 * Returns:
 *   The number of leading zero bits before the first one bit. If `u` is `0`,
 *   the result is undefined.
 *
 **************************************/
version (DigitalMars)
{
	@safe @nogc pure nothrow U clz(U)(U u)
			if (is(Unqual!U == uint) || is(Unqual!U == size_t))
	{
		pragma(inline, true);
		enum U max = 8 * U.sizeof - 1;
		return max - bsr(u);
	}

	static if (isX86)
	{
		@safe @nogc pure nothrow uint clz(U)(U u) if (is(Unqual!U == ulong))
		{
			pragma(inline, true);
			uint hi = u >> 32;
			return hi ? 31 - bsr(hi) : 63 - bsr(cast(uint) u);
		}
	}
}
else version (GNU)
{
	import gcc.builtins;

	alias clz = __builtin_clz;
	static if (isX86)
	{
		@safe @nogc pure nothrow uint clz(ulong u)
		{
			uint hi = u >> 32;
			return hi ? __builtin_clz(hi) : 32 + __builtin_clz(cast(uint) u);
		}
	}
	else
		alias clz = __builtin_clzl;
}
else version (LDC)
{
	@safe @nogc pure nothrow U clz(U)(U u)
			if (is(Unqual!U == uint) || is(Unqual!U == size_t))
	{
		pragma(inline, true);
		import ldc.intrinsics;

		return llvm_ctlz(u, false);
	}

	static if (is(size_t == uint))
	{
		@safe @nogc pure nothrow uint clz(U)(U u) if (is(Unqual!U == ulong))
		{
			pragma(inline, true);
			import ldc.intrinsics;

			return cast(uint) llvm_ctlz(u, false);
		}
	}
}
static if (__VERSION__ < 2071)
{
	// < 2.071 did not have 64-bit bsr/bsf on x86.
	@safe @nogc pure nothrow uint bsr(U)(U u) if (is(Unqual!U == ulong))
	{
		pragma(inline, true);
		uint hi = u >> 32;
		return hi ? bsr(hi) + 32 : bsr(cast(uint) u);
	}

	@safe @nogc pure nothrow uint bsf(U)(U u) if (is(Unqual!U == ulong))
	{
		pragma(inline, true);
		uint lo = cast(uint) u;
		return lo ? bsf(lo) : 32 + bsf(u >> 32);
	}
}
unittest
{
	assert(clz(uint(0x01234567)) == 7);
	assert(clz(ulong(0x0123456701234567)) == 7);
	assert(clz(ulong(0x0000000001234567)) == 7 + 32);
	assert(bsr(uint(0x01234567)) == 24);
	assert(bsr(ulong(0x0123456701234567)) == 24 + 32);
	assert(bsr(ulong(0x0000000001234567)) == 24);
	assert(bsf(uint(0x76543210)) == 4);
	assert(bsf(ulong(0x7654321076543210)) == 4);
	assert(bsf(ulong(0x7654321000000000)) == 4 + 32);
}

private enum 一UNITTESTING一;

// Insert a dummy main when unittesting outside of dub.
version (VibeCustomMain)
{
}
else version (unittest)
	void main()
{
}

private enum 一MISCELLANEOUS一;

pure nothrow @nogc
{
	/**
	 * Aligns a pointer to the closest multiple of $(D pot) (a power of two),
	 * which is equal to or larger than $(D value).
	 */
	T* alignPtrNext(T)(scope T* ptr, in size_t pot)
	in
	{
		assert(pot > 0 && pot.isPowerOf2);
	}
	body
	{
		return cast(T*)((cast(size_t) ptr + (pot - 1)) & -pot);
	}

	unittest
	{
		assert(alignPtrNext(cast(void*) 65, 64) == cast(void*) 128);
	}
}

@nogc @safe pure nothrow
{
	/// Returns whether the (positive) argument is an integral power of two.
	@property bool isPowerOf2(in size_t n)
	in
	{
		assert(n > 0);
	}
	body
	{
		return (n & n - 1) == 0;
	}

	version (LDC)
	{
		import core.simd : ubyte16;

		pragma(LDC_intrinsic, "llvm.x86.sse2.pmovmskb.128")
		uint moveMask(ubyte16);
	}
	else version (GNU)
	{
		import gcc.builtins;

		alias moveMask = __builtin_ia32_pmovmskb128;
	}

	template SIMDFromScalar(V, alias scalar)
	{
		// This wrapper is needed for optimal performance with LDC and
		// doesn't hurt GDC's inlining.
		V SIMDFromScalar()
		{
			enum V asVectorEnum = scalar;
			return asVectorEnum;
		}
	}

}