/*********************************
*** Class: PPolyCreatorOptions ***
*********************************/
PPolyCreatorOptions = function() {
	this.icon = new PIcon();
	this.icon.image = PEnvironment.kamapUrl + "images/icon_polypoint.gif";
	this.icon.iconSize = new PSize(10,10);
	this.icon.shadowSize = new PSize(0,0);
	this.icon.iconAnchor = new PPoint(5,5);

	this.line = new Object();
	this.line.color = "#999999";
	this.line.weight = 4;
	this.line.opacity = 0.7;

	this.poly = new Object();
	this.poly.color = "#eb5920";
	this.poly.weight = 4;
	this.poly.opacity = 0.7;
	this.poly.fill = "#eb7041";

	// add more options later
}

var polycreatorurl = "http://pin.gis.policymap.com";

/**************************
*** Class: PPolyCreator ***
**************************/
PPolyCreator = function(options) {
	if (options)
		this.options = options;
	else
		this.options = new PPolyCreatorOptions();

	this.click = null;
	this.points = [];
	this.savePoints = [];
	//this.places = [];
	//this.radius = null;
	//this.allPolylines = [];
	this.polyline = null;
	this.name = null;
	this.description = null;
	// This array will keep track of all the overlays added to the map that are used for building the region
	// So either the markers and polylines used for drawing an overlay, or the polygons used in assembling, or the marker and polygon for radius
	this.buildingOverlays = [];

	this.eventTypes = new Object();
	this.eventTypes.addpoly = 'addpoly';
	this.eventTypes.savepoly = 'savepoly';
	this.eventTypes.saveAssembledPoly = 'saveassemblepoly';
	this.eventTypes.saveCirclePoly = 'savecirclepoly';
	this.eventTypes.removepoly = 'removepoly';

	this.eventManager = new _eventManager();
	for (var ev in this.eventTypes)
		this.eventManager.registerEventID(ev);

	this.buildType = null;

	// 3 different type of custom regions that you can build
	// each type has an object to keep track of the required data
	this.DRAW = {};
	this.DRAW.title = 'Show Boundaries in Region:';
	this.DRAW.regions = {}; // keeps track of all drawn regions
	this.DRAW.ctypeid = '1';

	this.ASSEMBLE = {};
	this.ASSEMBLE.title = '<span>Select Areas on the Map By:</span>';
	this.ASSEMBLE.polygons = []; // used to keep track of the polygons as they're being added
	this.ASSEMBLE.places = [];
	this.ASSEMBLE.placeids = [];
	this.ASSEMBLE.ctypeid = '2';

	this.CIRCLE = {};
	this.CIRCLE.title = 'Show Boundaries in Region:';
	this.CIRCLE.centerpoint = null;
	this.CIRCLE.address = null;
	this.CIRCLE.radius = null;
	this.CIRCLE.ctypeid = '3';

	// keeps track of the custom places place objects and polygons as they're added to the map
	// this way we can remove the polygons and also keep track of each place so when using getPlacesWithin we have the right info
	this.customPlacesOnMap = {};
	this.customPlacesCount = 0;

	// keeps track of the polygons that are shown within the custom places so we know which overlays to remove when user clears the polygons within
	this.polygonsWithin = [];	
}

PPolyCreator.prototype.addListener = function(eventId, func) {
	this.eventManager.registerForEvent(eventId, [], func);
}

PPolyCreator.prototype.removeListener = function(eventId, func) {
	this.eventManager.deregisterForEvent(eventId, [], func);
}

PPolyCreator.prototype.attachMap = function(map) {
	this.map = map;
	this.initCustomRegionType();
}

PPolyCreator.prototype.detachMap = function() {
	if (this.map && this.click) 
		this.map.removeListener(this.click);
}

PPolyCreator.prototype.cancelPoly = function(stillBuilding) {
	if (!stillBuilding)
		this.resetBuildType();

	this.resetBuildOptions();
	//this.map.clearOverlays();
	this.clearBuildingOverlays();
	//this.detachMap();

	// since same widget is used for assembling and showing places within
	// we need to re-populate the boundaryWidget so it resets to the places within version
	this.boundaryWidget.populate();
}

// clear only the overlays for the custom region that's in the process of being built
PPolyCreator.prototype.clearBuildingOverlays = function() {
	var overlays = this.buildingOverlays;
	for (var i=0; i<overlays.length; i++) {
		this.map.removeOverlay(overlays[i]);
	}
	this.buildingOverlays = [];
}

PPolyCreator.prototype.resetBuildOptions = function() {
	this.points = [];
	this.places = [];
	this.name = null;
	this.description = null;
	// these are used in assembling by places
	this.ASSEMBLE.verts = [];
	this.ASSEMBLE.places = [];
	this.boundaryWidget.removeMapLayers();
	this.assembleInfoWidget.update();
	// these are used for custom circles
	this.CIRCLE.radius = null;
	this.CIRCLE.centerpoint = null;
	this.CIRCLE.centeraddress = null;

	if (this.map)
		this.map.closeInfoWindow();
}

PPolyCreator.prototype.reset = function() {
	this.resetBuildOptions();

	// clear object
	this.customPlacesOnMap = {};
	this.customPlacesCount = 0;

	// hide the widgets
	this.toggleWidgets();
}

PPolyCreator.prototype.addPoly = function(point, radius, places) {
	if (radius) {
		this.eventManager.triggerEvent('addpoly', [point]);
	}
	else if (places) {
		var point = this.ASSEMBLE.places[0].getVertices()[0][0];
		this.eventManager.triggerEvent('addpoly', [point]);
	}

	if (point.equals(this.points[0])) {
		this.points.push(point);
		//this.map.clearOverlays();
		this.clearBuildingOverlays();
		var polygon = new PPolygon(this.points,this.options.poly.color,this.options.poly.weight,this.options.poly.opacity,this.options.poly.fill);
		this.buildingOverlays.push(polygon);
		this.map.addOverlay(polygon);
		this.savePoints = this.points.slice();
		this.points = [];
		this.eventManager.triggerEvent('addpoly', this.savePoints);
	}
}
	
PPolyCreator.prototype.addPointLine = function(point) {
	this.points.push(point);
	if (this.map) {
		var marker = new PMarker(point, this.options.icon);
		this.buildingOverlays.push(marker);
		this.map.addOverlay(marker);
		if (this.points.length > 1) {
			var polyline = new PPolyline([point,this.points[this.points.length-2]],this.options.line.color,this.options.line.weight,this.options.line.opacity);
			this.buildingOverlays.push(polyline);
			this.map.addOverlay(polyline);
		}
	}
}

PPolyCreator.prototype.saveDrawPoly = function() {
	// ensure polygon and closed
	if (this.savePoints.length < 3) return;
	if (!this.savePoints[0].equals(this.savePoints[this.savePoints.length-1]))
		this.savePoints.push(this.savePoints[0]);

	//map.clearOverlays();
	this.clearBuildingOverlays();

	// send to servlet
	var query = "&vtc=MULTIPOLYGON(((";
	for (var i=0; i<this.savePoints.length; i++) {
		query += this.savePoints[i].lng() + "%20" + this.savePoints[i].lat();
		if (i < this.savePoints.length-1)
			query += ",";
	}
	query += ")))";
	query += "&name=" + encodeURIComponent(this.name);
	query += "&desc=" + encodeURIComponent(this.description);
	query += "&userid=" + session2.get('_userid');
	//query += "&contents=" + this.places.join(",");
	query += "&ctypeid=" + this.DRAW.ctypeid;
	
	var eman = this.eventManager;
	//eman.triggerEvent('savepoly',places);
	PAsync2.call(polycreatorurl + '/polygon?' + query, function(places) { eman.triggerEvent('savepoly',places); });
	//this.reset();
}

PPolyCreator.prototype.sharePoly = function(id, boundaryName, shareTo, message, callback) {
	var query = polycreatorurl + "/polygon?act=sha"
	query += "&id=" + id;
	query += "&userid=" + session2.get('_userid');
	query += "&bn=" + encodeURIComponent(boundaryName);
	query += "&to=" + encodeURIComponent(shareTo);
	query += "&m=" + encodeURIComponent(message);
	PAsync2.call(query,callback);
}

PPolyCreator.prototype.deletePoly = function(id, callback) {
	PAsync2.call(polycreatorurl + '/polygon?act=del&id='+id+'&userid='+session2.get('_userid'),callback);
}

PPolyCreator.prototype.load = function(ids, callback) {
	PAsync2.call(polycreatorurl + '/polygon?act=dsp&ids='+ids,callback);
}

PPolyCreator.prototype.polyload = function(bid, pname, plat, plng, callback) {
	PAsync2.call(polycreatorurl + '/polygon?act=dpp&bid=' + bid + '&pname=' + pname + '&plat=' + plat + '&plng=' + plng, callback);
}

PPolyCreator.prototype.loadByUser = function(id, callback) {
	PAsync2.call(polycreatorurl + '/polygon?act=get&fmt=js&userid='+id,callback);
}

PPolyCreator.prototype.initDrawRegion = function() {
	var polycreator = this;
	this.detachMap();

	this.click = PEvent.addListener(this.map, 'click', function(overlay, point) {
		if (overlay) {
			polycreator.addPoly(overlay.point);
		} else if (point) {
			polycreator.addPointLine(point);
		}
	});
}

PPolyCreator.prototype.addPolyMarker = function(place, polylines, html, map) {
	if (!this.map && map)
		this.map = map;

	// the points that are used for the clear and info markers
	var point1 = polylines[0].points[0];
	var midpos = Math.round(polylines[0].points.length/2);
	var point2 = polylines[0].points[midpos];

	// set up the markers
	var icon = new PIcon(PIcon.POINT);
	icon.iconSize = new PSize(12,12);
	icon.shadow = "";
	icon.image = 'images/remove_icon_active.png';
	var clearmarker = new PMarker(point2, icon);
	clearmarker.buildtype = this.buildType;
	icon.image = 'images/pins/polygon_red.png';
	var infomarker = new PMarker(point1, icon);

	clearmarker.image.index = this.getCustomPlacesCount();
	clearmarker.image.polylines = polylines;
	clearmarker.image.polycreator = this;
	clearmarker.image.infomarker = infomarker;
	clearmarker.image.clearmarker = clearmarker;
	clearmarker.image.place = place;
	// store the markers used for this custom region so we can remove them when necessary
	this.customPlacesOnMap[place.id].markers = [infomarker,clearmarker];
	if (html) {
		var polycreator = this;
		// since the event actually gets applied to the image of the marker object
		// we need to add the marker to the image so we can use it to open the infowindow in the mousedown event
		infomarker.image.infomarker = infomarker;
		infomarker.image.content = html;
		if(typeof html == "function")
			infomarker.image.content = html();

		// add events to to the markers
		PEvent.addListener(infomarker,'mousedown',function() {
			this.marker.openInfoWindowHtml(this.content);
		});
		PEvent.addListener(clearmarker, 'mousedown', function() {
			var index = this.index;
			var regions = this.polycreator.customPlacesOnMap;
			// remove place from map, it also removes the place from the session and from the dropdown if dropdown is active
			this.polycreator.removeCustomRegionFromMap(this.place);
		});
	}

	this.map.addOverlay(clearmarker);
	this.map.addOverlay(infomarker);
}

PPolyCreator.prototype.saveAssemblePoly = function() {
	var places = this.ASSEMBLE.places;

	this.clearBuildingOverlays();
	var labels = "";

	var pids = [];
	for (var p=0; p<places.length; p++) {
		pids.push(places[p].id);
	}

	// send to servlet
	var query = "&pids=" + pids.toString();
	query += "&name=" + encodeURIComponent(this.name);
	query += "&desc=" + encodeURIComponent(this.description);
	query += "&userid=" + session2.get('_userid');
	query += "&ctypeid=" + this.ASSEMBLE.ctypeid;

	var eman = this.eventManager;
	PAsync2.call(polycreatorurl + '/polygon?' + query, function(places) { eman.triggerEvent('savepoly',places); });
}

PPolyCreator.prototype.saveCirclePoly = function() {
	this.clearBuildingOverlays();

	var points = this.CIRCLE.points;
	//var centerpoint = this.CIRCLE.centerpoint;
	var radius = this.CIRCLE.radius;
	var address = this.CIRCLE.address;

	// send to servlet
	var query = "&vtc=MULTIPOLYGON(((";
	for (var i=0; i<points.length; i++) {
		query += points[i].lng() + "%20" + points[i].lat();
		if (i < points.length-1)
			query += ",";
	}
	query += ")))";
	//query += "&cpoint=" + centerpoint.lat() + ", " + centerpoint.lng();
	query += "&rad=" + radius;
	if (address)
		query += "&caddr=" + address;

	query += "&name=" + encodeURIComponent(this.name);
	query += "&desc=" + encodeURIComponent(this.description);
	query += "&userid=" + session2.get('_userid');
	query += "&ctypeid=" + this.CIRCLE.ctypeid;

	var eman = this.eventManager;
	PAsync2.call(polycreatorurl + '/polygon?' + query, function(places) { eman.triggerEvent('savepoly',places); });
}

PPolyCreator.prototype.initAssembleRegion = function(ptype) {
	// clear the polygons from previous type if there are any
	this.resetType();

	// show assemble info widget
	if (this.isBuildOn())
		this.assembleInfoWidget.show();

	this.detachMap();

	var polycreator = this;
	this.click = PEvent.addListener(this.map, 'click', function(overlay, point) {
		if (overlay)
			return;

		polycreator.addPlace(ptype, point)
	});
}

PPolyCreator.prototype.removeAssembledPlaceIfExists = function(place) {
	var assplaces = this.ASSEMBLE.places;
	var assverts = this.ASSEMBLE.verts;
	// if place is already selected remove place from assemble array and from vertices array
	for (var j=0; j<assplaces.length; j++) {
		if (assplaces[j].id == place.id) {
			for (var p=0; p<assplaces[j].savedPolys.length; p++)
				map.removeOverlay(assplaces[j].savedPolys[p]);
			assplaces.splice([j],1);
			assverts.splice([j],1);

			// update info displayed
			polycreator.assembleInfoWidget.update();
			return true;
		}
	}
	return false;
}

PPolyCreator.prototype.addPlace = function(ptype, point) {
	var geocoder = new PClientGeocoder();
	geocoder.getPlacesContaining(point, ptype, function(places) {
		var place = places[0];

		// Kluge for cities to not use unincorporated cities.
		// Unincorported cities have no state value in the db so that's how we know it's unincorporated
		if (ptype == PPlaceType.CITY) {
			for (var i=0; i<places.length; i++) {
				if (places[i].state != null)
					place = places[i];
			}
		}

		var verts = place.getVertices();
		var assverts = polycreator.ASSEMBLE.verts;
		var assplaces = polycreator.ASSEMBLE.places

		place.savedPolys = [];
		for (var i=0; i<verts.length; i++) {
			// check if place is already on map, if so remove it.
			// only need to check one time
			if (i == 0) {
				// this removes the polygons from the map if place is found and then returns true or false if it removed it or not
				if (polycreator.removeAssembledPlaceIfExists(place))
					return true;
			}

			var polygon = new PPolygon(verts[i], "#eb5920", 1, 0.5, '#ffffff');
			polycreator.ASSEMBLE.polygons.push(polygon);
			polycreator.buildingOverlays.push(polygon);
			polycreator.map.addOverlay(polygon);

			polycreator.ASSEMBLE.lastpoint = point;

/*			var html = "<div style='width: 200px; font-size: 11px'>";
			html += "Click other boundaries or<br />";
			html += "<a onmouseup='polycreator.showSaveInfoWindow(polycreator.ASSEMBLE.lastpoint)'>Save Region</a>";
			html += "</div>";

			polycreator.map.openInfoWindowHtml(point, html);
*/
			assverts.push(verts[i]);
			place.savedPolys.push(polygon);
			// Only store the place once all polygons are drawn so it doesn't duplicate
			if (i==verts.length-1)
				assplaces.push(place);

			// update info displayed
			polycreator.assembleInfoWidget.update();
		}
	});	
}

PPolyCreator.prototype.showSaveInfoWindow = function(point) {
	var polycreator = this;
	if (this.buildType == this.DRAW) {
		var html = "<div style='width: 200px; font-size: 11px'>";
		html += "Name: <input type='text' onchange='polycreator.name=this.value;' /><br>";
		html += "Description:<br><textarea onchange='polycreator.description=this.value;' cols='20' rows='3' /></textarea><br>";
		html += "<input type='submit' value='Save' onmouseup='javascript:polycreator.saveDrawPoly()' /> ";
		html += "<input type='button' value='Cancel' onmouseup='javascript:polycreator.cancelPoly(true)' />";
		html += "</div>";

		var icon = new PIcon(PIcon.POINT);
		icon.iconSize = new PSize(12,12);
		icon.shadow = "";
		icon.image = 'images/pins/polygon_red.png';
		var marker = new PMarker(point, icon);
		marker.image.point = point;
		PEvent.addListener(marker, "click", function() {
			polycreator.showSaveInfoWindow(this.point);
		});
		this.buildingOverlays.push(marker);

		this.map.addOverlay(marker);
		marker.openInfoWindowHtml(html);
		this.points = [];
	}
	else if (this.buildType == this.ASSEMBLE) {
		// don't allow if only one place is used
		if (this.ASSEMBLE.places.length < 2) {
			customAlert("You need more than one place to create this type of custom regions. Select another place and then click save region again.");
			return;
		}

		var html = "<div style='width: 200px; font-size: 11px'>";
		html += "Name: <input type='text' onchange='polycreator.name=this.value;' /><br>";
		html += "Description:<br><textarea onchange='polycreator.description=this.value;' cols='20' rows='3' /></textarea><br>";
		html += "<input type='submit' value='Save' onmouseup='javascript:polycreator.saveAssemblePoly()' /> ";
		html += "<input type='button' value='Cancel' onmouseup='javascript:map.closeInfoWindow()' />";
		html += "</div>";
		this.map.openInfoWindowHtml(point, html);
	}
	else if (this.buildType == this.CIRCLE) {
		var html = "<div style='width: 200px; font-size: 11px'>";
		html += "Name: <input type='text' onchange='polycreator.name=this.value;' /><br>";
		html += "Description:<br><textarea onchange='polycreator.description=this.value;' cols='20' rows='3' /></textarea><br>";
		html += "<input type='submit' value='Save' onmouseup='javascript:polycreator.saveCirclePoly()' /> ";
		html += "<input type='button' value='Cancel' onmouseup='javascript:polycreator.cancelPoly(true)' />";
		html += "</div>";

		var icon = new PIcon(PIcon.POINT);
		icon.iconSize = new PSize(12,12);
		icon.shadow = "";
		icon.image = 'images/pins/polygon_red.png';
		var marker = new PMarker(point, icon);
		marker.image.point = point;
		PEvent.addListener(marker, "click", function() {
			polycreator.showSaveInfoWindow(this.point);
		});
		this.buildingOverlays.push(marker);

		this.map.addOverlay(marker);
		marker.openInfoWindowHtml(html);
		this.points = [];
	}
}

PPolyCreator.prototype.resetType = function() {
	this.ASSEMBLE.verts = [];
	this.ASSEMBLE.places = [];

	// Clear all the polygons added with assembling if there are any
	var polygons = this.ASSEMBLE.polygons;
	for (var i=0; i<polygons.length; i++) {
		map.removeOverlay(polygons[i]);
	}
	this.assembleInfoWidget.update();
}

PPolyCreator.prototype.initRadiusRegion = function() {
	var polycreator = this;
	this.clearBuildingOverlays();
	this.detachMap();

	this.click = PEvent.addListener(this.map, 'click', function(overlay, point) {
		if (overlay)
			return;
		var miles = document.getElementById('radiusSetting').value;
		if (miles == 0 || miles == null) {
			var alerter = new PAlerter();
			var text = 'You need to add a radius.';
			var position = getAlertPosition(parseInt(alerter.box.style.width));
			alerter.popup(text, position[0], position[1], "OK");
			return;
		}

		// set the point as the value in the searchbox
		var searchValue = point.lat() + "," + point.lng();
		polycreator.circleWidget.searchbox.textbox.value =  searchValue;
//		polycreator.drawCircle(point, miles);
		var vert = polycreator.drawCircle(point, miles);
		var icon = new PIcon(PIcon.POINT);
		icon.iconSize = new PSize(12,12);
		icon.shadow = "";
		icon.image = 'images/pins/polygon_red.png';
		var marker = new PMarker(point, icon);
		polycreator.map.addOverlay(marker);
		polycreator.buildingOverlays.push(marker);

		var polyline = new PPolyline(vert, '#e68000');
		polycreator.buildingOverlays.push(polyline);
		polycreator.map.addOverlay(polyline);

		polycreator.eventManager.triggerEvent('addpoly', [point]);
	});
}

PPolyCreator.prototype.drawCircle = function(point, miles, recenter) {
	this.clearBuildingOverlays();

	var centerpoint = point;
	dist = miles * 1609.344

	// Gets the distance for the radius
	var radiusX = centerpoint.moveBy("0 1N", dist);
	var radiusY = centerpoint.moveBy("90 1N", dist);
	var xRadiusMetres = radiusX.lat() - centerpoint.lat();
	var yRadiusMetres = radiusY.lng() - centerpoint.lng();

	// Points for setting zoom bounds
	var pointyeast = centerpoint.lng() + yRadiusMetres;
	var pointywest = centerpoint.lng() - yRadiusMetres;
	var pointxsouth = centerpoint.lat() - xRadiusMetres;
	var pointxnorth = centerpoint.lat() + xRadiusMetres;
		
	var sw = new PLatLng(pointxsouth, pointywest);
	var ne = new PLatLng(pointxnorth, pointyeast);

	if (recenter)
		this.map.setCenterBounds(new PLatLngBounds(sw, ne));

	var circlepoints = [];
	with (Math) {
		for (var a = 0 ; a < 361 ; a+=5 ) {
			var aRad = a*(PI/180);
			var pointx = centerpoint.lat() + xRadiusMetres * cos(aRad);
			var pointy = centerpoint.lng() + yRadiusMetres * sin(aRad);

			var p = new PLatLng(pointx,pointy);
			circlepoints.push(p);
		}
	}
	this.CIRCLE.centerpoint = centerpoint;
	this.CIRCLE.radius = miles;
	this.CIRCLE.points = circlepoints;

	return circlepoints;
}

PPolyCreator.prototype.customRegionsOn = function() {
	if (this.getCustomPlacesCount() > 0)
		return true;
	else
		return false;
}

PPolyCreator.prototype.toggleWidgets = function() {
	// hide the circle and assembe widgets
	this.circleWidget.hide();
	this.assembleInfoWidget.hide();

	// Note: put this in the if statement below when showing places within custom regions is added back to the app
	// There are a few places in MapCommon.js that need to be uncommented out, all are noted just as is it is here
	this.boundaryWidget.hide();

	// clear and remove widget related things if no custom regions are on map
	if (!this.customRegionsOn()) {
		this.clearPolygonsWithin();
		this.clearBuildingOverlays();
	}
}

PPolyCreator.prototype.addPlacesWithinAllRegions = function(type) {
	// clear all the polygons everytime type is changed
	this.clearPolygonsWithin();
	var count = this.getCustomPlacesCount();
	var places = this.customPlacesOnMap;
	if (count > 0) {
		for (var i in places) {
			this.showPlacesWithin(places[i].place, type);
		}
	}
}

PPolyCreator.prototype.showPlacesWithin = function(place, type) {
	var polycreator = this;
	// get all the places within and add polygons for each
	place.getPlacesWithin(type, function(places) {
		for (var i=0; i<places.length; i++) {
			for (var j=0; j<places[i].getVertices().length; j++) {

				var poly = new PPolygon(places[i].getVertices()[j], '#eb5920', 3, 0.1, '#eb5920', 0.4);
				polycreator.map.addOverlay(poly);

				// need to keep track of all added polygons so we can remove them
				polycreator.polygonsWithin.push(poly);
			}
		}
	}, 3);
}

PPolyCreator.prototype.clearPolygonsWithin = function() {
	if (this.polygonsWithin.length > 0) {
		for (var i=0; i<this.polygonsWithin.length; i++)
			map.removeOverlay(this.polygonsWithin[i]);
	}
}

PPolyCreator.prototype.clearPolyline = function(polylines) {
	for (var i=0; i<polylines.length; i++) {
		this.map.removeOverlay(polylines[i]);

		if (polylines[i].infomarker) {
			this.map.removeOverlay(polylines[i].infomarker);
			this.map.removeOverlay(polylines[i].clearmarker);
		}
	}
}

PPolyCreator.prototype.clearPolylineAssembled = function(polylines) {
	// Clear all the polylines used in assembled area
	for (var i=0; i<polylines.length; i++) {
		for (var j=0; j<polylines[i].length; j++) {
			this.map.removeOverlay(polylines[i][j]);
		}
		if (polylines[i].infomarker) {
			this.map.removeOverlay(polylines[i].infomarker);
			this.map.removeOverlay(polylines[i].clearmarker);
		}
	}
}

// start the build process based on what type of region user selected
PPolyCreator.prototype.initCustomRegionType = function() {
	if (this.buildType == this.DRAW) {
		this.initDrawRegion();
	}
/*
	else if (this.buildType == this.ASSEMBLE) {
		this.initAssembleRegion(this.ASSEMBLE.placetype);
	}
*/
	else if (this.buildType == this.CIRCLE) {
		this.initRadiusRegion();
	}
}

PPolyCreator.prototype.isBuildOn = function() {
	return this.buildType ? true : false;
}

PPolyCreator.prototype.resetBuildType = function() {
	this.buildType = null;
}

PPolyCreator.prototype.addPolylines = function(place, html, map) {
	if (!map)
		this.map = map;
	var polylines = [];
	var vertices = place.getVertices();
	for (var i=0; i<vertices.length; i++) {
		var polyline = new PPolyline(vertices[i], '#e68000');
		//this.allPolylines.push(polyline);
		place.polyline = polyline;
		this.polyline = polyline;
		map.addOverlay(polyline);
		polylines.push(polyline);
	}
	this.customPlacesCount++;

	// populate object with the respective poylines and place so to keep track and be able to remove them from the map and sessions
	var count = this.getCustomPlacesCount();
	this.customPlacesOnMap[place.id] = {}
	this.customPlacesOnMap[place.id].polylines = polylines;
	this.customPlacesOnMap[place.id].place = place;

	this.addPolyMarker(place, polylines, html, map);

	// add to session
	this.addCustomRegionToSession(place);
}

PPolyCreator.prototype.removeCustomRegionFromMap = function(place) {
	var regions = this.customPlacesOnMap;

	this.clearPolyline(regions[place.id].polylines);
	var markers = regions[place.id].markers;
	// remove the info and clear markers
	for (var i=0; i<markers.length; i++) {
		this.map.removeOverlay(markers[i]);
	}
	var dropdownEl = regions[place.id].dropdownEl;
	if (dropdownEl) {
		dropdownEl.on = false;
		dropdownEl.className = "";
		dropdownEl.remove.src = 'images/close_button2.gif';
	}

	// delete place from object and substract from count
	delete regions[place.id];
	this.customPlacesCount--;

	// remove from session
	this.removeCustomRegionFromSession(place);

	// Note: This will be needed when we re-enable the boundaries within widget
	//this.toggleWidgets();
}

PPolyCreator.prototype.getCustomPlacesCount = function() {
	return this.customPlacesCount;
}

PPolyCreator.prototype.addCustomRegionToSession = function(place) {
	// Add custom region to session
	// Loop through all the custom regions on the map and add them all to the session
	var places = this.customPlacesOnMap;
	var cp = "";
	for (var i in places) {
		cp += places[i].place.id + ',';
	}
	cp = cp.substring(0,cp.length-1)

	session2.put('cp', cp);
}
// This is exactly the same as the above addCustomRegionToSession
// It's still being used though
// Will remove it and rename above function to be used in all custom region remove/add circumstances when there's time
PPolyCreator.prototype.removeCustomRegionFromSession = function(place) {
	var places = this.customPlacesOnMap;
	var cp = "";
	for (var i in places) {
		cp += places[i].place.id + ',';
	}
	cp = cp.substring(0,cp.length-1)

	session2.put('cp', cp);
}

PPolyCreator.prototype.hasBuildOverlays = function() {
	return (this.buildingOverlays.length > 0) ? true : false; 
}

/********************************************
***** Class: PPolyCreatorBoundaryWidget *****
********************************************/
// This widget is to show the boundaries within the custom regions
// And also is used in the assemble option to select what placetype to use when assembling
PPolyCreatorBoundaryWidget = function(polycreator) {
	this.polycreator = polycreator;
	this.listeners = []; // keeps track of the events added to the dropdown so we can remove them
	var container = document.createElement('div');
	this.container = container;
	container.id = 'PolyBoundaryWidget';
	container.className = 'CustomRegionWidgets';
	jQuery("#map").append(container);

	var div = document.createElement('div');
	div.className = 'title';
	this.titleContainer = div;
	this.defaultTitle = 'Show Boundaries in Region:';
	this.container.appendChild(div);

	var select = document.createElement('select');
	select.className = 'boundaries';
	select.disabled = true;
	this.container.appendChild(select);
	this.typeMenu = select;
}

PPolyCreatorBoundaryWidget.prototype = {
	enable : function() {
		this.typeMenu.disabled = false;
	},
	disable : function() {
		this.typeMenu.disabled = true;
	},
	show : function() {
		this.populate();
		this.container.style.display = "block";
	},
	hide : function() {
		this.container.style.display = "none";
	},
	addTitle : function() {
		if (this.polycreator.isBuildOn())
			this.titleContainer.innerHTML = this.polycreator.buildType.title;
		else
			this.titleContainer.innerHTML = this.defaultTitle;
	},
	populate : function() {
		for (var i=0; i<this.listeners.length; i++) {
			PEvent.removeListener(this.listeners[i])
		}

		// placetypes that will be available in the dropdown
		// When city and county subdivision map layers are done they'll get added to this array.
		var placetypes = [ PPlaceType.BLOCKGROUP, PPlaceType.CENSUSTRACT, PPlaceType.ZIP, PPlaceType.CITY, PPlaceType.COUNTY,
				PPlaceType.COUNTY_SUBDIVISION, PPlaceType.MD, PPlaceType.CBSA_07, PPlaceType.STATE, PPlaceType.CONGRESSIONAL, PPlaceType.SLD_UPPER,
				PPlaceType.SLD_LOWER, PPlaceType.SCHOOL, PPlaceType.CDBG ];

		var select = this.typeMenu;
		select.innerHTML = "";
		this.addTitle();

		if (!this.polycreator.isBuildOn() || this.polycreator.buildType != this.polycreator.ASSEMBLE) {
			var option = document.createElement('option');
			option.placetype = null;
			option.innerHTML = 'None';
			select.appendChild(option);
		}

		var z = map.getZoom();
		var ptype = PMIdentificationPrinter.placeTypeConfig.zooms[z];

		// When indicator is on then use the legends placetype as default for assembling
		if (map.getIndicator()) {
			var leg = map.getLegend();
			var ptype = leg.getBoundaryType();
		}
		else {
			// Get the default placetype for the current zoom level or the further out one if no default exists
			for ( var i = z; i >= 0; i--) {
				ptype = PPlaceTypeConfig.PLEGEND.zooms[i];
				if (ptype) {
					if (ptype.id) {
						break;
					}
				}
			}
		}

		for (var i=0; i<placetypes.length; i++) {
			var option = document.createElement('option');
			option.innerHTML = placetypes[i].getName();
			option.placetype = placetypes[i];

			// when assembling default to the default placetype for the zoom
			if (this.polycreator.buildType == this.polycreator.ASSEMBLE && placetypes[i] == ptype) {
				option.selected = true;
				this.addMapLayerAndInitAssemble(placetypes[i]);
			}
			select.appendChild(option);
		}

		select.widget = this;
		this.listeners.push(PEvent.addListener(select, 'change', function() {
			var polycreator = select.widget.polycreator;

			// clear the polygons within when "None" is selected, meaning no placetype is attributed to the option
			if (!this.options[this.selectedIndex].placetype) {
				polycreator.clearPolygonsWithin();
			} else if (polycreator.isBuildOn() && polycreator.buildType == polycreator.ASSEMBLE) {
				// if in the middle of building with one placetype the user switches types fire an alert
				if (polycreator.hasBuildOverlays()) {
					var text = "If you change the boundary type, you will clear all existing boundaries on the map.";
					var alerter = new PAlerter2();
					var position = getAlertPosition(parseInt(alerter.box.style.width));
					var s = this;
					var ok = function() {
						select.widget.addMapLayerAndInitAssemble(s.options[s.selectedIndex].placetype);
					};
					alerter.popup(text,position[0],position[1],"Cancel","OK",ok)
				}
				else
					select.widget.addMapLayerAndInitAssemble(this.options[this.selectedIndex].placetype);
			}
			else
				polycreator.addPlacesWithinAllRegions(this.options[this.selectedIndex].placetype);
		}));
	},

	addMapLayerAndInitAssemble : function(ptype) {
		this.removeMapLayers();
		this.addMapLayers(ptype);
		this.polycreator.initAssembleRegion(ptype);
	},
	addMapLayers : function(ptype) {
		this.maplayers = ptype.maplayers;
		if (this.maplayers) {
			for (var i=0; i<this.maplayers.length; i++) {
				// TODO: The map options should be it's own object, that way it'll be easy to track what layers are on/off
				// And then if the user had a map layer on before starting to build a region then we can have it stay on after they're done building.
				// The way this works now that's to complicated so the map layers will just refresh to the default mode once building is done.
				this.maplayers[i].on();
			}

			var scale = map.getScale();
			var text = "";
			var showAlert = false;

			// if map layer does not exist in current zoom level alert the user
			if (this.maplayers[0].minScale && scale < this.maplayers[0].minScale) {
				var label = this.maplayers[0].getLabel().replace("<br>", " ");
				var label = this.maplayers[0].getLabel().replace("<br>", " ");
				text = "To see the " + label + " boundaries and labels on the map you'll need to zoom out.";
				showAlert = true;
			}
			else if (this.maplayers[0].maxScale && scale > this.maplayers[0].maxScale) {
				var label = this.maplayers[0].getLabel().replace("<br>", " ");
				text = "To see the " + label + " boundaries and labels on the map you'll need to zoom in.";
				showAlert = true;
			}

			if (showAlert) {
				var alerter = new PAlerter();
				var position = getAlertPosition(parseInt(alerter.box.style.width));
				alerter.popup(text, position[0], position[1], "OK");
			}
		}
	},
	removeMapLayers : function() {
		if (this.maplayers) {
			for (var i=0; i<this.maplayers.length; i++)
				this.maplayers[i].off();
		}
	}
}

/******************************************
***** Class: PPolyCreatorCircleWidget *****
******************************************/
// This widget is only for the radius region
// It creates a search box and a radius box that allows the user to create a circle polyline around an address
PPolyCreatorCircleWidget = function(polycreator) {
	this.polycreator = polycreator;
	var container = document.createElement('div');
	this.container = container;
	container.id = 'PolyCircleWidget';
	container.className = 'CustomRegionWidgets';
	jQuery("#map").append(container);

	var div = document.createElement('div');
	div.className = 'title';
	this.titleContainer = div;
	this.titleContainer.innerHTML = 'Specify Center of Radius:';
	this.container.appendChild(div);

	var searchContainer = document.createElement('div');
	searchContainer.style.width = "390px";
	searchContainer.className = 'searchContainer';
	var searchTabTypes = ['Default'];
	var searchbox = new PTRFPlaceSearchBox(searchContainer, null, searchTabTypes);
	this.searchbox = searchbox;
	this.exampleAddress = 'e.g., "421 North Boundary Street, Williamsburg, VA 23185"';
	searchbox.textbox.value = this.exampleAddress;
	var that = this;
	searchbox.addListener('response', function(places) {
		if (places instanceof PAddress) {
			if (places.wasFound()) {
				that.showCircle(places);
			}
			else {
                                var alerter = new PAlerter();
                                var pos = getAlertPosition(parseInt(alerter.box.style.width));
                                var content = "Location \"<b>" + places.addr + "</b>\" not found. For help finding your address:  <a class='pagelinks' href='/blog?p=200' target='_blank'>click here</a>";
                                alerter.popup(content,pos[0],pos[1],"OK");
                        }
                } else {
                        var alerter = new PAlerter();
                        var pos = getAlertPosition(parseInt(alerter.box.style.width));
                        alerter.popup("Please specify a street address, not an area.",pos[0],pos[1],"OK");
                }
	});
	this.container.appendChild(searchContainer);

	var div = document.createElement('div');
	div.className = 'title';
	div.innerHTML = 'OR<br />Click Map to Center Radius';
	this.container.appendChild(div);

	var div = document.createElement('div');
	div.className = 'radiusDiv';

	var span = document.createElement('span');
	span.className = 'title';
	span.innerHTML = 'Specify Radius:';
	div.appendChild(span);
	var radius = document.createElement('input');
	radius.type = 'text';
	radius.className = 'radius';
	radius.id = "radiusSetting";
	radius.value = 0.5; // default radius
	PEvent.addListener(radius, 'keydown', function(e) {
		e = (e)?e:((event)?event:null);
		if (e && e.keyCode == 13)
			that.searchbox.submit();
	});

	this.radius = radius;
	div.appendChild(radius);

	var span = document.createElement('span');
	span.innerHTML = 'Miles';
	span.className = 'radiusText';
	div.appendChild(span);

	var go = document.createElement('input');
	go.type = 'image';
	go.src = 'images/global-button-go-xlarge.gif';
	go.alt = 'Go';
	go.style.margin = "-6px 5px";
	PEvent.addListener(go, 'click', function() {
		that.searchbox.submit();
	});
	div.appendChild(go);
	this.container.appendChild(div);
}

PPolyCreatorCircleWidget.prototype = {
	show : function() {
		// set textbox to default value
		this.searchbox.textbox.value = this.exampleAddress;

		this.container.style.display = "block";
	},
	hide : function() {
		this.container.style.display = "none";
	},
	showCircle : function(address) {
		var point = new PLatLng(address.y, address.x);
		var miles = this.polycreator.circleWidget.radius.value;
		var vert = this.polycreator.drawCircle(point, miles, true);
		// if address is PLatLng because user clicked on map to create custom region, than make the coordinates the address
		this.polycreator.CIRCLE.address = (address instanceof PLatLng) ? address : address.y + ', ' + address.x;
		var polyline = new PPolyline(vert, '#e68000');
		this.polycreator.map.addOverlay(polyline);
		this.polycreator.buildingOverlays.push(polyline);
		this.polycreator.eventManager.triggerEvent('addpoly', [point]);
	}
}


/**********************************************
**** Class: PPolyCreatorAssembleInfoWidget ****
**********************************************/
// Displays the places that are selected while assembling
PPolyCreatorAssembleInfoWidget = function(polycreator) {
	this.polycreator = polycreator;
	var container = document.createElement('div');
	container.id = "PolyAssembleInfoBox";
	container.className = "CustomRegionWidgets";
	this.container = container;

	var title = document.createElement('div');
	title.className = "title";
	//title.style.color = "#33F900";
	var html = "Click Map to Assemble Region";
	title.innerHTML = html

	// div used to show place labels
	var contenttitle = document.createElement('span');
	contenttitle.innerHTML = "Current places: ";
	var content = document.createElement('span');
	content.className = "placeLabels";
	this.content = content;

	jQuery(container).append(title);
	jQuery(container).append(contenttitle);
	jQuery(container).append(content);

	var footer = document.createElement('div');
	footer.className = "footer";
	var clear = document.createElement('a');
	clear.innerHTML = "Clear All and Start Over";
	clear.widget = this;
	clear.onclick = function() {
		this.widget.clear();
	}
	var save = document.createElement('a');
	save.innerHTML = "Save Region";
	save.widget = this;
	save.onclick = function() {
		this.widget.polycreator.showSaveInfoWindow(this.widget.polycreator.ASSEMBLE.lastpoint)
	}
/*
	var cancel = document.createElement('a');
	cancel.innerHTML = "Cancel";
	cancel.polycreator = this;
	cancel.onclick = function() {
		// cancel and remove element
		this.polycreator.cancelPoly();
		jQuery(this.polycreator.assembleInfoBox).remove();		
	}
*/
	jQuery(footer).append(clear);
	jQuery(footer).append(save);
	//jQuery(footer).append(cancel);
	jQuery(container).append(footer);
	jQuery('#map').append(container);
	this.update();
}

PPolyCreatorAssembleInfoWidget.prototype = {
	show : function() {
		this.container.style.display = "block";
	},
	hide : function() {
		this.container.style.display = "none";
	},
	clear : function() {
		// clear overlays
		this.polycreator.clearBuildingOverlays();
		// clear stored places so we can update the labels
		this.polycreator.ASSEMBLE.places = [];
		// update place labels
		this.polycreator.assembleInfoWidget.update();
	},
	update : function() {
		var div = this.content;
		jQuery(div).empty();
		var places = this.polycreator.ASSEMBLE.places;
		if (places && places.length == 0) {
			var span = document.createElement('span');
			span.className = "empty";
			span.innerHTML = "(no places selected)";
			jQuery(div).append(span);
		}
		
		// add link for each place
		for (var i=0; i<places.length; i++) {
			var a = document.createElement('a');

			// use identifier as label for block groups
			if (places[i].typeid == 15)
				a.innerHTML = places[i].identifier;
			else
				a.innerHTML = places[i].getLabel();

			a.title = "Remove";
			a.widget = this;
			a.place = places[i];
			a.onclick = function() {
				var polycreator = this.widget.polycreator;
				polycreator.removeAssembledPlaceIfExists(this.place);
			}
			jQuery(div).append(a);

			var comma = document.createElement('a');
			comma.className = "comma";
			comma.innerHTML = ", ";
			jQuery(div).append(comma);
		}
	}
}

/**************************************
 *** Class: PolyCreatorDropDownList ***
 *************************************/
PolyCreatorDropDownList = function(node, polycreator, map) {
	this.map = map;
	this.polycreator = polycreator;
	this.dropdown = node;
	this.container = node.parentNode.parentNode.parentNode;
	this.eventManager = new PEventManager();
	this.listeners = [];
}

PolyCreatorDropDownList.prototype = {
	refresh : function(places) {
		var l = this.listeners.length;
		for (var i=0; i<l; i++)
			PEvent.removeListener(this.listeners[i]);
		this.listeners = [];

		while(this.dropdown.hasChildNodes())
			this.dropdown.removeChild(this.dropdown.firstChild);

		for (var i=places.length-1; i>=0; i--) {
			var place = places[i];
			var li = document.createElement('li');
			var div = document.createElement('div');
			div.className = 'name';

			li.appendChild(div);
			li.index = i;
			li.dropdown = this;
			li.place = place;
			li.on = false;

			div.innerHTML = place.getLabel();

			var remove = document.createElement('img');
			remove.className = 'remove';
			remove.title = 'Remove';
			var activeSrc = 'images/remove_icon_active.png';
			var inactiveSrc = 'images/close_button2.gif';
			remove.src = inactiveSrc;
			// For charts the remove icon isn't needed for the drop down
			// Only one custom region is allowed at a time in charts, if that changes the remove option will have to be added
			if (PAGE_ID != "c_")
				li.appendChild(remove);

			var br = document.createElement('br');
			br.className = "clear";
			li.appendChild(br);

			// the image src changes when cusom region is selected from list
			li.remove = remove;

			// check if custom place is on the map
			// if so turn on the place in the dropdown
			if (polycreator.customPlacesOnMap[place.id]) {
				li.on = true;
				li.className = "active";
				li.remove = remove;
				remove.src = activeSrc;
				polycreator.customPlacesOnMap[place.id].dropdownEl = li;
			}

			this.listeners.push(PEvent.addListener(li, 'mousedown', function() {
				var place = this.place;
				this.dropdown.dropdown.style.display = "none";
				//this.dropdown.onchange();

				if (this.on == true) {
					// removes place from map and clears the place from the dropdown
					polycreator.removeCustomRegionFromMap(place);
				}
				else {
					if (PAGE_ID == "c_") {
						// for charts add custom place to global var and refresh cube and add place to session
						// currently only one custom place is allowed at a time so don't need to turn on the list item so it can be removed
						custom_place = place;
						refreshCube();
						session2.put('cp', place.id);
					}
					else {
						this.className = "active";
						this.remove.src = activeSrc;
						this.on = true;

						var html = function(){ return PMIdentificationPrinter.printCustomPolyPlaces(place); };
						polycreator.addPolylines(place, html, map);

						// when place is added we need to store the LI element so we can turn it off when needed
						polycreator.customPlacesOnMap[place.id].dropdownEl = this;
					
						map.setCenterBounds(place.getBounds());
					}
					this.dropdown.toggle();
				}
			}));

			this.dropdown.appendChild(li);
		}
	},
	toggle : function() {
		if (!isSubscriber()) {
			subscribeAlert();
			return;
		}

		if (this.dropdown.style.display == "none")
			this.dropdown.style.display = "block";
		else
			this.dropdown.style.display = "none";
	},
	show : function() {
		this.container.style.display = "block";
	},
	hide : function() {
		this.container.style.display = "none";
	},
	setUsersPlaces : function() {
		// get all the custom regions for the user and then populate the dropdown
		var that = this;
		var loading = document.createElement('li');
		loading.style.margin = "10px";
		loading.innerHTML = "Loading...";
		this.dropdown.appendChild(loading);
		polycreator.loadByUser(session2.get('_userid'), function(places) {
			that.refresh(places);
		});

		// show the custom regions drop down feature
		this.show();
	},
	reset : function() {
		this.dropdown.style.display = "none";
		this.setUsersPlaces();
	}
}


/*****************************
*** Class: PMap extensions ***
*****************************/
PMap.prototype.enablePolyCreator = function(polycreator) {
	polycreator.attachMap(this);
}

PMap.prototype.disablePolyCreator = function(polycreator) {
	polycreator.detachMap(this);
}