/*  HttpReader unit test program
 *  Copyright (C) 2006   Written by VCL
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#undef NDEBUG
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <list>

#ifdef WIN32
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>
#else
	#include <unistd.h>
	#define Sleep(miliseconds) usleep(miliseconds * 1000)
#endif

#include "std-http-reader.h"
#include "mirror-http-reader.h"

using namespace std;
using namespace OpenKore;


typedef HttpReader * (*HttpReaderCreator) (const char *url);
typedef HttpReader * (*HttpReaderPostCreator) (const char *url, const char *postData, int postDataSize);

#define SMALL_TEST_URL "http://www.openkore.com/test/HttpReader.txt"
#define SMALL_TEST_CONTENT "Hello world!\n"
#define SMALL_TEST_SIZE 13
#define SMALL_TEST_CHECKSUM 2773980202U

#define LARGE_TEST_URL "http://www.openkore.com:80/test/HttpReaderLarge.txt"
#define LARGE_TEST_SIZE 74048
#define LARGE_TEST_CHECKSUM 1690026430U

#define SLOW_TEST_URL "http://kambing.vlsm.org/gnu/gcc/gcc-4.1.0/gcc-core-4.1.0.tar.bz2"

#define ERROR_URL "http://www.openkore.com/test/FileNotFound.txt"
#define INVALID_URL "http://111.111.111.111:82/"
#define INVALID_URL2 "http://www.fooooooo.com"
#define SECURE_URL "https://sourceforge.net"

#define POST_TEST_URL "http://www.openkore.com/test/TestPost.php"
#define POST_TEST_DATA "mydata=hello+world"


static HttpReader *
createStdHttpReader(const char *url) {
	return StdHttpReader::create(url);
}

static HttpReader *
createStdHttpReaderPost(const char *url, const char *postData, int postDataSize) {
	return StdHttpReader::createAndPost(url, postData, postDataSize);
}

static HttpReader *
createMirrorHttpReader(const char *url) {
	list<const char *> urls;
	urls.push_back(url);
	return new MirrorHttpReader(urls, 3000);
}


/**
 * A class for testing a HttpReader implementation.
 */
class Tester {
public:
	/**
	 * Create a new Tester object.
	 *
	 * @param creatorFunc  A function which creates a HttpReader instance.
	 * @require creatorFunc != NULL
	 */
	Tester(HttpReaderCreator creatorFunc, HttpReaderPostCreator creatorPostFunc) {
		this->createHttpReader = creatorFunc;
		this->createHttpReaderPost = creatorPostFunc;
	}

	virtual ~Tester() {}

	/** Run the unit tests. */
	void
	virtual run() {
		printf("Testing status transitions (1)...\n");
		assert( testStatusTransitions(SMALL_TEST_URL) );
		printf("Testing status transitions (2)...\n");
		assert( testStatusTransitions(LARGE_TEST_URL) );
		printf("Testing status transitions (3)...\n");
		assert( !testStatusTransitions(ERROR_URL) );
		printf("Testing status transitions (4)...\n");
		assert( testStatusTransitions(SECURE_URL) );
		printf("Testing status transitions (5)...\n");

		printf("Testing getData (1)...\n");
		assert( testGetData(SMALL_TEST_URL, SMALL_TEST_CONTENT, SMALL_TEST_SIZE) );
		printf("Testing getData (2)...\n");
		assert( testGetData(LARGE_TEST_URL, NULL, LARGE_TEST_SIZE) );
		printf("Testing getData (3)...\n");
		assert( !testGetData(ERROR_URL, NULL, 0) );
		printf("Testing getData (4)...\n");
		assert( !testGetData(INVALID_URL2, NULL, 0) );

		printf("Testing pullData (1)...\n");
		assert( testPullData(SMALL_TEST_URL, SMALL_TEST_SIZE, SMALL_TEST_CHECKSUM) );
		printf("Testing pullData (2)...\n");
		assert( testPullData(LARGE_TEST_URL, LARGE_TEST_SIZE, LARGE_TEST_CHECKSUM) );
		printf("Testing pullData (3)...\n");
		assert( !testPullData(ERROR_URL, 0, 0) );
		printf("Testing pullData (4)...\n");
		assert( !testPullData(INVALID_URL2, 0, 0) );

		if (createHttpReaderPost != NULL) {
			printf("Testing POST...\n");
			testPOST(POST_TEST_URL, POST_TEST_DATA);
		}

		printf("Testing cancellation while connecting (1)...\n");
		testConnectCancellation(INVALID_URL);
		printf("Testing cancellation while connecting (2)...\n");
		testConnectCancellation(INVALID_URL2);
		printf("Testing cancellation while downloading...\n");
		testDownloadCancellation(SLOW_TEST_URL);
	}

protected:
	/**
	 * Calculate a simple checksum of the specified data.
	 */
	unsigned int
	calcChecksum(const char *data, unsigned int len, unsigned int seed = 0) {
		for (unsigned int i = 0; i < len; i++) {
			seed = seed * 32 + data[i];
		}
		return seed;
	}

private:
	HttpReaderCreator createHttpReader;
	HttpReaderPostCreator createHttpReaderPost;

protected:
	// Test whether status transitions behave as documented.
	bool
	testStatusTransitions(const char *url) {
		HttpReader *http = createHttpReader(url);
		HttpReaderStatus status = HTTP_READER_CONNECTING;
		HttpReaderStatus oldStatus;

		do {
			oldStatus = status;
			status = http->getStatus();

			switch (oldStatus) {
			case HTTP_READER_CONNECTING:
				assert(status == HTTP_READER_CONNECTING
					|| status == HTTP_READER_DOWNLOADING
					|| status == HTTP_READER_DONE
					|| status == HTTP_READER_ERROR);
				break;
			case HTTP_READER_DOWNLOADING:
				assert(status == HTTP_READER_DOWNLOADING
					|| status == HTTP_READER_DONE
					|| status == HTTP_READER_ERROR);
				break;
			case HTTP_READER_DONE:
				assert(status == HTTP_READER_DONE);
				break;
			case HTTP_READER_ERROR:
				assert(status == HTTP_READER_ERROR);
				break;
			default:
				printf("Unknown status %d\n", (int) status);
				abort();
				break;
			};
			Sleep(10);
		} while (status != HTTP_READER_DONE && status != HTTP_READER_ERROR);

		Sleep(1000);
		if (status == HTTP_READER_DONE) {
			assert(http->getStatus() == HTTP_READER_DONE);
		} else {
			assert(http->getStatus() == HTTP_READER_ERROR);
			assert(http->getSize() == -2);
		}
		delete http;
		return status == HTTP_READER_DONE;
	}

	// Test whether getData() works
	bool
	testGetData(const char *url, const char *content, unsigned int size) {
		HttpReader *http = createHttpReader(url);
		while (http->getStatus() != HTTP_READER_DONE
		    && http->getStatus() != HTTP_READER_ERROR) {
			Sleep(10);
		}

		if (http->getStatus() != HTTP_READER_DONE) {
			assert(http->getSize() == -2);
			delete http;
			return false;
		}

		unsigned int downloadedLen = 0;
		const char *downloadedData = http->getData(downloadedLen);
		assert(downloadedLen == size);
		assert(http->getSize() == (int) size);
		if (content != NULL) {
			assert(strcmp(downloadedData, content) == 0);
		}
		delete http;
		return true;
	}

	// Test whether pullData() works
	bool
	testPullData(const char *url, unsigned int expectedSize, unsigned int expectedChecksum) {
		HttpReader *http = createHttpReader(url);
		bool result;
		unsigned int checksum = 0;
		unsigned int size = 0;
		char buffer[1024];
		int ret;
		bool done = false;

		while (http->getStatus() == HTTP_READER_CONNECTING) {
			Sleep(10);
		}
		while (!done) {
			ret = http->pullData(buffer, sizeof(buffer));
			if (ret == -1) {
				Sleep(10);

			} else if (ret > 0) {
				checksum = calcChecksum(buffer, ret, checksum);
				size += ret;

			} else if (ret == -2 || ret == 0) {
				done = true;

			} else {
				printf("pullData() returned an invalid value: %d\n", ret);
				abort();
			}
		}

		result = http->getStatus() == HTTP_READER_DONE;
		if (result) {
			assert(expectedSize == size);
			assert(expectedChecksum == checksum);
		} else {
			assert(http->getSize() == -2);
		}

		delete http;
		return result;
	}

	// Test whether cancellation while connecting works.
	void
	testConnectCancellation(const char *url) {
		HttpReader *http = createHttpReader(url);
		time_t time1, time2;

		Sleep(1000);
		assert(http->getStatus() == HTTP_READER_CONNECTING
			|| http->getStatus() == HTTP_READER_ERROR);
		time1 = time(NULL);
		delete http;
		time2 = time(NULL);
		// Verify that cancellation doesn't take more than 2 seconds
		assert(time1 + 2 > time2);
	}

	// Test whether cancellation while downloading works.
	// You must pass an URL to a large file so that download
	// takes a while to complete.
	void
	testDownloadCancellation(const char *url) {
		HttpReader *http = createHttpReader(url);
		time_t time1, time2;

		while (http->getStatus() == HTTP_READER_CONNECTING) {
			Sleep(10);
		}
		assert(http->getStatus() == HTTP_READER_DOWNLOADING);
		Sleep(1000);

		time1 = time(NULL);
		delete http;
		time2 = time(NULL);
		assert(time1 + 2 > time2);
	}

	void testPOST(const char *url, const char *data) {
		HttpReader *http = createHttpReaderPost(url, data, -1);
		while (http->getStatus() != HTTP_READER_DONE
		    && http->getStatus() != HTTP_READER_ERROR) {
			Sleep(10);
		}

		assert(http->getStatus() == HTTP_READER_DONE);

		unsigned int downloadedLen = 0;
		const char *downloadedData = http->getData(downloadedLen);
		assert(strcmp(downloadedData, "yes") == 0);
		delete http;
	}
};

/**
 * A class for testing MirrorHttpReader.
 */
class MirrorTester: public Tester {
public:
	MirrorTester() : Tester(createMirrorHttpReader, NULL) {
	}

	virtual void
	run() {
		list<const char *> urls;
		Tester::run();

		printf("Testing usage of multiple mirrors (1)...\n");
		urls.push_back(INVALID_URL);
		urls.push_back(ERROR_URL);
		urls.push_back(LARGE_TEST_URL);
		urls.push_back(SECURE_URL); // Will never be used
		assert( testMirrors(urls, LARGE_TEST_SIZE, LARGE_TEST_CHECKSUM) );

		printf("Testing usage of multiple mirrors (2)...\n");
		urls.clear();
		urls.push_back(INVALID_URL);
		urls.push_back(ERROR_URL);
		urls.push_back("http://www.gnome.org:90");
		assert( !testMirrors(urls, 0, 0) );

		printf("Testing usage of multiple mirrors (3)...\n");
		urls.clear();
		urls.push_back(SECURE_URL);
		urls.push_back(INVALID_URL); // Never used
		urls.push_back(ERROR_URL);   // ditto
		assert( testMirrors(urls, 0, 0) );

		printf("Testing getData (5)...\n");
		assert( !testGetData(INVALID_URL, NULL, 0) );

		printf("Testing pullData (5)...\n");
		assert( !testPullData(INVALID_URL, 0, 0) );
	}

private:
	bool
	testMirrors(const list<const char *> &urls, unsigned int expectedSize,
		    unsigned int expectedChecksum) {
		HttpReader *http = new MirrorHttpReader(urls, 3000);
		HttpReaderStatus status;

		status = http->getStatus();
		while (status != HTTP_READER_DONE && status != HTTP_READER_ERROR) {
			Sleep(10);
			status = http->getStatus();
		}

		if (status == HTTP_READER_DONE && expectedChecksum != 0) {
			unsigned int len, checksum;
			const char *data;

			data = http->getData(len);
			assert(len == expectedSize);
			checksum = calcChecksum(data, len);
			assert(checksum == expectedChecksum);
		}
		delete http;
		return status == HTTP_READER_DONE;
	}
};

int
main() {
	StdHttpReader::init();
	Tester *tester;

	printf("### StdHttpReader\n");
	tester = new Tester(createStdHttpReader, createStdHttpReaderPost);
	tester->run();
	delete tester;

	printf("### MirrorHttpReader\n");
	tester = new MirrorTester();
	tester->run();
	delete tester;

	return 0;
}