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

#include "../SDL_test.h"

#include "fuzzer.h"


//! context for test-specific random number generator
static RND_CTX rndContext;

Uint64
GenerateExecKey(char *runSeed, char *suiteName,
				char *testName, int iterationNumber)
{
	if(runSeed == NULL) {
		fprintf(stderr, "Error: Incorrect runSeed given to GenerateExecKey function\n");
		return -1;
	}

	if(suiteName == NULL) {
		fprintf(stderr, "Error: Incorrect suiteName given to GenerateExecKey function\n");
		return -1;
	}

	if(testName == NULL) {
		fprintf(stderr, "Error: Incorrect testName given to GenerateExecKey function\n");
		return -1;
	}

	if(iterationNumber < 0) {
		fprintf(stderr, "Error: Incorrect iteration number given to GenerateExecKey function\n");
		return -1;
	}


	// Change to itoa
	char iterationString[16];
	memset(iterationString, 0, sizeof(iterationString));
	SDL_snprintf(iterationString, sizeof(iterationString) - 1, "%d", iterationNumber);

	// combine the parameters
	const Uint32 runSeedLength = strlen(runSeed);
	const Uint32 suiteNameLength = strlen(suiteName);
	const Uint32 testNameLength = strlen(testName);
	const Uint32 iterationStringLength = strlen(iterationString);

	// size of the entire + 3 for slashes and + 1 for '\0'
	const Uint32 entireString  = runSeedLength + suiteNameLength +
							  testNameLength + iterationStringLength + 3 + 1;

	char *buffer = SDL_malloc(entireString);
	if(!buffer) {
		return -1;
	}

	SDL_snprintf(buffer, entireString, "%s/%s/%s/%d", runSeed, suiteName,
			testName, iterationNumber);

	MD5_CTX md5Context;
	utl_md5Init(&md5Context);

	utl_md5Update(&md5Context, buffer, entireString);
	utl_md5Final(&md5Context);

	SDL_free(buffer);

	const char *execKey = md5Context.digest;

	//printf("Debug: digest = %s\n", execKey);

	// Casting fixes compiler warnings
	Uint64 key = ((Uint64) execKey[8])  << 56 |
					((Uint64) execKey[9])  << 48 |
					((Uint64) execKey[10]) << 40 |
					((Uint64) execKey[11]) << 32 |
					((Uint64) execKey[12]) << 24 |
					((Uint64) execKey[13]) << 16 |
					((Uint64) execKey[14]) << 8  |
					((Uint64) execKey[15]) << 0;

	return key;
}

void
InitFuzzer(Uint64 execKey)
{
	Uint32 a = (execKey >> 32)  & 0x00000000FFFFFFFF;
	Uint32 b = execKey & 0x00000000FFFFFFFF;

	//printf("Debug: execKey: %llx\n", execKey);
	//printf("Debug: a = %x - b = %x\n", a, b);

	utl_randomInit(&rndContext, a, b);
}

void
DeinitFuzzer()
{

}

Sint32
RandomInteger()
{
	return utl_randomInt(&rndContext);
}

Uint32
RandomPositiveInteger()
{
	return utl_randomInt(&rndContext);
}

Sint32
RandomIntegerInRange(Sint32 pMin, Sint32 pMax)
{
	Sint64 min = (Sint64) pMin, max = (Sint64) pMax;

	if(min > max) {
		Sint64 temp = min;
		min = max;
		max = temp;
	} else if(min == max) {
		return min;
	}

	Sint32 number = abs(utl_randomInt(&rndContext));

	return (number % ((max + 1) - min)) + min;
}

/*!
 * Generates boundary values between the given boundaries.
 * Boundary values are inclusive. See the examples below.
 * If boundary2 < boundary1, the values are swapped.
 * If boundary1 == boundary2, value of boundary1 will be returned
 *
 * Generating boundary values for Uint8:
 * BoundaryValues(sizeof(Uint8), 10, 20, True) -> [10,11,19,20]
 * BoundaryValues(sizeof(Uint8), 10, 20, False) -> [9,21]
 * BoundaryValues(sizeof(Uint8), 0, 15, True) -> [0, 1, 14, 15]
 * BoundaryValues(sizeof(Uint8), 0, 15, False) -> [16]
 * BoundaryValues(sizeof(Uint8), 0, 255, False) -> NULL
 *
 * Generator works the same for other types of unsigned integers.
 *
 * \param maxValue The biggest value that is acceptable for this data type.
 * 					For instance, for Uint8 -> 255, Uint16 -> 65536 etc.
 * \param pBoundary1 defines lower boundary
 * \param pBoundary2 defines upper boundary
 * \param validDomain Generate only for valid domain (for the data type)
 *
 * \param outBuffer The generated boundary values are put here
 * \param outBufferSize Size of outBuffer
 *
 * \returns NULL on error, outBuffer on success
 */
Uint64 *
GenerateUnsignedBoundaryValues(const Uint64 maxValue,
					Uint64 pBoundary1, Uint64 pBoundary2, SDL_bool validDomain,
					Uint64 *outBuffer, Uint32 *outBufferSize)
{
	Uint64 boundary1 = pBoundary1, boundary2 = pBoundary2;

	if(outBuffer != NULL) {
		SDL_free(outBuffer);
	}

	if(boundary1 > boundary2) {
		Uint64 temp = boundary1;
		boundary1 = boundary2;
		boundary2 = temp;
	}

	Uint64 tempBuf[8];
	memset(tempBuf, 0, 8 * sizeof(Uint64));

	Uint64 index = 0;

	if(boundary1 == boundary2) {
		tempBuf[index++] = boundary1;
	}
	else if(validDomain) {
		tempBuf[index++] = boundary1;

		if(boundary1 < UINT64_MAX)
			tempBuf[index++] = boundary1 + 1;

		tempBuf[index++] = boundary2 - 1;
		tempBuf[index++] = boundary2;
	}
	else {
		if(boundary1 > 0) {
			tempBuf[index++] = boundary1 - 1;
		}

		if(boundary2 < maxValue && boundary2 < UINT64_MAX) {
			tempBuf[index++] = boundary2 + 1;
		}
	}

	if(index == 0) {
		// There are no valid boundaries
		return NULL;
	}

	// Create the return buffer
	outBuffer = SDL_malloc(index * sizeof(Uint64));
	if(outBuffer == NULL) {
		return NULL;
	}

	SDL_memcpy(outBuffer, tempBuf, index * sizeof(Uint64));

	*outBufferSize = index;

	return outBuffer;
}

Uint8
RandomUint8BoundaryValue(Uint8 boundary1, Uint8 boundary2, SDL_bool validDomain)
{
	Uint64 *buffer = NULL;
	Uint32 size;

	// max value for Uint8
	const Uint64 maxValue = UINT8_MAX;

	buffer = GenerateUnsignedBoundaryValues(maxValue,
										(Uint64) boundary1, (Uint64) boundary2,
										validDomain, buffer, &size);
	if(buffer == NULL) {
		return -1; // Change to some better error value? What would be better?
	}

	Uint32 index = RandomInteger() % size;
	Uint8 retVal = (Uint8) buffer[index];

	SDL_free(buffer);

	return retVal;
}

Uint16
RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL_bool validDomain)
{
	Uint64 *buffer = NULL;
	Uint32 size;

	// max value for Uint16
	const Uint64 maxValue = UINT16_MAX;

	buffer = GenerateUnsignedBoundaryValues(maxValue,
										(Uint64) boundary1, (Uint64) boundary2,
										validDomain, buffer, &size);
	if(buffer == NULL) {
		return -1; // Change to some better error value? What would be better?
	}

	Uint32 index = RandomInteger() % size;
	Uint16 retVal = (Uint16) buffer[index];

	SDL_free(buffer);

	return retVal;
}

Uint32
RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL_bool validDomain)
{
	Uint64 *buffer = NULL;
	Uint32 size;

	// max value for Uint32
	const Uint64 maxValue = UINT32_MAX;

	buffer = GenerateUnsignedBoundaryValues(maxValue,
										(Uint64) boundary1, (Uint64) boundary2,
										validDomain, buffer, &size);
	if(buffer == NULL) {
		return -1; // Change to some better error value? What would be better?
	}

	Uint32 index = RandomInteger() % size;
	Uint32 retVal = (Uint32) buffer[index];

	SDL_free(buffer);

	return retVal;
}

Uint64
RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain)
{
	Uint64 *buffer = NULL;
	Uint32 size;

	// max value for Uint64
	const Uint64 maxValue = UINT64_MAX;

	buffer = GenerateUnsignedBoundaryValues(maxValue,
										(Uint64) boundary1, (Uint64) boundary2,
										validDomain, buffer, &size);
	if(buffer == NULL) {
		return -1; // Change to some better error value? What would be better?
	}

	Uint32 index = RandomInteger() % size;
	Uint64 retVal = (Uint64) buffer[index];

	SDL_free(buffer);

	return retVal;
}

Sint8
RandomSint8BoundaryValue()
{
	int value = 0; //GenerateBoundaryValueForSize(8);

	return (RandomPositiveInteger() % 2 == 0 ? value : -value);
}

char *
RandomAsciiString()
{
	return RandomAsciiStringWithMaximumLength(255);
}

char *
RandomAsciiStringWithMaximumLength(int maxSize)
{
	if(maxSize < 0) {
		return NULL;
	}

	int size = abs(RandomInteger()) % maxSize;
	char *string = SDL_malloc(size * sizeof(size));

	int counter = 0;
	for( ; counter < size; ++counter) {
		string[counter] = (char) RandomIntegerInRange(1, 127);
	}

	string[counter] = '\0';

	return string;
}