if( hq == undefined ) {
        var hq = {};
}

hq.spacePolygon = {

	layers : {},


	overStyle : {color: "#aaaaff", weight: 2, opacity: .5},
	hiddenStyle : {color: "#aaaaff", weight: 2, opacity: 0},
	selectedStyle : {color: "#3f3fb5", weight: 2, opacity: .5},

	layerType : 'neighborhoods',

	BaseUrl : $j('#hqDomain').val(),
	
	init : function() {
		console.group('spacePolygon::init');

		// ALL polygons that are loaded, regardless of where and if they are visible
 		this.polys = {};
                this.zoom = hq.map.gMap.getZoom();
                this.zoomName = '';
		this.loadedSpaces = {};
		this.activeLayer = $j('a.activeLayer').attr('layerId');

		// Pray this executes after the first postPaneLoad is triggere
		var sp = this;

		jQuery.each(jQuery.browser, function(i, val) {
                        if(val) {
                                sp.browser = i;
                        }
                });

                 if(sp.browser=='msie')
                        return;


                $j('a.overlay')
		.each(function() {
			var i = $j(this).attr('layerId');
			sp.polys[i] = {};
                        sp.layers[i] = {
                                zoomLevel : $j(this).attr('zoomLevel')
                        };
			
                })
		.click(toolbox.delegate(this.onOverlayChange, this));
		
		this.initLoadedSpaces();
			
		this.getSpacePoints();

		GEvent.addListener( hq.map.gMap, 'moveend', toolbox.delegate( this.getSpacePoints, this ) );
		GEvent.addListener( hq.map.gMap, 'mouseout', toolbox.delegate( this.onMapMouseOut, this ) );

		// Intercept clicks on the left sidebar to spaces

		$j( '#contentWrapper' )
			.bind( 'polygonsCreated', toolbox.delegate(this.onPostPaneLoad, this))
			.bind( 'layerChange', toolbox.delegate(this.clearLoaded, this))
			.bind( 'paneLoaded', toolbox.delegate(this.onPaneLoad, this));	
		

		$j('.spaceZoom').click(toolbox.delegate( this.onZoomClick, this ));

                this.onPaneLoad();
                
		console.groupEnd();
	},	
	
	// Depressing function to enable the click event for the 'x' and 'zoom'  in the left panel with each ajax reload
	onPaneLoad : function() {
		 var loaded = $j('#loadedSpaceIds').val();
		 var layerId = this.activeLayer;

		 loaded = loaded.split(',');

		 for(var i=0; i<loaded.length; i++) {
                                if(this.loadedSpaces[layerId]) {
                                        for(var j=0; j < this.loadedSpaces[layerId].length; j++) {
						$j('#clear_'+loaded[i]).unbind('click');
                                                $j('#clear_'+loaded[i]).click(toolbox.delegate(this.onClick, this, loaded[i] , this.polys[layerId][loaded[i]]) );
					}
				}
		}

		$j('.spaceZoom').unbind('click').click(toolbox.delegate( this.onZoomClick, this ));

		// Clear loaded spaces on saved search load
		$j('.savedSearchLink').click(toolbox.delegate( this.clearLoaded, this ) );
	},

	onPostPaneLoad : function() {
		console.group('spacePolygon::onPostPaneLoad');
		$j('a.spaceItem').unbind('click.sp').bind('click.sp', toolbox.delegate(this.onSpaceBoxClick, this));
		var loaded = $j('#loadedSpaceIds').val();

		if(!loaded) {	
			var curSpace = null;
	                for(var k in this.loadedSpaces) {
                        curSpace = this.loadedSpaces[k];
                        for(var i=0; i<curSpace.length; i++) {
                                if(this.polys[this.zoomName][curSpace[i]]) {
//                                      GEvent.trigger(this.polys[this.zoomName][this.loadedSpaces[i]], 'mouseover', this.loadedSpaces[i]);

                                        if(this.polys[this.zoomName] && this.polys[this.zoomName][curSpace[i]] )
        	                                this.polys[this.zoomName][curSpace[i]].setFillStyle(this.hiddenStyle);
                                    //    this.polys[this.zoomName][this.loadedSpaces[i]].show();
                                }
                        }
			this.loadedSpaces[k] = [];
                }
	
		} else {

		loaded = loaded.split(',');
		var found = false;
		var layerId = this.activeLayer;

		if(layerId && loaded) {
			for(var i=0; i<loaded.length; i++) {
				found = false;
				if(this.loadedSpaces[layerId]) {
					for(var j=0; j < this.loadedSpaces[layerId].length; j++) {
						if(loaded[i] == this.loadedSpaces[layerId][j]) {
							found = true;
							this.polys[layerId][loaded[i]].setFillStyle(this.selectedStyle);
 	                                               	this.polys[layerId][loaded[i]].show();

							$j('#clear_'+loaded[i]).unbind('click');
	                                                $j('#clear_'+loaded[i]).click(toolbox.delegate(this.onClick, this, loaded[i] , this.polys[layerId][loaded[i]]) );
						}
					}
				}
				if(!found) {
					
                                	if(this.polys[layerId] && this.polys[layerId][loaded[i]] ) {
                                        	this.polys[layerId][loaded[i]].setFillStyle(this.selectedStyle);
						this.polys[layerId][loaded[i]].show();

						$j('#clear_'+loaded[i]).unbind('click');
                                                $j('#clear_'+loaded[i]).click(toolbox.delegate(this.onClick, this, loaded[i] , this.polys[layerId][loaded[i]]) );

					} else {
						// Do another ajax call here, use this function as cb
					}
	
					this.loadedSpaces[layerId].push(loaded[i]);
				}
			}


			}
		}

		
		console.groupEnd();
	},

	getSpacePoints : function() {
		console.group('spacePolygon::getSpacePoints');
		//$j('a.spaceItem').click(toolbox.delegate(this.onSpaceBoxClick, this));
		if( this.curTrans ) {
                        console.info('Previous space search in progress, aborting');
                        this.curTrans.abort();
                        this.curTrans = null;
                }

		var loadedSpaces = false;

                this.zoom = hq.map.gMap.getZoom();
                this.activeLayer = $j('a.activeLayer').attr('layerId');

                if(!this.activeLayer || 
			this.activeLayer==hq.extentsSearch.layerId ||
			$j('#cbId').val()) {
		
			// Polygons are non applicable, return!
			this.clear();
			return;			
		}

                if(this.zoom < this.layers[this.activeLayer].zoomLevel) {
                        loadedSpaces = $j('#loadedSpaceIds').val();

                        if(!loadedSpaces && !$j('#byExtents').val()) {
                                console.info('aborting...zoom: ' + this.zoom + ' layerzoom: ' + this.layers[this.activeLayer].zoomLevel);
                                console.groupEnd();
                                return false;
                        }

                }

		$j('#clearSpacesLink').click(toolbox.delegate(this.clearLoaded, this));

		var extents = toolbox.getExtents(hq.map.gMap);

		var loadedSpaces = $j('#loadedSpaceIds').val(); 

//		$j( '#loadingMsg' ).fadeIn( this.FadeInDt )
		 $j.getJSON('http://dev04.com/utilities/get-space-points.php?jsoncallback=?',
		{
                                metroId : $j('#metroId').val(),
                                zoom : this.zoom,
                                minX : extents.minX,
                                maxX : extents.maxX,
                                minY : extents.minY,
                                maxY : extents.maxY,
                                layerId : this.activeLayer,
                                loadedSpaces : loadedSpaces
                        },toolbox.delegate( this.getSpacePolygon, this, this.activeLayer  )
 
			);

		/*
		this.curTrans = $j.ajax({
                        url : '/wp-content/plugins/hq_idx/utilities/get-space-points.php',
                        data : {
                                metroId : $j('#metroId').val(),
				zoom : this.zoom,
				minX : extents.minX,
				maxX : extents.maxX,
				minY : extents.minY,
				maxY : extents.maxY,
				layerId : this.activeLayer,
				loadedSpaces : loadedSpaces
                        },
			dataType: "json",
                        success : toolbox.delegate( this.getSpacePolygon, this, this.activeLayer  )
			

                });
		*/
		console.groupEnd();

		return false;
	},



        getSpacePolygon : function(res, resStatus, activeLayerId) {
		console.group('spacePolygon::getSpacePolygon');
		var i = 0;
		var oldZoom = this.zoomName;
		this.zoomName = activeLayerId;
		var layer = poly = null;

		for(var j in this.polys) {
			if(j==this.activeLayer)
	                        continue;

			layer = this.polys[j]; //this.layers[j];
			for(i in layer) {
				poly = this.polys[j][i];

				if(!poly.isHidden() &&  !poly.loaded) {
					poly.hide();
		        	        poly.setFillStyle(this.hiddenStyle);
				}
			}
		}
		
		for(i in res) {
			if(!this.polys[this.zoomName][i]) {
				this.polys[this.zoomName][i] = this.createPolygon(res[i], i);
			}
			this.polys[this.zoomName][i].show();
		}

		$j('#contentWrapper').trigger('polygonsCreated');

//		$j( '#loadingMsg' ).fadeOut( this.FadeOutDt );

		console.groupEnd();
		
        },

	createPolygon : function(ptData, i) {
		var polygon = GPolygon.fromEncoded({

                polylines: [
                        {
                          color: "#0000ff",
                          weight: 1,
                          opacity: 0,
                          points: ptData[0],
                          levels: ptData[1],
                          zoomFactor: 16,
                          numLevels: 1,
			  opts : {mouseOutTolerance: 1}
                        }

                        ]
                        ,
                        outline: false,
                        color: "#aaaaff",
                        opacity: 0,
                        fill: true,
			opts : {mouseOutTolerance: 1}

                
	        });

		//console.info('pts: ' + ptData[0]);
		//console.info('lvls: ' + ptData[1]);
	
		// Save layerId and hqId in the polygon
		polygon.hqData = {
			layerId : this.activeLayer,
			hqId : i
		}
	
		hq.map.gMap.addOverlay(polygon);

		GEvent.addListener( polygon, 'mouseout', toolbox.delegate(this.onMouseOut, this, i ) );
                GEvent.addListener( polygon, 'mouseover', toolbox.delegate(this.onMouseOver, this, i ) );
		GEvent.addListener( polygon, 'click', toolbox.delegate(this.onClick, this, i , polygon) );

		$j('#clear_'+i).click(toolbox.delegate(this.onClick, this, i , polygon) );

		return polygon;

	},

	onOverlayChange : function(evt, i) {
		console.group('spacePolygon::onOverlayChange');

		var $tgt = $j(evt.target);
		this.activeLayer = $tgt.attr('layerId');

		console.groupEnd();
	},

	onMouseOver : function(evt, i) {
		var zoom = hq.map.gMap.getZoom();

		if(!this.activeLayer || zoom < this.layers[this.activeLayer].zoomLevel) {
			console.info('aborting ' + i);
                        return ;
                }

		var curSpace = this.loadedSpaces[this.activeLayer];
		var len = curSpace.length;
	 	for(var j=0; j<len; j++) {
        	                if(curSpace[j]==i) {
					console.info('returning...');
                        	        return;
				}
        	}
		if(this.polys[this.activeLayer][i])
			this.polys[this.activeLayer][i].setFillStyle(this.overStyle);

	},

	onMouseOut : function(evt, i) {
		if(!this.activeLayer)
			return;

		var curSpace = this.loadedSpaces[this.activeLayer];
		var len = curSpace.length;
		for(var j=0; j<len; j++) {
        	               if(curSpace[j]==i)
                                return;
	               }
		if(this.polys[this.activeLayer][i])
			this.polys[this.activeLayer][i].setFillStyle(this.hiddenStyle);
	},

	onClick : function(evt, i, polygon) {
		console.group('spacePolygon::onClick');
		/*var zoom = hq.map.gMap.getZoom();
		if(zoom < this.layers[this.activeLayer].zoomLevel) {
                        console.info('aborting ' + i);
                        return false;
                }*/

		var $target = $j( evt.target );
		var data = polygon.hqData;
		var found = false;

		for(var j in this.loadedSpaces) {
			if(j==this.zoomName) {
				for(var k=0; k<this.loadedSpaces[j].length; k++) {
					if(this.loadedSpaces[j][k]==i) {
						found = true;
						this.loadedSpaces[j].splice(k, 1);		
					}
				}
			} else {
				this.loadedSpaces[j] = [];
			}
		}

		if(!found) { 
//			if(this.zoomName=='region')
//				this.loadedSpaces[this.zoomName] = [i];
//			else 
			this.loadedSpaces[this.zoomName].push(i);

        	        if(this.polys[this.zoomName] && this.polys[this.zoomName][i]) {
                	        this.polys[this.zoomName][i].setFillStyle(this.selectedStyle);
				this.polys[this.zoomName][i].loaded = true;
			}

		} else {
                        if(this.polys[this.zoomName] && this.polys[this.zoomName][i]) {
                                this.polys[this.zoomName][i].setFillStyle(this.hiddenStyle);
				this.polys[this.zoomName][i].loaded = false;
			}

		}

		hq.labels.onLabel( evt, data, null, 'click');
	
		console.groupEnd();
	
		return false;

	},

	onMapMouseOut : function(evt) {
             for(i in this.polys) {
			if(this.polys[i]) {
	                        for(j in this.polys[i]) {
					if(this.polys[i][j]) {
						GEvent.trigger(this.polys[i][j], 'mouseout', i);
					}
	                        } 
			}
             }
		
	},
	clearLoaded : function(evt) {
		if(evt)
			this.layerType = evt.id;

		for(var i in this.loadedSpaces) {
			for(var j=0; j<this.loadedSpaces[i].length; j++) {
				var id = this.loadedSpaces[i][j];

	                	if(this.polys[i] && this.polys[i][id]) {
		                        this.polys[i][id].setFillStyle(this.hiddenStyle);
					this.polys[i][id].hide();
				}

			}
		}

		this.activeLayer = null;	
		
		if(evt && evt.noLayer==false) {
			hq.listings.clear();

			this.initLoadedSpaces();
		
			this.getSpacePoints();
			
		}
	},

	// Clears and hides everything
	clear: function(evt) {
		  for(var i in this.polys) {
			for(var j in this.polys[i]) {

                                if(this.polys[i] && this.polys[i][j]) {
                                        this.polys[i][j].setFillStyle(this.hiddenStyle);
                                        this.polys[i][j].hide();
                                }

                        }
                }

	},

	// Initialize spaces based on links in the class 'overlay'
	// The key in each loaded space is its layer id
	initLoadedSpaces : function() {
		var sp = this;

		this.loadedSpaces = {};
	
		$j('a.overlay').each(function() {
			sp.loadedSpaces[$j(this).attr('layerId')] = [];
		});
	},

	onZoomClick : function(evt) {
		console.group('spacePolygon::onZoomClick');
		$tgt = $j(evt.target);
	
		$tgt = $j(evt.target);
                if( $tgt.is( 'a' ) == false ) {
                        $tgt = $tgt.parents( 'a:first' );
                }


		var yMin = $tgt.attr( 'yMin' );
                var yMax = $tgt.attr( 'yMax' );
                var xMin = $tgt.attr( 'xMin' );
                var xMax = $tgt.attr( 'xMax' );

		if(yMin && yMax && xMin && xMax) {
			var bounds = new GLatLngBounds();
                        bounds.extend( new GLatLng( yMin, xMin, true ) );
                        bounds.extend( new GLatLng( yMax, xMax, true ) );

                        hq.map.gMap.setCenter( bounds.getCenter() );

                        hq.map.gMap.setZoom(  hq.map.gMap.getBoundsZoomLevel( bounds ) );

		}

		console.groupEnd();
		
		return false;
	}


};

$j( document ).ready( toolbox.delegate( hq.spacePolygon.init, hq.spacePolygon ) );