// These are set to true if the respective pools are available, otherwise false
var pool_exacta;
var pool_first4;
var pool_quinella;

function setLoading(obj) {
	if (obj.options.length == 0) return null;
	var currentText = obj.options[obj.selectedIndex].text;
	obj.disabled = true;
	obj.options[obj.selectedIndex].text = Translate(MSG_LOADING);
	return currentText;
}

function unsetLoading(obj, currentText) {
	if (obj.options.length == 0) return;
	obj.options[obj.selectedIndex].text = currentText;
	obj.disabled = false;
}

// Checks to see if there is nothing in a response
// from an XML request
function emptyResponse(requestObject) {
	// Both checks required to accomodate different browsers
	return (requestObject.responseDocument == null 
		|| requestObject.responseDocument.documentElement == null) 
}

function hasPool(poolCode, poolCodesXml) {
	return poolCodesXml.indexOf("<poolCode>" + poolCode + "</poolCode>") > -1;
}


function getFormSingle(runnerNo, runName) {
	getForm(document.forms["betting"].raceNo.value, runnerNo, runName);	
}

function getForm(raceNo, runnerNo, runName) {
	var sUrl = g_sFormUrl;
	var formDate = document.forms["betting"].meetingDate.value.substring(0, 10);
	var _dateParts = formDate.split("/");
	if (_dateParts.length > 2)
	{
		var _partDay = _dateParts[0];
		if (_partDay.length < 2) _partDay = "0" + _partDay;
		formDate = _dateParts[2] + _dateParts[1] + _partDay;
	}
	sUrl += "?horsename=" + runName;
	sUrl += "&formdate=" + formDate;
	with (new DialogWindow(sUrl)) {
		Name = "FormGuide";	
		Width = Math.floor(window.screen.width * 0.75);
		Height = Math.floor(window.screen.height * 0.75);
		Scroll = true;
		Status = false;
		Resizable = true;
		RequiresLogin = false;
		Show();
	}
}

function getFormInternational(runnerName) {
	
	var encodedRunnerName = runnerName.replace(/ /g, "+");
	encodedRunnerName = encodedRunnerName.replace(/~/g, "\'"); 
	encodedRunnerName = encodedRunnerName.toUpperCase();
	var sUrl = g_sIntFromUrl;
	sUrl += "&horsename=" + encodedRunnerName ;
	with (new DialogWindow(sUrl)) {
		Name = "FormGuide";	
		Width = Math.floor(window.screen.width * 0.75);
		Height = Math.floor(window.screen.height * 0.75);
		Scroll = true;
		Status = false;
		Resizable = true;
		RequiresLogin = false;
		Show();
	}
}


function BetCoster() {
	var MAX_SELECTIONS = 4;
	
	var boxed;
	var c0, c1;
	var flexiBet;
	var place = 0;
	var s = new Array(MAX_SELECTIONS);
	var win = 0;

	this.costBet = function(type, wager, selections) {
		var cost = 0;
		var displayCost;
		var sl = selections;
		
		boxed = sl.isBoxed();
		flexiBet = sl.isFlexiBet();
		place = wager.toPlace();
		win = wager.toWin();

		for (var i=MAX_SELECTIONS-1; i>-1; --i) s[i] = null;
		for (var i=sl.fieldCount()-1; i>-1; --i) 
			s[i] = sl.getRunnerSelection(i);

		c0 = (s[0]==null)? 0: s[0].count();
		c1 = (s[1]==null)? 0: s[1].count();

		switch(type.selected()) 
		{
			case BetType.WINPLACE:
				cost = _cost_wpe();
				break;
			case BetType.QUINELLA:
				cost = _cost_quinella();
				break;
			case BetType.EXACTA:
				cost = _cost_exacta();
				break;
			case BetType.FIRSTFOUR:
				cost = _cost_firstFour();
				break;
			case BetType.TRIFECTA:
				cost = _cost_multiPosition(3) * win;
				break;
			case BetType.MYSTERYTRIFECTA:
				cost = win;
				break;
			case BetType.ALLUP:
				cost = _cost_allUp();
				break;
			case BetType.QUADRELLA:
			case BetType.TRIWIN:
				cost = _cost_quadrella();
				break;	
			default:
				cost = _cost_twoLegBet();
		}
	
		return cost;
	}

	var _boxedCombinations = function(selectionsCount, positions) {
		var _r = selectionsCount - positions;
		return (_r > -1)? (_factorial(selectionsCount) / _factorial(_r)): 0;
	}

	var _cost_allUp = function() {
		return c0 * win;
	}
	
	var _cost_exacta = function () {

		var combinations;
		var cost = 0;
		var duplicates = 0;

		if (boxed) {
			combinations = c0 * (c0 - 1);
			cost = combinations * win;

		} else {
			if (c0 > 0 && c1 > 0) {
				duplicates 
					= s[0].combination().countDuplicatesIn(s[1].combination());
				combinations = (c0 * c1) - duplicates;
				cost = combinations * win;
			}	
		}	
		return cost;
	}
	
	var _cost_firstFour = function () {	
		var combinations = _cost_multiPosition(4);
		return (flexiBet)
			? ((combinations > 0)? win: 0)
			: combinations * win;
	}
	
	var _cost_multiPosition = function(fields) {
		return ((boxed)
			? _boxedCombinations(c0, fields)
			: _uniqueCombinations(s, new NumberCombination(), fields));
	}
	
	var _cost_quadrella = function () {
		var c2 = (s[2]==null)? 0: s[2].count();
		var c3 = (s[3]==null)? 0: s[3].count();
		return c0 * c1 * c2 * c3 * win;
	}

	var _cost_quinella = function () {
		
		var combinations;
		var cost = 0;
		var duplicates = 0;
		var	f0 = (s[0]==null)? false: s[0].fieldSelected();
		var f1 = (s[1]==null)? false: s[1].fieldSelected();

		var standout = boxed;

		if (standout) {

			if (c0 > 0 && c1 > 1) {
			
				duplicates 
					= s[0].combination().countDuplicatesIn(s[1].combination());
				
				combinations = c0 * c1 - duplicates;

				if (!f0 && !f1) {
					combinations -= (duplicates * (duplicates - 1) / 2);
				}

				// Standout quinella must have at least two unique combinations
				cost = (combinations >= 2)? combinations * win: 0;
			
			} else if ((c0 > 1) && (c1 == 0)) {

				combinations = (c0 * c0) - c0;
				cost = ((combinations * win) / 2);
				if (f0) cost *= 2;

			}	
			
		} else {
			combinations = (c0 * c0) - c0;
			cost = ((combinations * win) / 2);

		}

		return cost;
	}
	
	var _cost_twoLegBet = function () {
		return c0 * c1 * win;
	}
	
	var _cost_wpe = function () {
 		var cost = 0;
		cost = (win * c0) + (place * c0);
		return cost;
	}

	var _factorial = function(n) {
		return (n<=1)? ((n<0)? 0: 1): n * _factorial(n-1);
	}
	
	var _uniqueCombinations = function(sets, selected, setCount) {
		var count = 0;
		var sl = selected.elementCount();
		var wset = sets[sl];
		if (wset != null) {
			wset = wset.combination();		
			var wsetCount = wset.elementCount();
			var elements = wset.elements();
			if (setCount > 1) {
				if (sl == setCount - 1) {
					for (var i=0; i<wsetCount; ++i) {
						if (!selected.contains(elements[i])) ++count;
					}
				} else {
					for (var i=0; i<wsetCount; ++i) {
						if (!selected.contains(elements[i])) {
							var sel = selected.clone();
							sel.add(elements[i]);
							count += _uniqueCombinations(sets, sel, setCount);
						}
					}
				}
			}
		}
		return count;
	}
}


function BetType() {

	BetType.ALLUP = 1;
	BetType.CONSOLATION = 2;
	BetType.DAILYDOUBLE = 4;
	BetType.EXACTA = 8;
	BetType.FIRSTFOUR = 16;
	BetType.MYSTERYTRIFECTA = 32;
	BetType.QUADRELLA = 64;
	BetType.QUINELLA = 128;
	BetType.RUNNINGDOUBLE = 256;
	BetType.TRIFECTA = 512;
	BetType.TRIWIN = 1024;
	BetType.WINPLACE = 2048;

	var DEFAULT = BetType.WINPLACE;

	var _type = new Array();
	_type[BetType.ALLUP] = "all_up";
	_type[BetType.CONSOLATION] = "cd";
	_type[BetType.DAILYDOUBLE] = "dd";
	_type[BetType.EXACTA] = "exacta";
	_type[BetType.FIRSTFOUR] = "ff";
	_type[BetType.MYSTERYTRIFECTA] = "?tf";
	_type[BetType.QUADRELLA] = "qd";
	_type[BetType.QUINELLA] = "quinella";
	_type[BetType.RUNNINGDOUBLE] = "rd";
	_type[BetType.TRIFECTA] = "trifecta";
	_type[BetType.TRIWIN] = "tw";
	_type[BetType.WINPLACE] = "win_place_eachway";

	var _multiLeg = BetType.ALLUP
		+ BetType.CONSOLATION
		+ BetType.DAILYDOUBLE
		+ BetType.QUADRELLA
		+ BetType.RUNNINGDOUBLE
		+ BetType.TRIWIN;
	
	var _selected = DEFAULT;

	var _codeFor = function(type) {
		return _type[type];
	}
	
	var _validType = function(type) {
		return _codeFor(type) != undefined;
	}

	this.codeFor = function(type) {
		return _codeFor(type);
	}
	
	this.multiLeg = function() {
		return _selected == (_multiLeg & _selected);
	}
	
	this.of = function() {
		var match = false;
		for (var i=arguments.length-1; i>=0; --i) {
			var type = arguments[i];
			if (_selected == type) {
				match = true;
				break;
			}
		}
		return match;
	}

	this.select = function(type) {
		_selected = _validType(type)?type:DEFAULT;
	}
	
	this.selectByCode = function(betTypeCode) {
		var match = false;
		for (var i=_type.length-1; i>0; i>>>=1) {
			match = _type[i] == betTypeCode;
			if (match) {
				setType = this.select(i);
				break;
			}
		}
		if (!match) this.select(DEFAULT);
	}
	
	this.selected = function() {
		return _selected;
	}

	this.selectedCode = function() {
		return _codeFor(_selected);
	}
	
	this.singleLeg = function() {
		return !this.multiLeg();
	}
}


function ClassicControlNaming() {

	var _BOX = "Box";
	var _EVENTID = "events";
	var _FIELD = "Field";
	var _FLEXIBET = "flexiBet";
	var _MYSTERY_AMOUNT = "mysteryType";
	var _MYSTERY_RACE = "race";
	var _PREFIX = "runner";
	var _PREFIX_BETTYPE_ALLUP = "allUpBetType";
	var _PREFIX_LEGSELECT = "legSelect";
	
	var _GROUP_MIN = "A";
	var _GROUP_MAX = "Z";

	var _charCode_groupMin = _GROUP_MIN.charCodeAt(0);
	var _prefix_length = _PREFIX.length;
	var _prefix_field = _PREFIX + _FIELD;
	var _prefix_field_length = _prefix_field.length;


	var _group_field = function(name) {
		return name.charAt(_prefix_field_length);
	}
	
	var _group_index = function(groupChar) {
		return groupChar.charCodeAt(0) - _charCode_groupMin;
	}
	
	var _group_runner = function(name) {
		return name.charAt(_prefix_length);
	}
	
	var _groupCodeFromIndex = function(index) {
		return String.fromCharCode(index + _charCode_groupMin);
	}
	
	var _stringStartsWith = function(s, start) {
		return s.indexOf(start) == 0;
	}

	var _validGroup = function(group) {
		var valid = false;
		if (group != null && group.length > 0) {
			var groupCode = group.charCodeAt(0);
			valid = (groupCode >= _charCode_groupMin 
				&& groupCode <= _GROUP_MAX.charCodeAt(0));
		}
		return valid;
	}
	

	this.allUpBetType = function(leg) {
		return _PREFIX_BETTYPE_ALLUP + leg;
	}
	
	this.box = function() {
		return _PREFIX + _BOX;
	}
	
	this.flexiBet = function() { return _FLEXIBET; }

	this.eventId = function() {
		return _EVENTID;
	}

	this.field = function(group) {
		return _prefix_field + _groupCodeFromIndex(group);
	}
	
	this.group_field = function(name) {
		return _group_index(_group_field(name));
	}
	
	this.group_runner = function(name) {
		return _group_index(_group_runner(name));
	}

	this.isNameOf_allUpBetType = function(name) {
		var pl = _PREFIX_BETTYPE_ALLUP.length;
		return (name.length == (pl + 1))
			&& _stringStartsWith(name, _PREFIX_BETTYPE_ALLUP)
			&& (this.number_leg(name) > 0);
	}
	
	this.isNameOf_box = function(name) {
		return name == this.box();
	}
	
	this.isNameOf_eventId = function(name) {
		return name == _EVENTID;
	}

	this.isNameOf_field = function(name) {
		return (name.length == (_prefix_field_length + 1))
			&& _stringStartsWith(name, _prefix_field)
			&& _validGroup(_group_field(name));
	}
	
	this.isNameOf_flexiBet = function(name) {
		return name == _FLEXIBET;
	}
	
	this.isNameOf_legSelect = function(name) {
		return (name.length == (_PREFIX_LEGSELECT.length + 1))
			&& (this.number_leg(name) > 0);
	}
		
	this.isNameOf_mysteryAmount = function(name) {
		return name == this.mysteryAmount();
	}
	
	this.isNameOf_mysteryRace = function(name) {
		return name == this.mysteryRace();
	}

	this.isNameOf_runner = function(name) {
		return (name.length >= (_prefix_length + 2))
			&& _stringStartsWith(name, _PREFIX)
			&& _validGroup(_group_runner(name))
			&& (this.number_runner(name) > 0);
	}
	
	this.isFieldFromGroup = function(name, groupIndex) {
		return this.isNameOf_field(name)
			&& (this.group_field(name) == groupIndex);
	}
		
	this.isRunnerFromGroup = function(name, groupIndex) {
		return this.isNameOf_runner(name)
			&& (this.group_runner(name) == groupIndex);
	}
	
	this.legSelect = function(leg) {
		return _PREFIX_LEGSELECT + leg;
	}
		
	this.mysteryAmount = function() {
		return _MYSTERY_AMOUNT;
	}
		
	this.mysteryRace = function() {
		return _MYSTERY_RACE;
	}
	
	this.number_leg = function(name) {
		return parseInt(name.substring(name.length - 1));
	}
	
	this.number_runner = function(name) {
		return parseInt(name.substring(_prefix_length + 1));
	}

	this.runner = function(group, number) {
		return _PREFIX + _groupCodeFromIndex(group) + number;
	}
}


function RacecardSelection() {

	RacecardSelection.RACE_CURRENT = "CURRENT";
	RacecardSelection.RACE_NEXT = "15";
	
	var DEFAULT_RACE = RacecardSelection.RACE_CURRENT;
	
	var _boxed = false;
	var _flexi = false;
	var _mystery = false;
	var _race = DEFAULT_RACE;
	var _runners = new RunnerSelectionList();

	
	this.add = function(fieldIndex, runnerNumber) {
		_runners.addSelection(fieldIndex, runnerNumber);
	}
	
	this.clear = function() {
		this.reveal();
		if (this.isBoxed()) this.setBoxed(false);
		if (this.isFlexiBet()) this.setFlexi(false);
		this.setRace(DEFAULT_RACE);
		_runners.removeAll();
	}
	
	this.deselectField = function(fieldIndex) {
		_runners.deselectField(fieldIndex);
	}
	
	this.fieldCount = function() {
		return _runners.count();
	}
	
	this.getRunnerSelection = function(fieldIndex) {
		return _runners.elementAt(fieldIndex);
	}
	
	this.getBetType = function() {
		return _betType;
	}
	
	this.getRace = function() {
		return _race;
	}
		
	this.getRaceNumber = function(legIndex) {
		var raceNumber = 0;
		var runnerSelection = _runners.elementAt(legIndex);
		if (runnerSelection != null) {
			raceNumber = runnerSelection.getRaceNumber();
		}
		return raceNumber;
	}
	
	this.getRaces = function() {
		var legs = this.fieldCount();
		var races = new Array(legs);
		for (var i=0; i<legs; ++i) races.push(this.getRaceNumber(i));
		return races;
	}
		
	this.isBoxed = function() {
		return _boxed;
	}
	
	this.isFlexiBet = function() {
		return _flexi;
	}
	
	this.isMystery = function() {
		return _mystery;
	}
	
	this.remove = function(fieldIndex, runnerNumber) {
		_runners.removeSelection(fieldIndex, runnerNumber);
	}

	this.removeAll = function(fieldIndex) {
		_runners.deselectAll(fieldIndex);
	}
	
	this.removeLeg = function(index) {
		_runners.removeAt(index);
	}

	this.reveal = function() {
		_mystery = false;
	}

	this.selectField = function(fieldIndex) {
		_runners.selectAll(fieldIndex);
	}
	
	this.setBoxed = function(box) {
		_boxed = box;
		this.removeLeg(3);
		this.removeLeg(2);
		this.removeLeg(1);
	}
		
	this.setEventId = function(fieldIndex, eventId) {
		_runners.setEventId(fieldIndex);
	}
	
	this.setFlexi = function(flexi) {
		_flexi = flexi;
	}
	
	this.setLegType = function(fieldIndex, type) {
		_runners.setType(fieldIndex, type);
	}
	
	this.setRace = function(race) {
		_race = (race == RacecardSelection.RACE_NEXT)
			?RacecardSelection.RACE_NEXT
			:DEFAULT_RACE;
	}
	
	this.setRaceNumber = function(fieldIndex, raceNumber) {
		_runners.setRaceNumber(fieldIndex, raceNumber);
	}
		
	this.shroud = function() {
		_mystery = true;
	}
}


function RunnerSelection() {
	
	RunnerSelection.TYPE_EACHWAY = "EW";
	RunnerSelection.TYPE_PLACE = "P";
	RunnerSelection.TYPE_WIN = "W";
	
	var TYPE_DEFAULT = RunnerSelection.TYPE_WIN;
	
	var _combination = new NumberCombination();
	var _eventId = 0;
	var _field = false;
	var _raceNumber = 0;
	var _type = TYPE_DEFAULT;

	this.combination = function() {
		return _combination;
	}

	this.count = function() {
		return _combination.elementCount();
	}

	this.deselect = function(number) {
		_combination.remove(number);
	}
	
	this.deselectAll = function() {
		_combination.removeAll();
	}
	
	this.deselectField = function() {
		_field = false;
	}

	this.fieldSelected = function() {
		return _field;
	}
	
	this.getEventId = function() {
		return _eventId;
	}
	
	this.getRaceNumber = function() {
		return _raceNumber;
	}	
	
	this.getType = function() {
		return _type;
	}
		
	this.select = function(number) {
		_combination.add(number);
	}

	this.selectField = function() {
		_field = true;
	}
	
	this.setEventId = function(eventId) {
		_eventId = eventId;
	}
	
	this.setRaceNumber = function(raceNumber) {
		_raceNumber = raceNumber;
	}
	
	this.setType = function(type) {
		_type = type;
	}
}


function RunnerSelectionList() {

	var _selection = new Array();
	
	var _indexInBounds = function(index) {
		index = parseInt(index);
		return (index > -1 && index < _selection.length);
	}

	var _newSelection = function() {
		return new RunnerSelection();
	}
	
	var _setLength = function (to) {
		var current = _selection.length;
		if (to > current) {
			for (var i = current; i < to; ++i)
				_selection[i] = _newSelection();
		} else if (to < length) {
			_selection = _selection.slice(0, to);
		}
	}
	
	var _validateIndex = function(index) {
		var validated = false;
		index = parseInt(index);
		if (index > -1) {
			if (index >= _selection.length) _setLength(index + 1);
			validated = _indexInBounds(index);
		}
		return validated;
	}
		
	this.add = function () {
		_selection.push(_newSelection());
	}
	
	this.addSelection = function(index, number) {
		if (_validateIndex(index)) {
			_selection[index].select(number);
		}
	}

	this.count = function () {
		return _selection.length;
	}

	this.deselectAll = function(index) {
		if (this.deselectField(index))
			_selection[index].deselectAll();
	}
	
	this.deselectField = function(index) {
		var done = false;
		if (_indexInBounds(index)) {
			_selection[index].deselectField();
			done = true;
		}
		return done;	
	}
		
	this.elementAt = function(index) {
		return (_indexInBounds(index))? _selection[index]: null;
	}
		
	this.removeAll = function() {
		_selection.length = 0;
	}
	
	this.removeAt = function (index) {
		if (_indexInBounds(index)) {
			switch( index ) {
				case 0: _selection.shift(); break;
				case (_selection.length - 1): _selection.pop(); break;
				default: _selection = _selection.slice(0, index)
						.concat(_selection.slice(index + 1));
			}
		}
	}
	
	this.removeSelection = function(index, number) {
		if (_indexInBounds(index)) {
			_selection[index].deselect(number);
		}
	}
	
	this.selectAll = function(index) {
		if (_validateIndex(index)) {
			_selection[index].selectField();
		}		
	}
	
	this.setEventId = function(index, id) {
		if (_validateIndex(index)) {
			_selection[index].setEventId(id);
		}		
	}

	this.setRaceNumber = function(index, number) {
		if (_validateIndex(index)) {
			_selection[index].setRaceNumber(number);
		}
	}

	this.setType = function(index, type) {
		if (_validateIndex(index)) {
			_selection[index].setType(type);
		}		
	}
}


function SpeedBetPlusTranslator() {

	var _AMOUNTDELIMITER = ":"
	var _DA = _AMOUNTDELIMITER;
	var _AND = "/";
	var _BOX = "/C";
	var _DELIMITER = " ";
	var _D = _DELIMITER;
	var _FIELD = "F";
	var _FLEXIBET = "F";
	var _MYSTERY = "?TF";
	var _OR = "+";
	var _WAGER_MYST = 1;
	var _WAGER_MYSTBOX = 3;
	
	var _bl = _BOX.length;
	
	var _boxed = function(str) {
		var s = str.split(_DA)[0]; 
		return s.substr(s.length - _bl).toUpperCase() == _BOX;
	}
	
	var _flexiBet = function(str) {
		var s = str.split(_DA);
		var sl = s.length;
		return ((sl > 1) && (s[sl-1].toUpperCase() == _FLEXIBET));
	}
	
	var _mystery = function(str) {
		return (str.substring(0, _MYSTERY.length).toUpperCase() == _MYSTERY);
	}
	
	this.betType = function(str) {
		var t = new BetType();
		if (_mystery(str)) {
			t.select(BetType.MYSTERYTRIFECTA);
		} else {
			t.selectByCode(str.split(_DA)[0].split(_D)[0]);
		}
		return t;
	}
	
	this.wagerAmount = function(str) {
		var w = new WagerAmount();
		if (_mystery(str)) {
			w.setWin((_boxed(str))? _WAGER_MYSTBOX: _WAGER_MYST);
		} else {
			var a = str.split(_DA);
			var al = a.length;
			if (al > 1) w.setWin(a[1]);
			if ((al > 2) && (a[2].toUpperCase() != _FLEXIBET)) {
				w.setPlace(a[2]);
			}
		}
		return w;
	}
		
	this.selections = function(str) {
		var s = new RacecardSelection();

		s.setFlexi(_flexiBet(str));
		
		str = str.split(_DA)[0];
				
		if (_boxed(str)) {
			s.setBoxed(true);
			str = str.substring(0, str.length - _bl);
		}
		
		if (_mystery(str)) {
			
			var tmp = str.split(_D);
			if (tmp.length > 0) {
				tmp = tmp[1].split(_AND);
				s.setRace((tmp == RacecardSelection.RACE_NEXT)
					? tmp: RacecardSelection.RACE_CURRENT);
			}
			s.shroud();
		
		} else {
			
			var a_fs = str.split(_D);
			var a_fsl = a_fs.length;
						
			var is = (a_fsl>1)?a_fsl-1:-1;
			var ir = (a_fsl>2)?1:-1;
			var it = (a_fsl>3)?2:-1;
			
			if (ir>-1) {
				var races = a_fs[ir].split(_AND);
				for (i=0; i<races.length; ++i)
					s.setRaceNumber(i, races[i]);
			}
			if (it>-1) {
				var types = a_fs[it].split(_AND);
				for (i=0; i<types.length; ++i)
					s.setLegType(i, types[i].toUpperCase());
			}
			if (is>-1) {
				a_fs = a_fs[is].split(_AND);
				var c, n;
				for (i=0; i<a_fs.length; ++i) {
					s_fs = a_fs[i];
					if (s_fs.toUpperCase() == _FIELD) {
						s.selectField(i);
					} else {
						c = s_fs.split(_OR);
						for (var j=0; j<c.length; j++) {
							n = parseInt(c[j]);
							if (n > 0) s.add(i, n);
						}
					}
				}
			}
		}
		return s;
	}

	this.betString = function(racecardSelection, betType, wager) {
		var t = betType;
		var w = wager;
		
		var picks = "";
		var races = "";
		var types = "";
		
		var s = racecardSelection;
		var fc = s.fieldCount();
		var o = "";
		
		if (s.isMystery()) {
			o += _MYSTERY + _D;
			var mr = s.getRace();
			o += (mr == RacecardSelection.RACE_CURRENT)
				? s.getRaceNumber(0): mr;
		} else {
			for (var i=0; i<fc; ++i) {
				
				var r = s.getRunnerSelection(i);
				
				var rn = r.getRaceNumber();
				if (rn > 0) {
					if (races.length > 0) races += _AND;
					races += rn;
					if (t.of(BetType.ALLUP)) {
						if (types.length > 0) types += _AND;
						types += r.getType();
					}
				}
				if (r.fieldSelected()) {
					picks += _FIELD;
				} else {
					var a = r.combination().elements();
					var rc = a.length;
					for (var j=0; j<rc; ++j) {
						picks += a[j];
						if (j<rc-1) picks += _OR;
					}
				}
				if (i<fc-1) picks += _AND;
			}
			if (races.length > 0) races += _D;
			if (types.length > 0) types += _D;
			o = t.selectedCode() + _D + races + types + picks;
		}
		if (s.isBoxed()) o += _BOX;
		
		if (!s.isMystery()) {
			o += _DA + w.toWin();
			if (t.of(BetType.WINPLACE)) o += _DA + w.toPlace();
			if (s.isFlexiBet()) o += _DA + _FLEXIBET;
		}
		
		//alert("Encoded selections: " + o);
		return o;
	}
}


function WagerAmount() {
	
	WagerAmount.MAXIMUM = 32000;
	
	var _place = 0;
	var _win = 0;

	var _roundAmount = function(amount) {
		amount = amount * 1;
		amount *= 2;
		amount = Math.round(amount);
		amount /= 2;
		amount = (amount > Math.floor(amount))? amount + "0": amount;
		return parseFloat(amount);
	}
	
	this.setPlace = function(amount) {
		amount = parseFloat(amount);
		if (this.validAmount(amount)) _place = amount;
	}
	
	this.setWin = function(amount) {
		amount = parseFloat(amount);
		if (this.validAmount(amount)) _win = amount;
	}
	
	this.toPlace = function() {
		return _roundAmount(_place);
	}
	
	this.toWin = function() {
		return _roundAmount(_win);
	}
	
	this.validAmount = function(amount) {
		return ((amount >= 0) && (amount <= WagerAmount.MAXIMUM));
	}
}