/******************************************************************************
* jquery.i18n.properties
* 
* Dual licensed under the GPL (http://dev.jquery.com/browser/trunk/jquery/GPL-LICENSE.txt) and 
* MIT (http://dev.jquery.com/browser/trunk/jquery/MIT-LICENSE.txt) licenses.
* 
* @version     1.0.x
* @author      Nuno Fernandes
* @url         www.codingwithcoffee.com
* @inspiration Localisation assistance for jQuery (http://keith-wood.name/localisation.html)
*              by Keith Wood (kbwood{at}iinet.com.au) June 2007
* 
*
* Nuno, whoever you are, I'm going to hunt you down and invade your personal space forever
* because clearly you aren't drinking enough coffee.
*
*****************************************************************************/

(function ($) {
    $.i18n = {};

    /** Map holding bundle keys (if mode: 'map') */
    $.i18n.map = {};

    /**
    * Load and parse message bundle files (.properties),
    * making bundles keys available as javascript variables.
    * 
    * i18n files are named <name>.js, or <name>_<language>.js or <name>_<language>_<country>.js
    * Where:
    *      The <language> argument is a valid ISO Language Code. These codes are the lower-case, 
    *      two-letter codes as defined by ISO-639. You can find a full list of these codes at a 
    *      number of sites, such as: http://www.loc.gov/standards/iso639-2/englangn.html
    *      The <country> argument is a valid ISO Country Code. These codes are the upper-case,
    *      two-letter codes as defined by ISO-3166. You can find a full list of these codes at a
    *      number of sites, such as: http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html
    * 
    * Sample usage for a bundles/Messages.properties bundle:
    * $.i18n.properties({
    *      name:      'Messages', 
    *      language:  'en_US',
    *      path:      'bundles'
    * });
    * @param  name                 (string/string[], required) names of file to load (eg, 'Messages' or ['Msg1','Msg2'])
    * @param  language             (string, optional) language/country code (eg, 'en', 'en_US', 'pt_PT'). if not specified, language reported by the browser will be used instead.
    * @param  path                 (string, optional) path of directory that contains file to load
    * @param  mode                 (string, optional) whether bundles keys are available as JavaScript variables/functions or as a map (eg, 'vars' or 'map')
    * @param  callback     (function, optional) callback function to be called after script is terminated
    */
    $.i18n.properties = function (settings) {
        // set up settings
        var defaults = {
            name: 'Messages',
            language: '',
            path: '',
            mode: 'vars',
            callback: function () { }
        };
        settings = $.extend(defaults, settings);
        if (settings.language === null || settings.language == '') {
            settings.language = $.i18n.browserLang();
        }
        if (settings.language === null) { settings.language = ''; }

        // load and parse bundle files
        var files = getFiles(settings.name);
        for (i = 0; i < files.length; i++) {
            // 1. load base (eg, Messages.properties)
            loadAndParseFile(settings.path + files[i] + '.properties', settings.language, settings.mode);
            // 2. with language code (eg, Messages_pt.properties)
            if (settings.language.length >= 2) {
                loadAndParseFile(settings.path + files[i] + '_' + settings.language.substring(0, 2) + '.properties', settings.language, settings.mode);
            }
            // 3. with language code and country code (eg, Messages_pt_PT.properties)
            if (settings.language.length >= 5) {
                loadAndParseFile(settings.path + files[i] + '_' + settings.language.substring(0, 5) + '.properties', settings.language, settings.mode);
            }
        }

        // call callback
        if (settings.callback) { settings.callback(); }
    };


    /**
    * When configured with mode: 'map', allows access to bundle values by specifying its key.
    * Eg, jQuery.i18n.prop('com.company.bundles.menu_add')
    */
    $.i18n.prop = function (key, placeHolderValues) {
        var value = $.i18n.map[key];
        if (value == null) { return '[' + key + ']'; }
        if (!placeHolderValues) {
            //if(key == 'spv.lbl.modified') {alert(value);}
            return value;
        } else {
            if (placeHolderValues.constructor != Array.constructor) {
                placeHolderValues = [placeHolderValues];
            }

            for (var i = 0; i < placeHolderValues.length; i++) {
                var regexp = new RegExp('\\{(' + i + ')\\}', "g");
                value = value.replace(regexp, placeHolderValues[i]);
            }
            return value;
        }
    };

    /** Language reported by browser, normalized code */
    $.i18n.browserLang = function () {
        return normaliseLanguageCode(navigator.language /* Mozilla */ || navigator.userLanguage /* IE */);
    }


    /** Load and parse .properties files */
    function loadAndParseFile(filename, language, mode) {
        $.ajax({
            url: filename,
            async: false,
            cache: false,
            contentType: 'text/plain;charset=UTF-8',
            dataType: 'text',
            success: function (data, status) {
                parseData(data, mode);
            }
        });
    }

    /** Parse .properties files */
    function parseData(data, mode) {
        var parsed = '';
        var parameters = data.split(/\n/);
        var regPlaceHolder = /(\{\d+\})/g;
        var regRepPlaceHolder = /\{(\d+)\}/g;
        var unicodeRE = /(\\u.{4})/ig;
        for (var i = 0; i < parameters.length; i++) {
            parameters[i] = parameters[i].replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
            if (parameters[i].length > 0 && parameters[i].match("^#") != "#") { // skip comments
                var pair = parameters[i].split('=');
                if (pair.length > 0) {
                    /** Process key & value */
                    var name = unescape(pair[0]).replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
                    var value = pair.length == 1 ? "" : pair[1];
                    // process multi-line values
                    while (value.match(/\\$/) == "\\") {
                        value = value.substring(0, value.length - 1);
                        value += parameters[++i].replace(/\s\s*$/, ''); // right trim
                    }
                    for (var s = 2; s < pair.length; s++) { value += '=' + pair[s]; }
                    value = value.replace(/"/g, '\\"'); // escape quotation mark (")
                    value = value.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim  

                    /** Mode: bundle keys in a map */
                    if (mode == 'map' || mode == 'both') {
                        // handle unicode chars possibly left out
                        var unicodeMatches = value.match(unicodeRE);
                        if (unicodeMatches) {
                            for (var u = 0; u < unicodeMatches.length; u++) {
                                value = value.replace(unicodeMatches[u], unescapeUnicode(unicodeMatches[u]));
                            }
                        }
                        // add to map
                        $.i18n.map[name] = value;
                    }

                    /** Mode: bundle keys as vars/functions */
                    if (mode == 'vars' || mode == 'both') {
                        // make sure namespaced key exists (eg, 'some.key') 
                        checkKeyNamespace(name);

                        // value with variable substitutions
                        if (regPlaceHolder.test(value)) {
                            var parts = value.split(regPlaceHolder);
                            // process function args
                            var first = true;
                            var fnArgs = '';
                            var usedArgs = [];
                            for (var p = 0; p < parts.length; p++) {
                                if (regPlaceHolder.test(parts[p]) && (usedArgs.length == 0 || usedArgs.indexOf(parts[p]) == -1)) {
                                    if (!first) { fnArgs += ','; }
                                    fnArgs += parts[p].replace(regRepPlaceHolder, 'v$1');
                                    usedArgs.push(parts[p]);
                                    first = false;
                                }
                            }
                            parsed += name + '=function(' + fnArgs + '){';
                            // process function body
                            var fnExpr = '"' + value.replace(regRepPlaceHolder, '"+v$1+"') + '"';
                            parsed += 'return ' + fnExpr + ';' + '};';

                            // simple value
                        } else {
                            parsed += name + '="' + value + '";';
                        }
                    } // END: Mode: bundle keys as vars/functions
                } // END: if(pair.length > 0)
            } // END: skip comments
        }
        try {
            eval(parsed); //yeugh! Is it on me! *twitches* I feel like it's on me.
        } catch (e) {
            if (console && console.debug) {
                console.debug(parsed);
            }
        }
    }

    /** Make sure namespace exists (for keys with dots in name) */
    function checkKeyNamespace(key) {
        var regDot = /\./;
        if (regDot.test(key)) {
            var fullname = '';
            var names = key.split(/\./);
            for (var i = 0; i < names.length; i++) {
                if (i > 0) { fullname += '.'; }
                fullname += names[i];
                try {
                    if (eval('typeof ' + fullname + ' == "undefined"')) { //bugger me, it gets worse.
                        eval(fullname + '={};');
                    }
                } catch (e) {
                    if (console && console.debug) {
                        console.debug("\""+ fullname + "\" is not legal syntax for a type.");
                    }
                }
            }
        }
    }

    /** Make sure filename is an array */
    function getFiles(names) {
        return (names && names.constructor == Array) ? names : [names];
    }

    /** Ensure language code is in the format aa_AA. */
    function normaliseLanguageCode(lang) {
        lang = lang.toLowerCase();
        if (lang.length > 3) {
            lang = lang.substring(0, 3) + lang.substring(3).toUpperCase();
        }
        return lang;
    }

    /** Unescape unicode chars ('\u00e3') */
    function unescapeUnicode(str) {
        // unescape unicode codes
        var codes = [];
        var code = parseInt(str.substr(2), 16);
        if (code >= 0 && code < Math.pow(2, 16)) {
            codes.push(code);
        }
        // convert codes to text
        var unescaped = '';
        for (var i = 0; i < codes.length; ++i) {
            unescaped += String.fromCharCode(codes[i]);
        }
        return unescaped;
    }

    /* Cross-Browser Split 1.0.1
    (c) Steven Levithan <stevenlevithan.com>; MIT License
    An ECMA-compliant, uniform cross-browser split method */
    var cbSplit;
    // avoid running twice, which would break `cbSplit._nativeSplit`'s reference to the native `split`
    if (!cbSplit) {
        cbSplit = function (str, separator, limit) {
            // if `separator` is not a regex, use the native `split`
            if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
                if (typeof cbSplit._nativeSplit == "undefined")
                    return str.split(separator, limit);
                else
                    return cbSplit._nativeSplit.call(str, separator, limit);
            }

            var output = [],
          lastLastIndex = 0,
          flags = (separator.ignoreCase ? "i" : "") +
                  (separator.multiline ? "m" : "") +
                  (separator.sticky ? "y" : ""),
          separator = RegExp(separator.source, flags + "g"), // make `global` and avoid `lastIndex` issues by working with a copy
          separator2, match, lastIndex, lastLength;

            str = str + ""; // type conversion
            if (!cbSplit._compliantExecNpcg) {
                separator2 = RegExp("^" + separator.source + "$(?!\\s)", flags); // doesn't need /g or /y, but they don't hurt
            }

            /* behavior for `limit`: if it's...
            - `undefined`: no limit.
            - `NaN` or zero: return an empty array.
            - a positive number: use `Math.floor(limit)`.
            - a negative number: no limit.
            - other: type-convert, then use the above rules. */
            if (limit === undefined || +limit < 0) {
                limit = Infinity;
            } else {
                limit = Math.floor(+limit);
                if (!limit) {
                    return [];
                }
            }

            while (match = separator.exec(str)) {
                lastIndex = match.index + match[0].length; // `separator.lastIndex` is not reliable cross-browser

                if (lastIndex > lastLastIndex) {
                    output.push(str.slice(lastLastIndex, match.index));

                    // fix browsers whose `exec` methods don't consistently return `undefined` for nonparticipating capturing groups
                    if (!cbSplit._compliantExecNpcg && match.length > 1) {
                        match[0].replace(separator2, function () {
                            for (var i = 1; i < arguments.length - 2; i++) {
                                if (arguments[i] === undefined) {
                                    match[i] = undefined;
                                }
                            }
                        });
                    }

                    if (match.length > 1 && match.index < str.length) {
                        Array.prototype.push.apply(output, match.slice(1));
                    }

                    lastLength = match[0].length;
                    lastLastIndex = lastIndex;

                    if (output.length >= limit) {
                        break;
                    }
                }

                if (separator.lastIndex === match.index) {
                    separator.lastIndex++; // avoid an infinite loop
                }
            }

            if (lastLastIndex === str.length) {
                if (lastLength || !separator.test("")) {
                    output.push("");
                }
            } else {
                output.push(str.slice(lastLastIndex));
            }

            return output.length > limit ? output.slice(0, limit) : output;
        };

        cbSplit._compliantExecNpcg = /()??/.exec("")[1] === undefined; // NPCG: nonparticipating capturing group
        cbSplit._nativeSplit = String.prototype.split;

    } // end `if (!cbSplit)`
    String.prototype.split = function (separator, limit) {
        return cbSplit(this, separator, limit);
    };

})(jQuery);