/* global define, window, XMLHttpRequest, ActiveXObject, XSLTProcessor, console, $, document, jQuery, FileReader, Btoa */
/* jshint bitwise:false  */
 
/**
* Utility module containing useful static classes.
*
* @module Utils
* @main Utils
*/
 
/**
* A set of functions used by at least one module in this project. The functions
* are generic enough that they may become useful for other modules later or functions
* that are shared amongst multiple modules should be added here.
*
* *__NOTE__: None of these functions require the global configuration object. (i.e. they
* are not exclusive to RAMP). For functions that depend on the global configuration
* object, place them in ramp.js.*
*
* @class Util
* @static
* @uses dojo/_base/array
* @uses dojo/_base/lang
* @uses dojo/topic
* @uses dojo/Deferred
* @uses esri/geometry/Extent
* @uses esri/graphic
*/
define(["dojo/_base/array", "dojo/_base/lang", "dojo/topic", "dojo/Deferred", "esri/geometry/Extent", "esri/graphic"],
    function (dojoArray, dojoLang, topic, Deferred, Extent, Graphic) {
        "use strict";
 
        /**
        * Helper function for wrapping File API calls in Promise objects.  Used for building a series of helpers which
        * call different file read methods.
        *
        * @method _wrapFileCallInPromise
        * @private
        * @param {String} readMethod a string indicating the FileReader method to call
        * @return {Function} a function which accepts a {File} object and returns a Promise
        */
        function _wrapFileCallInPromise(readMethod) {
            return function (file) {
                var reader = new FileReader(),
                    def = new Deferred();
 
                reader.onloadend = function (e) { def.resolve(e.target.result); };
                reader.onerror = function (e) { def.reject(e.target.error); };
                try {
                    reader[readMethod](file);
                } catch (e) {
                    def.reject(e);
                }
 
                return def.promise;
            };
        }
 
        return {
            /**
            * Checks if the console exists, if not, redefine the console and all console methods to
            * a function that does nothing. Useful for IE which does not have the console until the
            * debugger is opened.
            *
            * @method checkConsole
            * @static
            */
            checkConsole: function () {
                var noop = function () { },
                    methods = [
                        'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
                        'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
                        'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
                        'timeStamp', 'trace', 'warn'
                    ],
                    length = methods.length,
                    console = (window.console = window.console || {}),
                    method;
 
                while (length--) {
                    method = methods[length];
 
                    // Only stub undefined methods.
                    if (!console[method]) {
                        console[method] = noop;
                    }
                }
            },
 
            // String Functions
 
            /**
            * Returns an String that has it's angle brackets ('<' and '>') escaped (replaced by '&lt;' and '&gt;').
            * This will effectively cause the String to be displayed in plain text when embedded in an HTML page.
            *
            * @method escapeHtml
            * @static
            * @param {String} html String to escape
            * @return {String} escapeHtml Escaped string
            */
            escapeHtml: function (html) {
                return html.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
            },
 
            /**
            * Returns true if the given String is a number
            *
            * @method isNumber
            * @static
            * @param {String} input The string to check
            * @return {boolean} True if number
            */
            isNumber: function (input) {
                return isFinite(String(input).trim() || NaN);
            },
 
            /**
            * Parse the given String into a boolean. Returns true if the String
            * is the word "true" (case insensitive). False otherwise.
            *
            * @method parseBool
            * @static
            * @param {String} str The string to check
            * @return {boolean} True if `true`
            */
            parseBool: function (str) {
                return (str.toLowerCase() === 'true');
            },
 
            // Deferred
 
            /**
            * Executes the callback function only after all the deferred Objects in the
            * given deferredList has resolved.
            *
            * @method afterAll
            * @static
            * @param {array} deferredList A list of Deferred objects
            * @param {function} callback The callback to be executed
            */
            afterAll: function (deferredList, callback, context) {
                if (deferredList.length === 0) {
                    callback();
                    return;
                }
 
                var completed = 0; // Keeps track of the number of deferred that has resolved
                dojoArray.forEach(deferredList, function (deferred) {
                    deferred.then(function () {
                        completed++;
                        if (completed === deferredList.length) {
                            callback.call(context);
                        }
                    });
                });
            },
 
            // Serialization
 
            /**
            * Converts an array into a '+' separated String that can be used as
            * the query parameter of a URL.
            *
            *      arrayToQuery(["abc", 123, "efg"]) -> "abc+123+efg"
            *
            * *__NOTE:__ the array should only contain primitives, objects will not be serialized
            * properly.*
            *
            * @method arrayToQuery
            * @static
            * @param {array} array An array of primitives to be serialized
            * @return {String} A serialized representation of the given array
            */
            arrayToQuery: function (array) {
                return array.join("+");
            },
 
            /**
            * Converts a query String generated by arrayToQuery into an array object.
            * The array object will only contain Strings.
            *
            *      queryToArray("abc+123+efg") -> ["abc", "123", "efg"]
            *
            * @method queryToArray
            * @static
            * @param {String} query A query string to be converted
            * @return {String} A resulting array of strings
            */
            queryToArray: function (query) {
                return query.split("+");
            },
 
            // Event handling
 
            /**
            * A convenience method that wraps around Dojo's subscribe method to allow
            * a scope to hitched to the given callback function.
            *
            * @method subscribe
            * @static
            * @param {String} name Event name
            * @param {function} callback The callback to be executed
            * @param {object} scope Scope of the callback
            */
            subscribe: function (name, callback, scope) {
                if (scope) {
                    topic.subscribe(name, dojoLang.hitch(scope, callback));
                } else {
                    topic.subscribe(name, callback);
                }
            },
 
            /**
            * Subscribes to an event, after the event has occurred, the handle is
            * removed.
            *
            * @method subscribeOnce
            * @static
            * @param {String} name Event name
            * @param {function} callback The callback to be executed
            */
            subscribeOnce: function (name, callback) {
                var handle = null,
                    wrapper = function (evt) {
                        handle.remove();
                        callback(evt);
                    };
 
                return (handle = topic.subscribe(name, wrapper));
            },
 
            /**
            * Subscribes to a set of events, executes the callback when any of the events fire, then removes the handle.
            *
            * @method subscribeOnceAny
            * @static
            * @param  {String} names An array of event names
            * @param  {Function} callback The callback to be executed
            */
            subscribeOnceAny: function (names, callback) {
                var handles = [];
 
                function wrapper(evt) {
                    dojoArray.forEach(handles, function (handle) {
                        handle.remove();
                    });
 
                    callback(evt);
                }
 
                dojoArray.forEach(names, dojoLang.hitch(this,
                    function (name) {
                        handles.push(this.subscribeOnce(name, wrapper));
                    }));
            },
 
            /**
            * Given an array of event names published by topic.publish, call the given
            * callback function after ALL of the given events have occurred. An array of
            * arguments is passed to the callback function, the arguments are those returned
            * by the events (in the order that the events appear in the array).
            *
            * #####Example
            *
            * Assume somewhere a module publishes a "click" event:
            *
            *      topic.publish("click", { mouseX: 10, mouseY: 50 });
            *
            * and somewhere else another module publishes a "finishLoading" event:
            *
            *      topic.publish("finishLoading", { loadedPictures: [pic1, pic2] });
            *
            * Then if one wants to do something (e.g. display pictures) only after the pictures
            * have been loaded AND the user clicked somewhere, then:
            *
            * - args[0] will be the object returned by the "click" event
            * - which in this case will be: { mouseX: 10, mouseY: 50 }
            * - args[1] will be the object returned by the "finishLoading" event
            * - which in this case will be: { loadedPictures: [pic1, pic2] }
            *
            *
            *      subscribe(["click", "finishLoading"], function(args) {
            *          doSomething();
            *      });
            *
            * *__NOTE:__
            * If one of the events fires multiple times before the other event, the object
            * passed by this function to the callback will be the object returned when the
            * event FIRST fired (subsequent firings of the same event are ignored). Also, if
            * some event do not return an object, it will also be excluded in the arguments to
            * the callback function. So be careful! For example, say you subscribed to the events:
            * "evt1", "evt2", "evt3". "evt1" returns an object (call it "evt1Obj"), "evt2" does not,
            * "evt3" returns two objects (call it "evt3Obj-1" and "evt3Obj-2" respectively).
            * Then the array passed to the callback will be: ["evt1Obj", "evt3Obj-1", "evt3Obj-2"].*
            *
            * @method subscribeAll
            * @static
            * @param {array} nameArray An array of Strings containing the names of events to subscribe to
            * @param {function} callback The callback to be executed
            */
            subscribeAll: function (nameArray, callback) {
                // Keeps track of the status of all the events being subscribed to
                var events = [];
 
                dojoArray.forEach(nameArray, function (eventName, i) {
                    events.push({
                        fired: false,
                        args: null
                    });
 
                    topic.subscribe(eventName, function () {
                        // If this is the fire time the event fired
                        if (!events[i].fired) {
                            // Mark the event has fired and capture it's arguments (if any)
                            events[i].fired = true;
                            events[i].args = Array.prototype.slice.call(arguments);
 
                            // Check if all events have fired
                            if (dojoArray.every(events, function (event) {
                                return event.fired;
                            })) {
                                // If so construct an array with arguments from the events
                                var eventArgs = [];
                                dojoArray.forEach(events, function (event) {
                                    eventArgs.append(event.args);
                                });
                                callback(eventArgs);
                            }
                        }
                    });
                });
            },
 
            // Specialized Variables *
 
            /**
            * Creates an object that acts like a lazy variable (i.e. a variable whose value is only
            * resolved the first time it is retrieved, not when it is assigned). The value given to
            * the lazy variable should be the return value of the given initFunc. The returned object
            * has two methods:
            *
            * - get - returns the value of the variable, if it is the first time get is called, the
            * the initFunc will be called to resolve the value of the variable.
            * - reset - forces the variable to call the initFunc again the next time get is called
            *
            * @method createLazyVariable
            * @static
            * @param {function} initFunc A function to call to resolve the variable value
            * @return {Object} The lazy variable
            */
            createLazyVariable: function (initFunc) {
                var value = null;
                return {
                    reset: function () {
                        value = null;
                    },
 
                    get: function () {
                        if (value == null) {
                            value = initFunc();
                        }
                        return value;
                    }
                };
            },
 
            // FUNCTION DECORATORS
 
            /**
            * Returns a function that has the same functionality as the given function, but
            * can only be executed once (subsequent execution does nothing).
            *
            * @method once
            * @static
            * @param {function} func Function to be decorated
            * @return {function} Decorated function that can be executed once
            */
            once: function (func) {
                var ran = false;
                return function () {
                    if (!ran) {
                        func();
                        ran = true;
                    }
                };
            },
 
            // MISCELLANEOUS
 
            /**
            * Returns true if the given obj is undefined, false otherwise.
            *
            * @method isUndefined
            * @static
            * @param {object} obj Object to be checked
            * @return {boolean} True if the given object is undefined, false otherwise
            */
            isUndefined: function (obj) {
                console.warn('Think twice about using isDefined: consider checking explicitly or using a falsy test instead');
                return (typeof obj === 'undefined');
            },
 
            /**
            * Compares two graphic objects.
            *
            * @method compareGraphics
            * @static
            * @param  {Object} one Graphic object
            * @param  {Object} two Graphic object
            * @return {boolean} True if the objects represent the same feature
            */
            compareGraphics: function (one, two) {
                var oneKey = "0",
                    twoKey = "1",
                    objectIdField,
                    oneLayer,
                    twoLayer;
 
                if (one && two &&
                    $.isFunction(one.getLayer) && $.isFunction(two.getLayer)) {
                    oneLayer = one.getLayer();
                    twoLayer = two.getLayer();
                    objectIdField = oneLayer.objectIdField;
                    oneKey = oneLayer.sourceLayerId + one.attributes[objectIdField];
                    twoKey = twoLayer.sourceLayerId + two.attributes[objectIdField];
                }
 
                return oneKey === twoKey;
            },
 
            /**
            * Returns the width of the scrollbar in pixels. Since different browsers render scrollbars differently, the width may vary.
            *
            * @method scrollbarWidth
            * @static
            * @return {int} The width of the scrollbar in pixels
            * @for Util
            */
            scrollbarWidth: function () {
                var $inner = jQuery('<div style="width: 100%; height:200px;">test</div>'),
                    $outer = jQuery('<div style="width:200px;height:150px; position: absolute; top: 0; left: 0; visibility: hidden; overflow:hidden;"></div>').append($inner),
                    inner = $inner[0],
                    outer = $outer[0],
                    width1, width2;
 
                jQuery('body').append(outer);
                width1 = inner.offsetWidth;
                $outer.css('overflow', 'scroll');
                width2 = outer.clientWidth;
                $outer.remove();
 
                return (width1 - width2);
            },
 
            /**
            * Checks if the height of the scrollable content of the body is taller than its height;
            * if so, offset the content horizontally to accommodate for the scrollbar assuming target's width is
            * set to "100%".
            *
            * @method adjustWidthForSrollbar
            * @static
            * @param {jObject} body A DOM node with a scrollbar (or not)
            * @param {jObject} targets An array of jObjects to add the offset to
            */
            adjustWidthForSrollbar: function (body, targets) {
                var offset = body.innerHeight() < body[0].scrollHeight ? this.scrollbarWidth() : 0;
 
                dojoArray.map(targets, function (target) {
                    target.css({
                        right: offset
                    });
                });
            },
 
            /**
            * Waits until a given function is available and executes a callback function.
            *
            * @method executeOnLoad
            * @static
            * @param {Object} target an object on which to wait for function to appear
            * @param {function} func A function whose availability in question
            * @param {function} callback The callback function to be executed after func is available
            */
            executeOnLoad: function (target, func, callback) {
                var deferred = new Deferred(),
                    handle;
 
                deferred.then(function () {
                    window.clearInterval(handle);
                    //console.log("deferred resolved");
 
                    callback();
                });
 
                handle = window.setInterval(function () {
                    if ($.isFunction(target[func])) {
                        deferred.resolve(true);
                    }
                }, 500);
            },
 
            /**
            * Loops through all object properties and applies a given function to each. Resolves the given deferred when done.
            *
            * @method executeOnDone
            * @static
            * @param {object} o Object to look through
            * @param {function} func A function to be executed with each object propety. Accepts two parameters: property and deferred to be resolved when it's done.
            * @param {object} d A deferred to be resolved when all properties have been processed.
            */
            executeOnDone: function (o, func, d) {
                var counter = 0,
                    arr = [],
                    deferred;
 
                function fnOnDeferredCancel() {
                    d.cancel();
                }
 
                function fnOnDeferredThen() {
                    counter--;
                    if (counter === 0) {
                        d.resolve(true);
                    }
                }
 
                d = d || new Deferred();
 
                for (var q in o) {
                    if (o.hasOwnProperty(q)) {
                        arr.push(o[q]);
                    }
                }
 
                counter = arr.length;
 
                arr.forEach(function (p) {
                    deferred = new Deferred(fnOnDeferredCancel);
 
                    deferred.then(fnOnDeferredThen);
 
                    func(p, deferred);
                });
 
                if (counter === 0) {
                    d.resolve(true);
                }
            },
 
            /**
            * Generates an rfc4122 version 4 compliant guid.
            * Taken from here: http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
            *
            * @method guid
            * @static
            * @return {String} The generated guid string
            */
            // TODO: check if there is new/better code for guid generation
            guid: function () {
                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
                    var r = Math.random() * 16 | 0,
                        v = c === 'x' ? r : (r & 0x3 | 0x8);
                    return v.toString(16);
                });
            },
 
            /**
            * Returns an appropriate where clause depending on whether the query
            * is a String (returns a where clause with CASE INSENSITIVE comparison)
            * or an integer.
            *
            * @method getWhereClause
            * @static
            * @param {String} varName ???
            * @param {String | Number} query A query string
            * @return {String} The generated "where" clause
            */
            getWhereClause: function (varName, query) {
                if (this.isNumber(query)) {
                    return String.format("{0}={1}", varName, query);
                }
                return String.format("Upper({0})=Upper(\'{1}\')", varName, query);
            },
 
            /**
            * Converts html into text by replacing
            * all html tags with their appropriate special characters
            *
            * @method stripHtml
            * @static
            * @param {String} html HTML to be converted to text
            * @return {String} The HTML in text form
            */
            stripHtml: function (html) {
                var tmp = document.createElement("DIV");
                // jquery .text function converts html into text by replacing
                // all html tags with their appropriate special characters
                $(tmp).text(html);
                return tmp.textContent || tmp.innerText || "";
            },
 
            // Query geometry
            /*
            * Create a new extent based on the current map size, a point (X/Y coordinates), and a pixel tolerance value.
            * @method pointToExtent
            * @static
            * @param {Object} map The map control
            * @param {Object} point The location on screen (X/Y coordinates)
            * @param {Number} toleranceInPixel A value indicating how many screen pixels the extent should be from the point
            * @returns {Object} a new extent calculated from the given parameters
            *
            */
            pointToExtent: function (map, point, toleranceInPixel) {
                var pixelWidth = map.extent.getWidth() / map.width,
                    toleraceInMapCoords = toleranceInPixel * pixelWidth;
 
                return new Extent(point.x - toleraceInMapCoords,
                              point.y - toleraceInMapCoords,
                              point.x + toleraceInMapCoords,
                              point.y + toleraceInMapCoords,
                              map.spatialReference);
            },
 
            /**
            * Create boudingbox graphic for a bounding box extent
            *
            * @method createGraphic
            * @static
            * @param  {esri/geometry/Extent} extent of a bounding box
            * @return {esri/Graphic}        An ESRI graphic object represents a bouding box
            */
            createGraphic: function (extent) {
                return new Graphic({
                    geometry: extent,
                    symbol: {
                        color: [255, 0, 0, 64],
                        outline: {
                            color: [240, 128, 128, 255],
                            width: 1,
                            type: "esriSLS",
                            style: "esriSLSSolid"
                        },
                        type: "esriSFS",
                        style: "esriSFSSolid"
                    }
                });
            },
 
            /**
            * Checks if the string ends with the supplied suffix.
            *
            * @method endsWith
            * @static
            * @param {String} str String to be evaluated
            * @param {String} suffix Ending string to be matched
            * @return {boolean} True if suffix matches
            */
            endsWith: function (str, suffix) {
                return str.indexOf(suffix, str.length - suffix.length) !== -1;
            },
 
            /**
            * Recursively merge JSON objects into a target object.
            * The merge will also merge array elements.
            *
            * @method mergeRecursive
            * @static
            */
            mergeRecursive: function () {
                function isDOMNode(v) {
                    if (v === null) {
                        return false;
                    }
                    if (typeof v !== 'object') {
                        return false;
                    }
                    if (!('nodeName' in v)) {
                        return false;
                    }
                    var nn = v.nodeName;
                    try {
                        v.nodeName = 'is readonly?';
                    } catch (e) {
                        return true;
                    }
                    if (v.nodeName === nn) {
                        return true;
                    }
                    v.nodeName = nn;
                    return false;
                }
 
                // _mergeRecursive does the actual job with two arguments.
                // @param {Object} destination JSON object to have other objects merged into.  Parameter is modified by the function.
                // @param {Object} sourceArray Param array of JSON objects to merge into the source
                // @return {Ojbect} merged result object (points to destination variable)
                var _mergeRecursive = function (dst, src) {
                    if (isDOMNode(src) || typeof src !== 'object' || src === null) {
                        return dst;
                    }
 
                    for (var p in src) {
                        if (src.hasOwnProperty(p)) {
                            if ($.isArray(src[p])) {
                                if (dst[p] === undefined) {
                                    dst[p] = [];
                                }
                                $.merge(dst[p], src[p]);
                                continue;
                            }
 
                            if (src[p] === undefined) {
                                continue;
                            }
                            if (typeof src[p] !== 'object' || src[p] === null) {
                                dst[p] = src[p];
                            } else if (typeof dst[p] !== 'object' || dst[p] === null) {
                                dst[p] = _mergeRecursive(src[p].constructor === Array ? [] : {}, src[p]);
                            } else {
                                _mergeRecursive(dst[p], src[p]);
                            }
                        }
                    }
                    return dst;
                }, out;
 
                // Loop through arguments and merge them into the first argument.
                out = arguments[0];
                if (typeof out !== 'object' || out === null) {
                    return out;
                }
                for (var i = 1, il = arguments.length; i < il; i++) {
                    _mergeRecursive(out, arguments[i]);
                }
                return out;
            },
 
            /**
            * Applies supplied xslt to supplied xml. IE always returns a String; others may return a documentFragment or a jObject.
            *
            * @method transformXML
            * @static
            * @param {String} xmlurl Location of the xml file
            * @param {String} xslurl Location of the xslt file
            * @param {Function} callback The callback to be executed
            * @param {Boolean} returnFragment True if you want a document fragment returned (doesn't work in IE)}
            */
            transformXML: function (xmlurl, xslurl, callback, returnFragment, params) {
                var xmld = new Deferred(),
                    xsld = new Deferred(),
                    xml, xsl,
                    dlist = [xmld, xsld],
                    result,
                    error,
                    that = this;
 
                that.afterAll(dlist, function () {
                    if (!error) {
                        result = applyXSLT(xml, xsl);
                    }
                    callback(error, result);
                });
 
                // Transform XML using XSLT
                function applyXSLT(xmlString, xslString) {
                    var output, i;
                    if (window.ActiveXObject || window.hasOwnProperty("ActiveXObject")) { // IE
                        var xslt = new ActiveXObject("Msxml2.XSLTemplate"),
                            xmlDoc = new ActiveXObject("Msxml2.DOMDocument"),
                            xslDoc = new ActiveXObject("Msxml2.FreeThreadedDOMDocument"),
                            xslProc;
 
                        xmlDoc.loadXML(xmlString);
                        xslDoc.loadXML(xslString);
                        xslt.stylesheet = xslDoc;
                        xslProc = xslt.createProcessor();
                        xslProc.input = xmlDoc;
                        // [patched from ECDMP] Add parameters to xsl document (addParameter = ie only)
                        if (params) {
                            for (i = 0; i < params.length; i++) {
                                xslProc.addParameter(params[i].key, params[i].value, "");
                            }
                        }
                        xslProc.transform();
                        output = xslProc.output;
                    } else { // Chrome/FF/Others
                        var xsltProcessor = new XSLTProcessor();
                        xsltProcessor.importStylesheet(xslString);
                        // [patched from ECDMP] Add parameters to xsl document (setParameter = Chrome/FF/Others)
                        if (params) {
                            for (i = 0; i < params.length; i++) {
                                xsltProcessor.setParameter(null, params[i].key, params[i].value || "");
                            }
                        }
                        output = xsltProcessor.transformToFragment(xmlString, document);
 
                        // turn a document fragment into a proper jQuery object
                        if (!returnFragment) {
                            output = ($('body')
                                .append(output)
                                .children().last())
                                .detach();
                        }
                    }
                    return output;
                }
 
                // Distinguish between XML/XSL deferred objects to resolve and set response
                function resolveDeferred(filename, responseObj) {
                    console.log('resolving');
                    console.log(filename);
                    console.log(responseObj.responseText);
                    if (filename.endsWith(".xsl")) {
                        xsl = responseObj.responseText;
                        xsld.resolve();
                    } else {
                        xml = responseObj.responseText;
                        xmld.resolve();
                    }
                }
                    
                function loadXMLFileIE9(filename) {
                    var xdr = new window.XDomainRequest();
                    xdr.open("GET", filename);
                    xdr.onload = function () { resolveDeferred(filename, xdr); };
                    xdr.ontimeout = function () { console.log('xdr timeout'); };
                    xdr.onprogress = function () { console.log('xdr progress'); };
                    xdr.onerror = function (e) {
                        console.log(e);
                        error = true;
                        resolveDeferred(filename, xdr);
                    };
                    window.setTimeout(function () { xdr.send(); }, 0);
                }
                // IE10+
                function loadXMLFileIE(filename) {
                    var xhttp = new XMLHttpRequest();
                    xhttp.open("GET", filename);
                    try {
                        xhttp.responseType = "msxml-document";
                    } catch (err) { } // Helping IE11
                    xhttp.onreadystatechange = function () {
                        if (xhttp.readyState === 4) {
                            if (xhttp.status !== 200) {
                                error = true;
                            }
                            resolveDeferred(filename, xhttp);
                        }
                    };
                    xhttp.send("");
                }
 
                if ('withCredentials' in new XMLHttpRequest() && "ActiveXObject" in window) { // IE10 and above
                    loadXMLFileIE(xmlurl);
                    loadXMLFileIE(xslurl);
                } else if (window.XDomainRequest) {
                    // for IE9 use loadXMLFileIE9 for the metadata XML -- uses XDomainRequest internally and allows cross domain requests
                    // use regular XHR for the XSLT as that should be located on the same server as RAMP
                    // XDR will break on same origin requests unless the same response headers are set allowing cross domain
                    // FIXME: delete all this as soon as IE9 is off the support list as it is fragile and unpleasant to maintain
                    loadXMLFileIE9(xmlurl);
                    loadXMLFileIE(xslurl);
                } else { // Good browsers (Chrome/FF)
                    $.ajax({
                        type: "GET",
                        url: xmlurl,
                        dataType: "xml",
                        cache: false,
                        success: function (data) {
                            xml = data;
                            xmld.resolve();
                        },
                        error: function () {
                            error = true;
                            xmld.resolve();
                        }
                    });
 
                    $.ajax({
                        type: "GET",
                        url: xslurl,
                        dataType: "xml",
                        cache: false,
                        success: function (data) {
                            xsl = data;
                            xsld.resolve();
                        },
                        error: function () {
                            error = true;
                            xsld.resolve();
                        }
                    });
                }
            },
 
            /**
            * Parses a file using the FileReader API.  Wraps readAsText and returns a promise.
            *
            * @method readFileAsText
            * @static
            * @param {File} file a dom file object to be read
            * @return {Object} a promise which sends a string containing the file output if successful
            */
            readFileAsText: _wrapFileCallInPromise('readAsText'),
 
            /**
            * Parses a file using the FileReader API.  Wraps readAsBinaryString and returns a promise.
            *
            * @method readFileAsBinary
            * @static
            * @param {File} file a dom file object to be read
            * @return {Object} a promise which sends a string containing the file output if successful
            */
            readFileAsBinary: _wrapFileCallInPromise('readAsBinary'),
 
            /**
            * Parses a file using the FileReader API.  Wraps readAsArrayBuffer and returns a promise.
            *
            * @method readFileAsArrayBuffer
            * @static
            * @param {File} file a dom file object to be read
            * @return {Object} a promise which sends an ArrayBuffer containing the file output if successful
            */
            readFileAsArrayBuffer: _wrapFileCallInPromise('readAsArrayBuffer'),
 
            /**
            * Augments lists of items to be sortable using keyboard.
            * 
            * @method keyboardSortable
            * @param {Array} ulNodes An array of <ul> tags containing a number of <li> tags to be made keyboard sortable.
            * @param {Object} [settings] Additional settings
            * @param {Object} [settings.linkLists] Indicates if the supplied lists (if more than one) should be linked - items could be moved from one to another; Update: this is wrong - items can't be moved from list to list right now, but the keyboard focus can be moved between lists - need to fix.
            * @param {Object} [settings.onStart] A callback function to be called when the user initiates sorting process
            * @param {Object} [settings.onUpdate] A callback function to be called when the user moves the item around
            * @param {Object} [settings.onStop] A callback function to be called when the user commits the item to its new place ending the sorting process
            * @static
            */
            keyboardSortable: function (ulNodes, settings) {
                settings = dojoLang.mixin({
                    linkLists: false,
 
                    onStart: function () { },
                    onUpdate: function () { },
                    onStop: function () { }
                }, settings);
 
                ulNodes.each(function (index, _ulNode) {
                    var ulNode = $(_ulNode),
                        liNodes = ulNode.find("> li"),
                        //sortHandleNodes = liNodes.find(".sort-handle"),
                        isReordering = false,
                        grabbed;
 
                    // Reset focus, set aria attributes, and styling
                    function reorderReset(handle, liNodes, liNode) {
                        handle.focus();
                        liNodes.attr("aria-dropeffect", "move");
                        liNode.attr("aria-grabbed", "true").removeAttr("aria-dropeffect");
                    }
 
                    // try to remove event handlers to prevent double initialization
                    ulNode
                        .off("focusout", ".sort-handle")
                        .off("keyup", ".sort-handle");
 
                    ulNode
                        .on("focusout", ".sort-handle", function (event) {
                            var node = $(this).closest("li");
 
                            // if the list is not being reordered right now, release list item
                            if (node.hasClass("list-item-grabbed") && !isReordering) {
                                liNodes.removeAttr("aria-dropeffect");
                                node
                                    .removeClass("list-item-grabbed")
                                    .attr({ "aria-selected": false, "aria-grabbed": false });
 
                                grabbed = false;
 
                                console.log("Keyboard Sortable: OnStop -> ", event);
                                settings.onStop.call(null, event, { item: null });
                            }
                        })
                        .on("keyup", ".sort-handle", function (event) {
                            var liNode = $(this).closest("li"),
                                liId = liNode[0].id,
                                liIdArray = ulNode.sortable("toArray"),
                                liIndex = dojoArray.indexOf(liIdArray, liId);
 
                            // Toggle grabbed state and aria attributes (13 = enter, 32 = space bar)
                            if (event.which === 13 || event.which === 32) {
                                if (grabbed) {
                                    liNodes.removeAttr("aria-dropeffect");
                                    liNode
                                        .attr("aria-grabbed", "false")
                                        .removeClass("list-item-grabbed");
 
                                    console.log("Keyboard Sortable: OnStop -> ", liNode);
                                    settings.onStop.call(null, event, { item: liNode });
 
                                    grabbed = false;
                                } else {
                                    liNodes.attr("aria-dropeffect", "move");
                                    liNode
                                        .attr("aria-grabbed", "true")
                                        .removeAttr("aria-dropeffect")
                                        .addClass("list-item-grabbed");
 
                                    console.log("Keyboard Sortable: OnStart -> ", liNode);
                                    settings.onStart.call(null, event, { item: liNode });
 
                                    grabbed = true;
                                }
                                // Keyboard up (38) and down (40)
                            } else if (event.which === 38) {
                                if (grabbed) {
                                    // Don't move up if first layer in list
                                    if (liIndex > 0) {
                                        isReordering = true;
 
                                        liNode.prev().before(liNode);
 
                                        reorderReset($(this), liNodes, liNode);
 
                                        grabbed = true;
                                        liIndex -= 1;
 
                                        console.log("Keyboard Sortable: OnUpdate -> ", liNode);
                                        settings.onUpdate.call(null, event, { item: liNode });
 
                                        isReordering = false;
                                    }
                                } else {
                                    // if lists are linked, jump to the last item of the previous list, if any
                                    if (settings.linkLists &&
                                        liIndex === 0 &&
                                        index !== 0) {
                                        liNode = $(ulNodes[index - 1]).find("> li:last");
                                    } else {
                                        liNode = liNode.prev();
                                    }
 
                                    liNode.find(":tabbable:first").focus();
                                }
                            } else if (event.which === 40) {
                                if (grabbed) {
                                    // Don't move down if last layer in list
                                    if (liIndex < liNodes.length - 1) {
                                        isReordering = true;
 
                                        liNode.next().after(liNode);
 
                                        reorderReset($(this), liNodes, liNode);
 
                                        grabbed = true;
                                        liIndex += 1;
 
                                        console.log("Keyboard Sortable: OnUpdate -> ", liNode);
                                        settings.onUpdate.call(null, event, { item: liNode });
 
                                        isReordering = false;
                                    }
                                } else {
                                    // if lists are linked, jump to the first item of the next list, if any
                                    if (settings.linkLists &&
                                        liIndex === liNodes.length - 1 &&
                                        index < ulNodes.length - 1) {
                                        liNode = $(ulNodes[index + 1]).find("> li:first");
                                    } else {
                                        liNode = liNode.next();
                                    }
 
                                    liNode.find(":tabbable:first").focus();
                                }
                            }
                        });
                });
            },
 
            /**
             * Takes an array of timelines and their generator functions, clear and recreates timelines optionally preserving the play position.
             * ####Example of tls parameter
             * 
             *      [
             *          {
             *              timeline: {timeline},
             *              generator: {function}
             *          }
             *      ]
             *      
             * 
             * @method resetTimelines
             * @static
             * @param {Array} tls An array of objects containing timeline objects and their respective generator functions
             * @param {Boolean} keepPosition Indicates if the timeline should be set in the play position it was in before the reset
             */
            resetTimelines: function (tls, keepPosition) {
                var position;
 
                tls.forEach(function (tl) {
                    position = tl.timeLine.time(); // preserve timeline position
                    tl.timeLine.seek(0).clear();
 
                    tl.generator.call();
 
                    if (keepPosition) {
                        tl.timeLine.seek(position);
                    }
                });
            },
 
            /**
            * Checks if two spatial reference objects are equivalent.  Handles both wkid and wkt definitions
            *
            * @method isSpatialRefEqual
            * @static
            * @param {Esri/SpatialReference} sr1 First {{#crossLink "Esri/SpatialReference"}}{{/crossLink}} to compare
            * @param {Esri/SpatialReference} sr2 Second {{#crossLink "Esri/SpatialReference"}}{{/crossLink}} to compare
            * @return {Boolean} true if the two spatial references are equivalent.  False otherwise.
            */
            isSpatialRefEqual: function (sr1, sr2) {
                if ((sr1.wkid) && (sr2.wkid)) {
                    //both SRs have wkids
                    return sr1.wkid === sr2.wkid;
                } else if ((sr1.wkt) && (sr2.wkt)) {
                    //both SRs have wkt's
                    return sr1.wkt === sr2.wkt;
                } else {
                    //not enough info provided or mismatch between wkid and wkt.
                    return false;
                }
            },
 
            /**
            * Checks if the given dom node is present in the dom.
            *
            * @method containsInDom
            * @static
            * @param {Object} el DOM node to check
            * @return {Boolean} true if the given node is in the dom
            */
            containsInDom: function (el) {
                return $.contains(document.documentElement, el);
            },
 
            styleBrowseFilesButton: function (nodes) {
                var input,
                    button;
 
                function focusIn(event) {
                    event.data.button.not(".disabled").addClass("btn-focus btn-hover");
                }
 
                function focusOut(event) {
                    event.data.button.removeClass("btn-focus btn-hover btn-active");
                }
 
                function mouseEnter(event) {
                    event.data.button.not(".disabled").addClass("btn-hover");
                }
 
                function mouseLeave(event) {
                    event.data.button.removeClass("btn-hover btn-active");
                }
 
                function mouseDown(event) {
                    event.data.button.not(".disabled").addClass("btn-focus btn-hover btn-active");
                }
 
                function mouseUp(event) {
                    event.data.button.removeClass("btn-active");
                }
 
                nodes.each(function (i, node) {
                    node = $(node);
                    input = node.find("input[type='file']");
                    button = node.find(".browse-button");
 
                    input
                        .on("focusin", { button: button }, focusIn)
                        .on("focusout", { button: button }, focusOut)
 
                        .on("mouseenter", { button: button }, mouseEnter)
                        .on("mouseleave", { button: button }, mouseLeave)
 
                        .on("mousedown", { button: button }, mouseDown)
                        .on("mouseup", { button: button }, mouseUp)
                    ;
                });
            },
 
            /**
            * Detects either cell or line delimiter in a given csv data.
            *
            * @method detectDelimiter
            * @static
            * @param {String} data csv content
            * @param {String} [type] Type of the delimiter to detect. Possible values "cell" or "line". Defaults to "cell".
            * @return {String} Detected delimiter
            */
            detectDelimiter: function (data, type) {
                var count = 0,
                    detected,
 
                    escapeDelimiters = ['|', '^'],
                    delimiters = {
                        cell: [',', ';', '\t', '|', '^'],
                        line: ['\r\n', '\r', '\n']
                    };
 
                type = type !== "cell" && type !== "line" ? "cell" : type;
 
                delimiters[type].forEach(function (delimiter) {
                    var needle = delimiter,
                        matches;
 
                    if (escapeDelimiters.indexOf(delimiter) !== -1) {
                        needle = '\\' + needle;
                    }
 
                    matches = data.match(new RegExp(needle, 'g'));
                    if (matches && matches.length > count) {
                        count = matches.length;
                        detected = delimiter;
                    }
                });
 
                console.log(type + " delimiter detected: '" + (detected || delimiters[type][0]) + "'");
 
                return (detected || delimiters[type][0]);
            },
 
            /**
            * Converts HEX colour to RGB.
            * http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb/5624139#5624139
            *
            * @method hexToRgb
            * @static
            * @param {String} hex hex colour code
            * @return {Object} object containing r, g, and b components of the supplied colour
            */
            hexToRgb: function (hex) {
                // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
                var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
                hex = hex.replace(shorthandRegex, function (m, r, g, b) {
                    return r + r + g + g + b + b;
                });
 
                var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
                return result ? {
                    r: parseInt(result[1], 16),
                    g: parseInt(result[2], 16),
                    b: parseInt(result[3], 16)
                } : null;
            },
 
            /**
            * Converts RGB colour to HEX.
            * http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb/5624139#5624139
            *
            * @method rgbToHex
            * @static 
            * @param {Number} r r component
            * @param {Number} g g component
            * @param {Number} b b component
            * @return {Object} hex colour code 
            */
            rgbToHex: function (r, g, b) {
                return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
            },
 
            resetFormElement: function (e) {
                e.wrap('<form>').closest('form').get(0).reset();
                e.unwrap();
            },
 
            setSelectOptions: function (select, options, append) {
                //var optionsNode;
 
                if (!append) {
                    select.empty();
                    //select.append(optionsNode);
                }
 
                options.forEach(function (option) {
                    select.append($("<option/>", {
                        value: option.value,
                        text: option.text
                    }));
                });
            },
 
            // https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_.22Unicode_Problem.22
            /**
             * Base64 encoding for unicode text.
             * 
             * @method b64EncodeUnicode
             * @param {String} str a string to encode
             * @return {String} encoded string
             */
            b64EncodeUnicode: function (str) {
                return new Btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
                    return String.fromCharCode('0x' + p1);
                })).a;
            }
        };
    });