dojo.require("esri.map");
dojo.require("esri.toolbars.navigation");
dojo.require("esri.toolbars.draw");
dojo.require("esri.tasks.identify");
dojo.require("esri.tasks.geometry");

//EDITHERE
var WKID = 3420;
var mapServiceWKID = 3420;
var bufferWKID = 3420;
var startExtent = new esri.geometry.Extent(1302920.755, 1679317.599, 1561252.418, 1883205.956, new esri.SpatialReference({ wkid: WKID }));
//end of EDITHERE

var resizeTimer;
var reloadTimer1;
var reloadTimer2;

var map;
var mapService;
var geomService;
var mapLayer0, mapLayer1, mapLayer2, mapLayer3, mapLayer4;

var gp;
var navToolbar;
var navToolbarOpen = false;
var zoomToolbar;
var drawToolbar;
var queryTask;
var query;
var identify;
var identifyParams;
var border1;
var border2;
var symbol1;
var symbol2;
//var infoTemplate;
var identifyLayerID = -1;
var drawToolbarIsActive = false;
var navToolbarIsActive = false;

// querySrc is used to specify what type of query is taking place. It 
// could be a query for a single subject parcel, a query of comparable
// properties, or a query to get a feature for use as buffer input.
var querySrc = "";

var initMapApp = true;
var bufferOver = false;

// Variables to control immediate zoom and info window on mouseover events.
var autoZoom = true;
var autoInfo = false;

var pxMin = 0;
var pyMin = 0;
var pxMax = 0;
var pyMax = 0;

var graphic = null;

var tocCount = 0;

// These are used to disconnect from various dojo connections.
var connectMap = null;
var connectIdentify = null;
var connectNavToolbar = null;
var connectZoomToolbar = null;
var connectDrawToolbar = null;
var connectResize = null;
var connectBuffer = null;
var connectMouseOver = null;

var theOutLod = null;

var startExtent;

function initMap() {

    startExtent = new esri.geometry.Extent(xmin, ymin, xmax, ymax, new esri.SpatialReference({ wkid: mapServiceWKID }))
    if (mapServiceWKID == 102100)
    {  
   	lods = [{ "level": 8, "resolution": 611.49622628138, "scale": 2311162.217155 },
           { "level": 9, "resolution": 305.748113140558, "scale": 1155581.108577},
           { "level": 10, "resolution": 152.874056570411, "scale": 577790.554289 },
           { "level": 11, "resolution": 76.4370282850732, "scale": 288895.277144  },
           { "level": 12, "resolution": 38.2185141425366, "scale": 144447.638572  },
           { "level": 13, "resolution": 19.1092570712683, "scale": 72223.819286  },
           { "level": 14, "resolution": 9.55462853563415, "scale": 36111.909643  },
           { "level": 15, "resolution": 4.77731426794937, "scale": 18055.954822  },
           { "level": 16, "resolution": 2.38865713397468, "scale": 9027.977411  },
           { "level": 17, "resolution": 1.19432856685505, "scale": 4513.988705  },
           { "level": 18, "resolution": 0.597164283427525, "scale": 2256.9943525 },
           { "level": 19, "resolution": 0.298582141713763, "scale": 1128.49717625 }];    
    }
    else
    {
    	lods = [{ "level": 8, "resolution": 0.001373291015625, "scale": 577143.747208662 },
           { "level": 9, "resolution": 0.0006866455078125, "scale": 288571.873604331 },
           { "level": 10, "resolution": 0.00034332275390625, "scale": 144285.936802165 },
           { "level": 11, "resolution": 0.000171661376953125, "scale": 72142.9684010827 },
           { "level": 12, "resolution": 8.58306884765629E-05, "scale": 36071.4842005414 },
           { "level": 13, "resolution": 4.29153442382814E-05, "scale": 18035.7421002707 },
           { "level": 14, "resolution": 2.14576721191407E-05, "scale": 9017.87105013534 },
           { "level": 15, "resolution": 1.07288360595703E-05, "scale": 4508.93552506767 },
           { "level": 16, "resolution": 5.364418129850699E-6, "scale": 2254.467762533835 },
           { "level": 17, "resolution": 2.6822090649253494E-6, "scale": 1127.2338812669175 },
           { "level": 18, "resolution": 1.3411045324626747E-6, "scale": 563.6169406334587 },
           { "level": 19, "resolution": 6.705522662313373E-7, "scale": 281.80847031672937}];
    }

    switch (useLODs) {
        case "TRUE":
            map = new esri.Map("agsMap", {
                extent: startExtent, lods: lods
            });
            break;
        default:
            map = new esri.Map("agsMap", {
                extent: startExtent
            });
            break;
    }

    if (displayMap == "TRUE") {

        connectMap = dojo.connect(map, 'onLoad', function(theMap) {
            dojo.connect(dijit.byId('agsMap'), 'resize', function() {
                resizeMapDelay();
            });
        });

        ///*
        if (mapServicePath3 != null && mapServicePath3 != "" && useLODs == "TRUE") {
            dojo.connect(map, "onExtentChange", function(extent, delta, outLevelChange, outLod) {
                getMapLevel(extent, delta, outLevelChange, outLod);
            });
        }
        //*/
        if (mapServicePath0 != null && mapServicePath0 != "") {
            var url0 = mapServicePath0 + "MapServer";
            mapLayer0 = new esri.layers.ArcGISTiledMapServiceLayer(url0);
            map.addLayer(mapLayer0);
            mapLayer0.hide();
        }       
    

        // AGOL base map.
        if (mapServicePath3 != null && mapServicePath3 != "") {
            var url3 = mapServicePath3 + "MapServer";
console.log(url3);
            //mapLayer3 = new esri.layers.ArcGISTiledMapServiceLayer(url3);
            mapLayer3 = new esri.layers.ArcGISDynamicMapServiceLayer(url3);
            map.addLayer(mapLayer3);
            mapLayer3.show();
        }
        
        if (mapServicePath4 != null && mapServicePath4 != "") {
	    var imageServiceParameters = new esri.layers.ImageServiceParameters();
	    imageServiceParameters.format = "jpg";
        
            var url4 = mapServicePath4 + "ImageServer";
            mapLayer4 = new esri.layers.ArcGISImageServiceLayer(url4, { imageServiceParameters:imageServiceParameters });
            map.addLayer(mapLayer4);
            mapLayer4.hide();
        }                

        if (mapServicePath2 != null && mapServicePath2 != "") {
console.log (mapServicePath2);
	    var imageServiceParameters = new esri.layers.ImageServiceParameters();
	    if (mapServicePath4 != null && mapServicePath4 != "") 
	    {
	    	imageServiceParameters.format = "png";
	    }
	    else
	    {
	    	imageServiceParameters.format = "jpg";
	    }
        
            var url2 = mapServicePath2 + "ImageServer";
            mapLayer2 = new esri.layers.ArcGISImageServiceLayer(url2, { imageServiceParameters:imageServiceParameters });
            //mapLayer2 = new esri.layers.ArcGISTiledMapServiceLayer(url2);
            //mapLayer2.setImageFormat("jpg");
            map.addLayer(mapLayer2);
            mapLayer2.hide();
        }

        // Main parcel map.
        if (mapServicePath1 != null && mapServicePath1 != "") {
            var url1 = mapServicePath1 + "MapServer";
console.log(url1);
            mapLayer1 = new esri.layers.ArcGISDynamicMapServiceLayer(url1);
            //mapLayer1 = new esri.layers.ArcGISTiledMapServiceLayer(url1);
            map.addLayer(mapLayer1);
        }
        

        navToolbar = new esri.toolbars.Navigation(map);
        connectNavToolbar = dojo.connect(navToolbar);

        zoomToolbar = new esri.toolbars.Navigation(map);
        connectZoomToolbar = dojo.connect(zoomToolbar, "onExtentHistoryChange", extentHistoryChangeHandler);

        drawToolbar = new esri.toolbars.Draw(map);
        connectDrawToolbar = dojo.connect(drawToolbar, "onDrawEnd", executeMapIdentify);

        geomService = new esri.tasks.GeometryService(geometryServicePath);

        // Build query task.
        queryTask = new esri.tasks.QueryTask(mapServicePath1 + "MapServer/" + queryLayerNumber);
        query = new esri.tasks.Query();
        query.returnGeometry = true;
        query.outFields = queryOutputFields;

        // Create the infoTemplate to be used in an InfoWindow.
        // All ${attributeName} will be substituted with the attribute value for current feature.
        //infoTemplate = new esri.InfoTemplate("Parcel Info", infoTemplateFields);

        // Create symbols for selected features.
        border1 = new esri.symbol.SimpleLineSymbol();
        border1.color = new dojo.Color([100, 0, 0, 0.60]);
        border1.style = esri.symbol.SimpleLineSymbol.STYLE_SOLID;
        border1.width = 4;

        symbol1 = new esri.symbol.SimpleFillSymbol();
        symbol1.color = new dojo.Color([255, 255, 0, 0.1]);
        symbol1.style = esri.symbol.SimpleFillSymbol.STYLE_SOLID;
        symbol1.outline = border1;

        border2 = new esri.symbol.SimpleLineSymbol();
        border2.color = new dojo.Color([255, 255, 0, 0.5]);
        border2.style = esri.symbol.SimpleLineSymbol.STYLE_SOLID;
        border2.width = 8;

        symbol2 = new esri.symbol.SimpleFillSymbol();
        symbol2.color = new dojo.Color([0, 0, 255, 0.1]);
        symbol2.style = esri.symbol.SimpleFillSymbol.STYLE_SOLID;
        symbol2.outline = border2;

        border3 = new esri.symbol.SimpleLineSymbol();
        border3.color = new dojo.Color([0, 0, 100, 0.3]);
        border3.style = esri.symbol.SimpleLineSymbol.STYLE_SOLID;
        border3.width = 6;

        symbol3 = new esri.symbol.SimpleFillSymbol();
        symbol3.color = new dojo.Color([200, 200, 200, 0.4]);
        symbol3.style = esri.symbol.SimpleFillSymbol.STYLE_SOLID;
        symbol3.outline = border3;

        //dojo.connect(map, "onMouseMove", showCoordinates);
        //dojo.connect(map, "onMouseDrag", showCoordinates); 

        identify = new esri.tasks.IdentifyTask(mapServicePath1 + "MapServer");
        //connectIdentify = dojo.connect(identify, "onComplete", getIdentifyResults);
        identifyParams = new esri.tasks.IdentifyParameters();
        identifyParams.tolerance = 3;
        identifyParams.returnGeometry = true;

        if (initMapApp) {
            window.clearTimeout(reloadTimer);
            reloadTimer = window.setTimeout("getMapLayers();", timer);
            initMapApp = false;
        }
    }
    else
        focusDelay("Owner_Name");
}

/////////////////////////////////////
//Handles resize of browser
/////////////////////////////////////
function resizeMapDelay() {
    window.clearTimeout(resizeTimer);
    resizeTimer = window.setTimeout("resizeMap();", timer);
}
function resizeMap() {
    map.resize();
    map.reposition();
    sketch.resize();
    sketch.reposition();
}
/////////////////////////////////////

function getMapLevelDelay() {
    window.clearTimeout(reloadTimer1);
    reloadTimer1 = window.setTimeout("getMapLevel();", timer);
}

function getMapLevel(extent, delta, outLevelChange, outLod) {
    theOutLod = outLod.level;

    if (dojo.byId("agsMap") != null) {
        if (dojo.byId("agsMap").style.visibility == "visible") {
            if (theOutLod >= 7) {
                console.log("Level3: " + theOutLod);
                try
                {
                	mapLayer4.show();
                }
                catch(err)
                {
                }
                mapLayer2.show();
                mapLayer3.hide();
            }
            else {
                console.log("Level4: " + theOutLod);
                try
                {
                	mapLayer4.hide();
                }
                catch(err)
                {
                }                
                mapLayer2.hide();
                mapLayer3.show();
            }
        }
    }
}

function toggleMapMode(mode) {
    if (navToolbarIsActive) {
        navToolbar.deactivate();
        navToolbarIsActive = false;
    }
    if (drawToolbarIsActive) {
        drawToolbar.deactivate();
        drawToolbarIsActive = false;
    }

    switch (mode.id) {
        case "zoomin":
            navToolbar.activate(esri.toolbars.Navigation.ZOOM_IN);
            navToolbarIsActive = true;
            break;
        case "zoomout":
            navToolbar.activate(esri.toolbars.Navigation.ZOOM_OUT);
            navToolbarIsActive = true;
            break;
        case "identify":
            drawToolbar.activate(esri.toolbars.Draw.EXTENT);
            drawToolbarIsActive = true;
            break;
        default:
            navToolbar.deactivate();
            navToolbarIsActive = false;
            drawToolbar.deactivate();
            drawToolbarIsActive = false;
            break;
    }
}

function zoomToStartExtent() {
    map.setExtent(startExtent.expand(1.3), new esri.SpatialReference({ wkid: mapServiceWKID }), true);
}

function extentHistoryChangeHandler() {
    dijit.byId("zoomprev").disabled = navToolbar.isFirstExtent();
    //dijit.byId("zoomnext").disabled = navToolbar.isLastExtent();
}

function executeMapQuery(pid, src) {
    //KJ Edit- editing code about county code
    if (pid.substring(0, 3) != countyCode) {
        pid = countyCode + pid
    }

    //alert(pid);
    //console.log("function executeMapQuery");
    map.graphics.clear();
    graphic = null;
    query.where = "";

    // querySrc is used to partially determine what addtional 
    // action should be taken based on the query results.
    querySrc = src;

    if (pid != null && pid != "") {
        //togglePage('hidden', 'hidden', '', '', '', 'hidden', 'hidden', 'hidden', 'hidden', 'hidden',  'visible', 'Please wait ', 'agsmap_executeMapQuery');

        if (pid.indexOf("|") > -1) {
            // If pid contains a pipe (|), this is being called from the 
            // Comparable Properties report: "Click here to locate ALL on Map"
            mapPids = pid;

            var pids = pid.split("|");
            for (var a = 0; a < pids.length; a++) {
                if (pids[a] != "") {
                    if (a > 0)
                        query.where += " OR ";

                    query.where += pidField + " = '" + pids[a] + "'";
                }
            }
        }
        else {
            mapPids = "";
            query.where = pidField + " = '" + pid + "'";
        }
        console.log("Map query: '" + query.where + "'");

        // Executes the query and calls getQueryResults upon completion.
        console.log("map query: " + query.where);
        queryTask.execute(query, getQueryResults);

    }
    else {
        // This should never happen.
        togglePage('hidden', 'hidden', '', '', '', 'visible', 'visible', 'hidden', 'hidden', 'hidden', 'hidden', '', 'agsmap_executeMapQuery_blankPid');
    }
}

function executeMapIdentify(geometry) {
    //alert(identifyLayerID);
    document.location.href = "#top2";
    //console.log(geometry.type);
    mapPids = "";
    map.graphics.clear();
    graphic = null;

    geometry.setSpatialReference(new esri.SpatialReference({ wkid: mapServiceWKID }));
    identifyParams.geometry = geometry;
    identifyParams.mapExtent = map.extent;
    identifyParams.layerOption = "ALL";

    //console.log("identifyLayerID: " + identifyLayerID);
    identifyParams.layerIds = [identifyLayerID];

    //identify, "onComplete", getIdentifyResults
    identify.execute(identifyParams, function(featureSet) {
        getIdentifyResults(featureSet, "identify");
    });
}

function executeBuffer() {
    var pid1 = document.getElementById("h_pid1").value;
    //console.log("function executeBuffer");
    if (pid1 != null && pid1 != "" && pid1.indexOf("|") == -1) {
        executeMapQuery(pid1, "BUFFER");
    }
    else {
        alert("Please establish a Subject Property.");
    }
}
function startGeometryBuffer(featureResults) {
    //console.log(featureResults.length);
    var geomArr = [];
    if (featureResults.length >= 1) {

        if (featureResults.length == 1)
            executeGeometryBuffer(featureResults[0].geometry);
        else {
            /*
            ///////////////////////////////////////////////////
            NOT TO BE IMPLEMENTED UNTIL 10
            for (var g = 0; g < featureResults.length; g++) {
            geomArr.push(featureResults[g].geometry);
            }
            geomService.union(geomArr, executeGeometryBuffer);
            ///////////////////////////////////////////////////
            */

            executeGeometryBuffer(featureResults[0].geometry);

        }
    }
    else {
        alert("Nothing is selected.  Please establish a Subject Property.");
    }
}

function errorFunction(err) {
    alert("Error encountered!");
}

function executeGeometryBuffer(featureResults) {
    console.log(featureResults.type);

    if (featureResults != null) {
        var params = new esri.tasks.BufferParameters();
        params.distances = [dojo.byId("BufferDist").value];
        params.bufferSpatialReference = new esri.SpatialReference({ wkid: bufferWKID });
        params.outSpatialReference = map.spatialReference;
        params.unit = eval("esri.tasks.BufferParameters.UNIT_FOOT");
        console.log("Dist: " + dojo.byId("BufferDist").value);

        params.geometries = [featureResults];
        geomService.buffer(params, executeBufferIdentify);
    }
    else {
        alert("Nothing is selected.  Please establish a Subject Property.");
    }
}

function executeBufferIdentify(bufferResults) {
    document.location.href = "#top2";

    mapPids = "";
    map.graphics.clear();
    graphic = null;

    fetchBuffer(bufferResults, "executeBufferIdentify");

    bufferResults[0].setSpatialReference(new esri.SpatialReference({ wkid: mapServiceWKID }));
    identifyParams.geometry = bufferResults[0];
    identifyParams.mapExtent = map.extent;
    identifyParams.layerOption = "ALL";

    console.log("identifyLayerID: " + identifyLayerID);
    identifyParams.layerIds = [identifyLayerID];

    console.log("bufferResults: " + (bufferResults[0].type).toString());
    //identify, "onComplete", getIdentifyResults
    identify.execute(identifyParams, function(featureSet) {
        getIdentifyResults(featureSet, "buffer");
    });
}

function fetchBuffer(featureResults, src) {
    var selCount = featureResults.length;
    if (selCount > 0) {
        if (logLevel >= 0)
            console.log("function fetchBuffer\nResults length: " + featureResults.length + "\nsource: " + src);

        dojo.forEach(featureResults, function(geometry) {
            var graphic = new esri.Graphic(geometry, symbol3);
            map.graphics.add(graphic);
        });
    }

    //togglePage('hidden', 'hidden', '', '', '', 'visible', 'visible', 'hidden', 'hidden', 'hidden', 'hidden', '', 'agsmap_fetchBuffer');
}

function getIdentifyResults(featureSet, src) {
    //console.log("getIdentifyResults - src: " + src);

    //alert(src)
    fetchResults(featureSet, src);
}

function getQueryResults(featureSet) {
    // QueryTask returns a featureSet.
    // Performance enhancer - assign featureSet to a single variable.
    var featureResults = featureSet.features;
    //alert(featureResults.length);
    console.log("getQueryResults -- featureResults.length: " + featureResults.length);

    //if (featureResults.length > 0)
    console.log('Query source: ' + querySrc.toUpperCase());

    switch (querySrc.toUpperCase()) {
        case "BUFFER":
            startGeometryBuffer(featureResults);
            break;
        default:
            fetchResults(featureResults, "query");
            break;
    }
}

function fetchResults(featureResults, src) {
    // Remove all graphics from the maps graphics layer.
    //map.graphics.clear();
    console.log("+ + + function fetchResults\nResults length: " + featureResults.length + "\nsource: " + src);
    var selCount = featureResults.length;
    var pid1 = "";
    if (selCount > 0) {
        if (logLevel >= 3)
            alert("function fetchResults\nResults length: " + featureResults.length + "\nsource: " + src);

        //console.log("function fetchResults\nResults length: " + featureResults.length + "\nsource: " + src);

        var polyExt = new Array();
        var sxMin = new Array();
        var syMin = new Array();
        var sxMax = new Array();
        var syMax = new Array();
        var selEnv = new Array();

        // Loop through features and add them to the map.
        for (var a = 0; a < selCount; a++) {
            // Gets the current feature.
            // If featureResults contains features, it was established 
            // by a user identify and constitutes a feature set. 
            // Otherwise, featureResults was established by a query
            // and is comprised of a bunch of individual features.
            if (src.toUpperCase() == "IDENTIFY" || src.toUpperCase() == "BUFFER") {
                graphic = featureResults[a].feature;
            }
            else {
                graphic = featureResults[a];
            }

            // Sets the Symbol.
            graphic.setSymbol(symbol1);

            // Sets the infoTemplate.
            //graphic.setInfoTemplate(infoTemplate);

            // Adds graphic to the map graphics layer.
            map.graphics.add(graphic);

            // We may have multiple polygons.  So we collect and store each bounding 
            // box into an array so we can zoom the map to the selected polyon(s).
            var ring = graphic.geometry.rings.toString();
            var coords = ring.split(",");
            console.log("+ + + function fetchResults - ring " + a + " coords: " + coords);
            if (coords.length > 0) {
                polyExt = getPolyExtent(coords);
                sxMin[a] = polyExt[0];
                syMin[a] = polyExt[1];
                sxMax[a] = polyExt[2];
                syMax[a] = polyExt[3];
            }

            //alert("Content: " + graphic.getContent());
            // Establishes list of Pids resulting from user interaction with the map.
            // This code is subject to change based on the content of the infoTemplate.
            if (graphic.getContent() != null && graphic.getContent() != "") {
                console.log("+ + + function fetchResults - Graphic Content: " + graphic.getContent());
                pid1 = getGraphicPid(graphic.getContent());

                if (src.toUpperCase() == "IDENTIFY" || src.toUpperCase() == "BUFFER") {
                    //KJ edit- editing code regarding County code
                    if (pid1.substring(0, 3) == countyCode) {
                        //Do nothing
                    } else {
                        pid1 = countyCode + pid1;
                    }

                    if (mapPids == "")
                        mapPids = pid1;
                    else
                        mapPids += "|" + pid1;
                }
            }
        }

        // Establishes final map extent.
        if (sxMin.length > 0) {
            pxMin = sxMin[0];
            pyMin = syMin[0];
            pxMax = sxMax[0];
            pyMax = syMax[0];

            if (selCount > 1) {
                for (var c = 1; c < selCount; c++) {
                    pxMin = Math.min(sxMin[c], pxMin);
                    pyMin = Math.min(syMin[c], pyMin);
                    pxMax = Math.max(sxMax[c], pxMax);
                    pyMax = Math.max(syMax[c], pyMax);
                }
            }

            // If we are zooming to Pids from the Comparable Properties
            // report, we want to zoom in closer than normal.  See 
            // Comparable Properties: "Click here to locate ALL on Map"
            var zoomClose = false;
            if ((src.toUpperCase() == "QUERY" || src.toUpperCase() == "BUFFER") && mapPids.indexOf("|") > -1)
                zoomClose = true;
            // Use the new extent object to change the map extent.
            console.log("+ + + function fetchResults - Parcel Extent: " + pxMin + ',' + pyMin + ',' + pxMax + ',' + pyMax + ',')
            setMapExtent(pxMin, pyMin, pxMax, pyMax, zoomClose);
        }
        //alert(mapPids);

        var dateStamp = getDateStamp();
        //document.getElementById("mapTime").innerHTML = dateStamp + "&nbsp;";

        // If the user performed a Map Identify, we update the Search
        // Results with information about the selected parcels.  Or, if
        // the user did not perform an Identify but the mapPids variable
        // is populated, we update the Search Results with information of
        // the Comparable Properties that are now highlighted on the map.
        // querySrc was added because we only want the Search Results to
        // be updated in the case of Comparable Properties.

        //console.log("999xxx");

        if (src.toUpperCase() == "IDENTIFY" || src.toUpperCase() == "BUFFER" || (mapPids.indexOf("|") > -1 && querySrc.toUpperCase().indexOf("COMP") > -1)) {
            //alert(mapPids + "\n\n" + querySrc);

            // We set the hidden PID1 tag because it drives 
            // subsequent queries when the user returns to the map.
            if (selCount == 1)
                document.getElementById("h_pid1").value = mapPids;

            searchCount = selCount;

            if (src.toUpperCase() == "BUFFER")
                fetchSearchResults("Map", 1, searchCount);
            else
                fetchSearchResults("Map", 1, searchLimit);
        }
        else {
            mapPids = "";
        }
    }

    if (src.toUpperCase() != "BUFFER") {
        console.log("updateHdr 6");
        console.log(selCount + ", " + pid1 + ", " + document.getElementById("h_pid1").value);
        updateHdr(selCount, pid1, document.getElementById("h_pid1").value);
    }
}

function getGraphicPid(content) {
    //console.log("content: " + content);
    var pid = "";
    var pidFldUpper = pidHeader.toUpperCase();
    //var pidFldUpper = "PropertyNum";
    var contentArr = content.split(">");

    for (var j = 0; j < contentArr.length; j++) {
        //console.log("j: " + contentArr[j]);
        if (contentArr[j].indexOf(pidFldUpper + resultsSpacer) > -1) {
            var start = contentArr[j].indexOf(resultsSpacer);
            //alert(start);
            var tmppid = contentArr[j].substr((start + 3), (contentArr[j].indexOf("<br")));
            var end = tmppid.indexOf("<br");
            console.log("+ + + function getGraphicPid - tmppid: " + tmppid);
            pid = tmppid.substr(0, end);
            //alert(pid);
        }
    }
    return pid;
}

function zoomToPoly(pid1) {
    if (displayMap == "TRUE") {
        console.log("+ + + function zoomToPoly - pid1: " + pid1);
        var subjExists = false;
        if (document.getElementById("h_pid1").value != "" && document.getElementById("h_pid1").value.indexOf("|") == -1)
            subjExists = true;
        var flag = false;

        console.log("+ + + function zoomToPoly - graphic eq null: " + (graphic == null).toString());

        if (graphic != null) {
            if (autoZoom) {
                for (var a = 0; a < map.graphics.graphics.length; a++) {
                    //console.log("zoomToPoly - graphic " + a + " attributes: " + map.graphics.graphics[a].getContent());
                    if (map.graphics.graphics[a].getContent().indexOf(pid1) > -1) {
                        var polyExt = new Array();
                        var ring = map.graphics.graphics[a].geometry.rings.toString();
                        var coords = ring.split(",");
                        if (coords.length > 0) {

                            console.log("+ + + function zoomToPoly - coords: " + coords);

                            flag = true;
                            polyExt = getPolyExtent(coords);
                            //alert(polyExt.toString());
                            setMapExtent(polyExt[0], polyExt[1], polyExt[2], polyExt[3], false);
                            map.graphics.graphics[a].setSymbol(symbol2);
                            console.log("updateHdr 4");
                            updateHdr(1, pid1, document.getElementById("h_pid1").value);
                        }
                    }
                }
                //getMapLevelDelay()
            }
        }
        if (!subjExists && !flag) {
            console.log("updateHdr 7");
            updateHdr(0, pid1, document.getElementById("h_pid1").value);
        }
    }
}

function resetPolySymbol(pid1) {
    if (graphic != null) {
        var subjExists = false;
        if (document.getElementById("h_pid1").value != "" && document.getElementById("h_pid1").value.indexOf("|") == -1)
            subjExists = true;
        //console.log("autoZoom: " + (autoZoom).toString());
        if (autoZoom) {
            for (var a = 0; a < map.graphics.graphics.length; a++) {
                if (map.graphics.graphics[a].getContent().indexOf(pid1) > -1) {
                    map.graphics.graphics[a].setSymbol(symbol1);
                }
            }
            if (!subjExists && map.graphics.graphics.length > 1) {
                console.log("updateHdr 5");
                updateHdr(-1, pid1, document.getElementById("h_pid1").value);
            }
        }
    }
}

function updateHdr(selCount, pid1, pidSubj) {
    //console.log("function updateHdr -- pid1: " + pid1 + ", pidSubj: " + pidSubj);
    //console.log("function updateHdr -- h_pid1: " + dojo.byId("h_pid1").value);

    if (pid1 == null || pid1 == "")
        pid1 = "q";
    if (pidSubj == null || pidSubj == "")
        pidSubj = "p";

    switch (selCount) {
        case 0:
            document.getElementById("mapHdr").innerHTML = "* * * <a href='orka/parcelNotOnMap.htm' target='_blank' style='color:white; text-decoration:underline;'>Map data not available</a> * * *";
            break;
        case 1:
            if (pid1 != "")
                if (pidSubj != null && pidSubj != "") {
                //alert(pid1 +"\n"+ pidSubj);
                if (pid1 == pidSubj)
                    document.getElementById("mapHdr").innerHTML = "Subject Property " + pidSubj;
                else
                    if (pid1 == "q") {
                    document.getElementById("mapHdr").innerHTML = "Highlighted Parcel " + pidSubj;
                }
                else {
                    document.getElementById("mapHdr").innerHTML = "Highlighted Parcel " + pid1;
                }
            }
            else {
                document.getElementById("mapHdr").innerHTML = "Highlighted Parcel " + pid1;
            }
            else
                document.getElementById("mapHdr").innerHTML = "Map";
            break;
        default:
            if (pid1 == pidSubj && pid1.indexOf("|") == -1)
                document.getElementById("mapHdr").innerHTML = "Subject Property " + pidSubj;
            else
                document.getElementById("mapHdr").innerHTML = "Map";
            break;
    }
}

function getPolyExtent(coords) {
console.log("+ + + function getPolyExtent: " + coords[0] + ", " + coords[1] + ", " + coords[2] + ", " + coords[3]);

    var ext = new Array();
    var pxMin = 0;
    var pyMin = 0;
    var pxMax = 0;
    var pyMax = 0;
    var grX = 0;
    var grY = 0;

    pxMin = Number(coords[0]);
    pyMin = Number(coords[1]);
    pxMax = Number(coords[2]);
    pyMax = Number(coords[3]);

    for (var b = 0; b < coords.length; b = (b + 2)) {
        grX = Number(coords[b]);
        grY = Number(coords[b + 1]);
        pxMin = Math.min(grX, pxMin);
        pyMin = Math.min(grY, pyMin);
        pxMax = Math.max(grX, pxMax);
        pyMax = Math.max(grY, pyMax);
    }

    ext[0] = pxMin;
    ext[1] = pyMin;
    ext[2] = pxMax;
    ext[3] = pyMax;

    return ext;
}

function setMapExtent(xMin, yMin, xMax, yMax, zoomClose) {
    if (!isNaN(xMin) && !isNaN(yMin) && !isNaN(xMax) && !isNaN(yMax)) {
        console.log("+ + + function setMapExtent - Extent is good!!!");
        //var newExtent = new esri.geometry.Extent();
        var newExtent = new esri.geometry.Extent(xMin, yMin, xMax, yMax, new esri.SpatialReference({ wkid: mapServiceWKID }))
        /*newExtent.xmin = xMin;
        newExtent.ymin = yMin;
        newExtent.xmax = xMax;
        newExtent.ymax = yMax;*/

        if (zoomClose)
            map.setExtent(newExtent.expand(1.1));
        else {
            map.setExtent(newExtent.expand(1.8));
        }
    }
}

function unloadMap() {
    alert("!!!!!!!!!!!!!!!!!!");
    if (connectMap != null)
        dojo.disconnect(connectMap);
    if (connectNavToolbar != null)
        dojo.disconnect(connectNavToolbar);
    if (connectZoomToolbar != null)
        dojo.disconnect(connectZoomToolbar);
    if (connectDrawToolbar != null)
        dojo.disconnect(connectDrawToolbar);
    if (connectResize != null)
        dojo.disconnect(connectResize);
}

function getMapLayers() {
    //console.log(333);

    var htmlTxt = '';

    htmlTxt += '<table border="1">';
    for (var j = 0, jl = map.layerIds.length; j < jl; j++) {
        var currentLayer = map.getLayer(map.layerIds[j]);
        //console.log("url: " + currentLayer.url);
        var url = currentLayer.url.toString().toUpperCase();
        if (url.indexOf("IMAGESERVER") == -1) {
            for (var z = 0; z < currentLayer.layerInfos.length; z++) {
                //console.log(666);

                htmlTxt += '<tr>';
                htmlTxt += '<td NOWRAP class="searchResultsLightLeftTD"><input type="checkbox" id="tocLayer' + currentLayer.layerInfos[z].id + '" onClick="refreshLayers()"';
                if (currentLayer.layerInfos[z].defaultVisibility)
                    htmlTxt += ' checked';
                htmlTxt += '></td>';
                htmlTxt += '<td NOWRAP class="searchResultsLightLeftTD">';
                htmlTxt += currentLayer.layerInfos[z].name;

                // identifyLayerName is set at the start of this script.
                if (currentLayer.layerInfos[z].name.toUpperCase() == identifyLayerName.toUpperCase()) {
                    identifyLayerID = currentLayer.layerInfos[z].id;
                    //console.log(999);
                }
                htmlTxt += '</td>';
                htmlTxt += '</tr>';

                tocCount = z;
            }
        }
    }
    htmlTxt += '</table>';

    //dojo.byId("mapLayers").innerHTML = htmlTxt;

    if (identifyLayerID == -1)
        identifyLayerID = queryLayerNumber;

    console.log("identifyLayerID after getMapLayers: " + identifyLayerID);

    focusDelay("Owner_Name");
}