if (Object.isUndefined(GoogleMaps)) { var GoogleMaps = {conf:false} };
GoogleMaps.map;
GoogleMaps.markerIcon;
GoogleMaps.fromAddress;
GoogleMaps.name;
GoogleMaps.address;
GoogleMaps.isLoaded = false;
GoogleMaps.specialMarker = false;
GoogleMaps.routeMap = false;
GoogleMaps.markerInformation = {};
var routeMarkers = {};
PbLib.module.load('loader');

GoogleMaps.removeMarker = function (marker)
{
	return GoogleMaps.map.removeOverlay(marker);
}

GoogleMaps.setNewCenter = function (point, zoomlevel, maptype)
{
	return GoogleMaps.map.setCenter(point, parseInt(zoomlevel), maptype);
}

GoogleMaps.wheelevent = function(e)
{
	var event = e || window.event;
	if (event.preventDefault){
		event.preventDefault()
	}
	event.returnValue = false;
}

GoogleMaps.handleErrors = function()
{
	if (GoogleMaps.direction.getStatus().code == G_GEO_UNKNOWN_ADDRESS) {
		alert("No corresponding geographic location could be found for one of the specified addresses. This may be due to the fact that the address is relatively new, or it may be incorrect.\nError code: " + GoogleMaps.direction.getStatus().code);
	} else if (GoogleMaps.direction.getStatus().code == G_GEO_SERVER_ERROR) {
		alert("A geocoding or directions request could not be successfully processed, yet the exact reason for the failure is not known.\n Error code: " + GoogleMaps.direction.getStatus().code);
	} else if (GoogleMaps.direction.getStatus().code == G_GEO_MISSING_QUERY) {
		alert("The HTTP q parameter was either missing or had no value. For geocoder requests, this means that an empty address was specified as input. For directions requests, this means that no query was specified in the input.\n Error code: " + GoogleMaps.direction.getStatus().code);
	} else if (GoogleMaps.direction.getStatus().code == G_GEO_BAD_KEY) {
		alert("The given key is either invalid or does not match the domain for which it was given. \n Error code: " + GoogleMaps.direction.getStatus().code);
	} else if (GoogleMaps.direction.getStatus().code == G_GEO_BAD_REQUEST) {
		alert("A directions request could not be successfully parsed.\n Error code: " + GoogleMaps.direction.getStatus().code);
	} else {
		alert("An unknown error occurred.");
	}
}

GoogleMaps.copyPolyline = function(polyLine)
{
	var pLinePoints = Array();
	for (var n = 0; n < polyLine.getVertexCount(); n++) {
		pLinePoints.push(polyLine.getVertex(n));
	}
	return new GPolyline(pLinePoints, '#F7098A');
}

GoogleMaps.checkOverview = function()
{
	if (GoogleMaps.mapControls.goverviewmapcontrol.getOverviewMap()) {
		setTimeout("GoogleMaps.mapControls.goverviewmapcontrol.getOverviewMap().setMapType(eval(GoogleMaps.conf.defaultmaptype))", 5);
	} else {
		setTimeout("GoogleMaps.checkOverview()", 10);
	}
}

GoogleMaps.prepair = function ()
{
	var relationMap = $("googlemaps");
	if (GBrowserIsCompatible()) {
		if (!GoogleMaps.conf.defaultnotvisible) {
			GoogleMaps.map = new GMap2(relationMap);
			relationMap.setStyle({'overflow':'hidden'});
			if (GoogleMaps.conf.maptypecontrol == 1) {
				GoogleMaps.map.addControl(new GMapTypeControl());
			} else if (GoogleMaps.conf.maptypecontrol == 2) {
				GoogleMaps.map.addControl(new GHierarchicalMapTypeControl());
			}
			if (GoogleMaps.conf.zoomcontrol == 1) {
				GoogleMaps.map.addControl(new GSmallMapControl());
			} else if (GoogleMaps.conf.zoomcontrol == 2) {
				GoogleMaps.map.addControl(new GLargeMapControl());
			}
			if (GoogleMaps.conf.overviewmapcontrol) {
				GoogleMaps.mapControls.goverviewmapcontrol = new GOverviewMapControl();
				GoogleMaps.map.addControl(GoogleMaps.mapControls.goverviewmapcontrol);
				setTimeout("GoogleMaps.checkOverview()", 10);
			}
			if (GoogleMaps.conf.scalecontrol) {
				GoogleMaps.map.addControl(new GScaleControl());
			}
			if (!GoogleMaps.conf.draggable && !GoogleMaps.conf.doubleclick && !GoogleMaps.conf.overviewmapcontrol) {
				GoogleMaps.map.disableDragging();
			} else if (!GoogleMaps.conf.draggable) {
				GEvent.addListener(GoogleMaps.map, "dragstart", function(){
					GoogleMaps.currentPosition = GoogleMaps.map.getCenter();
					GoogleMaps.currentZoomlevel = GoogleMaps.map.getZoom();
				});
				GEvent.addListener(GoogleMaps.map, "dragend", function(){
					GoogleMaps.setNewCenter(GoogleMaps.currentPosition, GoogleMaps.currentZoomlevel);
				});
			}
			if (GoogleMaps.conf.doubleclick) {
				GoogleMaps.map.enableDoubleClickZoom();
			} else {
				GoogleMaps.map.disableDoubleClickZoom();
			}
			if (!GoogleMaps.conf.showinfowindow) {
				GoogleMaps.map.disableInfoWindow();
			}
			GoogleMaps.markerIcon = new GIcon();
			if (!GoogleMaps.conf.icon) {
				GoogleMaps.conf.icon = {
					url : PbLib.getNewURI('files/mod_googlemaps') + '/img/icon_gmap_procurios.png',
					width : 17,
					height : 20
				};
			}
			if (GoogleMaps.conf.icon) {
				if (GoogleMaps.conf.icon.url && GoogleMaps.conf.icon.width && GoogleMaps.conf.icon.height) {
					GoogleMaps.markerIcon.image = GoogleMaps.conf.icon.url;
					if (GoogleMaps.conf.shadow) {
						GoogleMaps.markerIcon.shadow = GoogleMaps.conf.shadow.url;
						GoogleMaps.markerIcon.shadowSize = new GSize(GoogleMaps.conf.shadow.width, GoogleMaps.conf.shadow.height);
					}

					GoogleMaps.markerIcon.iconSize = new GSize(GoogleMaps.conf.icon.width, GoogleMaps.conf.icon.height);
					if (GoogleMaps.conf.anchorpoint) {
						if (GoogleMaps.conf.anchorpoint == 'centre') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint((GoogleMaps.conf.icon.width / 2), (GoogleMaps.conf.icon.height / 2));
						} else if (GoogleMaps.conf.anchorpoint == 'topleft') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(0, 0);
						} else if (GoogleMaps.conf.anchorpoint == 'leftcentre') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(0, (GoogleMaps.conf.icon.height / 2));
						} else if (GoogleMaps.conf.anchorpoint == 'bottomleft') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(0, GoogleMaps.conf.icon.height);
						} else if (GoogleMaps.conf.anchorpoint == 'bottomcentre') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint((GoogleMaps.conf.icon.width / 2), GoogleMaps.conf.icon.height);
						} else if (GoogleMaps.conf.anchorpoint == 'bottomright') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(GoogleMaps.conf.icon.width, GoogleMaps.conf.icon.height);
						} else if (GoogleMaps.conf.anchorpoint == 'rightcentre') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(GoogleMaps.conf.icon.width, (GoogleMaps.conf.icon.height / 2));
						} else if (GoogleMaps.conf.anchorpoint == 'topright') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint(GoogleMaps.conf.icon.width, 0);
						} else if (GoogleMaps.conf.anchorpoint == 'topcentre') {
							GoogleMaps.markerIcon.iconAnchor = new GPoint((GoogleMaps.conf.icon.width / 2), 0);
						}
					}
				}
			}
			if (GoogleMaps.conf.scrollwheelzoom) {
				GoogleMaps.map.enableScrollWheelZoom();
				GEvent.addDomListener(GoogleMaps.map.getContainer(), "DOMMouseScroll", GoogleMaps.wheelevent);
				GoogleMaps.map.getContainer().onmousewheel = GoogleMaps.wheelevent;
			}
			if (GoogleMaps.conf.routeoptions > 0) {
				if (!GoogleMaps.direction) {
					GoogleMaps.direction = new GDirections();
					GoogleMaps.directionPoly;
					GEvent.addListener(GoogleMaps.direction, "error", GoogleMaps.handleErrors);
					GEvent.addListener(GoogleMaps.direction, "load", GoogleMaps.handleLoad);
				}
			}
			GoogleMaps.setNewCenter(new GLatLng(GoogleMaps.conf.lat, GoogleMaps.conf.lng), GoogleMaps.conf.zoomlevel, eval(GoogleMaps.conf.defaultmaptype));
			return true;
		} else {
			return false;
		}
	} else {
		relationMap.innerHTML = 'Sorry, your browser is not compatable with google maps';
	}
}

GoogleMaps.showInfoWindow = function (point, message, routeInfo)
{
	GoogleMaps.map.openInfoWindowHtml(point, message.infowindow + (routeInfo ? "<br /><a href='#' onclick='GoogleMaps.calculateRoute(\"" + routeInfo.lat + "\", \"" + routeInfo.lng + "\", \"" + message.lat + "\", \"" + message.lng + "\", \"" + message.name + "\", \"" + message.address + "\")'>Route</a>" : ""), {'maxWidth':150});
}

GoogleMaps.addMarker = function(markerInfo, routeInfo){
		GoogleMaps.markerInformation[markerInfo.relationid] = {
			'markerInfo': markerInfo,
			'routeInfo': routeInfo
		};
		routeMarkers[markerInfo.relationid] = GoogleMaps.createMarker(new GLatLng(markerInfo.lat, markerInfo.lng), markerInfo, routeInfo);
		GoogleMaps.map.addOverlay(routeMarkers[markerInfo.relationid]);
	}

GoogleMaps.createMarker = function(point, markerInfo, routeInfo){
	var markerOptions = {};
	if (GoogleMaps.markerIcon)
		markerOptions.icon = GoogleMaps.markerIcon;

	var marker = new GMarker(point, markerOptions);
	marker.value = markerInfo.name;
	GEvent.addListener(marker, "click", function(){
		if (!GoogleMaps.routeMap) {
			GoogleMaps.showRelationInformation(markerInfo.relationid);
		}
		else {
			GoogleMaps.showRelationInformation(markerInfo.relationid);
			GoogleMaps.showInfoWindow(point, markerInfo, routeInfo);
		}
	});
	return marker;
}

GoogleMaps.calculateRoute = function(startLat, startLng, endLat, endLng, name, address){
	PbLib.startLoader('');
	GoogleMaps.map.closeInfoWindow();
	GoogleMaps.name = name;
	GoogleMaps.address = address;
	var toAddress = endLat + ',' + endLng;
	GoogleMaps.direction.load("from: " + GoogleMaps.fromAddress + " to: " + toAddress, {
		"locale": $F('country'),
		getPolyline: true,
		getSteps: true
	});
	PbLib.stopLoader();
}

GoogleMaps.handleSubmit = function()
{
	GoogleMaps.routeMap = true;
	var searchBox = document.getElementById('googlemapsearch');
	GoogleMaps.fromAddress = $F('googlemapsearch').strip();

	$('googlemapsearch').update = GoogleMaps.fromAddress;
	if (GoogleMaps.isLoaded) {
		GoogleMaps.map.closeInfoWindow();

		if (GoogleMaps.conf.route && GoogleMaps.conf.routedescription) {
			$('routebox').childElements().each(function(childElement){childElement.remove();});
		}
	}
	if (!GoogleMaps.fromAddress.empty()) {
		PbLib.startLoader('');
		new Ajax.Request(PbLib.getNewURI('l/googlemaps/getnearestpoint'), {
			asynchronuos: false,
			parameters: {
							address:GoogleMaps.fromAddress,
							relation:GoogleMaps.conf.relationid,
							max:GoogleMaps.conf.numberofrelations,
							relationtype:GoogleMaps.conf.relationtypeid,
							addresstype:GoogleMaps.conf.addresstypeid,
							infowindowrow:GoogleMaps.conf.infowindowrow,
							searchresultrow:GoogleMaps.conf.searchresultrow,
							'country': $F('country')
						},
			onSuccess: function (response) {
				if (GoogleMaps.conf.routedescription) {
					$('routebox').hide();
				}
				if (!GoogleMaps.isLoaded) {
					$('googlemaps').setStyle({
						'width':parseInt(GoogleMaps.conf.width) + 'px',
						'height':parseInt(GoogleMaps.conf.height) + 'px'
						}).show();
					GoogleMaps.conf.defaultvisible = true;
					GoogleMaps.isLoaded = GoogleMaps.prepair();
				}
				response = response.responseText.evalJSON();
				if (!response.error) GoogleMaps.map.clearOverlays();
				$('search_result_box').childElements().each(function(childElement){childElement.remove();});
				var table = new Element('table', {'class': 'searchresult'});
				if (!response.error) {
					if (GoogleMaps.conf.maxresults > 1) {
						var square = new GLatLngBounds(new GLatLng(response.lat, response.lng));
						response.message.each(function(message){
							square.extend(new GLatLng(message.lat, message.lng));
							GoogleMaps.addMarker(message, response);
						});
						var icon = new GIcon();
						icon.image = PbLib.getNewURI('files/mod_googlemaps/icons/flag_green16.png');
						icon.iconSize = new GSize(16, 16);
						icon.iconAnchor = new GPoint(8, 16);
						var options = {};
						options.icon = icon;
						var marker = new GMarker(new GLatLng(response.lat, response.lng), options);
						GoogleMaps.map.addOverlay(marker);

						GoogleMaps.setNewCenter(square.getCenter(), GoogleMaps.map.getBoundsZoomLevel(square));
					}
					var count = 0;
					if (!Object.isUndefined(GoogleMaps.conf.routeToRelationid)) {
						response.message.each(function(elem) {
							if (elem.relationid == GoogleMaps.conf.routeToRelationid) {
								GoogleMaps.calculateRoute(response.lat, response.lng, elem.lat, elem.lng, elem.name, elem.address);
								if (elem.relationid != GoogleMaps.specialMarker) {
									if (routeMarkers[GoogleMaps.specialMarker]) {
										routeMarkers[GoogleMaps.specialMarker].setImage(GoogleMaps.conf.icon.url);
									}
									routeMarkers[elem.relationid ].setImage(GoogleMaps.conf.overicon);
									GoogleMaps.specialMarker = elem.relationid ;
									$('vestiging').value = elem.relationid ;
									new Ajax.Request(PbLib.getNewURI('l/koopzondag/getopening'), {
										asynchronuos: true,
										parameters: {
											relationid: elem.relationid,
											relationname: routeMarkers[GoogleMaps.specialMarker].value,
											addresstypeid: GoogleMaps.conf.addresstypeid,
											phonetypeid: GoogleMaps.conf.phonetypeid
										},
										onSuccess: function (response) {
											$('openinglist').update(response.responseText.evalJSON());
										}
									});
								}
							}
						}).bind(GoogleMaps, response);
					} else {
						GoogleMaps.calculateRoute(response.lat, response.lng, response.message.first().lat, response.message.first().lng, response.message.first().name, response.message.first().address);
						if (response.message.first().relationid != GoogleMaps.specialMarker) {
							if (routeMarkers[GoogleMaps.specialMarker]) {
								routeMarkers[GoogleMaps.specialMarker].setImage(GoogleMaps.conf.icon.url);
							}
							routeMarkers[response.message.first().relationid ].setImage(GoogleMaps.conf.overicon);
							GoogleMaps.specialMarker = response.message.first().relationid ;
							$('vestiging').value = response.message.first().relationid ;
							new Ajax.Request(PbLib.getNewURI('l/koopzondag/getopening'), {
								asynchronuos: true,
								parameters: {
									relationid: response.message.first().relationid,
									relationname: routeMarkers[GoogleMaps.specialMarker].value,
									addresstypeid: GoogleMaps.conf.addresstypeid,
									phonetypeid: GoogleMaps.conf.phonetypeid
								},
								onSuccess: function (response) {
									$('openinglist').update(response.responseText.evalJSON());
								}
							});
						}
					}
				}
				PbLib.stopLoader();
			}
		});
	}
}

GoogleMaps.handleLoad = function(){
	PbLib.startLoader('');
	if (GoogleMaps.directionPoly)
		GoogleMaps.map.removeOverlay(GoogleMaps.directionPoly);
	GoogleMaps.directionPoly = GoogleMaps.direction.getPolyline();
	GoogleMaps.setNewCenter(GoogleMaps.directionPoly.getBounds().getCenter(), GoogleMaps.map.getBoundsZoomLevel(GoogleMaps.directionPoly.getBounds()));
	GoogleMaps.map.addOverlay(GoogleMaps.directionPoly);
	if (GoogleMaps.conf.routeoptions > 1 && !$('routedescriptionlink')) {
		var routeDescriptionLink = new Element('img', {'id':'routedescriptionlink', 'src':PbLib.getNewURI('files/mod_brugman_forms/img/button_route.png'), 'class':'route-button'});
		Event.observe(routeDescriptionLink, 'click', function(event){
			var route = GoogleMaps.direction.getRoute(0);
			var routeDescription = PbLib.createDialog(null, 300, 400);
			$(routeDescription).setStyle({'overflow':'auto'});
			var table = new Element('table', {
				'class': 'routedescription'
			});
			$(routeDescription).update(table);
			var tbody = new Element('tbody');
			table.update(tbody);

			var step;
			var row;
			var cell;
			tbody.insert({top: new Element('tr', {'class': 'fromaddress'})
				.insert(new Element('th').update(new Element('img', {'src': PbLib.getNewURI('files/mod_googlemaps/icons/flag_green16.png')})))
				.insert(new Element('th').update(route.getStartGeocode().address))
				.insert(new Element('th', {'class': 'print'}).update(new Element('img', {'src': PbLib.getNewURI('files/mod_brugman_forms/img/printericon_brugman.png')})
					.observe("click", function(){window.open('http://maps.google.nl/maps?saddr=' + route.getStep(0).getLatLng().toUrlValue() + '&daddr=' + route.getEndLatLng().toUrlValue() + '&f=d&ie=UTF8&t=p&pw=2');})))
			});
			tbody.insert({
				bottom: new Element('tr').insert(new Element('td', {
					'colspan': '3'
				}).update(route.getSummaryHtml()))
			});

			for (var i = 0; i < route.getNumSteps(); i++) {
				step = route.getStep(i);
				tbody.insert({
					bottom: row = new Element('tr', {}).insert(new Element('td').update(i + 1)).insert(new Element('td').update(step.getDescriptionHtml())).insert(new Element('td', {
						'class': 'distance'
					}).update(step.getDistance().html))
				});
				if (i == (route.getNumSteps() - 1))
					row.addClassName('last');
			}
			tbody.insert({
				bottom: new Element('tr', {
					'class': 'toaddress'
				}).insert(new Element('th').update(new Element('img', {
					'src': GoogleMaps.conf.icon.url
				}))).insert(new Element('th', {
					'colSpan': '2'
				}).update(GoogleMaps.name + '<br />' + GoogleMaps.address))
			});
			Event.stop(event);
		});
		$('tomtom').insert({
			'before': routeDescriptionLink
		});
	}
	PbLib.stopLoader();
}

GoogleMaps.showRelationInformation = function(relationid) {
	if (relationid != GoogleMaps.specialMarker) {
		if (routeMarkers[GoogleMaps.specialMarker]) {
			routeMarkers[GoogleMaps.specialMarker].setImage(GoogleMaps.conf.icon.url);
		}
		routeMarkers[relationid].setImage(GoogleMaps.conf.overicon);
		GoogleMaps.specialMarker = relationid;
		$('vestiging').value = relationid;
		new Ajax.Request(PbLib.getNewURI('l/koopzondag/getopening'), {
			asynchronuos: true,
			parameters: {
				relationid: relationid,
				relationname: routeMarkers[GoogleMaps.specialMarker].value,
				addresstypeid: GoogleMaps.conf.addresstypeid,
				phonetypeid: GoogleMaps.conf.phonetypeid
			},
			onSuccess: function (response) {
				$('openinglist').update(response.responseText.evalJSON());
			}
		});
	}
}

GoogleMaps.getRelations = function () {
	new Ajax.Request(GoogleMaps.conf.url + '/' + GoogleMaps.conf.relationid, {
		parameters: {
			relation:GoogleMaps.conf.relationid,
			relationtype:GoogleMaps.conf.relationtypeid,
			addresstype:GoogleMaps.conf.addresstypeid,
			infowindowrow:GoogleMaps.conf.infowindowrow
		},
		onSuccess: function(response){
			var square = new GLatLngBounds();
			response.responseText.evalJSON().each(function(markerInfo){
				if (GoogleMaps.conf.autopan) {
					square.extend(new GLatLng(markerInfo.lat, markerInfo.lng));
				}
				GoogleMaps.addMarker(markerInfo);
			});
			if (GoogleMaps.conf.autopan) {
				GoogleMaps.setNewCenter(square.getCenter(), GoogleMaps.map.getBoundsZoomLevel(square));
			}
		}
	});
}

document.observe ("dom:loaded", function()
{
	if (GoogleMaps.conf.searchform != 2) {
		if ($('tablinks_informationwindow_search')) {$('tablinks_informationwindow_search').hide();}
	}
	if ($('tablinks_informationwindow_searchresult')) {$('tablinks_informationwindow_searchresult').hide();}
	if ($('tablinks_informationwindow_searchoptions')) {$('tablinks_informationwindow_searchoptions').hide();}
	if ($('tablinks_informationwindow_route')) {$('tablinks_informationwindow_route').hide();}
	GoogleMaps.isLoaded = GoogleMaps.prepair();
	if (GoogleMaps.isLoaded) {
		if (GoogleMaps.conf.url && !GoogleMaps.conf.address) {
			GoogleMaps.getRelations();
		}
	}
	if (GoogleMaps.conf.issearchable) {
		Event.observe($('searchform'), 'submit', function(event) {
			GoogleMaps.handleSubmit();
			Event.stop(event);
		});
		if (GoogleMaps.conf.address) {
			GoogleMaps.handleSubmit();
		}
		if (GoogleMaps.conf.showrelationbutton) {
			Event.observe($('showrelationbutton'), 'click', function(event) {
				$('googlemapscontainer').setStyle({'width':((GoogleMaps.conf.searchposition.match('(left|right)') && !GoogleMaps.conf.hidesearch ? parseInt(GoogleMaps.conf.searchwidth) : 0) + parseInt(GoogleMaps.conf.width)) + 'px'});
				if (GoogleMaps.conf.routedescription) {
					$('routebox').hide();
				}
				if (!GoogleMaps.isLoaded) {
					$('googlemaps').setStyle({
						'width':parseInt(GoogleMaps.conf.width) + 'px',
						'height':parseInt(GoogleMaps.conf.height) + 'px'
						}).show();
					GoogleMaps.conf.defaultvisible = true;
					GoogleMaps.isLoaded = GoogleMaps.prepair();
				}
				GoogleMaps.map.clearOverlays();
				$('search_result_box').childElements().each(function(childElement){childElement.remove();});
				GoogleMaps.getRelations();
			});
		}
	}

	$('vestiging').observe ('change', function() {
		if ($F(this) != 0) {
			if (GoogleMaps.specialMarker) {
				if ($F(this) != GoogleMaps.specialMarker) {
					GoogleMaps.showRelationInformation($F(this));
				}
			}
			else {
				GoogleMaps.showRelationInformation($F(this));
			}
			if (GoogleMaps.routeMap && GoogleMaps.markerInformation[$F(this)]) {
				GoogleMaps.showInfoWindow(routeMarkers[$F(this)].getPoint(), GoogleMaps.markerInformation[$F(this)].markerInfo, GoogleMaps.markerInformation[$F(this)].routeInfo);
			}
		}
	});

	Event.observe(window, 'unload', function()
	{
		if (GoogleMaps.isLoaded) {
			GoogleMaps.map.clearOverlays();
			GEvent.clearInstanceListeners(GoogleMaps.map.getContainer());
			GUnload();
		}
	})
})