/*
 * 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
 * - Doug Johnson
 */

/*
 *   Class representing the Customer Accounts table.
 */
#ifndef CUSTOMER_ACCOUNTS_AND_PERMISSIONS_TABLE_H
#define CUSTOMER_ACCOUNTS_AND_PERMISSIONS_TABLE_H

#include "EGenTables_common.h"
#include "CustomerTable.h"
#include "AddressTable.h"

#include "input/DataFileManager.h"

namespace TPCE {
const UINT iMaxCAPerms = 3; // maximum # of customers having permissions to the same account
const UINT iMinAccountsPerCustRange[3] = {1, 2, 5};
const UINT iMaxAccountsPerCustRange[3] = {4, 8, 10};
const UINT iMaxAccountsPerCust = 10; // must be the biggest number in iMaxAccountsPerCustRange array
const TIdent iStartingBrokerID = 1;

//  This is the fixed range from which person ids (like CIDs) are selected
//  for the *additional* permissions on the account that make the
//  content of ACCOUNT_PERMISSION table.
//
//  The range is fixed for any size database in order for the parallel loaders
//  to select person ids the same way and be compatible with runtime driver
//  (and to avoid database size parameter to the loader executable).
//
const TIdent iAccountPermissionIDRange = INT64_CONST(4024) * 1024 * 1024 - iDefaultStartFromCustomer;

const UINT iPercentAccountsWithPositiveInitialBalance = 80;

const double fAccountInitialPositiveBalanceMax = 9999999.99;
const double fAccountInitialNegativeBalanceMin = -9999999.99;

const UINT iPercentAccountAdditionalPermissions_0 = 60;
const UINT iPercentAccountAdditionalPermissions_1 = 38;
const UINT iPercentAccountAdditionalPermissions_2 = 2;

const UINT iPercentAccountTaxStatusNonTaxable = 20;
const UINT iPercentAccountTaxStatusTaxableAndWithhold = 50;
const UINT iPercentAccountTaxStatusTaxableAndDontWithhold = 30;

// Number of RNG calls to skip for one row in order
// to not use any of the random values from the previous row.
const UINT iRNGSkipOneRowCustomerAccount = 10; // real max count in v3.5: 7

enum eTaxStatus { eNone = -1, eNonTaxable = 0, eTaxableAndWithhold, eTaxableAndDontWithhold };

typedef struct CUSTOMER_ACCOUNT_AND_PERMISSION_ROW {
	CUSTOMER_ACCOUNT_ROW m_ca;
	ACCOUNT_PERMISSION_ROW m_perm[iMaxCAPerms + 1];
} * PCUSTOMER_ACCOUNT_AND_PERMISSION_ROW;

class CCustomerAccountsAndPermissionsTable : public TableTemplate<CUSTOMER_ACCOUNT_AND_PERMISSION_ROW> {
	const TaxableAccountNameDataFile_t &m_TaxableAccountName;
	const NonTaxableAccountNameDataFile_t &m_NonTaxableAccountName;
	TIdent m_iStartFromCustomer;
	TIdent m_iCustomerCount;
	TIdent m_iStartingCA_ID;      // first CA_ID for the current customer
	UINT m_iRowsToGenForCust;     // total # of rows to generate for a given
	                              // portfolio
	UINT m_iRowsGeneratedForCust; // rows already generated for a particular
	                              // portfolio
	CCustomerTable m_cust;
	CPerson m_person;
	UINT m_iPermsForCA;
	TIdent m_iBrokersCount;
	CAddressTable m_addr; // ADDRESS table - to calculate tax for TRADE
	UINT m_iLoadUnitSize;
	CCustomerSelection m_CustomerSelection;
	bool m_bCacheEnabled;
	int m_iCacheSizeNA;
	TIdent m_iCacheOffsetNA;
	UINT *m_CacheNA;
	int m_iCacheSizeTS;
	TIdent m_iCacheOffsetTS;
	eTaxStatus *m_CacheTS;

	/*
	 *   Generate only the Customer Account row.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           none.
	 */
	void GenerateCARow() {
		int iAcctType;

		// Generate customer account row.
		//
		GenerateNextCA_AD();

		m_row.m_ca.CA_C_ID = GetCurrentC_ID(); // get from CUSTOMER

		// Generate broker id.
		m_row.m_ca.CA_B_ID = GenerateBrokerIdForAccount(m_row.m_ca.CA_ID);

		// Generate tax status and account name.
		if ((m_row.m_ca.CA_TAX_ST = (char)GetAccountTaxStatus(m_row.m_ca.CA_ID)) ==
		    eNonTaxable) {                                                      // non-taxable account
			iAcctType = (int)m_row.m_ca.CA_ID % m_NonTaxableAccountName.size(); // select account type

			snprintf(m_row.m_ca.CA_NAME, sizeof(m_row.m_ca.CA_NAME), "%s %s %s",
			         m_person.GetFirstName(m_row.m_ca.CA_C_ID).c_str(),
			         m_person.GetLastName(m_row.m_ca.CA_C_ID).c_str(), m_NonTaxableAccountName[iAcctType].NAME_CSTR());
		} else {                                                             // taxable account
			iAcctType = (int)m_row.m_ca.CA_ID % m_TaxableAccountName.size(); // select account type

			snprintf(m_row.m_ca.CA_NAME, sizeof(m_row.m_ca.CA_NAME), "%s %s %s",
			         m_person.GetFirstName(m_row.m_ca.CA_C_ID).c_str(),
			         m_person.GetLastName(m_row.m_ca.CA_C_ID).c_str(), m_TaxableAccountName[iAcctType].NAME_CSTR());
		}

		if (m_rnd.RndPercent(iPercentAccountsWithPositiveInitialBalance)) {
			m_row.m_ca.CA_BAL = m_rnd.RndDoubleIncrRange(0.00, fAccountInitialPositiveBalanceMax, 0.01);
		} else {
			m_row.m_ca.CA_BAL = m_rnd.RndDoubleIncrRange(fAccountInitialNegativeBalanceMin, 0.00, 0.01);
		}
	}

	/*
	 *   Helper function to generate parts of an ACCOUNT_PERMISSION row.
	 *
	 *   PARAMETERS:
	 *           IN  CA_ID       - customer account id
	 *           IN  C_ID        - customer id
	 *           IN  szACL       - Access-Control-List string on the account
	 *           OUT row         - ACCOUNT_PERMISSION row structure to fill
	 *
	 *   RETURNS:
	 *             none.
	 */
	void FillAPRow(TIdent CA_ID, TIdent C_ID, const char *szACL, ACCOUNT_PERMISSION_ROW &row) {
		row.AP_CA_ID = CA_ID;
		m_cust.GetC_TAX_ID(C_ID, row.AP_TAX_ID);
		strncpy(row.AP_L_NAME, m_person.GetLastName(C_ID).c_str(), sizeof(row.AP_L_NAME));
		strncpy(row.AP_F_NAME, m_person.GetFirstName(C_ID).c_str(), sizeof(row.AP_F_NAME));
		strncpy(row.AP_ACL, szACL, sizeof(row.AP_ACL));
	}

	/*
	 *   Generate only the Account Permissions row(s).
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           none.
	 */
	void GenerateAPRows() {
		int iAdditionalPerms;
		TIdent CID_1, CID_2;

		// Generate account permissions rows.

		// Generate the owner row
		FillAPRow(m_row.m_ca.CA_ID, m_row.m_ca.CA_C_ID, "0000", m_row.m_perm[0]);

		iAdditionalPerms = GetNumPermsForCA(m_row.m_ca.CA_ID);
		switch (iAdditionalPerms) {
		case 0:
			m_iPermsForCA = 1; // 60%
			break;
		case 1:
			GetCIDsForPermissions(m_row.m_ca.CA_ID, m_row.m_ca.CA_C_ID, &CID_1, NULL);
			m_iPermsForCA = 2; // 38%
			// generate second account permission row
			FillAPRow(m_row.m_ca.CA_ID, CID_1, "0001", m_row.m_perm[1]);
			break;
		case 2:
			GetCIDsForPermissions(m_row.m_ca.CA_ID, m_row.m_ca.CA_C_ID, &CID_1, &CID_2);
			m_iPermsForCA = 3; // 2%
			// generate second account permission row
			FillAPRow(m_row.m_ca.CA_ID, CID_1, "0001", m_row.m_perm[1]);
			// generate third account permission row
			FillAPRow(m_row.m_ca.CA_ID, CID_2, "0011", m_row.m_perm[2]);
			break;
		}
	}

public:
	/*
	 *  Constructor.
	 *
	 *  PARAMETERS:
	 *       IN  dfm                     - input flat files loaded in memory
	 *       IN  iLoadUnitSize           - should always be 1000
	 *       IN  iCustomerCount          - number of customers to generate
	 *       IN  iStartFromCustomer      - ordinal position of the first
	 * customer in the sequence (Note: 1-based)
	 *
	 *  RETURNS:
	 *       not applicable.
	 */
	CCustomerAccountsAndPermissionsTable(const DataFileManager &dfm,
	                                     UINT iLoadUnitSize, // # of customers in one load unit
	                                     TIdent iCustomerCount, TIdent iStartFromCustomer, bool bCacheEnabled = false)
	    : TableTemplate<CUSTOMER_ACCOUNT_AND_PERMISSION_ROW>(), m_TaxableAccountName(dfm.TaxableAccountNameDataFile()),
	      m_NonTaxableAccountName(dfm.NonTaxableAccountNameDataFile()), m_iStartFromCustomer(iStartFromCustomer),
	      m_iCustomerCount(iCustomerCount), m_iRowsToGenForCust(0), m_iRowsGeneratedForCust(0),
	      m_cust(dfm, iCustomerCount, iStartFromCustomer), m_person(dfm, iStartFromCustomer, bCacheEnabled),
	      m_iPermsForCA(0), m_iBrokersCount(iLoadUnitSize / iBrokersDiv),
	      m_addr(dfm, iCustomerCount, iStartFromCustomer, bCacheEnabled), m_iLoadUnitSize(iLoadUnitSize),
	      m_bCacheEnabled(bCacheEnabled) {
		if (m_bCacheEnabled) {
			m_iCacheSizeNA = iDefaultLoadUnitSize;
			m_iCacheOffsetNA = iStartFromCustomer + iTIdentShift;
			m_CacheNA = new UINT[m_iCacheSizeNA];
			for (int i = 0; i < m_iCacheSizeNA; i++) {
				m_CacheNA[i] = 0;
			}

			m_iCacheSizeTS = iDefaultLoadUnitSize * iMaxAccountsPerCust;
			m_iCacheOffsetTS = ((iStartFromCustomer - 1) + iTIdentShift) * iMaxAccountsPerCust;
			m_CacheTS = new eTaxStatus[m_iCacheSizeTS];
			for (int i = 0; i < m_iCacheSizeTS; i++) {
				m_CacheTS[i] = eNone;
			}
		}
	};

	/*
	 *  Destructor.
	 */
	~CCustomerAccountsAndPermissionsTable() {
		if (m_bCacheEnabled) {
			delete[] m_CacheNA;
			delete[] m_CacheTS;
		}
	};

	/*
	 *   Reset the state for the next load unit.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           none.
	 */
	void InitNextLoadUnit() {
		m_rnd.SetSeed(m_rnd.RndNthElement(
		    RNGSeedTableDefault, (RNGSEED)(GetCurrentC_ID() * iMaxAccountsPerCust * iRNGSkipOneRowCustomerAccount)));

		ClearRecord(); // this is needed for EGenTest to work

		if (m_bCacheEnabled) {
			m_iCacheOffsetNA += iDefaultLoadUnitSize;
			for (int i = 0; i < m_iCacheSizeNA; i++) {
				m_CacheNA[i] = 0;
			}
			m_iCacheOffsetTS += iDefaultLoadUnitSize * iMaxAccountsPerCust;
			for (int i = 0; i < m_iCacheSizeTS; i++) {
				m_CacheTS[i] = eNone;
			}
		}
	}

	/*
	 *   Generate the number of accounts for a given customer id.
	 *
	 *   PARAMETERS:
	 *           IN  CID             - customer id
	 *           IN  iCustomerTier   - customer tier (indicating trading
	 * frequency)
	 *
	 *   RETURNS:
	 *       number of accounts
	 */
	UINT GetNumberOfAccounts(TIdent CID, eCustomerTier iCustomerTier) {
		UINT iNumAccounts = 0;

		// We will sometimes get CID values that are outside the current
		// load unit (cached range).  We need to check for this case
		// and avoid the lookup (as we will segfault or get bogus data.)
		TIdent index = CID - m_iCacheOffsetNA;
		bool bCheckCache = (index >= 0 && index < m_iCacheSizeNA);
		if (m_bCacheEnabled && bCheckCache) {
			iNumAccounts = m_CacheNA[index];
		}

		if (iNumAccounts == 0) {
			UINT iMinAccountCount;
			UINT iMod;
			UINT iInverseCID;

			iMinAccountCount = iMinAccountsPerCustRange[iCustomerTier - eCustomerTierOne];
			iMod = iMaxAccountsPerCustRange[iCustomerTier - eCustomerTierOne] - iMinAccountCount + 1;
			iInverseCID = m_CustomerSelection.GetInverseCID(CID);

			// Note: the calculations below assume load unit contains 1000
			// customers.
			//
			if (iInverseCID < 200) // Tier 1
			{
				iNumAccounts = (iInverseCID % iMod) + iMinAccountCount;
			} else {
				if (iInverseCID < 800) // Tier 2
				{
					iNumAccounts = ((iInverseCID - 200 + 1) % iMod) + iMinAccountCount;
				} else // Tier 3
				{
					iNumAccounts = ((iInverseCID - 800 + 2) % iMod) + iMinAccountCount;
				}
			}

			if (m_bCacheEnabled && bCheckCache) {
				m_CacheNA[index] = iNumAccounts;
			}
		}
		return iNumAccounts;
	}

	/*
	 *   Generate a random account for the specified customer.
	 *   The distribution is uniform across all the accounts for the customer.
	 *
	 *   PARAMETERS:
	 *           IN  RND                 - external Random Number Generator
	 *           IN  iCustomerId         - customer id
	 *           IN  iCustomerTier       - customer tier (indicating trading
	 * frequency) OUT piCustomerAccount   - customer account id OUT
	 * piAccountCount      - total number of accounts that the customer has
	 *
	 *   RETURNS:
	 *           none.
	 */
	void GenerateRandomAccountId(CRandom &RND,                // in - external RNG
	                             TIdent iCustomerId,          // in
	                             eCustomerTier iCustomerTier, // in
	                             TIdent *piCustomerAccount,   // out
	                             int *piAccountCount)         // out
	{
		TIdent iCustomerAccount;
		int iAccountCount;
		TIdent iStartingAccount;

		iAccountCount = GetNumberOfAccounts(iCustomerId, iCustomerTier);

		iStartingAccount = GetStartingCA_ID(iCustomerId);

		// Select random account for the customer
		//
		iCustomerAccount = RND.RndInt64Range(iStartingAccount, iStartingAccount + iAccountCount - 1);

		if (piCustomerAccount != NULL) {
			*piCustomerAccount = iCustomerAccount;
		}

		if (piAccountCount != NULL) {
			*piAccountCount = iAccountCount;
		}
	}

	/*
	 *   Generate a random account for the specified customer.
	 *
	 *   PARAMETERS:
	 *           IN  RND                 - external Random Number Generator
	 *           IN  iCustomerId         - customer id
	 *           IN  iCustomerTier       - customer tier (indicating trading
	 * frequency)
	 *
	 *   RETURNS:
	 *           customer account id.
	 */
	TIdent GenerateRandomAccountId(CRandom &RND, TIdent iCustomerId, eCustomerTier iCustomerTier) {
		TIdent iAccountOffset;
		INT32 iAccountCount;
		TIdent iStartingAccount;

		iAccountCount = GetNumberOfAccounts(iCustomerId, iCustomerTier);

		iStartingAccount = GetStartingCA_ID(iCustomerId);

		iAccountOffset = (TIdent)RND.RndInt64Range(0, (INT64)iAccountCount - 1);

		return (iStartingAccount + iAccountOffset);
	}

	/*
	 *   Get starting account id for a given customer id.
	 *   This is needed for the driver to know what account ids belong to a
	 * given customer.
	 *
	 *   PARAMETERS:
	 *           IN  CID         - customer id
	 *
	 *   RETURNS:
	 *           first account id of the customer.
	 */
	TIdent GetStartingCA_ID(TIdent CID) {
		// start account ids on the next boundary for the new customer
		return ((CID - 1) * iMaxAccountsPerCust + 1);
	}

	/*
	 *   Get (maximum potential) ending account id for a given customer id.
	 *   This is needed for the driver to restrict query results to active
	 * accounts.
	 *
	 *   PARAMETERS:
	 *           IN  CID         - customer id
	 *
	 *   RETURNS:
	 *           last account id of the customer.
	 */
	TIdent GetEndingCA_ID(TIdent CID) {
		return (CID + iTIdentShift) * iMaxAccountsPerCust;
	}

	/*
	 *   Generate next CA_ID and update state information.
	 *   It is stored in the internal record structure and also returned.
	 *   The number of rows generated is incremented. This is why
	 *   this function cannot be called more than once for a record.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           next account id of the customer.
	 */
	TIdent GenerateNextCA_AD() {
		if (GetCurrentC_ID() % iDefaultLoadUnitSize == 0) {
			InitNextLoadUnit();
		}

		++m_iLastRowNumber;

		if (m_iRowsGeneratedForCust == m_iRowsToGenForCust) { // select next customer id as all the rows
			                                                  // for this customer have been generated
			m_cust.GenerateNextC_ID();
			m_addr.GenerateNextAD_ID();  // next address id (to get the one for
			                             // this customer)
			m_iRowsGeneratedForCust = 0; // no row generated yet
			// total # of accounts for this customer
			m_iRowsToGenForCust =
			    GetNumberOfAccounts(m_cust.GetCurrentC_ID(), m_cust.GetC_TIER(m_cust.GetCurrentC_ID()));

			m_iStartingCA_ID = GetStartingCA_ID(m_cust.GetCurrentC_ID());
		}

		m_row.m_ca.CA_ID = m_iStartingCA_ID + m_iRowsGeneratedForCust;

		++m_iRowsGeneratedForCust;

		// store state info
		m_bMoreRecords = m_cust.MoreRecords() || m_iRowsGeneratedForCust < m_iRowsToGenForCust;

		return m_row.m_ca.CA_ID;
	}

	/*
	 *   Generate the number (0-2) of additional permission rows for a certain
	 * account. This number is needed by the driver.
	 *
	 *   PARAMETERS:
	 *           IN  CA_ID       - customer account id
	 *
	 *   RETURNS:
	 *           number of ACCOUNT_PERMISSION rows.
	 */
	int GetNumPermsForCA(TIdent CA_ID) {
		RNGSEED OldSeed;
		UINT iThreshold;
		UINT iNumberOfPermissions;

		OldSeed = m_rnd.GetSeed();

		m_rnd.SetSeed(m_rnd.RndNthElement(RNGSeedBaseNumberOfAccountPermissions, (RNGSEED)CA_ID));

		iThreshold = m_rnd.RndGenerateIntegerPercentage();

		if (iThreshold <= iPercentAccountAdditionalPermissions_0) {
			iNumberOfPermissions = 0; // 60% of accounts have just the owner row permissions
		} else {
			if (iThreshold <= iPercentAccountAdditionalPermissions_0 + iPercentAccountAdditionalPermissions_1) {
				iNumberOfPermissions = 1; // 38% of accounts have one additional permisison row
			} else {
				iNumberOfPermissions = 2; // 2% of accounts have two additional permission rows
			}
		}

		m_rnd.SetSeed(OldSeed);
		return (iNumberOfPermissions);
	}

	/*
	 *   Generate customer ids for ACCOUNT_PERMISSION table for a given account
	 * id. Driver needs to know what those customer ids are based on the account
	 * id.
	 *
	 *   PARAMETERS:
	 *           IN  CA_ID       - customer account id
	 *           IN  Owner_CID   - customer id of the account owner
	 *           OUT CID_1       - first customer id in the ACL list of the
	 * account OUT CID_2       - second customer id in the ACL list of the
	 * account
	 *
	 *   RETURNS:
	 *           none.
	 */
	void GetCIDsForPermissions(TIdent CA_ID, TIdent Owner_CID, TIdent *CID_1, TIdent *CID_2) {
		RNGSEED OldSeed;

		if (CID_1 == NULL)
			return;

		OldSeed = m_rnd.GetSeed();
		m_rnd.SetSeed(m_rnd.RndNthElement(RNGSeedBaseCIDForPermission1, (RNGSEED)CA_ID));

		// Select from a fixed range that doesn't depend on the number of
		// customers in the database. This allows not to specify the total
		// number of customers to EGenLoader, only how many a particular
		// instance needs to generate (may be a fraction of total). Note: this
		// is not implemented right now.
		*CID_1 = m_rnd.RndInt64RangeExclude(iDefaultStartFromCustomer,
		                                    iDefaultStartFromCustomer + iAccountPermissionIDRange, Owner_CID);

		if (CID_2 != NULL) {
			// NOTE: Reseeding the RNG here for the second CID value. The use of
			// this sequence is fuzzy because the number of RNG values consumed
			// is dependant on not only the CA_ID, but also the CID value chosen
			// above for the first permission. Using a different sequence here
			// may help prevent potential overlaps that might occur if the same
			// sequence from above were used.
			m_rnd.SetSeed(m_rnd.RndNthElement(RNGSeedBaseCIDForPermission2, (RNGSEED)CA_ID));
			do // make sure the second id is different from the first
			{
				*CID_2 = m_rnd.RndInt64RangeExclude(iDefaultStartFromCustomer,
				                                    iDefaultStartFromCustomer + iAccountPermissionIDRange, Owner_CID);
			} while (*CID_2 == *CID_1);
		}

		m_rnd.SetSeed(OldSeed);
	}

	/*
	 *   Generate tax id for a given CA_ID.
	 *   This is needed to calculate tax on sale proceeds for the TRADE table.
	 *
	 *   PARAMETERS:
	 *           IN  iCA_ID      - customer account id
	 *
	 *   RETURNS:
	 *           tax status for the account.
	 */
	eTaxStatus GetAccountTaxStatus(TIdent iCA_ID) {
		eTaxStatus eCATaxStatus = eNone;

		// We will sometimes get CA values that are outside the current
		// load unit (cached range).  We need to check for this case
		// and avoid the lookup (as we will segfault or get bogus data.)
		TIdent index = iCA_ID - m_iCacheOffsetTS;
		bool bCheckCache = (index >= 0 && index < m_iCacheSizeTS);
		if (m_bCacheEnabled && bCheckCache) {
			eCATaxStatus = m_CacheTS[index];
		}

		if (eCATaxStatus == eNone) {
			RNGSEED OldSeed;
			UINT iThreshold;

			OldSeed = m_rnd.GetSeed();

			m_rnd.SetSeed(m_rnd.RndNthElement(RNGSeedBaseAccountTaxStatus, (RNGSEED)iCA_ID));

			iThreshold = m_rnd.RndGenerateIntegerPercentage();
			if (iThreshold <= iPercentAccountTaxStatusNonTaxable) {
				eCATaxStatus = eNonTaxable;
			} else {
				if (iThreshold <= iPercentAccountTaxStatusNonTaxable + iPercentAccountTaxStatusTaxableAndWithhold) {
					eCATaxStatus = eTaxableAndWithhold;
				} else {
					eCATaxStatus = eTaxableAndDontWithhold;
				}
			}
			m_rnd.SetSeed(OldSeed);

			if (m_bCacheEnabled && bCheckCache) {
				m_CacheTS[index] = eCATaxStatus;
			}
		}
		return eCATaxStatus;
	}

	/*
	 *   Get the country and division address codes for the customer that
	 *   owns the current account.
	 *   These codes are used to get the tax rates and calculate tax on trades
	 *   in the TRADE table.
	 *
	 *   PARAMETERS:
	 *           OUT iDivCode        - division (state/province) code
	 *           OUT iCtryCode       - country (USA/CANADA) code
	 *
	 *   RETURNS:
	 *           none.
	 */
	void GetDivisionAndCountryCodesForCurrentAccount(UINT &iDivCode, UINT &iCtryCode) {
		m_addr.GetDivisionAndCountryCodes(iDivCode, iCtryCode);
	}

	/*
	 *   Generate a broker id for a certain account.
	 *   Used in CTradeGen for updating YTD values.
	 *
	 *   PARAMETERS:
	 *           IN  iCA_ID      - customer account id
	 *
	 *   RETURNS:
	 *           broker id that corresponds to the account.
	 */
	TIdent GenerateBrokerIdForAccount(TIdent iCA_ID) {
		//  Customer that own the account (actually, customer id minus 1)
		//
		TIdent iCustomerId = ((iCA_ID - 1) / iMaxAccountsPerCust) - iTIdentShift;

		// Set the starting broker to be the first broker for the current load
		// unit of customers.
		//
		TIdent iStartFromBroker = (iCustomerId / m_iLoadUnitSize) * m_iBrokersCount + iStartingBrokerID + iTIdentShift;

		// Note: this depends on broker ids being integer numbers from
		// contiguous range. The method of generating broker ids should be in
		// sync with the CBrokerTable.
		return m_rnd.RndNthInt64Range(RNGSeedBaseBrokerId, (RNGSEED)iCA_ID - (10 * iTIdentShift), iStartFromBroker,
		                              iStartFromBroker + m_iBrokersCount - 1);
	}

	/*
	 *   Generate all column values for the next row
	 *   and store them in the internal record structure.
	 *   Increment the number of rows generated.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           TRUE, if there are more records in the ADDRESS table; FALSE
	 * othewise.
	 */
	bool GenerateNextRecord() {
		GenerateCARow();
		GenerateAPRows();

		// Return false if all the rows have been generated
		return (MoreRecords());
	}

	/*
	 *   Return CUSTOMER_ACCOUNT row from the internal structure.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           current CUSTOMER_ACCOUNT record.
	 */
	// PCUSTOMER_ACCOUNT_ROW   GetCARow() {return &m_row.m_ca;}
	const CUSTOMER_ACCOUNT_ROW &GetCARow() {
		return m_row.m_ca;
	}
	/*
	 *   Return ACCOUNT_PERMISSION row from the internal structure.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           current ACCOUNT_PERMISSION record.
	 */
	const ACCOUNT_PERMISSION_ROW &GetAPRow(UINT i) {
		if (i < m_iPermsForCA)
			return m_row.m_perm[i];
		else
			throw std::range_error("Account Permission row index out of bounds.");
	}

	/*
	 *   Return the number of ACCOUNT_PERMISSION rows for the current
	 * CUSTOMER_ACCOUNT row.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           the number of permissions for the account.
	 */
	UINT GetCAPermsCount() {
		return m_iPermsForCA;
	}

	/*
	 *   Return the customer ID for the currently generated CA_ID id.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           customer id of the account in the current CUSTOMER_ACCOUNT
	 * record.
	 */
	TIdent GetCurrentC_ID() {
		return m_cust.GetCurrentC_ID();
	}
	/*
	 *   Return the customer tier for the currently generated CA_ID id.
	 *
	 *   PARAMETERS:
	 *           none.
	 *
	 *   RETURNS:
	 *           customer tier of the customer, whose account is in the current
	 * CUSTOMER_ACCOUNT record.
	 */
	eCustomerTier GetCurrentC_TIER() {
		return m_cust.GetC_TIER(m_cust.GetCurrentC_ID());
	}
};

} // namespace TPCE

#endif // CUSTOMER_ACCOUNTS_AND_PERMISSIONS_TABLE_H