/**
 * core common class place all global methods here
 * @author michaeld
 */

/**
 * a non destructive utility method that allows you to create a namespace
 * 
 * @param {String} namespaceString the namespace to create
 * @returns {Object}
 */
function namespace(namespaceString) {
    var parts = namespaceString.split('.'), parent = window, currentPart = '';

    for ( var i = 0, length = parts.length; i < length; i++) {
        currentPart = parts[i];
        parent[currentPart] = parent[currentPart] || {};
        parent = parent[currentPart];
    }

    return parent;
}

// create the AFL_JS namespace and all subnamespaces required for this file
namespace('AFL_JS.Common.Busyness.Storage');

/**
 * method can be used to cancel event propagation
 * 
 * @returns {Boolean}
 */
AFL_JS.Common.CancelEvent = function() {
    return false;
};

AFL_JS.Common.Busyness.IsBusy = function(name) {
    return AFL_JS.Common.Busyness.Storage[name] || false;
};

AFL_JS.Common.Busyness.Set = function(name, value, timeout) {
    timeout = timeout || false;
    AFL_JS.Common.Busyness.Storage[name] = value;
    if (timeout) {
        setTimeout(function() {
            AFL_JS.Common.Busyness.Set(name, !(value), false);
        }, timeout);
    }
};

/**
 * returns the number of characters in the passed input field
 * 
 * @param {Object} oInput
 * @param {Number} iAllowed
 * @returns {Object}
 */
AFL_JS.Common.CharactersCount = function(oInput, iAllowed) {
    var Value = oInput.value;
    var Current = Value.length;
    var Left = 0;
    if (Current > iAllowed) {
        Value = Value.substr(0, iAllowed);
        oInput.value = Value;
        if (oInput.tagName.toUpperCase() == 'TEXTAREA') {
            oInput.innerHTML = Value;
        }
    } else {
        Left = iAllowed - Current;
    }
    return {
        'Left' : Left,
        'Current' : Current
    };
};

/**
 * displays a countdown of the number of characters left in the input field
 * 
 * @param {Object} oInput The input field to count the characters of
 * @param {Object} oDisplay the html container to show the count in
 * @param {Number} iAllowed the number of allowed characters
 * @param {String} sInfo the message to display use [%COUNT%] to display the
 *            count and use [%MAX%] to display the limit
 */
AFL_JS.Common.CountDownCharacters = function(oInput, oDisplay, iAllowed, sInfo) {

    var Chars = AFL_JS.Common.CharactersCount(oInput, iAllowed);

    if (!Object.isUndefined(sInfo)) {
        oDisplay.innerHTML = sInfo.replace('[%COUNT%]', Chars.Left).replace(
                '[%MAX%]', iAllowed);
    } else {
        oDisplay.innerHTML = Chars.Left;
    }
};

/**
 * 
 * 
 * @deprecated
 * @param obj
 * @returns {Boolean}
 */

AFL_JS.Common.CountCharacters = function(oInput, oDisplay, iAllowed, sInfo) {

    var Chars = AFL_JS.Common.CharactersCount(oInput, iAllowed);

    if (!Object.isUndefined(sInfo)) {
        oDisplay.innerHTML = sInfo.replace('[%COUNT%]', Chars.Current).replace(
                '[%MAX%]', iAllowed);
    } else {
        oDisplay.innerHTML = Chars.Current;
    }
};

/**
 * detects if the current browser is internet explorer
 * 
 * @returns {Boolean}
 */
AFL_JS.Common.IsIE = ((document.all) && (navigator.userAgent.indexOf('Opera') == -1)) ? true
        : false;

AFL_JS.Common.isArray = function(obj) {
    if (obj.constructor.toString().indexOf("Array") == -1)
        return false;
    else
        return true;
};

/**
 * Base64 encode / decode http://www.webtoolkit.info/
 */
var Base64 = {

    // private property
    _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

    // public method for encoding
    encode : function(input) {
        var output = "";
        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
        var i = 0;

        input = Base64._utf8_encode(input);

        while (i < input.length) {

            chr1 = input.charCodeAt(i++);
            chr2 = input.charCodeAt(i++);
            chr3 = input.charCodeAt(i++);

            enc1 = chr1 >> 2;
            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
            enc4 = chr3 & 63;

            if (isNaN(chr2)) {
                enc3 = enc4 = 64;
            } else if (isNaN(chr3)) {
                enc4 = 64;
            }

            output = output + this._keyStr.charAt(enc1)
                    + this._keyStr.charAt(enc2) + this._keyStr.charAt(enc3)
                    + this._keyStr.charAt(enc4);

        }

        return output;
    },

    // public method for decoding
    decode : function(input) {
        var output = "";
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;

        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

        while (i < input.length) {

            enc1 = this._keyStr.indexOf(input.charAt(i++));
            enc2 = this._keyStr.indexOf(input.charAt(i++));
            enc3 = this._keyStr.indexOf(input.charAt(i++));
            enc4 = this._keyStr.indexOf(input.charAt(i++));

            chr1 = (enc1 << 2) | (enc2 >> 4);
            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
            chr3 = ((enc3 & 3) << 6) | enc4;

            output = output + String.fromCharCode(chr1);

            if (enc3 != 64) {
                output = output + String.fromCharCode(chr2);
            }
            if (enc4 != 64) {
                output = output + String.fromCharCode(chr3);
            }

        }

        output = Base64._utf8_decode(output);

        return output;

    },

    // private method for UTF-8 encoding
    _utf8_encode : function(string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";

        for ( var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }
        }

        return utftext;
    },

    // private method for UTF-8 decoding
    _utf8_decode : function(utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;

        while (i < utftext.length) {

            c = utftext.charCodeAt(i);

            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            } else if ((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i + 1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            } else {
                c2 = utftext.charCodeAt(i + 1);
                c3 = utftext.charCodeAt(i + 2);
                string += String.fromCharCode(((c & 15) << 12)
                        | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }
        }
        return string;
    }
};