/*
 * Legal Notice
 *
 * This document and associated source code (the "Work") is a part of a
 * benchmark specification maintained by the TPC.
 *
 * The TPC reserves all right, title, and interest to the Work as provided
 * under U.S. and international laws, including without limitation all patent
 * and trademark rights therein.
 *
 * No Warranty
 *
 * 1.1 TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE INFORMATION
 *     CONTAINED HEREIN IS PROVIDED "AS IS" AND WITH ALL FAULTS, AND THE
 *     AUTHORS AND DEVELOPERS OF THE WORK HEREBY DISCLAIM ALL OTHER
 *     WARRANTIES AND CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
 *     INCLUDING, BUT NOT LIMITED TO, ANY (IF ANY) IMPLIED WARRANTIES,
 *     DUTIES OR CONDITIONS OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
 *     PURPOSE, OF ACCURACY OR COMPLETENESS OF RESPONSES, OF RESULTS, OF
 *     WORKMANLIKE EFFORT, OF LACK OF VIRUSES, AND OF LACK OF NEGLIGENCE.
 *     ALSO, THERE IS NO WARRANTY OR CONDITION OF TITLE, QUIET ENJOYMENT,
 *     QUIET POSSESSION, CORRESPONDENCE TO DESCRIPTION OR NON-INFRINGEMENT
 *     WITH REGARD TO THE WORK.
 * 1.2 IN NO EVENT WILL ANY AUTHOR OR DEVELOPER OF THE WORK BE LIABLE TO
 *     ANY OTHER PARTY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO THE
 *     COST OF PROCURING SUBSTITUTE GOODS OR SERVICES, LOST PROFITS, LOSS
 *     OF USE, LOSS OF DATA, OR ANY INCIDENTAL, CONSEQUENTIAL, DIRECT,
 *     INDIRECT, OR SPECIAL DAMAGES WHETHER UNDER CONTRACT, TORT, WARRANTY,
 *     OR OTHERWISE, ARISING IN ANY WAY OUT OF THIS OR ANY OTHER AGREEMENT
 *     RELATING TO THE WORK, WHETHER OR NOT SUCH AUTHOR OR DEVELOPER HAD
 *     ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * Contributors
 * - Sergey Vasilevskiy, Matt Emmerton, Doug Johnson
 */

//
// Defines the entry point for the console application.
//
#include <string>

#include "main/EGenLoader_stdafx.h"
#include "input/DataFileManager.h"

using namespace TPCE;

// Driver Defaults
TIdent iStartFromCustomer = iDefaultStartFromCustomer;
TIdent iCustomerCount = iDefaultCustomerCount;      // # of customers for this instance
TIdent iTotalCustomerCount = iDefaultCustomerCount; // total number of customers in the database
UINT iLoadUnitSize = iDefaultLoadUnitSize;          // # of customers in one load unit
UINT iScaleFactor = 500;                            // # of customers for 1 tpsE
UINT iDaysOfInitialTrades = 300;

// These flags are used to control which tables get generated and loaded.
bool bTableGenerationFlagNotSpecified = true; // assume no flag is specified.
bool bGenerateFixedTables = false;
bool bGenerateGrowingTables = false;
bool bGenerateScalingTables = false;
bool bGenerateUsingCache = true;

char szInDir[iMaxPath];
#ifdef COMPILE_FLAT_FILE_LOAD
char szOutDir[iMaxPath];
FlatFileOutputModes FlatFileOutputMode;
#endif
#ifdef COMPILE_ODBC_LOAD
char szServer[iMaxHostname];
char szDB[iMaxDBName];
#endif
#if defined(COMPILE_ODBC_LOAD) || defined(COMPILE_CUSTOM_LOAD)
char szLoaderParms[1024];
#endif

#ifndef FLAT_IN_PATH
#define FLAT_IN_PATH "flat_in/"
#endif

#ifndef FLAT_OUT_PATH
#define FLAT_OUT_PATH "flat_out/"
#endif

enum eLoadImplementation {
	NULL_LOAD = 0, // no load - generate data only
	FLAT_FILE_LOAD,
	ODBC_LOAD,
	CUSTOM_LOAD // sponsor-provided load mechanism
};
#if defined(DEFAULT_LOAD_TYPE)
eLoadImplementation LoadType = DEFAULT_LOAD_TYPE;
#elif defined(COMPILE_FLAT_FILE_LOAD)
eLoadImplementation LoadType = FLAT_FILE_LOAD;
#elif defined(COMPILE_ODBC_LOAD)
eLoadImplementation LoadType = ODBC_LOAD;
#elif defined(COMPILE_CUSTOM_LOAD)
eLoadImplementation LoadType = CUSTOM_LOAD;
#else
eLoadImplementation LoadType = NULL_LOAD;
#endif

/*
 * Prints program usage to std error.
 */
void Usage() {
	fprintf(stderr, "Usage:\n");
	fprintf(stderr, "EGenLoader [options] \n\n");
	fprintf(stderr, " Where\n");
	fprintf(stderr, "  Option                       Default     Description\n");
	fprintf(stderr, "   -b number                   %" PRId64 "           Beginning customer ordinal position\n",
	        iStartFromCustomer);
	fprintf(stderr, "   -c number                   %" PRId64 "        Number of customers (for this instance)\n",
	        iCustomerCount);
	fprintf(stderr, "   -t number                   %" PRId64 "        Number of customers (total in the database)\n",
	        iTotalCustomerCount);
	fprintf(stderr,
	        "   -f number                   %d         Scale factor (customers "
	        "per 1 tpsE)\n",
	        iScaleFactor);
	fprintf(stderr,
	        "   -w number                   %d          Number of Workdays "
	        "(8-hour days) of \n",
	        iDaysOfInitialTrades);
	fprintf(stderr, "                                           initial trades "
	                "to populate\n");
	fprintf(stderr, "   -i dir                      %-11s Directory for input files\n", FLAT_IN_PATH);
	fprintf(stderr, "   -l [FLAT|ODBC|CUSTOM|NULL]  FLAT        Type of load\n");
#ifdef COMPILE_FLAT_FILE_LOAD
	fprintf(stderr, "   -m [APPEND|OVERWRITE]       OVERWRITE   Flat File output mode\n");
	fprintf(stderr, "   -o dir                      %-11s Directory for output files\n", FLAT_OUT_PATH);
#endif
#ifdef COMPILE_ODBC_LOAD
	fprintf(stderr, "   -s string                   localhost   Database server\n");
	fprintf(stderr, "   -d string                   tpce        Database name\n");
#endif
#if defined(COMPILE_ODBC_LOAD) || defined(COMPILE_CUSTOM_LOAD)
	fprintf(stderr, "   -p string                               Additional "
	                "parameters to loader\n");
#endif
	fprintf(stderr, "\n");
	fprintf(stderr, "   -x                          -x          Generate all tables\n");
	fprintf(stderr, "   -xf                                     Generate all "
	                "fixed-size tables\n");
	fprintf(stderr, "   -xd                                     Generate all "
	                "scaling and growing tables\n");
	fprintf(stderr, "                                           (equivalent to -xs -xg)\n");
	fprintf(stderr, "   -xs                                     Generate scaling tables\n");
	fprintf(stderr, "                                           (except BROKER)\n");
	fprintf(stderr, "   -xg                                     Generate "
	                "growing tables and BROKER\n");
	fprintf(stderr, "   -g                                      Disable "
	                "caching when generating growing tables\n");
}

void ParseCommandLine(int argc, char *argv[]) {
	int arg;
	char *sp;
	char *vp;

	/*
	 *  Scan the command line arguments
	 */
	for (arg = 1; arg < argc; ++arg) {

		/*
		 *  Look for a switch
		 */
		sp = argv[arg];
		if (*sp == '-') {
			++sp;
		}
		*sp = (char)tolower(*sp);

		/*
		 *  Find the switch's argument.  It is either immediately after the
		 *  switch or in the next argv
		 */
		vp = sp + 1;
		// Allow for switched that don't have any parameters.
		// Need to check that the next argument is in fact a parameter
		// and not the next switch that starts with '-'.
		//
		if ((*vp == 0) && ((arg + 1) < argc) && (argv[arg + 1][0] != '-')) {
			vp = argv[++arg];
		}

		/*
		 *  Parse the switch
		 */
		switch (*sp) {
		case 'b':
			sscanf(vp, "%" PRId64, &iStartFromCustomer);
			if (iStartFromCustomer <= 0) { // set back to default
				// either number parsing was unsuccessful
				// or a bad value was specified
				iStartFromCustomer = iDefaultStartFromCustomer;
			}
			break;
		case 'c':
			sscanf(vp, "%" PRId64, &iCustomerCount);
			break;
		case 't':
			sscanf(vp, "%" PRId64, &iTotalCustomerCount);
			break;
		case 'f':
			iScaleFactor = (UINT)atoi(vp);
			break;
		case 'w':
			iDaysOfInitialTrades = (UINT)atoi(vp);
			break;

		case 'i': // Location of input files.
			strncpy(szInDir, vp, sizeof(szInDir));
			if (('/' != szInDir[strlen(szInDir) - 1]) && ('\\' != szInDir[strlen(szInDir) - 1])) {
				strncat(szInDir, "/", sizeof(szInDir) - strlen(szInDir) - 1);
			}
			break;

		case 'l': // Load type.
#ifdef COMPILE_FLAT_FILE_LOAD
			if (0 == strcmp(vp, "FLAT")) {
				LoadType = FLAT_FILE_LOAD;
				break;
			}
#endif
#ifdef COMPILE_ODBC_LOAD
			if (0 == strcmp(vp, "ODBC")) {
				LoadType = ODBC_LOAD;
				break;
			}
#endif
			if (0 == strcmp(vp, "NULL")) {
				LoadType = NULL_LOAD;
				break;
			}
#ifdef COMPILE_CUSTOM_LOAD
			if (0 == strcmp(vp, "CUSTOM")) {
				LoadType = CUSTOM_LOAD;
				break;
			}
#endif
			Usage();
			exit(ERROR_BAD_OPTION);
			break;

#ifdef COMPILE_FLAT_FILE_LOAD
		case 'm': // Mode for output of flat files.
			if (0 == strcmp(vp, "APPEND")) {
				FlatFileOutputMode = FLAT_FILE_OUTPUT_APPEND;
			} else if (0 == strcmp(vp, "OVERWRITE")) {
				FlatFileOutputMode = FLAT_FILE_OUTPUT_OVERWRITE;
			} else {
				Usage();
				exit(ERROR_BAD_OPTION);
			}
			break;

		case 'o': // Location for output files.
			strncpy(szOutDir, vp, sizeof(szOutDir));
			if (('/' != szOutDir[strlen(szOutDir) - 1]) && ('\\' != szOutDir[strlen(szOutDir) - 1])) {
				strncat(szOutDir, "/", sizeof(szOutDir) - strlen(szOutDir) - 1);
			}
			break;
#endif
#ifdef COMPILE_ODBC_LOAD
		case 's': // Database server name.
			strncpy(szServer, vp, sizeof(szServer));
			break;

		case 'd': // Database name.
			strncpy(szDB, vp, sizeof(szDB));
			break;
#endif
#if defined(COMPILE_ODBC_LOAD) || defined(COMPILE_CUSTOM_LOAD)
		case 'p': // Loader Parameters
			strncpy(szLoaderParms, vp, sizeof(szLoaderParms));
			break;
#endif
		case 'g': // Disable Cache for Growing Tables (CTradeGen)
			bGenerateUsingCache = false;
			break;
		case 'x':                                     // Table Generation
			bTableGenerationFlagNotSpecified = false; // A -x flag has been used

			if (NULL == vp || *vp == '\0') {
				bGenerateFixedTables = true;
				bGenerateGrowingTables = true;
				bGenerateScalingTables = true;
			} else if (0 == strcmp(vp, "f")) {
				bGenerateFixedTables = true;
			} else if (0 == strcmp(vp, "g")) {
				bGenerateGrowingTables = true;
			} else if (0 == strcmp(vp, "s")) {
				bGenerateScalingTables = true;
			} else if (0 == strcmp(vp, "d")) {
				bGenerateGrowingTables = true;
				bGenerateScalingTables = true;
			} else {
				Usage();
				exit(ERROR_BAD_OPTION);
			}
			break;

		default:
			Usage();
			fprintf(stderr, "Error: Unrecognized option: %s\n", sp);
			exit(ERROR_BAD_OPTION);
		}
	}
}

/*
 * This function validates EGenLoader parameters that may have been
 * specified on the command line. It's purpose is to prevent passing of
 * parameter values that would cause the loader to produce incorrect data.
 *
 * Condition: needs to be called after ParseCommandLine.
 *
 * PARAMETERS:
 *       NONE
 *
 * RETURN:
 *       true                    - if all parameters are valid
 *       false                   - if at least one parameter is invalid
 */
bool ValidateParameters() {
	bool bRet = true;

	// Starting customer must be a non-zero integral multiple of load unit size
	// + 1.
	//
	if ((iStartFromCustomer % iLoadUnitSize) != 1) {
		cout << "The specified starting customer (-b " << iStartFromCustomer
		     << ") must be a non-zero integral multiple of the load unit size (" << iLoadUnitSize << ") + 1." << endl;

		bRet = false;
	}

	// Total number of customers in the database cannot be less
	// than the number of customers for this loader instance
	//
	if (iTotalCustomerCount < iStartFromCustomer + iCustomerCount - 1) {
		iTotalCustomerCount = iStartFromCustomer + iCustomerCount - 1;
	}

	// Customer count must be a non-zero integral multiple of load unit size.
	//
	if ((iLoadUnitSize > iCustomerCount) || (0 != iCustomerCount % iLoadUnitSize)) {
		cout << "The specified customer count (-c " << iCustomerCount
		     << ") must be a non-zero integral multiple of the load unit size (" << iLoadUnitSize << ")." << endl;

		bRet = false;
	}

	// Total customer count must be a non-zero integral multiple of load unit
	// size.
	//
	if ((iLoadUnitSize > iTotalCustomerCount) || (0 != iTotalCustomerCount % iLoadUnitSize)) {
		cout << "The total customer count (-t " << iTotalCustomerCount
		     << ") must be a non-zero integral multiple of the load unit size (" << iLoadUnitSize << ")." << endl;

		bRet = false;
	}

	// Completed trades in 8 hours must be a non-zero integral multiple of 100
	// so that exactly 1% extra trade ids can be assigned to simulate aborts.
	//
	if ((INT64)(HoursPerWorkDay * SecondsPerHour * iLoadUnitSize / iScaleFactor) % 100 != 0) {
		cout << "Incompatible value for Scale Factor (-f) specified." << endl;
		cout << HoursPerWorkDay << " * " << SecondsPerHour << " * Load Unit Size (" << iLoadUnitSize
		     << ") / Scale Factor (" << iScaleFactor << ") must be integral multiple of 100." << endl;

		bRet = false;
	}

	if (iDaysOfInitialTrades == 0) {
		cout << "The specified number of 8-Hour Workdays (-w " << (iDaysOfInitialTrades) << ") must be non-zero."
		     << endl;

		bRet = false;
	}

	return bRet;
}

/*
 *   Create loader class factory corresponding to the
 *   selected load type.
 */
CBaseLoaderFactory *CreateLoaderFactory(eLoadImplementation eLoadType) {
	switch (eLoadType) {
	case NULL_LOAD:
		return new CNullLoaderFactory();

#ifdef COMPILE_ODBC_LOAD
	case ODBC_LOAD:
		return new CODBCLoaderFactory(szServer, szDB, szLoaderParms);
#endif // #ifdef COMPILE_ODBC_LOAD

#ifdef COMPILE_FLAT_FILE_LOAD
	case FLAT_FILE_LOAD:
		return new CFlatLoaderFactory(szOutDir, FlatFileOutputMode);
#endif //#ifdef COMPILE_FLAT_FILE_LOAD

#ifdef COMPILE_CUSTOM_LOAD
	case CUSTOM_LOAD:
		return new CCustomLoaderFactory(szLoaderParms);
#endif //#ifdef COMPILE_CUSTOM_FILE_LOAD

	default:
		assert(false); // this should never happen
	}

	return NULL; // should never happen
}

int main(int argc, char *argv[]) {
	CBaseLoaderFactory *pLoaderFactory; // class factory that creates table loaders
	CGenerateAndLoadStandardOutput Output;
	CGenerateAndLoad *pGenerateAndLoad;
	CDateTime StartTime, EndTime, LoadTime; // to time the database load

	// Output EGen version
	PrintEGenVersion();

	// Establish defaults for command line options.
#ifdef COMPILE_ODBC_LOAD
	strncpy(szServer, "localhost", sizeof(szServer));
	strncpy(szDB, "tpce", sizeof(szDB));
#endif
	strncpy(szInDir, FLAT_IN_PATH, sizeof(szInDir));
#ifdef COMPILE_FLAT_FILE_LOAD
	strncpy(szOutDir, FLAT_OUT_PATH, sizeof(szOutDir));
	FlatFileOutputMode = FLAT_FILE_OUTPUT_OVERWRITE;
#endif

	// Get command line options.
	//
	ParseCommandLine(argc, argv);

	// Validate global parameters that may have been modified on
	// the command line.
	//
	if (!ValidateParameters()) {
		return ERROR_INVALID_OPTION_VALUE; // exit from the loader returning a
		                                   // non-zero code
	}

	// Let the user know what settings will be used.
	cout << endl << endl << "Using the following settings." << endl << endl;
	switch (LoadType) {
#ifdef COMPILE_ODBC_LOAD
	case ODBC_LOAD:
		cout << "\tLoad Type:\t\tODBC" << endl;
		cout << "\tServer Name:\t\t" << szServer << endl;
		cout << "\tDatabase:\t\t" << szDB << endl;
		break;
#endif
#ifdef COMPILE_FLAT_FILE_LOAD
	case FLAT_FILE_LOAD:
		cout << "\tLoad Type:\t\tFlat File" << endl;
		switch (FlatFileOutputMode) {
		case FLAT_FILE_OUTPUT_APPEND:
			cout << "\tOutput Mode:\t\tAPPEND" << endl;
			break;
		case FLAT_FILE_OUTPUT_OVERWRITE:
			cout << "\tOutput Mode:\t\tOVERWRITE" << endl;
			break;
		}
		cout << "\tOut Directory:\t\t" << szOutDir << endl;
		break;
#endif
#ifdef COMPILE_CUSTOM_LOAD
	case CUSTOM_LOAD:
		cout << "\tLoad Type:\t\tCustom" << endl;
		cout << "\tLoader Parms:\t\t" << szLoaderParms << endl;
		break;
#endif
	case NULL_LOAD:
	default:
		cout << "\tLoad Type:\t\tNull load (generation only)" << endl;
		break;
	}
	cout << "\tIn Directory:\t\t" << szInDir << endl;
	cout << "\tStart From Customer:\t" << iStartFromCustomer << endl;
	cout << "\tCustomer Count:\t\t" << iCustomerCount << endl;
	cout << "\tTotal customers:\t" << iTotalCustomerCount << endl;
	cout << "\tLoad Unit:\t\t" << iLoadUnitSize << endl;
	cout << "\tScale Factor:\t\t" << iScaleFactor << endl;
	cout << "\tInitial Trade Days:\t" << iDaysOfInitialTrades << endl;
	cout << "\tCaching Enabled:\t" << (bGenerateUsingCache ? "true" : "false") << endl;
	cout << endl << endl;

	// Know the load type => create the loader factory.
	//
	pLoaderFactory = CreateLoaderFactory(LoadType);

	try {
		// Create a unique log name for this loader instance.
		// Simultaneous loader instances are to be run with
		// disjoint customer ranges, so use this fact to
		// construct a unique name.
		//
		char szLogFileName[64];

		snprintf(&szLogFileName[0], sizeof(szLogFileName), "EGenLoaderFrom%" PRId64 "To%" PRId64 ".log",
		         iStartFromCustomer, (iStartFromCustomer + iCustomerCount) - 1);

		// Create log formatter and logger instance
		CLogFormatTab fmt;
		CEGenLogger logger(eDriverEGenLoader, 0, szLogFileName, &fmt);

		// Set up data file manager for lazy load.
		const DataFileManager dfm(std::string(szInDir), iTotalCustomerCount, iTotalCustomerCount);

		// Create the main class instance
		pGenerateAndLoad = new CGenerateAndLoad(dfm, iCustomerCount, iStartFromCustomer, iTotalCustomerCount,
		                                        iLoadUnitSize, iScaleFactor, iDaysOfInitialTrades, pLoaderFactory,
		                                        &logger, &Output, szInDir, bGenerateUsingCache);

		//  The generate and load phase starts here.
		//
		StartTime.Set();

		// Generate static tables if appropriate.
		if ((bTableGenerationFlagNotSpecified && (iStartFromCustomer == iDefaultStartFromCustomer)) ||
		    bGenerateFixedTables) {
			pGenerateAndLoad->GenerateAndLoadFixedTables();
		}

		// Generate dynamic scaling tables if appropriate.
		if (bTableGenerationFlagNotSpecified || bGenerateScalingTables) {
			pGenerateAndLoad->GenerateAndLoadScalingTables();
		}
		// Generate dynamic trade tables if appropriate.
		if (bTableGenerationFlagNotSpecified || bGenerateGrowingTables) {
			pGenerateAndLoad->GenerateAndLoadGrowingTables();
		}

		//  The generate and load phase ends here.
		//
		EndTime.Set();

		LoadTime.Set(0);                                             // clear time
		LoadTime.Add(0, (int)((EndTime - StartTime) * MsPerSecond)); // add ms

		cout << endl << "Generate and load time: " << LoadTime.ToStr(01) << endl << endl;

		delete pGenerateAndLoad; // don't really need to do that, but just for
		                         // good style
		delete pLoaderFactory;   // don't really need to do that, but just for
		                         // good style

	} catch (CBaseErr &err) {
		cout << endl << "Error " << err.ErrorNum() << ": " << err.ErrorText();
		if (err.ErrorLoc()) {
			cout << " at " << err.ErrorLoc() << endl;
		} else {
			cout << endl;
		}
		return 1;
	}
	// operator new will throw std::bad_alloc exception if there is no
	// sufficient memory for the request.
	//
	catch (std::bad_alloc &) {
		cout << endl << endl << "*** Out of memory ***" << endl;
		return 2;
	} catch (std::exception &err) {
		cout << endl << endl << "Caught Exception: " << err.what() << endl;
	} catch (...) {
		cout << endl << endl << "Caught Unknown Exception" << endl;
	}

	return 0;
}