func BenchmarkDoCreateAccount(b *testing.B) {
	for n := 0; n < b.N; n++ {
		accountDetail := AccountDetails{
			"",
			"",
			"User,Test",
			decimal.NewFromFloat(0.),
			decimal.NewFromFloat(0.),
			decimal.NewFromFloat(0.),
			"cheque",
			0,
		}

		accountHolderDetail := AccountHolderDetails{
			"Test",
			"User",
			"1900-01-01",
			"19000101-1000-100",
			"555-123-1234",
			"",
			"[email protected]er.com",
			"Address 1",
			"Address 2",
			"Address 3",
			"22202",
		}

		ti := time.Now()
		sqlTime := int32(ti.Unix())
		_ = doCreateAccount(sqlTime, &accountDetail, &accountHolderDetail)
		_ = doDeleteAccount(&accountDetail)
	}
}

func setAccountDetails(data []string) (accountDetails AccountDetails, err error) {
	if len(data) < 15 {
		return AccountDetails{}, errors.New("accounts.setAccountDetails: Not all fields required present")
	}

	if data[4] == "" {
		return AccountDetails{}, errors.New("accounts.setAccountDetails: Family name cannot be empty")
	}
	if data[3] == "" {
		return AccountDetails{}, errors.New("accounts.setAccountDetails: Given name cannot be empty")
	}
	accountDetails.BankNumber = BANK_NUMBER
	accountDetails.AccountHolderName = data[4] + "," + data[3] // Family Name, Given Name
	accountDetails.AccountBalance = decimal.NewFromFloat(OPENING_BALANCE)
	accountDetails.Overdraft = decimal.NewFromFloat(OPENING_OVERDRAFT)
	accountDetails.AvailableBalance = decimal.NewFromFloat(OPENING_BALANCE + OPENING_OVERDRAFT)
	// Get account type
	accountType := data[14]
	switch accountType {
	case "":
		accountType = "cheque" // Default to chequing account
		break
	case "savings", "cheque", "merchant", "money-market", "cd", "ira", "rcp", "credit", "mortgage", "loan":
		// Valid
		break
	default:
		return AccountDetails{}, errors.New("accounts.setAccountDetails: Account type not valid, must be one of savings, cheque, merchant, money-market, cd, ira, rcp, credit, mortgage, loan")
		break
	}
	accountDetails.Type = accountType

	return
}

//Encode generates a geozip bucket id for a given latitude and longitude.
//Argument validate is true if a validation is to be performed.
//Precision is a number in the range of [0, 18] such that 0 gives lowest precision (000000000000000000) and 18 gives the most precise bucket id.
func Encode(latitude, longitude float64, validate bool, precision int) int64 {
	if validate && !Valid(latitude, longitude) {
		return 0
	}
	latitudeShifted := decimal.NewFromFloat(latitude).Add(decimal.NewFromFloat(90.0))
	longitudeShifted := decimal.NewFromFloat(longitude).Add(decimal.NewFromFloat(180.0))
	latString := latitudeShifted.String() + ".0"
	lonString := longitudeShifted.String() + ".0"
	latParts := strings.Split(latString, ".")
	lonParts := strings.Split(lonString, ".")
	latString = resizeCharacteristic(latParts[0]) + resizeMantissa(latParts[1])
	lonString = resizeCharacteristic(lonParts[0]) + resizeMantissa(lonParts[1])
	bucketString := zip(latString, lonString)
	bucket, err := strconv.ParseInt(bucketString, 10, 64)
	if err != nil {
		fmt.Errorf("Error parsing zipped string to int64")
	}
	for i := 0; i < maxPrecision-precision; i++ {
		bucket /= 10
	}
	for i := 0; i < maxPrecision-precision; i++ {
		bucket *= 10
	}
	return bucket
}

func Money(value interface{}, code string) (MoneyObject, error) {
	currency, found := CurrencyTypes[code]
	if !found {
		return MoneyObject{}, errors.New("Code not found.")
	}

	var money decimal.Decimal
	var moneyObject MoneyObject

	switch v := value.(type) {
	case string:
		m, err := decimal.NewFromString(v)
		if err != nil {
			return MoneyObject{}, err
		}
		money = m
	case float32:
		money = decimal.NewFromFloat(float64(v))
	case float64:
		money = decimal.NewFromFloat(v)
	case int:
		money = decimal.NewFromFloat(float64(v))
	default:
		return MoneyObject{}, errors.New("Value could not be translated.")
	}

	moneyObject.money = money
	moneyObject.currency = currency

	return moneyObject, nil
}

func TestDoCreateAccount(t *testing.T) {
	//accountDetails AccountDetails, accountHolderDetails AccountHolderDetails
	accountDetail := AccountDetails{
		"",
		"",
		"User,Test",
		decimal.NewFromFloat(0.),
		decimal.NewFromFloat(0.),
		decimal.NewFromFloat(0.),
		0,
	}

	ti := time.Now()
	sqlTime := int32(ti.Unix())
	err := doCreateAccount(sqlTime, &accountDetail)

	if err != nil {
		t.Errorf("DoCreateAccount does not pass. Looking for %v, got %v", nil, err)
	}

	err = doDeleteAccount(&accountDetail)
	if err != nil {
		t.Errorf("DoDeleteAccount does not pass. Looking for %v, got %v", nil, err)
	}
}

//Decode is the inverse operation of Encode.
//Decode returns latitude, longitude, and whether or not they are both represented precisely as float64 types.
func Decode(bucket int64) (float64, float64, bool) {
	var latitudeUnshifted, longitudeUnshifted decimal.Decimal
	var latitude, longitude float64
	var err error
	var exact bool
	bucketString := strconv.FormatInt(bucket, 10)
	for len(bucketString) < 18 {
		bucketString = "0" + bucketString
	}

	latString, lonString := unzip(bucketString)
	latString = latString[0:3] + "." + latString[3:]
	lonString = lonString[0:3] + "." + lonString[3:]

	latitudeUnshifted, err = decimal.NewFromString(latString)
	longitudeUnshifted, err = decimal.NewFromString(lonString)
	if err != nil {
		fmt.Errorf("Error creating decimal from string")
	}
	latitudeUnshifted = latitudeUnshifted.Sub(decimal.NewFromFloat(90.0))
	longitudeUnshifted = longitudeUnshifted.Sub(decimal.NewFromFloat(180.0))
	latitude, exact = latitudeUnshifted.Float64()
	longitude, exact = longitudeUnshifted.Float64()
	return latitude, longitude, exact
}

func TestSquareRootOfFour(t *testing.T) {
	four := decimal.NewFromFloat(4.0)
	sqrt := Sqrt(four)
	if !sqrt.Equals(decimal.NewFromFloat(2.0)) {
		t.Fatalf("Square root of %s is %s", four, sqrt)
	}
	t.Logf("Square root of %s is %s", four, sqrt)
}

func BenchmarkAddDecimalWithoutNew(b *testing.B) {
	decimalStartFloat := decimal.NewFromFloat(StartFloat)
	decimalFactor := decimal.NewFromFloat(Factor)

	for n := 0; n < b.N; n++ {
		AddDecimalWithoutNew(decimalStartFloat, decimalFactor)
	}
}

func AddDecimal() (calculated decimal.Decimal) {
	decimalStartFloat := decimal.NewFromFloat(StartFloat)
	decimalFactor := decimal.NewFromFloat(Factor)

	calculated = decimalStartFloat.Add(decimalFactor)

	return
}

func MultiplyDecimal() (calculated decimal.Decimal) {
	decimalStartFloat := decimal.NewFromFloat(StartFloat)
	decimalFactor := decimal.NewFromFloat(Factor)

	calculated = decimalStartFloat.Mul(decimalFactor)

	return
}

func TestCanWidthdraw(t *testing.T) {

	account := CreateAccount(10)
	account.Deposit(decimal.NewFromFloat(20))

	account.Withdraw(decimal.NewFromFloat(50))
	assert.Equal(t, decimal.NewFromFloat(20).String(), account.GetBalance().String())

}

// Square root using Newton's method
// Shamelessly ripped from https://gist.github.com/marcellodesales/2487009
func Sqrt(x decimal.Decimal) decimal.Decimal {
	p := decimal.NewFromFloat(0.0)
	z := decimal.NewFromFloat(1.0)
	for !p.Sub(z).Equals(ConstMin) {
		z = newton(z, x)
		p = newton(z, x)
	}
	return z
}

func TestCalculate(t *testing.T) {
	irrf := NewIRRF(irrfByYear["2016"])
	for _, testCase := range testCases {
		irrfDue := irrf.Calculate(decimal.NewFromFloat(testCase.irrfBase))
		if irrfDue.Cmp(decimal.NewFromFloat(testCase.irrfDue)) != 0 {
			t.Errorf("Expected %v, got %v", testCase.irrfDue, irrfDue)
		}
	}
}

func TestCalculate(t *testing.T) {
	inss := NewINSS(inssByYear["2016"])
	for _, testCase := range testCases {
		inssDue := inss.Calculate(decimal.NewFromFloat(testCase.grossSalary))
		if inssDue.Cmp(decimal.NewFromFloat(testCase.inssDue)) != 0 {
			t.Errorf("Expected %v, got %v", testCase.inssDue, inssDue)
		}
	}
}

func setupGrid() *Grid {
	grid := NewGrid(NewCoord(decimal.NewFromFloat(0.0),
		decimal.NewFromFloat(0.0)), decimal.NewFromFloat(90.0),
		decimal.NewFromFloat(180.0), nil, nil)
	grid.Append(coordA)
	grid.Append(coordB)
	grid.Append(coordC)
	grid.Append(coordD)
	return grid
}

func TestDeposit(t *testing.T) {

	account := CreateAccount(10)
	assert.Equal(t, account.GetBalance(), decimal.NewFromFloat(0))

	account.Deposit(decimal.NewFromFloat(2510.50))
	assert.Equal(t, account.GetBalance(), decimal.NewFromFloat(2510.50))

	// Attempt to deposit negative value
	_, err := account.Deposit(decimal.NewFromFloat(-1))
	assert.NotNil(t, err)

}

func BenchmarkSavePainTransaction(b *testing.B) {
	config, _ := configuration.LoadConfig()
	SetConfig(&config)

	for n := 0; n < b.N; n++ {
		sender := AccountHolder{"accountNumSender", "bankNumSender"}
		receiver := AccountHolder{"accountNumReceiver", "bankNumReceiver"}
		trans := PAINTrans{101, sender, receiver, decimal.NewFromFloat(0.), decimal.NewFromFloat(0.), 10., 10., "Test desc", "approved"}

		_ = savePainTransaction(trans)
		_ = removePainTransaction(trans)
	}
}

func main() {
	rand.Seed(time.Now().UTC().UnixNano())

	termChan := make(chan os.Signal, 1)
	signal.Notify(termChan, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)

	cant := 0
	log.Println("Flooding with transactions... =D")
	initialDate, _ := time.Parse("2-JAN-06 15:04:05", "1-JAN-14 10:00:00")

	for i := 0; i < 5; i++ {
		go func() {
			for {
				id := fmt.Sprintf("%v", rand.Intn(10000))
				from := randomdata.Currency()
				to := randomdata.Currency()
				rate := decimal.NewFromFloat(randomdata.Decimal(1, 2, 2))
				sell := decimal.NewFromFloat(randomdata.Decimal(50, 1000, 2))
				buy := rate.Mul(sell)
				tp := initialDate.Add(time.Hour * 24 * time.Duration(cant)).
					Format("2-JAN-06 15:04:05")

				oc := randomdata.Country(randomdata.TwoCharCountry)

				m := map[string]interface{}{
					"userId":             id,
					"currencyFrom":       from,
					"currencyTo":         to,
					"amountSell":         sell,
					"amountBuy":          buy,
					"rate":               rate,
					"timePlaced":         tp,
					"originatingCountry": oc,
				}
				mJson, _ := json.Marshal(m)
				contentReader := bytes.NewReader(mJson)
				req, _ := http.NewRequest("POST", "http://localhost:8080/api/v1/transaction", contentReader)
				req.Header.Set("Content-Type", "application/json")
				client := &http.Client{}
				client.Do(req)
				cant++

				time.Sleep(time.Millisecond * time.Duration(3000))
			}
		}()
	}

	<-termChan
	log.Println("total messages:", cant)
}

func TestSummary(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		summaryAPI := fmt.Sprintf("/accounts/%d/summary", TestAccountID)
		assert.Equal(t, summaryAPI, req.RequestURI)

		err := respondWithFixture(w, "summary.json")
		require.NoError(t, err)
	}))
	defer ts.Close()

	ar := newClient(ts.URL, "Token", nil).Accounts(TestAccountID)
	summary, err := ar.Summary()
	require.NoError(t, err)

	assert.Equal(t, 1788402, summary.InvestorID)
	assert.Equal(t, decimal.NewFromFloat(50.77), summary.AvailableCash)
	assert.Equal(t, decimal.NewFromFloat(100.15), summary.AccountTotal)
	assert.Equal(t, decimal.NewFromFloat(0.26), summary.AccruedInterest)
	assert.Equal(t, decimal.NewFromFloat(0), summary.InFundingBalance)
	assert.Equal(t, decimal.NewFromFloat(0.16), summary.ReceivedInterest)
	assert.Equal(t, decimal.NewFromFloat(0.62), summary.ReceivedPrincipal)
	assert.Equal(t, decimal.NewFromFloat(0), summary.ReceivedLateFees)
	assert.Equal(t, decimal.NewFromFloat(49.38), summary.OutstandingPrincipal)
	assert.Equal(t, 2, summary.TotalNotes)
	assert.Equal(t, 3, summary.TotalPortfolios)
}

func orderTests(t *testing.T, order Order) {
	// Check that dates are parsed
	d := time.Date(2016, time.May, 17, 4, 14, 36, 0, time.UTC)
	if !d.Equal(*order.CreatedAt) {
		t.Errorf("Order.CreatedAt returned %+v, expected %+v", order.CreatedAt, d)
	}

	// Check null dates
	if order.ProcessedAt != nil {
		t.Errorf("Order.ProcessedAt returned %+v, expected %+v", order.ProcessedAt, nil)
	}

	// Check prices
	p := decimal.NewFromFloat(10)
	if !p.Equals(*order.TotalPrice) {
		t.Errorf("Order.TotalPrice returned %+v, expected %+v", order.TotalPrice, p)
	}

	// Check null prices, notice that prices are usually not empty.
	if order.TotalTax != nil {
		t.Errorf("Order.TotalTax returned %+v, expected %+v", order.TotalTax, nil)
	}

	// Check customer
	if order.Customer == nil {
		t.Error("Expected Customer to not be nil")
	}
	if order.Customer.Email != "[email protected]" {
		t.Errorf("Customer.Email, expected %v, actual %v", "[email protected]", order.Customer.Email)
	}
}