/**
    调用前提必须加jquery.js
    创建方正生僻字键盘 有一个固定的"fzkb_container"样式
    selector 必填，输入域input标签的id
    网页必须有一个元素可通过 $("." + selector + "_fz_span") 选择
    position 非必填，用于键盘定位，定位 eg:{'top': '300', 'right': '200', 'bottom': '', 'left': ''}
    custom 非必填，自定义配置对象，用于修改键盘宽度等等eg:{width:300, fzKeyboardHeight:200}
    eventsobj 非必填，自定义事件对象eg: {
        init:初始化完成事件
        initFont:默认的字体加载完成事件
        show:当键盘弹出之后触发的事件
        hide:当键盘收起之后触发的事件
        inputChat:每输入一个字都触发的事件
        deleteChat:删除一个字触发的事件
        inputComplet:点击确认，表示输入完成，回显之前触发事件
        error:生僻字加载失败的事件
    }
**/
function fzKeyboard(selector, position, custom, eventsobj) {
    try {
        if (!selector) return;
        if (!spzBrowserFlag()) {
            $("." + selector + "_fz_span").hide();
        }
    } catch (error) {}

    var kb = null;
    if(typeof eventsobj != 'object') eventsobj = {};

    $("." + selector + "_fz_span").click(function() {
        if(typeof FzKeyboard != "function"){
            var ver = top.window.fzDomainVer || new Date().getTime();
            var fzJsSrc = '/P1StaRes/V6/STY1/CN/js/SPZ/fzKeyboard_py.js?ver='+ ver;
            loadScript(fzJsSrc, inputSpz);
        }else{
            inputSpz();
        }
    });
    function inputSpz(){
        fzToken(function(){
            if(typeof FzKeyboard != "function"){
                typeof eventsobj.error === 'function' && eventsobj.error();
                return false;
            }
            var fzConfig = top.window.fzConfig;
            var option = {
                "domainUrl": fzConfig.domainUrl,
                "contextPath": fzConfig.contextPath,
                "tid": fzConfig.tid,
                "token": fzConfig.token,
                "onlyUncc": false,
                "hideAnimate": false,
                "drag": true,
                "writingType": 1,
                "css": "fzkb_container",
                "width": 500,
                "fzKeyboardHeight": 300,
                events: {
                    init: function(){
                        setTimeout(function() {
                            if (kb) {
                                kb.show();
                            }
                        }, 100);
                        try {
                            typeof eventsobj.init === 'function' && eventsobj.init();
                        } catch (error) {}
                    },
                    initFont: function(){
                        try {
                            typeof eventsobj.initFont === 'function' && eventsobj.initFont();
                        } catch (error) {}
                    },
                    show: function() {
                        try {
                            typeof eventsobj.show === 'function' && eventsobj.show();
                        } catch (error) {}
                        try {
                            if(typeof position === 'object'){
                                $(".fzkb_container").css({
                                    "top": position.top? position.top + "px" : 'auto',
                                    "right": position.right? position.right + "px" : 'auto',
                                    "bottom": position.bottom? position.bottom + "px" : 'auto',
                                    "left": position.left? position.left + "px" : 'auto'
                                });
                            }
                        } catch (error) {}
                    },
                    hide: function() {
                        try {
                            typeof eventsobj.hide === 'function' && eventsobj.hide();
                        } catch (error) {}
                    },
                    inputChat: function() {
                        try {
                            typeof eventsobj.inputChat === 'function' && eventsobj.inputChat();
                        } catch (error) {}
                    },
                    deleteChat: function(res) {
                        try {
                            typeof eventsobj.deleteChat === 'function' && eventsobj.deleteChat();
                        } catch (error) {}
                    },
                    inputComplet: function(res) {
                        try {
                            typeof eventsobj.inputComplet === 'function' && eventsobj.inputComplet();
                        } catch (error) {}
                    },
                    error: function(res) {
                        try {
                            typeof eventsobj.error === 'function' && eventsobj.error();
                        } catch (error) {}
                    }
                }
            };
            if (custom) {
                $.extend(option, custom);
            }
            kb = new FzKeyboard("#" + selector, option);
        }, function(){
            try {
                typeof eventsobj.error === 'function' && eventsobj.error();
            } catch (error) {}
        })
    }
    function loadScript(src, callback) {
        var script = document.createElement('script');
        script.type = "text/javascript";
        if(script.readyState){
            script.onreadystatechange = function(){
                if(script.readyState == "complete" || script.readyState == "loaded"){
                    callback();
                }
            }
        }else{
            script.onload = function(){
                callback();
            }
        }
        script.src = src;
        document.body.appendChild(script);
    }
}

/**
    调用前提必须加bundle.js
    用于显示生僻字
    selector 必填，选择器数组eg，['.class1','.class2']
    custom 非必填，自定义配置对象，用于只加载标签内的生僻字等eg:{onlyUncc:true}
    eventsobj 非必填，自定义事件对象eg: {
        beforeLoad:生僻字加载前事件
        loading:生僻字加载中事件
        loaded:生僻字加载完成事件
        onError:生僻字加载失败事件
        loadStyle:生僻字加载成功返回样式数据事件
    }
**/
function fzWordShow(selector, custom, eventsobj) {
    try {
        if (!selector || !spzBrowserFlag()) return;
        var spzStrFlag = false;
        for (var i = 0; i < selector.length; i++) {
            var elval = $(selector[i]).text() || $(selector[i]).val();
            if (elval && judgeIsCommonWordTxm(elval)) {
                spzStrFlag = true;
                break;
            }
        }
        if (!spzStrFlag) return;
    } catch (error) {}

    if(typeof eventsobj != 'object') eventsobj = {};
    fzToken(function(){
        var fzConfig = top.window.fzConfig;
        var option = {
            "domainUrl": fzConfig.domainUrl,
            "contextPath": fzConfig.contextPath,
            "tid": fzConfig.tid,
            "token": fzConfig.token,
            "onlyUncc": false,
            events: {
                beforeLoad: function() {
                    try {
                        typeof eventsobj.beforeLoad === 'function' && eventsobj.beforeLoad();
                    } catch (error) {}
                },
                loading: function() {
                    try {
                        typeof eventsobj.loading === 'function' && eventsobj.loading();
                    } catch (error) {}
                },
                loaded: function() {
                    try {
                        typeof eventsobj.loaded === 'function' && eventsobj.loaded();
                    } catch (error) {}
                },
                onError: function() {
                    try {
                        typeof eventsobj.onError === 'function' && eventsobj.onError();
                    } catch (error) {}
                },
                loadStyle: function(res) {
                    try {
                        typeof eventsobj.loadStyle === 'function' && eventsobj.loadStyle();
                    } catch (error) {}
                }
            }
        };
        if (custom) {
            $.extend(option, custom);
        }
        window.fzUWS = new UncommonWordShow(selector, option);
    }, function(){
        try {
            typeof eventsobj.onError === 'function' && eventsobj.onError();
        } catch (error) {}
    })
};

/**
    获取方正token
**/
function fzToken(successCB, failCB) {
    if (top.window.fzConfig) {
        typeof successCB === "function" && successCB();
        return;
    }
    var fzConfig = {
        domainUrl: top.window.fzDomainUrl || 'https://rccis.ccb.com',
        contextPath: 'srf'
    };
    
    $.ajax({
        url: fzConfig.domainUrl + '/token?channel=CCVEP&txcode=CCVHB0901',
        type: 'get',
        dataType: 'jsonp',
        contentType: "application/json",
        crossDomain: true == !(document.all),
        success: function(data) {
            if(data.code == "0000") {
                fzConfig.token = data.token;
                fzConfig.tid = data.tid;

                top.window.fzConfig = fzConfig;
                typeof successCB === "function" && successCB();
            }else{
                typeof failCB === "function" && failCB();
            }
        },
        error: function(){
            typeof failCB === "function" && failCB();
        }
    });
}

/**
    原生title属性无法显示生僻字
    目前方案，去掉对应的title属性
**/
function fzRemoveTitle() {
    return null;
}

/**
    ajax数据需要调用
**/
function fzRefresh() {
    if (window.fzUWS) {
	    window.fzUWS.refresh();
	}
}

function spzBrowserFlag() {
    var Browser_Agent = navigator.userAgent.toLowerCase();
    if ((Browser_Agent.indexOf("msie 8.0") != -1) || (Browser_Agent.indexOf("msie 9.0") != -1)) {
        return false;
    }
    return true;
}
/**
 * 判断是否包含生僻字
 * @param {*} String 传入的字符
 * @return {*} Boolean 返回布尔值 ture: 包含生僻字  false: 不包含生僻字
 */
function judgeIsCommonWordTxm(str) {
    // 过滤特殊字符
    function filterChar(str) {
      var Fa = /^[\s]+|[\s]+|&nbsp;|\u3000+/gi;
      var Ga = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
      var ka = "".trim;
      var xa = ka && !ka.call("\ufeff\u00a0") ?
        function (b) {
          return null == b ? "" : ka.call(b)
        } : function (b) {
        return null == b ? "" : (b + "").replace(Ga, "")
      };
  
      var reg = /[\u0020-\u273D\u3001-\u3129\u338E-\u33D5\u4DC0-\u4DFF\uFE10-\uFFE5]+/g; //除生僻字外的字符区间
      //去掉无用的字符
      str = str.replace(Fa, "");
      //空格
      str = xa(str);
      str = str.replace(/\s+/gi,"");
      str = str.replace(/^\s+&/gi,"");
      str = str.replace(reg,"");
      
      return str;
    }
  
    // 文字去重
    function unique(arr) {         
      var arr2 = [];
      for (var i = 0; i < arr.length; i++) {
        if (arr2.length) {
          if (findInArr(arr[i])) {
            arr2.push(arr[i]);
          }
        } else {
          arr2.push(arr[i]);
        } 
      }
      function findInArr(str) {    
        for (var j = 0; j < arr2.length; j++) {
          if (str == arr2[j]) {
            return false;
          }
        }
        return true;  
      }
      
      return arr2;
    };
  
    // 过滤除生僻字以外的汉字,字母数字,字符(包含半角和全角时的字符);
    function filterAllGBKWord(arr){
      var reg = /[\u4E00-\u9FA5]+/g;
      var str = arr.join("");
      str = str.replace(reg,"");
  
      return strToArr(str);
    }
  
    // 汉字字符串转化成数组
    function strToArr(char) {
      var arr = [];
      for (var i = 0; i < char.length; i++) {   
        var str = parseInt(char.charCodeAt(i), 10).toString(16);
        if (str >= 'd800' && str <= 'dbff') {
          arr.push(char.charAt(i)+char.charAt(i+1));
          i++;
        } else {
          arr.push(char.charAt(i));
        }
      }
      return arr;
    };
  
    var chars = filterChar(str); // 过滤特殊字符
    var charsArr = strToArr(chars); // 字符转数组
    charsArr = unique(charsArr); // 数组去重
    var uncommonWordArr = filterAllGBKWord(charsArr); // 获取生僻字的数组
  
    return uncommonWordArr.length > 0 ? true : false
}