#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <random>

#include "ParallelSearch.hpp"
#include "TestRunner.hpp"
#include "Parameters.hpp"

// Type of our hay stack: a list of strings
typedef std::vector<std::string> WordList;

typedef ParallelSearch<WordList::const_iterator> ParallelWordSearch;

void create_testdata(WordList& words)
{
	const char start = 'A';
	const char end = 'Z';
	char str[4] = { 'A', 'A', 'A', 'A' };

	for (str[0] = start; str[0] <= end; str[0]++)
		for (str[1] = start; str[1] <= end; str[1]++)
			for (str[2] = start; str[2] <= end; str[2]++)
				for (str[3] = start; str[3] <= end; str[3]++)
				{
					words.push_back(std::string(str, 4));
				}

}

void shuffle_testdata(WordList& words)
{
	auto rng = std::default_random_engine{};
	std::shuffle(words.begin(), words.end(), rng);
}

void run_wordsearch(ParallelWordSearch& search)
{
	search.run();
}

bool check_result(const WordList& haystack, const std::string& pattern, const ParallelWordSearch::ResultList& result)
{
	bool result_is_valid = true;

	// check number of matches
	const unsigned TESTPATTERN_LENGTH = 4;
	unsigned expected_count = static_cast<unsigned>(pow(26.0, double(TESTPATTERN_LENGTH - pattern.size())));
	std::cout << "number of matches expected: " << expected_count << " got: " << result.size() << " --> ";
	if (result.size() == expected_count)
	{
		std::cout << "OK" << std::endl;
	}
	else
	{
		std::cout << "ERROR" << std::endl;
		result_is_valid = false;
	}

	// verify matches contain the search-pattern
	unsigned valid_count = 0;
	for (WordList::const_iterator itr : result)
	{
		if (itr->substr(0, pattern.size()) == pattern)
		{
			valid_count++;
		}
		else
		{
			std::cout << "found mismatch: " << *itr << std::endl;
			result_is_valid = false;
		}
	}

	std::cout << "verified " << valid_count << " matches --> " << ((result.size() == valid_count) ? "OK" : "ERROR") << std::endl;
}

int main(int argc, char** argv)
{
	Parameters parameters;
	double time_span;
	WordList test_data;

	std::cout << "ParallelSearch Demo" << std::endl << std::endl;

	if (false == parameters.parseCmdLine(argc, argv))
	{
		parameters.show_usage(argv[0]);
		exit(1);
	}

	std::cout << "Workercount:     " << parameters.WorkerCount() << std::endl;
	std::cout << "Search pattern:  " << parameters.SearchPattern() << std::endl;
	std::cout << std::endl;

	time_span = TestRunner(create_testdata, test_data);
	std::cout << "created test_data (" << test_data.size() << " words) in " << time_span << " seconds" << std::endl;
	
	time_span = TestRunner(shuffle_testdata, test_data);
	std::cout << "shuffled test_data in " << time_span << " seconds" << std::endl;

	ParallelWordSearch wordSearch(1, test_data.begin(), test_data.end(), parameters.SearchPattern());

	time_span = TestRunner(run_wordsearch, wordSearch);
	std::cout << "linear search found " << wordSearch.get_result().size() << " matches in " << time_span << " seconds" << std::endl;
	
	ParallelWordSearch parallelWordSearch(parameters.WorkerCount(), test_data.begin(), test_data.end(), parameters.SearchPattern());
	time_span = TestRunner(run_wordsearch, parallelWordSearch);
	std::cout << "parallel search found " << parallelWordSearch.get_result().size() << " matches in " << time_span << " seconds" << std::endl;
	
	std::cout << std::endl;
	std::cout << "checking result of parallel search ..." << std::endl;
	bool result_valid = check_result(test_data, parameters.SearchPattern(), parallelWordSearch.get_result());

	std::cout << std::endl << "Result is " << (result_valid ? "VALID" : "INVALID") << std::endl;
	std::cout << std::endl;
	
	return 0;
}