//var curID;
/*
---------------------------------------------------------------------------
NAME:			teaserItem
PARAMETERS:		_id - an id
_isActive - true if the teaser should show in the live site
_isDefault - true if the teaser is designated as such & will go first   
_isAlert - true if teaser is an alert
_browseId - id for "read more"
_content - html content for the teaser
_readmoreTitle - title for "read more"
... other stuff
DESCRIPTION:	object to hold teaser data
--------------------------------------------------------------------------
*/
function teaserItem(_id, _isActive, _isDefault, _isAlert, _browseId, _content, _readmoreTitle) {
    try {
        // properties
        this.id = _id ? _id : '';
        this.isActive = _isActive;
        this.isDefault = _isDefault;
        this.isAlert = _isAlert;
        this.browseId = _browseId;
        this.content = _content ? _content : '';
        this.readmoreTitle = _readmoreTitle ? _readmoreTitle : '';
        this.error = '';
        this.topic = '';
        this.hotTopic = '';
        this.keyword = '';

        // methods
        this.hasSearch = teaserItem_hasSearch;
    }
    catch (err) {
        this.error = err.description;
    }
}

/*
---------------------------------------------------------------------------
NAME:			teaserItem_hasSearch
PARAMETERS:		void
DESCRIPTION:	returns true if there is a search defined for this teaser
--------------------------------------------------------------------------
*/
function teaserItem_hasSearch() {
    try {
        return (0 < this.hotTopic.length || 0 < this.topic.length || 0 < this.keyword.length)
    }
    catch (err) {
        this.error = err.description;
    }

    return false;
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser
PARAMETERS:		_teaserXml - xml to use as the teaser data source
DESCRIPTION:	object to help with rotating teaser content
--------------------------------------------------------------------------
*/
function rotatingTeaser(_teaserXml) {
    try {
        // static attributes
        this.debug = false;
        this.schema =
			{
			    elementTag: "item"
			, idAttribute: "id"
			, activeAttribute: "active"
			, defaultAttribute: "default"
			, alertAttribute: "alert"
			, browseIdAttribute: "browseid"
			, contentTag: "content"
			, articleTag: "article"
			, topicTag: "topic"
			, readmoreTitleAttribute: "readmoreTitle"
			, hotTopicTag: "hottopic"
			, keywordTag: "keyword"
			, readmoreTag: "readmore"
			}

        // methods
        this.selectNodes = rotatingTeaser_selectNodes;
        this.newDocument = rotatingTeaser_newDocument;
        this.parse = rotatingTeaser_parse;
        this.randomItem = rotatingTeaser_randomItem;
        this.nextItem = rotatingTeaser_nextItem;
        this.createTeaserFromXml = rotatingTeaser_createTeaserFromXml;

        // create xml document from teaser xml
        this.xmlDoc = this.parse(_teaserXml);
        this.lastDefaultIndex = -1;
        this.lastAlertIndex = -1;
        this.lastTeaserIndex = -1;
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_randomItem
PARAMETERS:		void
DESCRIPTION:	pulls teaser items out of xmlDoc and returns a random 
teaserItem object
--------------------------------------------------------------------------
*/
function rotatingTeaser_randomItem() {
    try {
        var xmlAlerts;
        var xmlTeasers;

        // get all of the alert elements
        xmlAlerts = this.selectNodes("//" + this.schema.elementTag + "[(@" + this.schema.alertAttribute + "='true' and (not(@" + this.schema.defaultAttribute + ") or @" + this.schema.defaultAttribute + "='true') ]");
        // get all of the teaser elements
        xmlTeasers = this.selectNodes("//" + this.schema.elementTag + "[(not(@" + this.schema.alertAttribute + ") or @" + this.schema.alertAttribute + "='false') and (not(@" + this.schema.defaultAttribute + ") or @" + this.schema.defaultAttribute + "='true') ]");

        // if we have no alerts & no teasers return "no data"
        if ((!xmlAlerts || 0 == xmlAlerts.length) && (!xmlTeasers || 0 == xmlTeasers.length)) {
            return new teaserItem('-1', false, false, false, 'No Data');
        }

        // if we don't have any teasers, and we've used all of the alerts, reset the alert counter
        if ((!xmlTeasers || 0 == xmlTeasers.length) && (this.lastAlertIndex >= xmlAlerts.length - 1)) {
            //this.lastAlertIndex = -1;
            this.lastAlertIndex = 1;
        }

        // if we have alerts (and we haven't already displayed them all), return the first alert we haven't already displayed
        if (xmlAlerts && (this.lastAlertIndex < xmlAlerts.length - 1)) {
            ++this.lastAlertIndex;
            return this.createTeaserFromXml(xmlAlerts[this.lastAlertIndex]);
        }

        // if we have teasers & we don't have alerts (or we have displayed all of the alerts already) return a random teaser		

        var xmlTeaser = xmlTeasers[Math.floor(Math.random() * xmlTeasers.length)];

        if (xmlTeaser) {
            return this.createTeaserFromXml(xmlTeaser);
        }
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }

    // return empty teaser object
    return new teaserItem('-1', false, false, false, 'Error');
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_nextItem
PARAMETERS:		void
DESCRIPTION:	goes through all the teasers, default first, then alerts, rinse, lather, repeat
--------------------------------------------------------------------------
*/
function rotatingTeaser_nextItem() {
    try {
        var xmlDefault;
        var xmlAlerts;
        var xmlTeasers;
        var teaserReturn = null;

        // get any default elements (to show before alerts)
        //xmlDefault = this.selectNodes("//" + this.schema.elementTag + "[@" + this.schema.defaultAttribute + "='true']");
        xmlDefault = this.selectNodes("//" + this.schema.elementTag + "[@" + this.schema.defaultAttribute + "='true']");

        // get all of the alert elements
        //xmlAlerts = this.selectNodes("//" + this.schema.elementTag + "[@" + this.schema.alertAttribute + "='true']");
        xmlAlerts = this.selectNodes("//" + this.schema.elementTag + "[@" + this.schema.alertAttribute + "='true' and @" + this.schema.activeAttribute + "='true']");

        // get all of the teaser elements
        xmlTeasers = this.selectNodes("//" + this.schema.elementTag + "[(not(@" + this.schema.defaultAttribute + ") or @" + this.schema.defaultAttribute + "='false') and (not(@" + this.schema.alertAttribute + ") or @" + this.schema.alertAttribute + "='false')]");

        // if we have no alerts & no teasers return "no data"
        if ((!xmlDefault || 0 == xmlDefault.length) && (!xmlAlerts || 0 == xmlAlerts.length) && (!xmlTeasers || 0 == xmlTeasers.length)) {
            return new teaserItem('-1', false, false, false, 'No Data');
        }
        
        // if we have a default (and we haven't already displayed them all), return the first default we haven't already displayed
        if (xmlDefault && (this.lastDefaultIndex < xmlDefault.length - 1)) {
            ++this.lastDefaultIndex;
            teaserReturn = this.createTeaserFromXml(xmlDefault[this.lastDefaultIndex]);
        }
        // if we have alerts (and we haven't already displayed them all), return the first alert we haven't already displayed
        else if (xmlAlerts && (this.lastAlertIndex < xmlAlerts.length - 1)) {
            ++this.lastAlertIndex;
            teaserReturn = this.createTeaserFromXml(xmlAlerts[this.lastAlertIndex]);
        }
        else if (xmlTeasers && (this.lastTeaserIndex < xmlTeasers.length - 1)) {
            ++this.lastTeaserIndex;
            teaserReturn = this.createTeaserFromXml(xmlTeasers[this.lastTeaserIndex]);
        }

        //reset the counters if we moved to the end
        if (xmlDefault && 0 < xmlDefault.length) {
            // reset to begining of alerts if we are at the end of the teasers 
            //if ( (!xmlTeasers || 0 == xmlTeasers.length || (this.lastTeaserIndex >= xmlTeasers.length-1)) && this.lastDefaultIndex >= xmlDefault.length-1)
            //	{
            //if (!(xmlTeasers && (this.lastTeaserIndex < xmlTeasers.length-1)))
            if ((!xmlTeasers || 0 == xmlTeasers.length || (this.lastTeaserIndex >= xmlTeasers.length - 1)) && (!xmlAlerts || 0 == xmlAlerts.length || (this.lastAlertIndex >= xmlAlerts.length - 1))) {
                this.lastDefaultIndex = -1;
            }
        }

        if (xmlAlerts && 0 < xmlAlerts.length) {
            // reset to begining of alerts if we are at the end of the teasers and the alerts
            if ((!xmlTeasers || 0 == xmlTeasers.length || (this.lastTeaserIndex >= xmlTeasers.length - 1)) && this.lastAlertIndex >= xmlAlerts.length - 1) {
                this.lastAlertIndex = -1;
            }
        }
        if (xmlTeasers && 0 < xmlTeasers.length) {
            // reset the teasers if we are at the end of them
            if (this.lastTeaserIndex >= xmlTeasers.length - 1) {
                this.lastTeaserIndex = -1;
            }
        }
        // return the teaser we found
        if (teaserReturn) {
            return teaserReturn;
        }

    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }

    // return empty teaser object
    return new teaserItem('-1', false, false, false, 'Error');
}









/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_createTeaserFromXml
PARAMETERS:		xmlNode - source xml
DESCRIPTION:	return teaser object from xml node
--------------------------------------------------------------------------
*/
function rotatingTeaser_createTeaserFromXml(xmlNode) {
    // pull the id & allert attriubtes out of the item element
    var id = xmlNode.getAttribute(this.schema.idAttribute); 		//<-- id attribute
    var isActive = xmlNode.getAttribute(this.schema.activeAttribute);
    var isDefault = xmlNode.getAttribute(this.schema.defaultAttribute); // <-- default attribute
    var isAlert = xmlNode.getAttribute(this.schema.alertAttribute); //<-- alert attribute
    var browseId = xmlNode.getAttribute(this.schema.browseIdAttribute);
    var readmoreTitle;

    // pull the content element out of the item element
    var xmlCell = xmlNode.getElementsByTagName(this.schema.contentTag)[0];
    var content = (xmlCell && xmlCell.firstChild) ? xmlCell.firstChild.data : '';

    // get a title for our content - grab it from the content
    readmoreTitle = xmlCell.getAttribute('title');
    // but overwrite it if there is content in the readmore tag
    var nextCell = xmlNode.getElementsByTagName(this.schema.readmoreTag)[0];
    if (nextCell)
    { readmoreTitle = nextCell.getAttribute('title') }

    // return a new teaser object
    var newItem = new teaserItem(id ? id : '', Boolean(isActive), Boolean(isDefault), Boolean(isAlert), browseId ? browseId : '', content, readmoreTitle ? readmoreTitle : '');

    // search variables
    var hotTopic;
    var topic;
    var keyword;

    // get defined hot topic for search
    xmlCell = xmlNode.getElementsByTagName(this.schema.hotTopicTag)[0];
    hotTopic = (xmlCell && xmlCell.firstChild) ? xmlCell.firstChild.data : '';
    newItem.hotTopic = hotTopic.toString();

    // get topic for search (only if we don't have a hot topic)
    if (0 == hotTopic.length) {
        xmlCell = xmlNode.getElementsByTagName(this.schema.topicTag)[0];
        topic = (xmlCell && xmlCell.firstChild) ? xmlCell.firstChild.data : '';
        newItem.topic = topic.toString();
    }

    // get keyword for search (only if we don't have a hot topic or topic)
    if (0 == hotTopic.length && 0 == topic.length) {
        xmlCell = xmlNode.getElementsByTagName(this.schema.keywordTag)[0];
        keyword = (xmlCell && xmlCell.firstChild) ? xmlCell.firstChild.data : '';
        newItem.keyword = keyword.toString();
    }

    return newItem;
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_parse
PARAMETERS:		_teaserXml - source xml
DESCRIPTION:	parses xml string and returns document object
--------------------------------------------------------------------------
*/
function rotatingTeaser_parse(_teaserXml) {
    try {
        // convert passed in xml string into document object
        if (typeof DOMParser != "undefined") {
            // Mozilla (Firefox et al.)
            return (new DOMParser()).parseFromString(_teaserXml, "application/xml");
        }
        else if (typeof ActiveXObject != "undefined") {
            // IE 6+
            var doc = this.newDocument();
            doc.loadXML(_teaserXml);
            return doc;
        }
        else {
            // Safari method (load the data as a url)
            var url = "data:text/xml;charset=utf-8," + encodeURIComponent(_teaserXml);
            var request = new XMLHttpRequest();

            request.open("GET", url, false);
            request.send(null);
            return request.responseXML;
        }
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }

    return null;
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_selectNodes(xpathExpression)
PARAMETERS:		xpathExpression - XPath expression used to select nodes
DESCRIPTION:	select nodes fromt the xml document using the given xpath
expression
--------------------------------------------------------------------------
*/
function rotatingTeaser_selectNodes(xpathExpression) {

    // get all of the alert elements
    if (this.xmlDoc && browserType == "ie") {
        // IE way to select nodes in an xml document
        return this.xmlDoc.selectNodes(xpathExpression);
    }

    if (this.xmlDoc && window.XPathEvaluator) {
        var oEvaluator = new XPathEvaluator();

        // W3C way to select nodes        
        var oResult = oEvaluator.evaluate(xpathExpression, this.xmlDoc, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
        xmlRows = new Array;

        if (oResult != null) {
            var oElement = oResult.iterateNext();
            while (oElement) {
                xmlRows.push(oElement);
                oElement = oResult.iterateNext();
            }
        }

        return xmlRows;
    }
    else {
        return null;
    }
}

/*
---------------------------------------------------------------------------
NAME:			rotatingTeaser_newDocument
PARAMETERS:		rootTagName - root tag for new document
namespaceURL - namespace URL for new document
DESCRIPTION:	Create a new empty document object
--------------------------------------------------------------------------
*/
function rotatingTeaser_newDocument(rootTagName, namespaceURL) {
    try {
        if (!rootTagName) {
            rootTagName = '';
        }
        if (!namespaceURL) {
            namespaceURL = '';
        }

        if (document.implementation && document.implementation.createDocument) { // w3c method		
            return document.implementation.createDocument(namespaceURL, rootTagName, null);
        }
        else { // IE method
            var doc = new ActiveXObject("MSXML2.DOMDocument");

            if (rootTagName) {
                var prefix = "";
                var tagname = rootTagName;
                var p = rootTagName.indexOf(':');
                if (p != -1) {
                    prefix = rootTagName.substring(0, p);
                    tagname = rootTagName.substring(p + 1);
                }

                if (namespaceURL) {
                    if (!prefix) {
                        prefix = "a0";
                    }
                }
                else {
                    prefix = "";
                }

                var text = "<" + (prefix ? (prefix + ":") : "") + tagname + (namespaceURL ? (" xmlns:" + prefix + '="' + namespaceURL + '"') : "") + "/>";
                doc.loadXML(text);
            }
            return doc;
        }
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }

    return null;
}
/*
---------------------------------------------------------------------------
NAME:			displayTeaser()
PARAMETERS:		null
DESCRIPTION:	take a teaser and place the content into an existing panel named 'content'
--------------------------------------------------------------------------
*/
function displayTeaser() {
    try {

        if (theTease) {
            // get a random teaser
            // var randomTeaser = theTease.randomItem();

            // go through teasers in an orderly fashion
            var scrollTeasers = theTease.nextItem();
            if (scrollTeasers && content) {
                // update the hidden id value
                if (currentTeaserId) {
                    currentTeaserId.value = scrollTeasers.id;
                }

                // show/hide search related elements
                if (scrollTeasers.hasSearch()) {
                    show('findbutton');
                }
                else {
                    hide('geocontrol');
                    hide('findbutton');
                }

                // show/hide the 'read more' button based on teaser browse id
                if (scrollTeasers.browseId && 0 < scrollTeasers.browseId.length) {
                    show('morebutton');
                    setUrl(scrollTeasers.browseId, scrollTeasers.readmoreTitle);
                }
                else {
                    hide('morebutton');
                }
                var translationCookie = readCookie("autoTranslateLanguage");
                if (null == translationCookie || 0 == translationCookie.length) {
                    content.innerHTML = scrollTeasers.content;
                }
                else {
                    //alert('div.' + content.id);
                    //$('#' + content.id).translate(translationCookie);
                    $.translate(scrollTeasers.content, 'en', translationCookie, {
                        complete: function (translation) { $('#' + content.id).html(translation); }
                    });
                }
            }
            // keep the teasers rollin'
            if (TeaserCount > 1) {
                timerID = setTimeout("displayTeaser()", interval);
            }
            //by default, we're not going to force focus here, only if someone is manually working through the teasers.
            //location.href = anchor;
        }
        else if (timerID) {
            clearTimeout(timerID);
            timerID = 0;
        }
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }
}
/*
---------------------------------------------------------------------------
NAME:			stopTeaser()
PARAMETERS:		null
DESCRIPTION:	stop the teaser but let it resume if need be
--------------------------------------------------------------------------
*/

function stopTeaser() {
    try {
        clearTimeout(timerID);
        timerID = 0;
        location.href = anchor;
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }
}
/*
---------------------------------------------------------------------------
NAME:			next()
PARAMETERS:		null
DESCRIPTION:	get the next teaser in the set
--------------------------------------------------------------------------
*/
function next() {
    try {
        var scrollTeasers = theTease.nextItem();
        if (scrollTeasers && content) {
            // update the hidden id value
            if (currentTeaserId) {
                currentTeaserId.value = scrollTeasers.id;
            }

            // show/hide search related elements
            if (scrollTeasers.hasSearch()) {
                show('findbutton');
            }
            else {
                hide('geocontrol');
                hide('findbutton');
            }

            // show/hide the 'read more' button based on teaser browse id
            if (scrollTeasers.browseId && 0 < scrollTeasers.browseId.length) {
                show('morebutton');
                setUrl(scrollTeasers.browseId, scrollTeasers.readmoreTitle);
            }
            else {
                hide('morebutton');
            }

            content.innerHTML = scrollTeasers.content;
        }
        clearTimeout(timerID);
        timerID = 0;
        location.href = anchor;
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }
}

function setUrl(browseId, title) {
    try {

        title = title.replace(/ /g, "_");
        title = title + ".aspx";
        var sUrl = "browsetips.aspx?TipId=TEASERID&Title=TITLE&referrer=default.aspx#teaser";
        sUrl = sUrl.replace(/TEASERID/, URLEncode(browseId));
        sUrl = sUrl.replace(/TITLE/, URLEncode(title));
        oLink = document.getElementById('morelink');
        oLink.href = sUrl;
    }
    catch (err) {
        if (this.debug) {
            alert(err.description);
        }
        this.error = err.description;
    }
}

function goToGeocontrol() {
    location.href = '#geocontrol';
}

function URLEncode(clearString) {
    var output = '';
    var x = 0;
    clearString = clearString.toString();
    var regex = /(^[a-zA-Z0-9_.]*)/;
    while (x < clearString.length) {
        var match = regex.exec(clearString.substr(x));
        if (match != null && match.length > 1 && match[1] != '') {
            output += match[1];
            x += match[1].length;
        } else {
            if (clearString[x] == ' ')
                output += '+';
            else {
                var charCode = clearString.charCodeAt(x);
                var hexVal = charCode.toString(16);
                output += '%' + (hexVal.length < 2 ? '0' : '') + hexVal.toUpperCase();
            }
            x++;
        }
    }
    return output;
}