/**
 * 此文件的头部注释
 */

/*global jquery: false, window: false */

(function ($) {
    'use strict';

    var pe,
        tools;

    pe = window.pe = {};

    tools = {
        /**
         * 判断要加的链接符是?还是&
         * @param {} url 
         * @returns {} 
         */
        connect: function (url) {
            var connect = "?";
            if (url.indexof("?") > -1) {
                connect = "&";
            }
            return connect;
        },
        /**
         * 不同的浏览器分割hash码
         * @param {} url 
         * @returns {} 
         */
        diffbrowsersplithash: function (hash) {
            var hashstr = "";
            if (hash.indexof("#/") > -1) {
                hashstr = hash.split("#/")[1];
            } else if (hash.indexof("##") > -1) {
                hashstr = hash.split("##")[1];
            }
            return hashstr;
        },
        /**
         * 特殊处理state参数

         * @param {} url 
         * @returns {} 
         */
        filterstatespecialchar: function (stateparam) {
            if (stateparam.substring(0, 1) === "/") {
                return stateparam.substring(1);
            }

            return stateparam;
        },
        /**
         * 合并url的参数。
         * @param {string} url 要合并参数的url
         * @param {object<string,object>} param 参数 ，使用键值对对象。
         * @returns {string} 合并完成后的js
         */
        connecturl: function (url, param) {
            var querystring = url.split('?')[1] || '';
            var params = [];
            if (querystring) {
                params = querystring.split('&');
            }

            if (param) {
                for (var item in param) {
                    if (param.hasownproperty(item)) {
                        params.push(item + '=' + param[item]);
                    }
                }
            }

            return url.split('?')[0] + '?' + params.join('&');
        },

        /**
        * 生成一组随机的id号码
        * @param len 长度
        * @param radix   参数
        * @returns {string}  id号码
        */
        uuid: function (len, radix) {
            len = len || 8;
            radix = radix || 2;
            var chars = '0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz'
                .split(''); // undone [2014-4-17] [] 变量小写命名。这里为什么要把chars变量赋值给chars，而不直接用chars。
            var chars = chars,
                uuid = [],
                i;
            radix = radix || chars.length;
            if (len) {
                for (i = 0; i < len; i++) {
                    uuid[i] = chars[0 | math.random() * radix];
                }
            } else {
                var r;
                uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
                uuid[14] = '4';
                for (i = 0; i < 36; i++) {
                    if (!uuid[i]) {
                        r = 0 | math.random() * 16;
                        uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
                    }
                }
            }
            return uuid.join('');
        },
        errorresulthandler: {
            'notauthenticated': function (result) {
                window.top.location.href = result.logonurl;

                return '';
            },

            'notauthorized': function (result) {
                return '您没有权限查看所请求的内容';
            }

        },
        regexhelper: {
            url: /(http:\/)?\/[^\/]+/

        },
        /**
        * 裁剪字符串
        * @param str {string} 要剪裁的字符串
        * @param n {number} 剪裁的长度
        * @returns {string}  剪裁好的字符串。
        */
        truncatestr: function (str, n) { // undone [2014-4-17] [] 函数命名不要使用简写；变量命名问题；变量统一在代码块开头命名，还是就近命名（变量i）？
            var r = /[^\x00-\xff]/g;
            var i;
            if (str.replace(r, 'mm').length <= n) {
                return str;
            }
            // n = n - 3;    
            var m = math.floor(n / 2);
            for (i = m; i < str.length; i++) {
                if (str.substr(0, i).replace(r, 'mm').length >= n) {
                    return str.substr(0, i) + '...';
                }
            }

            return str;
        },
        htmlencode: function (text) {
            return $('<div/>').text(text).html();
        },
        htmldecode: function (text) {
            return $('<div/>').html(text).text();
        },
        /*
         * 给url增加当前的hash值
         * @param url {string} 要增加hash值的url
         * @return {string} 增加了hash值得url
         */
        addcurrenthash: function (url) {
            if (!!url) {
                var hash = 'state=' + window.location.hash.replace(/^#*/, '');
                hash = hash.replace("%20", "+");
                url += (/\?/.test(url) ? '&' : '?') + hash;
            }
            return url;
        },

        /**
         * 路径操作助手。
         */
        pathhelperutils: {
            /**
            * 路径上传目录替换符转换为上传目录， 处理兼容情况。
            * @param {string} path 原路径。
            * @param {string} symbol
            * @param {string} uploaddirectory
            * @return {string} 返回结果。
            */
            replacepathsymbolforshow: function (path, symbol, uploaddirectory) {
                if (path && symbol && uploaddirectory) {
                    path = path.trimstartreplace("~");
                    uploaddirectory = uploaddirectory.trimstartreplace("~");

                    if (path.indexof(symbol) == 0) {
                        var uploadpathprefix = ""; //// 上传目录前缀，默认是空字符串。
                        path = uploadpathprefix + uploaddirectory + path.substring(symbol.length);
                    }
                }

                return path;
            },
            /**
            * 路径上传目录替换符转换为上传目录， 处理兼容情况。
            * @param {string} path 原路径。
            * @param {string} symbol 上传目录替换符。
            * @param {string} uploadvirtualpath 上传虚拟路径。
             * @param {object} regexp 正则表达式regexp对象，如果传入则使用传入的，否则使用内部正则表达式的。
            * @return {string} 返回结果。
            */
            replacecontentsymbolforshow: function (path, symbol, uploadvirtualpath, regexp) {
                var regexstring = "((src|href)\\s*=\\s*(\"|\'))\\$?\\/(\\/|\\w|\\.|\\{|\\})*";
                if (path && symbol && uploadvirtualpath) {
                    path = path.trimstartreplace("~");
                    uploadvirtualpath = uploadvirtualpath.trimstartreplace("~");

                    if (!regexp) {
                        regexp = new regexp(regexstring, 'gi');
                    }

                    path = path.replace(regexp, function (match, p1) {
                        var value = match;
                        if (match && p1 && match.indexof(p1) == 0) {
                            var attributevalue = match.substring(p1.length);
                            attributevalue = attributevalue.replacepathsymbolforshow(symbol, uploadvirtualpath);
                            value = p1.concat(attributevalue);
                        }

                        return value;
                    });
                }

                return path;
            },
            trimstartreplace: function (orignal, target) {
                if (orignal && target && orignal.length >= target.length) {
                    while (orignal && orignal.indexof(target) == 0) {
                        orignal = orignal.substring(target.length);
                    }
                }

                return orignal;
            }
        }
    };

    pe.tools = tools;

    //object .create
    if (typeof object.create !== 'function') {
        object.create = function (o) {
            var f = function () {};
            f.prototype = o;

            return new f();
        };
    }

    //function method

    if (typeof function.method !== 'function') {
        function.prototype.method = function (name, func) {
            this.prototype[name] = func;
            return this;
        };
    }

    pe.messager = {
        sendmessage: function (frame, eventname, senddata) {
            var $iframe = $(frame);
            var data = {
                event: 'power.' + eventname,
                data: senddata
            };
            frame.contentwindow.postmessage(json.stringify(data), '*');
        }
    };

    /**
     * 替换路径中的上传占位符。
     * @param {string} symbol 目录替换符。
     * @param {any} uploaddirectory 上传虚拟目录路径。
     * @return {string} 结果。
     */
    string.prototype.replacepathsymbolforshow = function (symbol, uploaddirectory) {
        var path = this;
        return pe.tools.pathhelperutils.replacepathsymbolforshow(path, symbol, uploaddirectory);
    };

    /**
     * 替换内容中的上传站位符。
     * @param {string} symbol 目录替换符。
     * @param {string} uploadpath 上传虚拟目录路径。
     * @param {object} regexp 自定义正则。如果传入则使用传入的，如果没有则使用默认的。
     * @return {string} 结果。
     */
    string.prototype.replacecontentsymbolforshow = function (symbol, uploadpath, regexp) {
        var content = this;
        return pe.tools.pathhelperutils.replacecontentsymbolforshow(content, symbol, uploadpath, regexp);
    };

    string.prototype.trimstartreplace = function (target) {
        var orignal = this;
        return pe.tools.pathhelperutils.trimstartreplace(orignal, target);
    };
}(jquery));