var points = [];
var marker = null;
var highlighted_marker = null;
var point_markers = [];


var coord, tabset, marker;
var g_map = null;
var geocoder = null;


function load_map( dom_id, lat, lon, map_html ) {
  if (GBrowserIsCompatible()) {
	coord = new GLatLng( lat, lon );
	tabset = [ new GInfoWindowTab("General", map_html) ];
	
	//alert(map_html);
	g_map = new GMap2(document.getElementById( dom_id ));
	g_map.addControl( new GSmallMapControl() );
	g_map.addControl( new GMapTypeControl(true) );
	g_map.setCenter(coord, 13);
	
	//Create Marker & Listener
	marker = new GMarker( coord );
	GEvent.addListener(marker, "click", function() {
		marker.openInfoWindowTabsHtml( tabset );
	});
	
	g_map.addOverlay( marker );
	marker.openInfoWindowTabsHtml( tabset );
	
	geocoder = new GClientGeocoder();
  }
}

/*
function showAddress(address) {
  if (geocoder) {
	  
	geocoder.getLatLng(
		address,
		function(point) {
		  if (!point) {
			alert(address + " not found");
		  } else {
			g_map.setCenter(point, 13);
			
			//Create Marker & Listener
			//marker = new GMarker( point );
			marker.setLatLng( point );
			
			//g_map.addOverlay(marker);
			marker.openInfoWindowHtml( tabset );
		  }
		}
	);
	
  }	
}
*/





// Encode a signed number in the encode format.
function encodeSignedNumber(num) {
  var sgn_num = num << 1;

  if (num < 0) {
    sgn_num = ~(sgn_num);
  }

  return(encodeNumber(sgn_num));
}

// Encode an unsigned number in the encode format.
function encodeNumber(num) {
  var encodeString = "";

  while (num >= 0x20) {
    encodeString += (String.fromCharCode((0x20 | (num & 0x1f)) + 63));
    num >>= 5;
  }

  encodeString += (String.fromCharCode(num + 63));
  return encodeString;
}


// Create the encoded polyline and level strings.
function createEncodings(pset, version) {
  var i = 0;

  var plat = 0;
  var plng = 0;

  var encoded_points = "";
  var encoded_levels = "";
  
  if( isUndefined(version) ){
	  version = '2';
  }
  //alert(JSON.stringify(pset))

  for(i = 0; i < pset.length; ++i) {
    var point = pset[i];
	if(version == '3'){
		//var myLatlng = new google.maps.LatLng(point.b, point.c);
		var lat = point.b;
		var lng = point.c;
	}else{
		if( isset(point.Latitude) ){
			var lat = point.Latitude;
			var lng = point.Longitude;
		}else if( isset(point.Ud) ){
			var lat = point.Ud;
			var lng = point.La;			
		}
		
		if( isset(point.Level) ){
			var level = point.Level;
		}
	}    


    var late5 = Math.round(lat * 1e5);
    var lnge5 = Math.round(lng * 1e5);

    dlat = late5 - plat;
    dlng = lnge5 - plng;

    plat = late5;
    plng = lnge5;

    encoded_points += encodeSignedNumber(dlat) + encodeSignedNumber(dlng);
    
	if( isset(point.Level) ){
		encoded_levels += encodeNumber(level);
	}
  }
  
  result = {'points': encoded_points, 'levels': encoded_levels};

  return result;
}


// Decode an encoded polyline into a list of lat/lng tuples.
function decodeLine (encoded, version) {
  var len = encoded.length;
  var index = 0;
  var array = [];
  var lat = 0;
  var lng = 0;
  
  if( isUndefined(version) ){
	  version = '2';
  }
  //txt = '';

  while (index < len) {
    var b;
    var shift = 0;
    var result = 0;
    do {
      b = encoded.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    var dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lat += dlat;

    shift = 0;
    result = 0;
    do {
      b = encoded.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    var dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lng += dlng;

	if(version == '3'){
		var myLatlng = new google.maps.LatLng(lat * 1e-5, lng * 1e-5);
		//alert( JSON.stringify(myLatlng) );
		array.push(myLatlng);
	}else{
    	array.push([lat * 1e-5, lng * 1e-5]);
	}
	//txt += "\n"+JSON.stringify( [lat * 1e-5, lng * 1e-5] );
  }
  //alert( txt );  

  return array;
}

// Decode an encoded levels string into a list of levels.
function decodeLevels(encoded) {
  var levels = [];

  for (var pointIndex = 0; pointIndex < encoded.length; ++pointIndex) {
    var pointLevel = encoded.charCodeAt(pointIndex) - 63;
    levels.push(pointLevel);
  }

  return levels;
}


function pointsToLatLon(json_coords){
	var points = [];
	for (var i = 0; i < json_coords.length; i++) {
		if( isset(json_coords[i].lat) ){ 
			var point = new GLatLng(json_coords[i].lat, json_coords[i].lon);
		}else{
			var point = new GLatLng(json_coords[i][0], json_coords[i][1]);
		}
		points.push(point);
	}
	return points;
}


function getVertices(polyObj, version){
	var array = [];
	
	if( isUndefined(version) ){
		version = '2';
	}

	if(version == '3'){	
		polyObj.forEach(function(v, k){
			array.push(v);
		});
	}else{
		for(x=0;x<polyObj.getVertexCount();x++){
			latlon = polyObj.getVertex(x);
			array.push(latlon);
		}	
	}
	
	return array;
}


// Determines if a point is inside a polygon
function inZone(pt, polyObj, version){
	if( isUndefined(version) ){
		version = '2';
	}
	
	var isInZone = 0;
    var points = getVertices(polyObj, version);
	var j = polyObj.getVertexCount()-1;
    for (var i = 0; i < points.length; j = i++) {
        if ((((points[i].lat() <= pt.lat()) && (pt.lat() < points[j].lat())) ||
             ((points[j].lat() <= pt.lat()) && (pt.lat() < points[i].lat()))) &&
            (pt.lng() < (points[j].lng() - points[i].lng()) *
             (pt.lat() - points[i].lat()) / (points[j].lat() - points[i].lat()) + points[i].lng())) {
            isInZone++;
        }
    }
    if ((isInZone % 2) == 0) {
        return false;
    }
    else {
        return true;
    }
}