/* ws/fastSearch/static/js/page_request.js */ /* UTF8-Côôkie */

/************************************************************************************************************************************************************************************************************************/

/*

Possible values for <PROP>.AVAILABLE:

	true		is available
	false		is not available
	null		unknown / contact us for availability

*/


function	requestClass(countries, propPreviewWidth, propPreviewHeight, requestedProp, visitedProp, thanksPage, backToSearchText, goToSearchText)
{
	var self = this;

	/* CONFIG */

	this.dateFormat = '%a, %d %b %Y';

	this.missingText = 'Please fill-in the fields marked as missing and try again.';
	this.invalidText = 'Please fill-in the fields marked as invalid and try again.';
	this.emailInvalidText = 'The provided email address is not valid.';
	this.emailConfirmFailureText = 'The confirmed email address does not match the original.';
	this.errorRetryText = 
		'An unexpected problem has occured while submitting your request.\n'+
		'\n'+
		'Do you want to retry submitting your request?'
	;
	this.errorText = 
		'Your request was NOT submitted.\n'+
		'\n'+
		'Please try again later.';

	this.availabilityText = {
		'available'		:	'Available for your dates',
		'notAvailable'	:	'Not available for your dates',
		'unknown'		:	'Please contact us for availability'
	};


	this.reqFields = [
		'REQ_ARRIVAL',
		'REQ_DEPARTURE',
		'REQ_FIRSTNAME',
		'REQ_LASTNAME',
		'REQ_EMAIL',
		'REQ_EMAIL_CONFIRM',
		'REQ_PHONE',
		'REQ_N_ADULTS',
		'REQ_N_CHILD_0_3',
		'REQ_N_CHILD_4_13',
		'REQ_COUNTRY',
		'REQ_COMMENT'
	];

	/* Availability check (on init, and after a dates change) */

	this.availabilityAjax = new fsAjaxRequest(true);
	this.availabilityAjax.onLoad = function(data)
	{
		self.onAvailability(data);
	}
	this.availabilityAjax.onError = this.availabilityAjax.onTimeout = function()
	{
		self.onAvailability(null);	// No retry feature
	}

	this.availabilityRequestPending = false;


	this.submitObject = null;
	this.submitAjax = new fsAjaxRequest(true);
	this.submitAjax.onLoad = function(data)
	{
		self.onSubmitResult(data);
	}
	this.submitAjax.onError = this.submitAjax.onTimeout = function()
	{
		self.onSubmitError();

	}

	/* Init property lists */
	
	function	initList(arr, allProp)
	{
		var	list = new kigoList();

		for(var i = 0; i < arr.length; i++)
		{
			list.add(
			{
				'ID'		:	arr[i].ID,
				'NAME'		:	arr[i].NAME,
				'PHOTO'		:	arr[i].PHOTO,
				'URL'		:	arr[i].URL,
				'AVAILABLE'	:	null,
				'GAW'		:	arr[i].GAW
			});
			
			allProp.push(arr[i].ID);
		}
		return list;
	}

	this.allProp = [];
	this.requestedProp = initList(requestedProp, this.allProp);
	this.visitedProp = initList(visitedProp, this.allProp);
	this.thanksPage = thanksPage;
	this.backToResultListText = backToSearchText;
	this.goToSearchText = goToSearchText;


	/* Other inits */

	this.propPreviewWidth = propPreviewWidth;
	this.propPreviewHeight = propPreviewHeight;

	this.requestAdwords = null;

	vkDom.onLoad(
		function()
		{
			self.onPageLoad(countries);
		}
	);
}

requestClass.prototype.onPageLoad = function(countries)
{
	var	self = this;
	var	arrival = vkDom.el('REQ_ARRIVAL'), departure = vkDom.el('REQ_DEPARTURE');


	/**********************************************************************/
	// Setup the countries list
	{
		var	sel = new kigoSelect('REQ_COUNTRY');

		sel.addOption(0, '-- Please select --', 'e-1 odd first');

		for(var i = 0; i < countries.length; i++)
			sel.addOption(countries[i].ID, countries[i].NAME, 'e-'+(i+2)+' '+(i%2?'odd':'even')+' '+(i==countries.length-1?'last':'middle'));

		this.selClasses(sel.domNode());
	}


	/**********************************************************************/
	// Initialize most fields from a previous submit

	for(var i = 0; i < this.reqFields.length; i++)
	{
		switch(field = this.reqFields[i])
		{
			case 'REQ_FIRSTNAME':
			case 'REQ_LASTNAME':
			case 'REQ_EMAIL':
			case 'REQ_EMAIL_CONFIRM':
			case 'REQ_PHONE':
			/*
			case 'REQ_N_ADULTS':
			case 'REQ_N_CHILD_0_3':
			case 'REQ_N_CHILD_4_13':
			*/
				vkDom.el(field).value = vkDom.getCookie(field, '');
				break;

			case 'REQ_COUNTRY':
				(new kigoSelect(vkDom.el(field))).setValue(kigo.intval(vkDom.getCookie(field, 0)));
				break;
		}
	}


	/**********************************************************************/
	// Initialize dates & calendars
	{
		var	arr = vkDom.getCookie('ARRIVAL_DATE', '');
		var	dep = vkDom.getCookie('DEPARTURE_DATE', '');

		if(
			arr.length &&
			dep.length
		)
		{
			arrival.value = (kigoDate.createFromMysql(arr)).display();
			departure.value = (kigoDate.createFromMysql(dep)).display();
		}
		else
		{
			arrival.value = '';
			departure.value = '';
		}
	}


	/**********************************************************************/
	// Setup calendars


	// Dates change handler
	function	onDatesChange()
	{
		//debug.text('onDatesChange()');

		// Cancel any pending availability request
		if(this.availabilityRequestPending)
		{
			this.availabilityAjax.abort();
			availabilityRequestPending = false;
		}

		if(
			vkDom.el('REQ_ARRIVAL').value.length &&
			vkDom.el('REQ_DEPARTURE').value.length
		)
		{
			var	stay = vkDom.el('request_dates_stay');
			var	span = document.createElement('span');

			var	nights = kigoDate.createFromCalendar(vkDom.el('REQ_ARRIVAL').value).daysDiff(kigoDate.createFromCalendar(vkDom.el('REQ_DEPARTURE').value));

			span.appendChild(document.createTextNode(nights+' night'+(nights > 1 ? 's' : '')));

			vkDom.clean(stay);
			stay.appendChild(span);

			vkDom.removeClass('request_dates_stay', 'none');

			// Okay, do an availability request, which will run a new render...
			if(self.allProp.length)
				self.requestAvailability();
		}
		else
		{
			vkDom.addClass('request_dates_stay', 'none');
			self.renderRequestedProperties();
			self.renderVisitedProperties();
		}
	}


	// Arrival date
	arrival.onclick = function()
	{
		// 07/12/2009 - Do not remove the departure date any more ; remove it - if required (conflict) - when the new date is selected

		self.currentCalendar = new Calendar(
			1,										// firstDayOfWeek
			vkDom.el('REQ_ARRIVAL').value,			// dateStr
			function(cal)							// onSelected
			{
				if(cal.dateClicked)
				{
					// 07/12/2009 - From now on, we're overwriting the departure date if and only if it is less or equal to the arrival date!
				
					vkDom.el('REQ_ARRIVAL').value = cal.date.print(cal.dateFormat);

					if(vkDom.el('REQ_DEPARTURE').value.length)
					{
						var	dt = kigoDate.createFromDate(cal.date);

						if(dt.compare(kigoDate.createFromCalendar(vkDom.el('REQ_DEPARTURE').value)) <= 0)
							vkDom.el('REQ_DEPARTURE').value = '';

						onDatesChange();
					}

					cal.hide();
				}
			},
			function(cal)							// onClose
			{
				cal.hide();
			}
		);

		self.currentCalendar.setDisabledHandler(
			function(date, year, month, day)
			{
				++month;

				// Disable all dates in the past
				if(kigoDate.today().compare(new kigoDate(day, month, year)) < 0)
					return true;
				// 07/12/2009 - Don't disable dates that are >= current departure date any more, read above
				return false;
			}
		);

		var	year = kigoDate.today().getYear();

		self.currentCalendar.setDateFormat(self.dateFormat);
		self.currentCalendar.setRange(year, year+6);
		self.currentCalendar.create();
		self.currentCalendar.refresh();
		self.currentCalendar.showAtElement(vkDom.el('REQ_ARRIVAL'));
	}




	// Departure date
	departure.onclick = function()
	{
		var	defaultDate;

		if(vkDom.el('REQ_DEPARTURE').value.length)
			defaultDate = vkDom.el('REQ_DEPARTURE').value;
		else
		{
			if(vkDom.el('REQ_ARRIVAL').value.length)
				defaultDate = kigoDate.createFromCalendar(vkDom.el('REQ_ARRIVAL').value).addDays(1).calendar();
			else
				defaultDate = '';
		}

		self.currentCalendar = new Calendar(
			1,										// firstDayOfWeek
			defaultDate,							// dateStr
			function(cal)							// onSelected
			{
				if(cal.dateClicked)
				{
					vkDom.el('REQ_DEPARTURE').value = cal.date.print(cal.dateFormat); 
					onDatesChange();
					cal.hide(); 
				}
			},
			function(cal)							// onClose
			{
				cal.hide();
			}
		);

		self.currentCalendar.setDisabledHandler(
			function(date, year, month, day)
			{
				++month;

				// Disable all dates in the past
				if(kigoDate.today().compare(new kigoDate(day, month, year)) < 0)
					return true;

				// Disable all dates that are <= current arrival date
				if(vkDom.el('REQ_ARRIVAL').value.length)
					return kigoDate.createFromCalendar(vkDom.el('REQ_ARRIVAL').value).compare(new kigoDate(day, month, year)) <= 0;

				return false;
			}
		);

		var	year = kigoDate.today().getYear();

		self.currentCalendar.setDateFormat(self.dateFormat);
		self.currentCalendar.setRange(year, year+6);
		self.currentCalendar.create();
		self.currentCalendar.refresh();
		self.currentCalendar.showAtElement(vkDom.el('REQ_DEPARTURE'));
	}






	/**********************************************************************/
	// Filter input on numeric-only fields...

	function	setupNumberFilter(field)
	{
		var	filter = function(ev)
		{
			var	obj;
			var	charCode;

			if(ev.target)
				obj = ev.target;
			else if(ev.srcElement)
				obj = ev.srcElement;
			else
				return true;

			// Okay, first of all, whatever the filter is, allow any selection keys (backspace, arrows, home, end...)
			
			if(ev['charCode'])
				charCode = ev.charCode;
			else if(ev['keyCode'])
				charCode = ev.keyCode;
			else
				return true;

			switch(charCode)
			{
				case 8:		// Backspace
				case 9:		// Tab
				case 13:	// Enter
				case 35:	// End
				case 36:	// Home
				case 37:	// Left
				case 38:	// Up
				case 39:	// Right
				case 40:	// Down
				case 46:	// Delete

				// Digits
				case 48:	//	0
				case 49:	//	1
				case 50:	//	2
				case 51:	//	3
				case 52:	//	4
				case 53:	//	5
				case 54:	//	6
				case 55:	//	7
				case 56:	//	8
				case 57:	//	9

					return true;
			}

			if(ev.preventDefault)
				ev.preventDefault();
			return false;
		}

		if(window.addEventListener)
			vkDom.el(field).addEventListener('keypress', filter, false);
		else if(window.attachEvent)
			vkDom.el(field).attachEvent('onkeypress', filter);
	}
	
	setupNumberFilter('REQ_N_ADULTS');
	setupNumberFilter('REQ_N_CHILD_0_3');
	setupNumberFilter('REQ_N_CHILD_4_13');


	/**********************************************************************/

	// Do the first render of requested properties...
	onDatesChange();

	// 09/12/2009 - from property pages
	// Add the "back" link if coming from the search page...
	
	{	// 14/12/2009 - Okay, the link is now always present, but the text changed based on where the user comes from...
		var	linkUrl = null;
		var	linkText = null;
		var	lastSearch = vkDom.getCookie('LAST_SEARCH');

		if(
			lastSearch !== null &&
			this.backToResultListText.length	
		)
		{
			linkUrl = WS_ROOT+_SEARCH_URL+'#'+lastSearch;
			linkText = this.backToResultListText;
			// 22/12/2009 - We no longer forget the last search
			// vkDom.removeCookie('LAST_SEARCH');
		}
		else if(
			lastSearch == null &&
			this.goToSearchText.length	
		)
		{
			linkUrl = WS_ROOT+_SEARCH_URL;
			linkText = this.goToSearchText;
		}

		if(linkUrl)
		{
			(new kigoDom('searchmenus')).append(
				kigoDom.create('div', { 'className' : 'back_to_list' }).append(
					kigoDom.create('a', {
											'href'	:	linkUrl,
											'title'	:	linkText
										}).append(
						kigoDom.create('span').append(
							linkText
						)
					)
				)
			);
		}
	}
}









requestClass.prototype.renderTable = function(requested)
{
	var	self = this;
	var	props, container;
	var	table, tbody, headColumns = [];
	var	showAvailability = vkDom.el('REQ_ARRIVAL').value.length && vkDom.el('REQ_DEPARTURE').value.length && !this.availabilityRequestPending;
	var	choiceSelTpl, trClass;

	if(requested)
	{
		// REQUESTED PROPERTIES
		props = this.requestedProp.array();
		container = 'fieldset-requested';

	}
	else
	{
		// VIEWED PROPERTIES
		props = this.visitedProp.array();
		container = 'fieldset-visited';
	}


	function	createHeaderColumn(text, cls)
	{
		return	kigoDom.create('td', { 'className' : cls }).append(
					kigoDom.create('span').append(
						text
					)
				);
	}


	function	createButtonColumn(text, cls, callback)
	{
		return	kigoDom.create('td', { 'className' : cls }).append(
					kigoDom.create(
						'a',
						{
							'href'		:	'#',
							'title'		:	text
						},
						null,
						callback
					).append(
						kigoDom.create('span').append(
							text
						)
					)
				);
	}



	// Prepare a couple of table-specific elements and callbacks
	if(requested)
	{
		// Setup the "Remove" event
		function	removeEvent(id)
		{
			return {
				'click'	:	
					function()
					{
						// Remove from requested list - add to visited list
						self.visitedProp.add(self.requestedProp.remove(id));

						// Update cookies
						var	requested = [], visited = [];

						self.requestedProp.forEach(
							function(value)
							{
								requested.push(value.ID);
							}
						);
						self.visitedProp.forEach(
							function(val)
							{
								visited.push(val.ID);
							}
						);

						vkDom.setCookie('REQUESTED_PROPERTIES', requested.join(':'));
						vkDom.setCookie('VISITED_PROPERTIES', visited.join(':'));
					
						// Render both
						self.renderRequestedProperties();
						self.renderVisitedProperties();

						return false;
					}
			};
		}
		
		// Setup the "Reorder" event
		function	reorderEvent(sel, id)
		{
			sel.selectedIndex = id;
			sel.onchange = function()
			{
				// Reorder the ordered list
				self.requestedProp.move(id, this.selectedIndex);
				// Render
				self.renderRequestedProperties();
			}

			return sel;
		}

		// Create the dropdown once for all
		choiceSelTpl = new kigoSelect(kigoDom.create('select').domNode());
		for(var i = 0; i < props.length; i++)
			choiceSelTpl.addOption(i, i+1);
		this.selClasses(choiceSelTpl.domNode());

	}
	else
	{
		// Setup the "Add" event
		function	addEvent(id)
		{
			return {
				'click'	:	
					function()
					{
						// Remove from visited list - add to requested list
						self.requestedProp.add(self.visitedProp.remove(id));

						// Update cookies
						var	requested = [], visited = [];

						self.requestedProp.forEach(
							function(value)
							{
								requested.push(value.ID);
							}
						);
						self.visitedProp.forEach(
							function(val)
							{
								visited.push(val.ID);
							}
						);

						vkDom.setCookie('REQUESTED_PROPERTIES', requested.join(':'));
						vkDom.setCookie('VISITED_PROPERTIES', visited.join(':'));
					
						// Render both
						self.renderVisitedProperties();
						self.renderRequestedProperties();

						return false;
					}
			};
		}
	}





	if(props.length)
	{
		if(requested)
		{
			headColumns.push(
				createHeaderColumn('Choice', 'choice')
			);
		}

		headColumns.push(
			createHeaderColumn('Property', 'property')
		);

		if(showAvailability)
		{
			headColumns.push(
				createHeaderColumn('Availability', 'availability')
			);
		}

		if(requested)
		{
			headColumns.push(
				createHeaderColumn('Remove', 'remove')
			);
		}
		else
		{
			headColumns.push(
				createHeaderColumn('Add', 'add')
			);
		}

		/* Build the table & header */

		table = kigoDom.create('table', { 'className' : 'has_availability-'+(showAvailability?'yes':'no') }).append(
			kigoDom.create('thead').append(
				kigoDom.create('tr').appendArray(
					headColumns
				)
			),
			tbody = kigoDom.create('tbody')
		);

		/* Loop on properties and add them */

		for(var i = 0; i < props.length; i++)
		{
			var	bodyColumns = [];

			if(requested)
			{
				bodyColumns.push(
					kigoDom.create('td', { 'className' : 'choice' }).append(
						reorderEvent((new kigoDom(choiceSelTpl.domNode())).clone(true).domNode(), i)
					)
				);
			}

			bodyColumns.push(
				kigoDom.create('td', { 'className' : 'property' }).append(
					kigoDom.create(
						'a',
						{
							'href'		:	props[i].URL,
							'title'		:	props[i].NAME
						}
					).append(
						kigoDom.create(
							'img', 
							{
								'alt'		:	props[i].NAME,
								'title'		:	props[i].NAME,
								'src'		:	WS_ROOT+'ppp/img/FILLRECT-'+this.propPreviewWidth+'-'+this.propPreviewHeight+'-'+props[i].PHOTO+'.jpg'
							}
						),
						kigoDom.create('span').append(
							props[i].NAME
						)
					)
				)
			);

			if(showAvailability)
			{
				var	text, cls;

				if(props[i].AVAILABLE == true)
				{
					text = this.availabilityText.available;
					cls = 'availability-yes';
				}
				else if(props[i].AVAILABLE == false)
				{
					text = this.availabilityText.notAvailable;
					cls = 'availability-no';
				}
				else
				{
					text = this.availabilityText.unknown;
					cls = 'availability-ask';
				}

				bodyColumns.push(
					kigoDom.create('td', { 'className' : 'availability '+cls }).append(
						kigoDom.create('span').append(
							text
						)
					)
				);
			}


			if(requested)
			{
				bodyColumns.push(
					createButtonColumn('Remove', 'remove', removeEvent(i))
				);
			}
			else
			{
				bodyColumns.push(
					createButtonColumn('Add', 'add', addEvent(i))
				);
			}


			// 14/12/2009 - TR classes

			trClass = [ 'e-'+(i+1), i%2 ? 'even' : 'odd' ];

			if(i == 0 && props.length == 1)
				trClass.push('single');
			else if(i == 0)
				trClass.push('first');
			else if(i == props.length-1)
				trClass.push('last');
			else
				trClass.push('middle');

			tbody.append(
				kigoDom.create('tr', { 'className' : trClass.join(' ') }).appendArray(
					bodyColumns
				)
			);
		}


		kigoDom.getById(container).getByTagName('div', 0).empty().append(table);
		vkDom.removeClass(container, 'none');
	}
	else
		vkDom.addClass(container, 'none');
}





requestClass.prototype.renderRequestedProperties = function()
{
	this.renderTable(true);
}


requestClass.prototype.renderVisitedProperties = function()
{
	this.renderTable(false);
}






requestClass.prototype.requestAvailability = function()
{
	this.availabilityRequestPending = true;

	// Fire a render of requested properties (in 'loading' state)
	this.renderRequestedProperties();
	this.renderVisitedProperties();

	this.availabilityAjax.post(
		WS_ROOT + 'ajax/request_availability.xml',
		{
			'ARRIVAL'		:	kigoDate.createFromCalendar(vkDom.el('REQ_ARRIVAL').value).mysql(),
			'DEPARTURE'		:	kigoDate.createFromCalendar(vkDom.el('REQ_DEPARTURE').value).mysql(),
			'PROP'			:	this.allProp
		}
	);
}





requestClass.prototype.onAvailability = function(availability)	// object indexed by property id...
{
	this.availabilityRequestPending = false;

	// Loop on all our lists and assign the new availability information
	function	assignAvailability(value, idx, list)
	{
		list.get(idx).AVAILABLE = (availability && kigo.isset(availability[value.ID])) ? (availability[value.ID] == 1 ? true : false) : null;
	}

	this.requestedProp.forEach(assignAvailability);
	this.visitedProp.forEach(assignAvailability);

	this.renderRequestedProperties();
	this.renderVisitedProperties();
}






/************************************************************************************************************/

requestClass.prototype.onSubmit = function()
{
	
	var	i, field, missing = null, invalid = null;


	// Check mandatory fields

	for(i = 0; i < this.reqFields.length; i++)
	{
		switch(field = this.reqFields[i])
		{
			case 'REQ_ARRIVAL':
			case 'REQ_DEPARTURE':
			case 'REQ_FIRSTNAME':
			case 'REQ_LASTNAME':
			case 'REQ_EMAIL':
			case 'REQ_EMAIL_CONFIRM':
			case 'REQ_PHONE':

				if(!kigo.trim(vkDom.el(field).value).length)
				{
					vkDom.addClass(vkDom.el(field).parentNode, 'missing');
					if(!missing)
						missing = field;
				}
				else
					vkDom.removeClass(vkDom.el(field).parentNode, 'missing');

				break;

			case 'REQ_N_ADULTS':

				if(
					!kigoVal.INT8(vkDom.el(field).value, 1)	// Verify max in a separate test
				)
				{
					vkDom.addClass(vkDom.el(field).parentNode, 'missing');
					if(!missing)
						missing = field;
				}
				else if(
					kigo.intval(vkDom.el(field).value) > 20	// TODO: constantify this!
				)
				{
					vkDom.addClass(vkDom.el(field).parentNode, 'missing');
					if(!invalid)
						invalid = field;
				}
				else
					vkDom.removeClass(vkDom.el(field).parentNode, 'missing');

				break;

			case 'REQ_N_CHILD_0_3':
			case 'REQ_N_CHILD_4_13':

				// These may be empty but if set may not exceed boundaries
				if(
					kigo.trim(vkDom.el(field).value).length &&
					!kigoVal.INT8(vkDom.el(field).value, 0, 20)
				)
				{
					vkDom.addClass(vkDom.el(field).parentNode, 'missing');
					if(!invalid)
						invalid = field;
				}
				else
					vkDom.removeClass(vkDom.el(field).parentNode, 'missing');

				break;

			case 'REQ_COUNTRY':

				if(!vkDom.el(field).selectedIndex)
				{
					vkDom.addClass(vkDom.el(field).parentNode, 'missing');
					if(!missing)
						missing = field;
				}
				else
					vkDom.removeClass(vkDom.el(field).parentNode, 'missing');

				break;
		}
	}


	if(missing)
	{
		vkDom.focus(missing);
		alert(this.missingText);
		return;
	}

	if(invalid)
	{
		vkDom.focus(invalid);
		alert(this.invalidText);
		return;
	}


	if(vkDom.el('REQ_EMAIL').value != vkDom.el('REQ_EMAIL_CONFIRM').value)
	{
		vkDom.addClass(vkDom.el('REQ_EMAIL').parentNode, 'missing');
		vkDom.addClass(vkDom.el('REQ_EMAIL_CONFIRM').parentNode, 'missing');

		alert(this.emailConfirmFailureText);
		return;
	}


	if(!kigoVal.EMAIL(vkDom.el('REQ_EMAIL').value))
	{
		vkDom.addClass(vkDom.el('REQ_EMAIL').parentNode, 'missing');
		vkDom.addClass(vkDom.el('REQ_EMAIL_CONFIRM').parentNode, 'missing');

		alert(this.emailInvalidText);
		return;
	}


	// Okay, we're ready for submitting the request...
	// Build the post object
	var	po = {};


	po.REQ_ARRIVAL = kigoDate.createFromCalendar(vkDom.el('REQ_ARRIVAL').value).mysql();
	po.REQ_DEPARTURE = kigoDate.createFromCalendar(vkDom.el('REQ_DEPARTURE').value).mysql();

	po.REQ_SELECTED = [];
	this.requestedProp.forEach(
		function(value)
		{
			po.REQ_SELECTED.push(value.ID);
		}
	);
	
	po.REQ_VISITED = [];
	this.visitedProp.forEach(
		function(value)
		{
			po.REQ_VISITED.push(value.ID);
		}
	);

	po.REQ_FIRSTNAME = kigo.trim(vkDom.el('REQ_FIRSTNAME').value);
	po.REQ_LASTNAME = kigo.trim(vkDom.el('REQ_LASTNAME').value);
	po.REQ_EMAIL = kigo.trim(vkDom.el('REQ_EMAIL').value);
	po.REQ_PHONE = kigo.trim(vkDom.el('REQ_PHONE').value);

	po.REQ_N_ADULTS = kigo.intval(vkDom.el('REQ_N_ADULTS').value);
	po.REQ_N_CHILD_0_3 = kigoVal.INT8(vkDom.el('REQ_N_CHILD_0_3').value) ? kigo.intval(vkDom.el('REQ_N_CHILD_0_3').value) : 0;
	po.REQ_N_CHILD_4_13 = kigoVal.INT8(vkDom.el('REQ_N_CHILD_4_13').value) ? kigo.intval(vkDom.el('REQ_N_CHILD_4_13').value) : 0;
	
	po.REQ_COUNTRY = (new kigoSelect('REQ_COUNTRY')).getValue();

	po.REQ_COMMENT = kigo.trim(vkDom.el('REQ_COMMENT').value);

	// Remember the object for error/timeout retries
	this.submitObject = po;

	// Remember some values (in cookies) for the next request (remember them for a month or so)
	for(i = 0; i < this.reqFields.length; i++)
	{
		switch(field = this.reqFields[i])
		{
			case 'REQ_FIRSTNAME':
			case 'REQ_LASTNAME':
			case 'REQ_EMAIL':
			case 'REQ_EMAIL_CONFIRM':
			case 'REQ_PHONE':
			/*
			case 'REQ_N_ADULTS':
			case 'REQ_N_CHILD_0_3':
			case 'REQ_N_CHILD_4_13':
			*/
				vkDom.setCookie(field, vkDom.el(field).value, 2592000);	// 30 days
				break;

			case 'REQ_COUNTRY':
				vkDom.setCookie(field, (new kigoSelect(field)).getValue(), 2592000);	// 30 days
				break;
		}
	}

	vkDom.addClass('make_request', 'submitting');
	this.submit();
}



requestClass.prototype.submit = function()
{
	this.submitAjax.post(
		WS_ROOT + 'ajax/submit_request.xml',
		this.submitObject
	);
}


requestClass.prototype.onSubmitResult = function(resId)
{
	var	self = this;

	if(resId != null)
	{
		// 08/12/2009
		// Okay, do a google adwords request for all the requested properties. Wait till we get a reply for every image load...

		this.requestAdwords = new requestAdwordsClass();

		this.requestAdwords.onLoad = function()
		{
			window.location = self.thanksPage;
		}


		this.requestedProp.forEach(
			function(value)
			{
				if(value.GAW != null)
					self.requestAdwords.add(value.GAW);
			}
		);

		this.requestAdwords.load(2);	// 2 threads
	}
	else
		this.onSubmitError();
}

requestClass.prototype.onSubmitError = function()
{
	if(confirm(this.errorRetryText))
		this.submit();
	else
	{
		alert(this.errorText);
		vkDom.removeClass('make_request', 'submitting');
	}
}



/*********************************************/
/* TOOLS */

requestClass.prototype.selClasses = function(sel)
{
	// Post-processes a dropdown and assigns e-x and single/first/middle/last classes
	var	cls;

	for(var i = 0; i < sel.length; i++)
	{
		cls = [ 'e-'+(i+1), i%2 ? 'even' : 'odd'];

		if(i == 0 && sel.length == 1)
			cls.push('single');
		else if(i == 0)
			cls.push('first');
		else if(i == sel.length-1)
			cls.push('last');
		else
			cls.push('middle');

		sel.options[i].className = cls.join(' ');
	}
}





















/************************************************************************************************************/
/* Google adwords > helper class for recording several requests */

function	requestAdwordsClass()
{
	this.queue = [];
	this.loading = [];
	this.remaining = 0;
}

requestAdwordsClass.prototype.add = function(url)
{
	this.queue.push(url);
}

requestAdwordsClass.prototype.load = function(threads)
{
	if(!(this.remaining = this.queue.length))
	{
		this.onLoad();
		return
	}

	for(var i = 0; i < threads; i++)
		this.unqueueNext();
}

requestAdwordsClass.prototype.unqueueNext = function()
{
	var	self = this;

	function	onImageLoad()
	{
		if(!(--self.remaining))
			self.onLoad();
		else
			self.unqueueNext();
	}

	if(this.queue.length)
	{
		var	img = new Image();


		if(window.addEventListener)
		{
			img.addEventListener('load', onImageLoad, false);
			img.addEventListener('error', onImageLoad, false);
		}
		else
		{
			img.attachEvent('onload', onImageLoad);
			img.attachEvent('onerror', onImageLoad);
		}
		
		img.src = this.queue.shift();

		// Keep reference to this element
		this.loading.push(img);
	}
}



requestAdwordsClass.prototype.onLoad = function()
{
	// To be overriden
}