var tc_DivIsVisible = false;
var tc_AutoCompletePlugin = null;
var tc_LastQ = null;
var tc_ResultsCurrentlyShown = false;
var tc_DivClicked = false;
var urlLevels = 0;

// set this to true to see alerts of when each function is called, 
// good for tracing flow through the app.
var tc_DebugModeOn = false;

// -------------------------------------------------------------------------------------------------------------------------------------
//  AutoComplete Functionality - [BEGIN]
// -------------------------------------------------------------------------------------------------------------------------------------
jQuery.tc_autocomplete = function(input, options) {
    if (tc_DebugModeOn) {
        alert("Constructor called.");
    }
    // Create a link to self
    var me = this;

    // Create jQuery object for input element
    var $input = $(input).attr("autocomplete", "off");

    // Apply inputClass if necessary
    if (options.inputClass) {
        $input.addClass(options.inputClass);
    }

    // Create results div
    var results = document.createElement("div");

    // Create jQuery object for results
    var $results = $(results);

    $results.hide().addClass(options.resultsClass).css("position", "absolute");

    if (options.width > 0) {
        $results.css("width", options.width);
    }

    // Add to body element
    $("body").append(results);

    var stateDDL = GetSearchStringForControl("drpStates");
    $(stateDDL).change(ClearTerritoryInfo);

    input.tc_autocomplete = me;

    var timeout = null;
    var prev = "";
    var active = -1;
    var keyb = false;
    var cache = {};
    var hasFocus = false;
    var lastKeyPressCode = null;

    // flush cache
    function flushCache() {
        if (tc_DebugModeOn) {
            alert("flushCache() called.");
        }

        cache = {};
        cache.data = {};
        cache.length = 0;
    };

    // show the loading graphic
    $input.addClass(options.loadingClass);

    // if there is a data array supplied
    if (options.data != null) {
        var sFirstChar = "", stMatchSets = {}, row = [];

        // no url was specified, we need to adjust the cache length to make sure it fits the local data store
        if (typeof options.url != "string") {
            options.cacheLength = 1;
        }

        // loop through the array and create a lookup structure
        for (var i = 0; i < options.data.length; i++) {
            // if row is a string, make an array otherwise just reference the array
            row = ((typeof options.data[i] == "string") ? [options.data[i]] : options.data[i]);

            // if the length is zero, don't add to list
            if (row[0].length > 0) {
                // get the first character
                sFirstChar = row[0].substring(0, 1).toLowerCase();
                // if no lookup array for this character exists, look it up now
                if (!stMatchSets[sFirstChar]) stMatchSets[sFirstChar] = [];
                // if the match is a string
                stMatchSets[sFirstChar].push(row);
            }
        }

        // add the data items to the cache
        for (var k in stMatchSets) {
            // increase the cache size
            options.cacheLength++;
            // add to the cache
            addToCache(k, stMatchSets[k]);
        }
    }

    // external method so that functions outside of class can 
    // call in to refresh the cache
    $.fn.tc_autocomplete.refreshCache = function(data) {
        if (tc_DebugModeOn) {
            alert("refreshCache called. data=" + data);
        }

        options.data = null;
        flushCache();
        options.data = data;

        // if there is a data array supplied
        if (options.data != null) {
            var sFirstChar = "", stMatchSets = {}, row = [];

            // no url was specified, we need to adjust the cache length to make sure it fits the local data store
            if (typeof options.url != "string") options.cacheLength = 1;

            // loop through the array and create a lookup structure
            for (var i = 0; i < options.data.length; i++) {
                // if row is a string, make an array otherwise just reference the array
                row = ((typeof options.data[i] == "string") ? [options.data[i]] : options.data[i]);

                // if the length is zero, don't add to list
                if (row[0].length > 0) {
                    // get the first character
                    sFirstChar = row[0].substring(0, 1).toLowerCase();
                    // if no lookup array for this character exists, look it up now
                    if (!stMatchSets[sFirstChar]) stMatchSets[sFirstChar] = [];
                    // if the match is a string
                    stMatchSets[sFirstChar].push(row);
                }
            }

            // add the data items to the cache
            for (var k in stMatchSets) {
                // increase the cache size
                options.cacheLength++;
                // add to the cache
                addToCache(k, stMatchSets[k]);
            }
        }

        requestData(tc_LastQ);
    };

    // external method so that functions outside of tc_autocomplete class can call
    // in to refresh the results
    $.fn.tc_autocomplete.showResults = function() {
        showResults();
    };

    // handles keydown event for input field.
    $input.keydown(function(e) {
        if (tc_DebugModeOn) {
            alert("$input.keydown called. e=" + e);
        }
        // track last key pressed
        lastKeyPressCode = e.keyCode;
        switch (e.keyCode) {
            case 38: // up
                e.preventDefault();
                moveSelect(-1);
                break;
            case 40: // down
                e.preventDefault();
                moveSelect(1);
                break;
            case 9:  // tab
            case 13: // return
                if (selectCurrent()) {
                    // make sure to blur off the current field
                    $input.get(0).blur();
                    e.preventDefault();
                }
                break;
            default:
                active = -1;
                if (timeout) clearTimeout(timeout);
                timeout = setTimeout(function() { onChange(); }, options.delay);
                break;
        }
    });

    // called when the input field gains focus
    $input.focus(function() {
        if (tc_DebugModeOn) {
            alert("$input.focus() called.");
        }
        // track whether the field has focus, we shouldn't process 
        // any results if the field no longer has focus
        hasFocus = true;

        // if the field regains focus with values in the field, 
        // we should show any results from the cache that match 
        // what is in the input field.
        var v = $input.val();
        if (v.length > 0) {
            requestData(v);
        }
    });

    // called when the input field loses focus
    $input.blur(function(event) {
        if (tc_DebugModeOn) {
            alert("$input.blur() called.");
        }
        // track whether the field has focus
        hasFocus = false;
        hideResults();
    });

    hideResultsNow();

    $results.focus(function() {
        if ($results.html() != "") {
            showResults();
        }
    });

    $results.blur(function() {
        // IE has a weird bug where the focus & blur events
        // fire when the div initially gains focus.
        if (!tc_DivClicked) {
            tc_DivClicked = true;
            $results.focus();
        } else {
            tc_DivClicked = false;
            hideResults();
        }
    });

    // called when the test in the input field changes.
    function onChange() {
        if (tc_DebugModeOn) {
            alert("onChange called.");
        }

        // ignore if the following keys are pressed: [del] [shift] [capslock]
        if (lastKeyPressCode == 46 || (lastKeyPressCode > 8 && lastKeyPressCode < 32)) {
            return $results.hide();
        }

        if ($input.val() != "") {
            $input.addClass(options.loadingClass);
            GetTerritoryListData(true, true, urlLevels);
        }
    };

    // moves through the results list.
    function moveSelect(step) {
        if (tc_DebugModeOn) {
            alert("moveSelect(step) called. step=" + step);
        }

        var lis = $("li", results);
        if (!lis) {
            return;
        }

        active += step;

        if (active < 0) {
            active = 0;
        }
        else if (active >= lis.size()) {
            active = lis.size() - 1;
        }

        lis.removeClass("tc_over");

        $(lis[active]).addClass("tc_over");
    };

    // selects the currently highlighted result in the list.
    function selectCurrent() {
        if (tc_DebugModeOn) {
            alert("selectCurrent() called.");
        }

        var li = $("li.tc_over", results)[0];
        if (!li) {
            var $li = $("li", results);
            if (options.selectOnly) {
                if ($li.length == 1) {
                    li = $li[0];
                }
            }
            else if (options.selectFirst) {
                li = $li[0];
            }
        }
        if (li) {
            selectItem(li);
            return true;
        }
        else {
            return false;
        }
    };

    // call to select an item in the list and do a bunch of stuff
    // when that happens.
    function selectItem(li) {
        if (tc_DebugModeOn) {
            alert("selectItem(li) called. li=" + li);
        }

        if (!li) {
            li = document.createElement("li");
            li.extra = [];
            li.selectValue = "";
        }

        var v = $.trim(li.selectValue ? li.selectValue : li.innerHTML);
        input.lastSelected = v;
        prev = v;

        // split result string so it can be displayed in Class Code textbox
        // and Class Code description label.
        var firstDash = v.indexOf("-");
        var firstComma = v.indexOf(",");
        var terrCode = v.substring(0, firstDash - 1);
        var terrCity = v.substring(firstDash + 1, firstComma);
        var terrStateAbbrev = v.substring(firstComma + 1, firstComma + 4).trim();
        var terrZip = v.substring(firstComma + 4, v.length).trim();
        var terrDesc = v.substring(firstDash + 1, v.length).trim();

        var lblISOTerrDesc = GetSearchStringForControl("lblISOTerrDescription");
        var hiddenTerrCity = GetSearchStringForControl("terrCity");
        var hiddenTerrZip = GetSearchStringForControl("terrZip");
        var stateDDL = GetSearchStringForControl("drpStates");

        $(hiddenTerrCity).val(terrCity);
        $(hiddenTerrZip).val(terrZip);
        $(stateDDL).val(terrStateAbbrev);

        $results.html("");

        $input.val(terrCode);

        hideResultsNow();

        $(lblISOTerrDesc).text(terrCode + " - " + terrDesc);

        if (options.onItemSelect) {
            setTimeout(function() { options.onItemSelect(li) }, 1);
        }
    };

    // selects a portion of the input string
    function createSelection(start, end) {
        if (tc_DebugModeOn) {
            alert("createSelection(start, end) called. start=" + start + ", end=" + end);
        }
        // get a reference to the input element
        var field = $input.get(0);
        if (field.createTextRange) {
            var selRange = field.createTextRange();
            selRange.collapse(true);
            selRange.moveStart("character", start);
            selRange.moveEnd("character", end);
            selRange.select();
        }
        else if (field.setSelectionRange) {
            field.setSelectionRange(start, end);
        }
        else {
            if (field.selectionStart) {
                field.selectionStart = start;
                field.selectionEnd = end;
            }
        }

        field.focus();
    };

    // fills in the input box w/the first match (assumed to be the best match)
    function autoFill(sValue) {
        if (tc_DebugModeOn) {
            alert("autoFill(sValue) called. sValue=" + sValue);
        }
        // if the last user key pressed was backspace, don't autofill
        if (lastKeyPressCode != 8) {
            // fill in the value (keep the case the user has typed)
            $input.val($input.val() + sValue.substring(prev.length));
            // select the portion of the value not typed by the user 
            // (so the next character will erase)
            createSelection(prev.length, sValue.length);
        }
    };

    // shows the results div to the user.
    function showResults() {
        if (tc_DebugModeOn) {
            alert("showResults() called.");
        }

        var pos = 0;
        if (!tc_DivIsVisible) {
            // get the position of the input field right now (in case the DOM is shifted)
            pos = findPos(input);
        }
        else {
            var toggleDiv = document.getElementById("toggleDiv");
            pos = findPos(toggleDiv);
        }

        // either use the specified width, or autocalculate based on form element
        var iWidth = (options.width > 0) ? options.width : $input.width();

        tc_ResultsCurrentlyShown = true;
        // reposition
        $results.css({
            width: parseInt(iWidth) + "px",
            top: (pos.y + input.offsetHeight) + "px",
            left: pos.x + "px"
        }).show();
    };

    // hide the results from the user.
    function hideResults() {
        if (tc_DebugModeOn) {
            alert("hideResults() called.");
        }

        if (timeout) {
            clearTimeout(timeout);
        }

        timeout = setTimeout(hideResultsNow, 200);
    };

    // hide the results from the user
    function hideResultsNow() {
        if (tc_DebugModeOn) {
            alert("hideResultsNow() called.");
        }

        if (timeout) {
            clearTimeout(timeout);
        }

        $input.removeClass(options.loadingClass);

        if ($results.is(":visible")) {
            tc_ResultsCurrentlyShown = false;
            $results.hide();
        }

        if (options.mustMatch) {
            var v = $input.val();
            if (v != input.lastSelected) {
                selectItem(null);
            }
        }
    };

    // receive data from the cache
    function receiveData(q, data) {
        if (tc_DebugModeOn) {
            alert("receiveData(q, data) called. q=" + q + ", data=" + data);
        }

        if (data) {
            $input.removeClass(options.loadingClass);
            results.innerHTML = "";

            if ($.browser.msie) {
                // we put a styled iframe behind the calendar so 
                // HTML SELECT elements don't show through
                $results.append(document.createElement('iframe'));
            }

            // add items to ul
            results.appendChild(dataToDom(data));

            // autofill in the complete box w/the first match as 
            // long as the user hasn't entered in more data
            if (options.autoFill && ($input.val().toLowerCase() == q.toLowerCase())) {
                autoFill(data[0][0]);
            }

            showResults();
        }
        else {
            hideResultsNow();
        }
    };

    // parse the data, not sure if this is used any longer.
    function parseData(data) {
        if (tc_DebugModeOn) {
            alert("parseDate(data) called. data=" + data);
        }
        if (!data) return null;
        var parsed = [];
        var rows = data.split(options.lineSeparator);
        for (var i = 0; i < rows.length; i++) {
            var row = $.trim(rows[i]);
            if (row) {
                parsed[parsed.length] = row.split(options.cellSeparator);
            }
        }
        return parsed;
    };

    // add data to the DOM so it can be displayed to the user.
    function dataToDom(data) {        
        var ul = document.createElement("ul");
        var num = data.length;

        // limited results to a max number
        if ((options.maxItemsToShow > 0) && (options.maxItemsToShow < num)) num = options.maxItemsToShow;

        for (var i = 0; i < num; i++) {
            var row = data[i];
            if (!row) continue;
            
            var li = document.createElement("li");
            if (options.formatItem) {
                li.innerHTML = options.formatItem(row, i, num);
                li.selectValue = row[0];
            }
            else {
                li.innerHTML = row[0];
                li.selectValue = row[0];
            }
            
            var extra = null;
            if (row.length > 1) {
                extra = [];
                for (var j = 1; j < row.length; j++) {
                    extra[extra.length] = row[j];
                }
            }
            li.extra = extra;
            ul.appendChild(li);
            $(li).hover(
				    function() {
				        $("li", ul).removeClass("tc_over");
				        $(this).addClass("tc_over");
				        active = $("li", ul).indexOf($(this).get(0));
				    },
				    function() { $(this).removeClass("tc_over"); }
			        ).click(function(e) {
			            e.preventDefault();
			            e.stopPropagation();
			            selectItem(this)
			        });
        }

        return ul;
    };

    // request data from the cache
    function requestData(q) {
        if (tc_DebugModeOn) {
            alert("requestData(q) called. q=" + q);
        }

        var data = options.cacheLength ? loadFromCache(q) : null;

        // receive the cached data
        if (data) {
            receiveData(q, data);
        }
        else {
            // if there's been no data found, remove the loading class
            $input.removeClass(options.loadingClass);
        }
    };

    // load results from the cache
    function loadFromCache(q) {
        if (tc_DebugModeOn) {
            alert("loadFromCache(q) called. q=" + q);
        }
        if (!q) {
            return null;
        }

        if (cache.data != null) {
            if (cache.data[q]) {
                return cache.data[q];
            }

            if (options.matchSubset) {
                for (var i = q.length - 1; i >= options.minChars; i--) {
                    var qs = q.substr(0, i);
                    var c = cache.data[qs];
                    if (c) {
                        var csub = [];
                        for (var j = 0; j < c.length; j++) {
                            var x = c[j];
                            var x0 = x[0];
                            if (matchSubset(x0, q)) {
                                csub[csub.length] = x;
                            }
                        }

                        return csub;
                    }
                }
            }
        }

        return null;
    };

    // load all the results from the cache with no option to
    // search or match subsets.
    function loadAllFromCache() {
        if (tc_DebugModeOn) {
            alert("loadAllFromCache() called.");
        }

        return cache.data;
    };

    // matches a subset of the entered text inside of each entry
    // in the cache.
    function matchSubset(s, sub) {
        if (tc_DebugModeOn) {
            alert("matchSubset(s, sub) called. s=" + s + ", sub=" + sub);
        }

        if (!options.matchCase) s = s.toLowerCase();

        var regexExpression = ".";
        var entriesToSearchFor = sub.split(" ");
        if (entriesToSearchFor.length > 0) {
            for (var i = 0; i < entriesToSearchFor.length; i++) {
                regexExpression += "*" + entriesToSearchFor[i] + ".";
            }
        }

        var regexObj = new RegExp(regexExpression, "i");
        var bool = regexObj.test(s);
        return bool;
    };

    // callback to flush cache.
    this.flushCache = function() {
        if (tc_DebugModeOn) {
            alert("this.flushCache called.");
        }

        flushCache();
    };

    // callback to set options.extraParams 
    this.setExtraParams = function(p) {
        if (tc_DebugModeOn) {
            alert("this.setExtraParams called.");
        }

        options.extraParams = p;
    };

    // callback to find value in cache.
    this.findValue = function() {
        if (tc_DebugModeOn) {
            alert("this.findValue called.");
        }
        var q = $input.val();

        if (!options.matchCase) {
            q = q.toLowerCase();
        }

        var data = options.cacheLength ? loadFromCache(q) : null;
        if (data) {
            findValueCallback(q, data);
        }
        else if ((typeof options.url == "string") && (options.url.length > 0)) {
            $.get(makeUrl(q), function(data) {
                data = parseData(data)
                addToCache(q, data);
                findValueCallback(q, data);
            });
        }
        else {
            // no matches
            findValueCallback(q, null);
        }
    }

    // callback callback for findValue()
    function findValueCallback(q, data) {
        if (tc_DebugModeOn) {
            alert("findValueCallback(q, data) called. q=" + q + ", data=" + data);
        }

        if (data) {
            $input.removeClass(options.loadingClass);
        }

        var num = (data) ? data.length : 0;
        var li = null;

        for (var i = 0; i < num; i++) {
            var row = data[i];

            if (row[0].toLowerCase() == q.toLowerCase()) {
                li = document.createElement("li");
                if (options.formatItem) {
                    li.innerHTML = options.formatItem(row, i, num);
                    li.selectValue = row[0];
                }
                else {
                    li.innerHTML = row[0];
                    li.selectValue = row[0];
                }

                var extra = null;
                if (row.length > 1) {
                    extra = [];
                    for (var j = 1; j < row.length; j++) {
                        extra[extra.length] = row[j];
                    }
                }

                li.extra = extra;
            }
        }

        if (options.onFindValue) setTimeout(function() { options.onFindValue(li) }, 1);
    }

    // adds an entry to the cache.
    function addToCache(q, data) {
        if (tc_DebugModeOn) {
            alert("addToCache(q, data) called. q=" + q + ", data=" + data);
        }

        if (!data || !q || !options.cacheLength) {
            return;
        }

        if (!cache.length || cache.length > options.cacheLength) {
            flushCache();
            cache.length++;
        }
        else if (!cache[q]) {
            cache.length++;
        }

        tc_LastQ = q;
        cache.data[q] = data;
    };

    // finds the position on the current html page to display
    // the div for the results.
    function findPos(obj) {
        if (tc_DebugModeOn) {
            alert("findPos(obj) called. obj=" + obj);
        }

        var curleft = obj.offsetLeft || 0;
        var curtop = obj.offsetTop || 0;

        while (obj = obj.offsetParent) {
            curleft += obj.offsetLeft
            curtop += obj.offsetTop
        }

        return { x: curleft, y: curtop };
    }
}

// main entry point into object
jQuery.fn.tc_autocomplete = function(url, options, data) {
    // Make sure options exists
    options = options || {};
    // Set url as option
    options.url = url;
    // set some bulk local data
    options.data = ((typeof data == "object") && (data.constructor == Array)) ? data : null;

    // Set default values for required options
    options.inputClass = options.inputClass || "tc_input";
    options.resultsClass = options.resultsClass || "tc_results";
    options.lineSeparator = options.lineSeparator || "\n";
    options.cellSeparator = options.cellSeparator || "|";
    options.minChars = options.minChars || 1;
    options.delay = options.delay || 500;
    options.matchCase = options.matchCase || 0;
    options.matchSubset = options.matchSubset || 1;
    options.matchContains = options.matchContains || 0;
    options.cacheLength = options.cacheLength || 1;
    options.mustMatch = options.mustMatch || 0;
    options.extraParams = options.extraParams || {};
    options.loadingClass = options.loadingClass || "tc_loading";
    options.selectFirst = options.selectFirst || false;
    options.selectOnly = options.selectOnly || false;
    options.maxItemsToShow = options.maxItemsToShow || -1;
    options.autoFill = options.autoFill || false;
    options.width = parseInt(options.width, 10) || 0;

    this.each(function() {
        var input = this;
        jQuery.tc_autocomplete(input, options);
    });

    // Don't break the chain!
    return this;
}

// just another way to call the autocomplete object if you have an 
// array of data. Don't want to force the user to use a URL.
jQuery.fn.tc_autocompleteArray = function(data, options) {
    return this.tc_autocomplete(null, options, data);
}

// does a simple indexOf on data passed into it.
jQuery.fn.indexOf = function(e) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] == e) return i;
    }
    return -1;
};

// -------------------------------------------------------------------------------------------------------------------------------------
//  AutoComplete Functionality - [END]
// -------------------------------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------------------------------
//  AJAX Webservice Calls - [BEGIN]
// -------------------------------------------------------------------------------------------------------------------------------------

// calls the TerritoryCodeLookupService webservice and returns the data in xml format.
function GetTerritoryCodeData(stateAbbrevVar, userInputVar, rateSetDateVar, businessUnitVar, callback) {
    var urlprefix = "";
    var i;
    for (i = 0; i < urlLevels; i++) {
        urlprefix += "../";
    }

    var params = '{ "stateAbbrev":"' + stateAbbrevVar + '", "userInput":"' + userInputVar + '", "rateSetEffDate":"' + rateSetDateVar + '", "businessUnit":"' + businessUnitVar + '"}';

    $.ajax({
        type: "POST",
        url: urlprefix + "Webservices/TerritoryCodeLookupService.asmx/GetTerritoryCodes",
        data: params,
        contentType: "application/json; charset=utf-8",
        dataType: "json",
        success: function(result) { 
            callback(result); 
        },
        error: function(xhr, ajaxOptions, thrownError) {
            alert(xhr.responseText);
        } 
    });
}

// -------------------------------------------------------------------------------------------------------------------------------------
//  AJAX Webservice Calls - [END]
// -------------------------------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------------------------------
//  Data Methods - [BEGIN]
// -------------------------------------------------------------------------------------------------------------------------------------
// gets the data for the dropdown list
function GetTerritoryListData(hitwebservice, select, levels) {
    var stateDDL = GetSearchStringForControl("drpStates");
    var terrCodeTB = GetSearchStringForControl("txtISOTerrCode");
    var rateSetDate = GetSearchStringForControl("hiddenRateSetDate");
    var businessUnit = GetSearchStringForControl("hiddenBusinessUnit");
    urlLevels = levels;

    if (hitwebservice) {  
        $(terrCodeTB).addClass("tc_loading");

        var stateAbbrev = "All";
        if ($(stateDDL).val() != 0) {
            stateAbbrev = $(stateDDL).val();
        }

        var userInput = $(terrCodeTB).val();
        var rateSetDate = $(rateSetDate).val();
        var businessUnitCode = $(businessUnit).val();

        if (stateAbbrev != 0) {
            // call GetTerritoryCodeData to access the web service
            GetTerritoryCodeData(stateAbbrev, userInput, rateSetDate, businessUnitCode, function(result) {
                var data = "";

                for (var i = 0; i < result.d.length; i++) {
                    var territoryCode = result.d[i].TerritoryCode;
                    var stateAbbrev = result.d[i].StateAbbreviation;
                    var cityName = result.d[i].CityName;
                    var zipCode = result.d[i].ZipCode;
                    data += territoryCode + " - " + cityName + ", " + stateAbbrev + " " + zipCode + "||";
                }                

                if (data == "") {
                    data += "No results returned based on search criteria.";
                }

                // create an array of data for the autocomplete control
                var finaldata = data.split("||");

                // if the call came from a drop down list, refresh the cache instead of creating
                // a new autocomplete control.
                if (select) {
                    $.fn.tc_autocomplete.refreshCache(finaldata);
                }
                else {
                    // TODO: Need to make the width value dynamic somehow.
                    // fill the autocomplete div behind the scenes with data        
                    $(terrCodeTB).tc_autocompleteArray(finaldata, { maxItemsToShow: 500, width: 250 });
                }
            })
        }
        else {
            $(terrCodeTB).tc_autocompleteArray("", { maxItemsToShow: 500, width: 250 });
            $(terrCodeTB).removeClass("tc_loading");
        }
    }
    else {
        $(terrCodeTB).tc_autocompleteArray("No results.", { maxItemsToShow: 500, width: 250 });
        $(terrCodeTB).removeClass("tc_loading");
    }
}

// -------------------------------------------------------------------------------------------------------------------------------------
//  Data Methods - [END]
// -------------------------------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------------------------------
//  Misc Methods - [BEGIN]
// -------------------------------------------------------------------------------------------------------------------------------------

// builds a search string for the HTML element that matches the string passed in.   
function GetSearchStringForControl(string) {
    return "*[id$='" + string + "']";
}

// goes through all drop down lists in the filter functionality and
// creates an array of values. It then calls GetClassCodeListData to 
// get the data from the webservice and refresh the cache.
function ClearTerritoryInfo() {
    var terrCodeTB = GetSearchStringForControl("txtISOTerrCode");
    var lblISOTerrDesc = GetSearchStringForControl("lblISOTerrDescription");
    var hiddenTerrCity = GetSearchStringForControl("terrCity");
    var hiddenTerrZip = GetSearchStringForControl("terrZip");

    $(hiddenTerrCity).val("");
    $(hiddenTerrZip).val("");
    $(lblISOTerrDesc).text("");
    $(terrCodeTB).val("");    
}

// -------------------------------------------------------------------------------------------------------------------------------------
//  Misc Methods - [END]
// -------------------------------------------------------------------------------------------------------------------------------------