/**
 * 2021-03-02 增加无外观签名
 * 2021-05-26 增加在线打开URL文件
 * */
var NetcaUtils = (function(){

    'use strict';
    var that = {};

    /**判断当前是否手动盖章界面*/
    that.isUserManualSignUI = function () {
        if ($('.netcasignpdf').length) {
            return true;
        }
        return false;
    };

    /**转换成pdf.js能直接解析的Uint8Array类型*/
    that.convertDataURIToBinary = function(dataURI){
        var raw = window.atob(dataURI);
        var rawLength = raw.length;
        var array = new Uint8Array(new ArrayBuffer(rawLength));
        for (var i = 0; i < rawLength; i++) {
            array[i] = raw.charCodeAt(i) & 0xff;
        }
        return array;
    };
    /**Uint8Array转为base64*/
    that.arrayBufferToBase64 =function(buffer) {
        var binary = '';
        var bytes = new Uint8Array(buffer);
        for (var len = bytes.byteLength, i = 0; i < len; i++) {
            binary += String.fromCharCode(bytes[i]);
        }
        return window.btoa(binary);
    };
    return that;
})();


var NetcaSignAPI = (function(){
    'use strict';
    var that = {
        VerifyInfos: null //验证信息
    };
    var isOnlineverifyrevoke = null;
    var click_x = null;
    var click_y = null;
    var sealImage_halfWidth = null;
    var sealImage_halfheight = null;
    var sealImageSrc = null;
    var certEncode = null;
    var originImage_width = null;
    var originImage_height = null;
    var tagObj = {
        width: '', //签章图片宽度
        height: '' //签章图片高度
    };
    var timeStamp = {
        tsaUrl: '', //时间戳地址
        tsaUsr: '', //时间戳服务对应用户名
        tsaPwd: '',//时间戳服务对应用户的密码
        tsaHashAlgo: ''
    };
    var revInfoIncludeFlag = null; //是否包含吊销信息
    var isVerifyRevoke = null;//是否获取吊销信息
    var verifyLevel = null; //验证级别
    var signFields = []; //签名域信息
    var isDisplayVerifyTips = null;
    var isVerifyOpen = false; //初次进入页面，是否开启在线自动验证文档有效性
    var isVerifyOpenWithOpenBtn = null; //使用打开按钮时，是否开启在线自动验证文档有效性
    var filedFlag = false; //判断是否为刚签完的章
    var zoom = false; //缩放
    var completedStreamId; //已签数据流信息
    var unfinishedStreamId; //未完成数据流信息
    var bigFileSize = 20; //大文件
    var writeLength = 10; //写入文件大小

    that.initUI = function(){

        if(NetcaUtils.isUserManualSignUI()) {

            // 签章绑定事件
            that.bindSignFn('netcasign');
            that.bindSignFn('connect');
            that.bindSignFn('batchsign');
            that.bindSignFn('pagingsign');

            // 显示签章菜单背景色
            that.transBackground('netcasign');
            that.transBackground('batchsign');
            that.transBackground('pagingsign');


            // toorbar 签章按钮
            $('#sign').click(function(){

                if($('.netcasignmenu').css('display') === 'none') {
                    $('.netcasignmenu').css('display','block');
                } else if($('.netcasignmenu').css('display') === 'block') {
                    $('.netcasignmenu').css('display','none');
                }
            });

            /// 签章菜单  hover
            for(var k=0; k<$('.netcasignmemuitem').length;k++) {
                (function(k){
                    $('.netcasignmemuitem').eq(k).hover(function(){
                        $(this).children('ul').css('display','block');
                        $(this).css('background','#DBECFF');
                    },function(){
                        $(this).children('ul').css('display','none');
                        $(this).css('background','#fff');
                    });
                })(k)
            }

            /**选中option，缩放pdf*/
            that.zoomPDFBySelectOptionScale();

            //绑定事件
            document.getElementById('verify').addEventListener('click',function(){
                that.isLoading();
                isDisplayVerifyTips = true;
                if(that.isBigFile(NetcaPDFSeal.SetPDFBytes)){
                    that.signedDataVerify('','',verifyLevel,isOnlineverifyrevoke, unfinishedStreamId)
                } else {
                    that.signedDataVerify('',NetcaPDFSeal.SetPDFBytes,verifyLevel,isOnlineverifyrevoke)
                }
            });

            document.getElementById('print').addEventListener('click',that.printPDF);
            document.getElementById('netcainvalidClose').addEventListener('click', function(){that.closeSignedDataVerifyInfo('netcainvalidClose')});
            document.getElementById('netcaclose2').addEventListener('click', function(){that.closeSignedDataVerifyInfo('netcaclose2')});
            document.getElementById('netcainvalidBtn').addEventListener('click', that.displaySignedDataVerifyInfo);
            document.getElementById('zoomIn').addEventListener('click', that.zoomPDF);
            document.getElementById('zoomOut').addEventListener('click', that.zoomPDF);
            document.getElementById('closeFile').addEventListener('click', that.closeFile);

            // 控件显示
            $('#netcasignpdf').css('display','block');
            $('#NetcaReaderAx').css('display','none');

            //打开按钮
            $('#openFile input[type="file"]').on('change', function(ev){
                var file = ev.target.files[0];
                that.openFile(file);
            });

        }
    };
    // 缩放PDF
    that.zoomPDF = function(){
        zoom = true;
        that.getSignatureFieldInfo(NetcaPDFSeal.SetPDFBytes, unfinishedStreamId);
    };
    /**获取证书列表*/
    that.getCertList = function(e){

        if($('.netcasignmenu').css('display') === 'block'){
            $('.netcasignmenu').css('display','none');
        }

        var clickTargetId = e.target.parentNode.parentNode.getAttribute('id'); //员工 机构 法人
        var clickTargetClass = e.target.getAttribute('class'); //普通  批量 骑缝章 切换用户


        // 签章0 批量签章1 骑缝章2 切换用户3   普通签章0 员工签章1 机构签章2 法人签章3
        var signObj = that.signFn(clickTargetId, clickTargetClass);

        var index = that.isLoading();

        if(clickTargetId){
            // 粤商通
            that.selectSealSigntureInfoWithDispaly(signObj, index);
        } else {
            // 标准版
            that.isInsertKey(signObj, index);
        }

    };
    that.signFn = function(targetId, targetClass) {

        var _type , _key;
        switch(targetId) {
            // 员工签章
            case 'netcastaff':
                _type = 1;
                break;
            // 机构签章
            case 'netcaorganization':
                _type = 2;
                break;
            // 法人签章
            case 'netcalegalperson':
                _type = 3;
                break;
            // 普通签章
            default:
                _type = 0;
                break;
        }
        switch(targetClass) {
            // 签章
            case 'netcasign':
                _key = 0;
                break;
            // 批量签章
            case 'batchsign':
                _key = 1;
                break;
            // 骑缝章
            case 'pagingsign':
                _key = 2;
                break;
            // 切换用户
            case 'connect':
                _key = 3;
                break;
        }
        if(_key === 0 || _key === 3){
            // 普通签章
            return {
                signMenu: _type,
                signType:_key,
                batchSignParams: null,
                acrosspageSignParams:null
            }
        } else{
            // 批量签章  骑缝章
            return {
                signMenu: _type,
                signType:_key,
                batchSignParams: {  // 批量签章参数
                    startPageNum: 1,//开始页码
                    endPageNum: globalPDFViewerApplication.pagesCount//结束页码，-1表示最后一页
                },
                acrosspageSignParams:{ // 骑缝章参数
                    startPageNum: 1,//开始页码
                    endPageNum: globalPDFViewerApplication.pagesCount//结束页码，-1表示最后一页
                }
            }
        }
    };
    // 绑定签章按钮初始化功能事件
    that.bindSignFn = function(name){
        var eleName = document.getElementsByClassName(name);
        for(var i=0;i<eleName.length;i++){
            (function(i){
                document.getElementsByClassName(name)[i].addEventListener('click', that.getCertList);
            }(i))
        }
    };
    // 点击 签章 按钮，普通签章，先判断是否插入key
    that.isInsertKey = function(signObj, index) {
        var params = {};
        NetcaPKI.isInsertKey(params)
            .Then(function (res) {
                if (res.insertCount > 0) {
                    that.InsertCallBack(signObj, index);
                }
                else {
                    that.UnInsertCallBack(res, index);
                }
            })
            .Catch(function (res) {
                that.UnInsertCallBack(res, index);

            });
    };
    that.InsertCallBack = function(signObj, index) {
        that.selectSealSigntureInfoWithDispaly(signObj, index)
    };
    that.UnInsertCallBack = function(res, index) {
        layer.close(index);
        if(!res.insertCount){
            alert('找不到签名证书，请检查设备是否连接正确')
        }
    };
    // 点击签章按钮，弹出证书选择框
    that.selectSealSigntureInfoWithDispaly = function(signObj, index){

        var params = {
            signMenu: signObj.signMenu,
            signType: signObj.signType,
            batchSignParams: signObj.batchSignParams,
            acrosspageSignParams: signObj.acrosspageSignParams
        };
        NetcaPKI.SelectSealSigntureInfoWithDispaly(params)
            .Then(function(res) {
                NetcaSignAPI.selectSealSigntureInfoWithDispalySuccessCallBack(res, signObj,index);
            })
            .Catch(function(res) {
                NetcaSignAPI.selectSealSigntureInfoWithDispalyFailCallBack(res, index)
            });

    };
    that.selectSealSigntureInfoWithDispalySuccessCallBack = function(res, signObj,index) {

        certEncode = res.cert; //证书编码
        tagObj.width = res.width; //印章宽度
        tagObj.height = res.height; //印章高度
        sealImageSrc = res.picture; //印章编码
        if(signObj.acrosspageSignParams || signObj.batchSignParams){
            signObj.acrosspageSignParams.startPageNum = res.acrosspageSignParams.startPageNum;
            signObj.acrosspageSignParams.endPageNum = res.acrosspageSignParams.endPageNum;
            signObj.batchSignParams.startPageNum = res.batchSignParams.startPageNum;
            signObj.batchSignParams.endPageNum = res.batchSignParams.endPageNum;
        }
        // 无外观签名
        if(res.type === 2){
            that.seal_SignSealPosition(-1, res.type);
            return;
        }
        that.setSignImageSize();
        that.signImageMoveEvent(signObj, res.type);
        layer.close(index);
    };
    that.selectSealSigntureInfoWithDispalyFailCallBack = function(res, index) {
        layer.close(index);
        alert(res.msg);
    };

    /**
     设置跟随鼠标移动的图片大小
     图像的像素宽度为 originImage_width，水平分辨率为 72 点/英寸
     如果调用此方法在分辨率为 96 点/英寸的设备上绘制该图像，则所呈现图像的像素宽度就是： (originImage_width/72)*96
     * */
    that.setSignImageSize = function(){

        var val = that.getScale();//缩放比例
        var scale = 0.75;//当前缩放比例
        $('#NetcaSignMoveImage').width(tagObj.width);
        $('#NetcaSignMoveImage').height(tagObj.height);
        $('#NetcaSignMoveImage').attr('src',"data:image/PNG;base64," + sealImageSrc);

        originImage_width = $('#NetcaSignMoveImage').width();
        var w = (originImage_width * val)/ scale;
        $('.NetcaSignMoveDiv').width(w);

        originImage_height = $('#NetcaSignMoveImage').height();
        var h = (originImage_height * val)/ scale;
        $('.NetcaSignMoveDiv').height(h);

        $('#NetcaSignMoveImage').css({
            'width':'100%',
            'height':'100%'
        });

        sealImage_halfWidth = parseInt($('.NetcaSignMoveDiv').width()) / 2;
        sealImage_halfheight = parseInt($('.NetcaSignMoveDiv').height()) / 2;

    };
    /**鼠标移动签章图片事件 mousemove*/
    that.signImageMoveEvent = function(signObj, type){

        $(document).mousemove(function(event){
            var ev = event || window.event;
            /**position left和top 设置鼠标位于图片中央*/
            $('.NetcaSignMoveDiv').css({
                'display':'block',
                'left':ev.clientX - sealImage_halfWidth + 'px',
                'top':ev.clientY - sealImage_halfheight +'px'
            })
        });


        $(document).mousedown(function(){
            that.netcaPDFClickEvent(signObj, type)
        });

        $(document).mouseup(function(){
            $(document).unbind('mousedown');
            $(document).unbind('mousemove');
        });
        /**点击右键  取消签章*/
        $(document).bind('contextmenu', function(){
            that.hideSignImage();
            $('#viewer').unbind('click');
            return false;
        });

    };
    // 打开文件
    that.openPDF = function(base64Val) {

        if(that.isBigFile(base64Val)){
            // 重新打开时  删除旧的streamId,保存新的streamId
            if(unfinishedStreamId){
                that.destoryStreamCallBack(unfinishedStreamId)
            }
            unfinishedStreamId = completedStreamId;
        } else {
            unfinishedStreamId = null;
            completedStreamId = null;
        }

        // 渲染入口
        var Bytes = NetcaUtils.convertDataURIToBinary(base64Val);
        globalPDFViewerApplication.open(Bytes);
    };

    that.isLoading = function() {
        var loading = layer.load(1, {
            shade: [0.1,'#000'] //0.1透明度的白色背景
        });
        return loading
    };
    // 打开按钮
    that.openFile = function(file){
        isVerifyOpen = isVerifyOpenWithOpenBtn;//打开按钮，文档加载时是否自动验证文档有效性
        that.isLoading();
        var reader = new FileReader();
        reader.readAsDataURL(file);

        reader.onload = function (){
            var result = reader.result.split(',')[1];
            NetcaPDFSeal.setPDFBytes(result);
            that.openPDF(result);
            if(that.isBigFile(result)){
                var params = {srcBytes: result};
                that.createStreamCallBack(params);
            } else {
                that.getSignatureFieldInfo(NetcaPDFSeal.SetPDFBytes);//小文件
            }
        };

        // 验证提示隐藏
        $('#netcasignedDataVerify').css('display', 'none');
        $('#netcaDisplaySignedDataVerify').css('display', 'none');
        $('#viewerContainer').css('margin-top', '0');
    };
    //高度累加,计算纵坐标
    that.addHeight = function(n){

        var result = 0;
        while(n >= 2) {
           var _height = $('#viewer .page').eq(n-2).height() + 11;
           result += _height;
           n--;
        }
        return result;
    };
    // viewer点击事件
    that.netcaPDFClickEvent = function(signObj, type){

        var pdfviewer = document.getElementById('netcasignpdf');
        var pdfviewerL = pdfviewer.offsetLeft;
        var pdfviewerT = pdfviewer.offsetTop;

        var flag = 2;
        var pageNum = globalPDFViewerApplication.page;//当前页码
        // 前n-1页 高度
        var _height = 0;
        if(pageNum > 1){
            _height = that.addHeight(pageNum);
        }
        $('#viewer').click(function(e){
            flag--;
            /**鼠标点击的位置，相对于文档的左边缘/上边缘*/
            var client_x = e.clientX;
            var client_y = e.clientY;

            var viewer_width = $('#viewer').width();
            var blank_top = $('#toolbarViewer').height() + 9;
            var pdfscrollTop = $('#viewerContainer').scrollTop(); //文档滚动高度

            //验证提示信息的高度
            if($('#netcasignedDataVerify').css('display') === 'block'){
                blank_top = blank_top + $('#netcasignedDataVerify').outerHeight();
            }

            var clicky_temp = client_y - blank_top + pdfscrollTop - pdfviewerT;
            click_y = clicky_temp - _height;

            var page_width = $('#viewer .page').eq(pageNum-1).width();
            var blank_left = (viewer_width - page_width) / 2;
            var clickx_temp =  client_x - pdfviewerL;
            click_x = clickx_temp - blank_left;

            //假如显示第1页，签第2页的位置
            var currentPageHeight = that.addHeight(pageNum + 1);
            if(currentPageHeight < clicky_temp){
                pageNum = pageNum + 1;
                that.calculateCurrentHeightAgain(pageNum, clickx_temp, clicky_temp, viewer_width);
            }

            // 假如显示第2页，签第1页页尾位置
            if(click_y<0){
                //计算负数  重算高度  宽度
                pageNum = pageNum -1;
                that.calculateCurrentHeightAgain(pageNum, clickx_temp, clicky_temp, viewer_width);
            }

            if(flag>0){
                /**每次点击只触发一次签章 超出文档左右界线不能点击签章*/
                if(click_x>0 && (viewer_width - click_x - blank_left) >= blank_left){
                    that.isLoading();
                    if(signObj.signType === 1 || signObj.signType === 2) {
                        // 批量签章  骑缝章
                        that.Seal_signatureCreatorBatchOrAcrossPage(signObj, pageNum, type)
                    } else {
                        // 签章函数
                        that.seal_SignSealPosition(pageNum, type)
                    }
                } else {
                    that.hideSignImage();
                    alert('不在签章范围内')
                }
            }
        })
    };
    that.calculateCurrentHeightAgain = function(pageNum, clickx_temp, clicky_temp, viewer_width){
        var _height;
        if(pageNum > 1){
            _height = that.addHeight(pageNum);
        } else {
            _height = 0;
        }
        click_y = clicky_temp - _height;

        var page_width = $('#viewer .page').eq(pageNum-1).width();
        var blank_left = (viewer_width - page_width) / 2;
        click_x = clickx_temp - blank_left;
    };
    that.seal_SignSealPositionForBigFileWriteCallBack = function(signParams)
	 {
         signParams.srcBytes = '';
         signParams.srcStreamId = streamId; //streamId 全局变量

         NetcaPKI.SignatureCreatorPdfSignSealFieldOrPosition(signParams)
             .Then(function (res) {
                 that.SignatureCreatorSuccessCallBack(res);
             })
             .Catch(function (res) {
                 that.SignatureCreatorFailedCallBack(res);
             });
	 };

     that.seal_SignSealPositionForBigFile = function(signParams) {

         that.seal_SignSealPositionForBigFileWriteCallBack(signParams);
	 };

    that.seal_SignSealPosition = function(_pageNum, _type) {

        var newscale = that.getScale();//缩放比例
        var scale = 0.75; // 75% 对应72dpi; 如果不是75%缩放比例，需要对应转换为72dpi的坐标大小
        var _xPos = parseInt((scale / newscale)*(click_x - sealImage_halfWidth));//签名域/签章左下角的水平向右方向坐标
        var _yPos = parseInt((scale / newscale)*(click_y - sealImage_halfheight));//签名域/签章左下角的垂直向上方向坐标

        var params = {
            srcFile: '',                      //源pdf文件
            srcBytes: NetcaPDFSeal.SetPDFBytes,                    //源Pdf文件的Base64编码
            destFile: '',                    //目标pdf文件
            certEncode: certEncode,                //签名证书Base64编码
            selMode: 1,                      //操作模式
            signFieldText: '',          //签名域显示的文字
            sealImageEncode: sealImageSrc,      //签章图片Base64编码
            revInfoIncludeFlag: revInfoIncludeFlag,//是否包含吊销信息
            SignPosition:                           //签名位置对象
                {
                    pageNum: _pageNum,                  //PDF文档的页码
                    xPos: _xPos,                        //签名域/签章左下角的水平向右方向坐标
                    yPos: _yPos,                        //签名域/签章左下角的垂直向上方向坐标
                    width: parseInt(originImage_width),                      //签名域/签章的宽度
                    height: parseInt(originImage_height)                    //签名域/签章的高度
                },
            Tsa:                                    //时间戳对象
                {
                    tsaUrl: timeStamp.tsaUrl,                    //时间戳地址
                    tsaUsr: timeStamp.tsaUsr,                    //时间戳服务对应用户名
                    tsaPwd: timeStamp.tsaPwd,                    //时间戳服务对应用户的密码
                    tsaHashAlgo: timeStamp.tsaHashAlgo           //时间戳使用的hash算法，例如”sha-1”，”sha-256”等
                },
            synVerify: true, //签完名之后同步验证文档
            synGetSignFiled: true, //签完名之后同步获取签名域
            level: verifyLevel, //验证级别
            onlineVerifyRevok: isOnlineverifyrevoke //是否在线验证吊销信息

        };

        if(_type === 2){
            //无外观签名
            params.sealImageEncode = null;
            params.SignPosition =
            {
                pageNum:-1,
                xPos:0,
                yPos:0,
                width:0,
                height:0
            };
            params.visible=false;
        }

		if(that.isBigFile(params.srcBytes))
        {
            params.srcBytes = '';
            params.srcStreamId = unfinishedStreamId;
            params.isReturnStreamId = true;
        }

        NetcaPKI.SignatureCreatorPdfSignSealFieldOrPosition(params)
            .Then(function (res) {
                filedFlag = true;//开启刚签完的章能撤章
                that.SignatureCreatorSuccessCallBack(res);
            })
            .Catch(function (res) {
                that.SignatureCreatorFailedCallBack(res);
            });

    };
    /**批量签章或骑缝章 要求文件没有做过电子签章/签名*/
    that.Seal_signatureCreatorBatchOrAcrossPage = function(signObj, _pageNum, _type){
        //var page = _pageNum;//当前页码
        var newscale = that.getScale();//缩放比例
        var scale = 0.75; // 75% 对应72dpi; 如果不是75%缩放比例，需要对应转换为72dpi的坐标大小
        var _xPos = parseInt((scale / newscale)*(click_x - sealImage_halfWidth));//签名域/签章左下角的水平向右方向坐标
        var _yPos = parseInt((scale / newscale)*(click_y - sealImage_halfheight));//签名域/签章左下角的垂直向上方向坐标
        //Tsa对象说明
        var Tsa = {
            tsaUrl: timeStamp.tsaUrl,      //时间戳地址
            tsaUsr: timeStamp.tsaUsr,       //时间戳服务对应用户名
            tsaPwd: timeStamp.tsaPwd,        //时间戳服务对应用户的密码
            tsaHashAlgo: timeStamp.tsaHashAlgo
        };
        //批量签章
        if(signObj.signType === 1){
            //batchSeal对象说明
            var batchSeal = {
                signaturePage: signObj.batchSignParams.startPageNum, //电子签章所在页码，目前仅支持批量签章开始页或结束页
                xPos: _xPos,                         //签名域/签章左下角的水平向右方向坐标
                yPos: _yPos,                         //签名域/签章左下角的垂直向上方向坐标
                width: parseInt(originImage_width),
                height: parseInt(originImage_height),
                startPage: signObj.batchSignParams.startPageNum,   // 从开始页计算，第n页：例如：1为第一页；
                endPage: signObj.batchSignParams.endPageNum       //从最尾页计算，最后第n页：例如：-1为最后一页
            };
            var params = {
                srcBytes : NetcaPDFSeal.SetPDFBytes,                 //目标pdf文件
                certEncode : certEncode,                //签名证书Base64编码
                sealImageEncode : sealImageSrc,                      //签章图片Base64编码
                revInfoIncludeFlag : revInfoIncludeFlag,//是否包含吊销信息
                batchSeal: batchSeal,                                //batchSeal对象说明
                Tsa: Tsa,                                             //Tsa对象说明
                synVerify: true, //签完名之后同步验证文档
                synGetSignFiled: true, //签完名之后同步获取签名域
                level: verifyLevel, //验证级别
                onlineVerifyRevok: isOnlineverifyrevoke //是否在线验证吊销信息

            };

            if(that.isBigFile(params.srcBytes)) {
                params.srcBytes = '';
                params.srcStreamId = unfinishedStreamId;
                params.isReturnStreamId = true;
            }

            NetcaPKI.signatureCreatorBatchSeal(params)
                .Then(function(res){
                    NetcaSignAPI.SignatureCreatorSuccessCallBack(res)
                })
                .Catch(function(res){
                    NetcaSignAPI.SignatureCreatorFailedCallBack(res)
                })
        }
        //骑缝章
        if(signObj.signType === 2){
            //acrossPageSeal对象说明
            var acrossPageSeal = {
                signaturePage: signObj.acrosspageSignParams.startPageNum, //电子签章所在页码，目前仅支持批量签章开始页或结束页
                xPos: _xPos,                         //签名域/签章左下角的水平向右方向坐标
                yPos: _yPos,                         //签名域/签章左下角的垂直向上方向坐标
                width: parseInt(originImage_width),
                height: parseInt(originImage_height),
                startPage: signObj.acrosspageSignParams.startPageNum,     // 从开始页计算，第n页：例如：1为第一页；
                endPage: signObj.acrosspageSignParams.endPageNum       //从最尾页计算，最后第n页：例如：-1为最后一页
            };
            var params = {
                srcBytes : NetcaPDFSeal.SetPDFBytes,                 //目标pdf文件
                certEncode : certEncode,                //签名证书Base64编码
                sealImageEncode : sealImageSrc,                      //签章图片Base64编码
                revInfoIncludeFlag : revInfoIncludeFlag,//是否包含吊销信息
                acrossPageSeal: acrossPageSeal,                                //batchSeal对象说明
                Tsa: Tsa,                                             //Tsa对象说明
                synVerify: true, //签完名之后同步验证文档
                synGetSignFiled: true, //签完名之后同步获取签名域
                level: verifyLevel, //验证级别
                onlineVerifyRevok: isOnlineverifyrevoke //是否在线验证吊销信息

            };

            if(that.isBigFile(params.srcBytes)) {
                params.srcBytes = '';
                params.srcStreamId = unfinishedStreamId;
                params.isReturnStreamId = true;
            }

            NetcaPKI.signatureCreatorAcrossPageSeal(params)
                .Then(function(res){
                    NetcaSignAPI.SignatureCreatorSuccessCallBack(res)
                })
                .Catch(function(res){
                    NetcaSignAPI.SignatureCreatorFailedCallBack(res)
                })
        }
    };


	 that.SignatureCreatorSuccessReadStreamUpdateCallBack = function(res, signSuccessRes,index)
	 {

            completedStreamId = res.streamId;
		    signSuccessRes.destFileEncode=signSuccessRes.destFileEncode+res.data;
		    if(!res.hasMoreData)
			{
                that.SignatureCreatorCallBack(signSuccessRes, res.streamId);
				return;
			}
			var params = {
				streamId: res.streamId,
				length: writeLength*1024*1024
			};


		 NetcaPKI.readStream(params)
            .Then(function (res) {
                that.SignatureCreatorSuccessReadStreamUpdateCallBack(res, signSuccessRes);
            })
            .Catch(function (res) {
                that.SignatureCreatorFailedCallBack(res, index);
            });


	 };

	 that.SignatureCreatorSuccessReadStreamCallBack = function(signSuccessRes)
	 {
        completedStreamId = signSuccessRes.destFileStream.streamId;
		signSuccessRes.destFileEncode='';
		var params = {
			streamId: signSuccessRes.destFileStream.streamId,
			length: writeLength*1024*1024
		};


		 NetcaPKI.readStream(params)
            .Then(function (res) {
                that.SignatureCreatorSuccessReadStreamUpdateCallBack(res, signSuccessRes);
            })
            .Catch(function (res) {
                that.SignatureCreatorFailedCallBack(res);
            });


	 };

    // 签章成功回调
    that.SignatureCreatorSuccessCallBack = function(res){

        var streamId;
        if(res.destFileStream){
            streamId = res.destFileStream.streamId;
        }

        //大文件
		if(res.destFileEncode == null ||res.destFileEncode.length ==0 )
		{

            that.SignatureCreatorSuccessReadStreamCallBack(res);
			return;

		}

        that.SignatureCreatorCallBack(res, streamId)

    };
    // 签章成功回调
    that.SignatureCreatorCallBack = function(res, streamId){


        that.resetOriginalState(res.destFileEncode);
        that.SignatureCallBack(res, streamId);
        NetcaPDFSeal.setPDFBytes(res.destFileEncode);

        alert('签名/章成功');

        var interval = setInterval(function(){
            if (globalPDFViewerApplication.pdfDocument == null) {
                console.info('Loading...');
            } else {

                if($('#viewer .page').length>0){
                    console.info('Load Success...');
                    clearInterval(interval);
                    that.describeSignatureField(); //描绘签名域
                    that.createRevokeEvent(streamId); //撤章事件
                }
            }
        }, 1000);

        certEncode = null;
        sealImageSrc = null;
        if(that.signCallbackEvent != null)
        {
            that.signCallbackEvent(JSON.stringify(res))
        }
    };
    that.SignatureCallBack = function(res){

        signFields = res.signFields; //签名域信息
        that.VerifyInfos = res.VerifyInfos; //验证信息


        that.displaySignedDataVerifyTip( res.VerifyInfos); // toobar下验证提示信息
        that.createSignedDataVerifyInfo(); // 创建左边 签名状态  每个签名信息
        that.displayCert(); // 显示证书信息
        that.displayInfoFeild(); // 每个签名信息伸展或收缩显示


        layer.closeAll('loading');

    };
    //创建数据流
    that.createStreamCallBack = function(signParams){

        var params = {
            length: signParams.srcBytes.length
        };

        NetcaPKI.createStream(params)
            .Then(function (res) {
                unfinishedStreamId = res.streamId;
                that.writeStreamCallBack(res, signParams)

            })
            .Catch(function (res) {

                layer.closeAll('loading');
                alert(res.msg);

            });

    };
    // 写入数据流
    that.writeStreamCallBack = function(res, signParams) {

        //写入数据完成
        if( res.streamWritePos >= signParams.srcBytes.length ) {


            that.getSignatureFieldInfo('', res.streamId);
            return;

        }
        var params = {
            streamId:res.streamId,
            data:signParams.srcBytes.substr(res.streamWritePos,writeLength*1024*1024)
        };

        NetcaPKI.writeStream(params)
            .Then(function (res) {
                that.writeStreamCallBack(res, signParams);
            })
            .Catch(function (res) {
                layer.closeAll('loading');
                alert(res.msg);
            });

    };
    //读取数据流
    that.readStreamCallBack = function() {

        //10M
        var params = {
            streamId: stream.streamId,
            length: writeLength*1024*1024
        };

        NetcaPKI.readStream(params)
            .Then(function (res) {
                that.readStreamUpdateCallBack(res)
            })
            .Catch(function (res) {
                alert(res.msg)
            });

    };
    that.readStreamUpdateCallBack = function(res) {

        NetcaPDFSeal.SetPDFBytes += res.data;
    };
    // 销毁数据流
    that.destoryStreamCallBack = function(id){
        var params = {
            streamId: id
        };
        NetcaPKI.destoryStream(params)
            .Then(function (res) {
               // console.log('销毁数据成功')
            })
            .Catch(function (res) {
                alert(res.msg)
            });
    };
    //  大文件 与 小文件 处理方式划分
    that.isBigFile = function(srcBytes){
        if (srcBytes != null && srcBytes.length >  bigFileSize*1024 * 1024)
        {
            return true;
        } else {
            return false;
        }
    };

    // 签章失败回调
    that.SignatureCreatorFailedCallBack = function(res){

        that.hideSignImage();
        alert("签名/章失败 " + res.msg);
        if(that.signCallbackEvent != null)
        {
           that.signCallbackEvent(JSON.stringify(res))
        }
        layer.closeAll('loading');
    };
    /**
     * 隐藏签章图片
     * */
    that.hideSignImage = function(){
        $('.NetcaSignMoveDiv').css({'display':'none'});
    };
    /**
     * 重置状态：关闭layer、签章图片隐藏、展示最新pdf
     * */
    that.resetOriginalState = function(res){
        that.openPDF(res);
        $('#NetcaSignMoveImage').attr('src','');
        that.hideSignImage();

    };
    //获取页面缩放比例
    that.getScale = function(){
        var scale = Number($('#scaleSelect').val());//缩放比例
        /*
           ctrl+鼠标缩放页面时，缩放倍数不是option中预设的，获取到的scale会是0；
           通过globalPDFViewerApplication.getCurrentScale()拿到当前的scale
       * */
        var currentScale = globalPDFViewerApplication.getCurrentScale();
        scale = scale ?scale:currentScale;
        return scale;
    };
    /**
     * 获取签章客户端的配置信息
     * */
    that.getSealConfigInfo = function(OpenPDFBytes) {

        that.isLoading();
        $(".netcafieldInfo").remove(); //先删除旧的签名域
        var params = {};
        NetcaPKI.getSealConfigInfo(params)
            .Then(function(res) {
                that.getSealConfigInfoSuccessCallBack(res, OpenPDFBytes);
            })
            .Catch(function(res) {
                that.getSealConfigInfoFailCallBack(res)
            });

    };
    that.getSealConfigInfoSuccessCallBack = function(res, OpenPDFBytes){

        isVerifyRevoke = res.verify.isVerifyRevoke; //是否验证签名时签名证书的吊销状态
        isOnlineverifyrevoke = res.verify.isOnlineVerifyRevoke;//是否在线获取吊销信息
        verifyLevel = res.verify.verifySignLevel;//验证签名的级别 3：验证签名和证书，并且验证签名证书的吊销状态；但不验证CA证书是否吊销

        revInfoIncludeFlag = res.sign.isRevokeInclude;//签名时是否嵌入吊销状态
        //签名时是否嵌入时间戳
        var isTsaInclude = res.sign.isTsaInclude;
        if(isTsaInclude){
            for(var i=0;i<res.timeStamp.length;i++){
                (function(i){
                    if(res.timeStamp[i].checked){
                        timeStamp.tsaUrl = res.timeStamp[i].url;
                    }
                })(i);
            }
        }

        // 打开文档时是否自动验证签名
        isVerifyOpen = res.verify.isVerifyOpen;
        isVerifyOpenWithOpenBtn = res.verify.isVerifyOpen;

        // 第一次创建数据流  大文件 创建流后再去验证文档
        if(that.isBigFile(OpenPDFBytes)){

            var params = { srcBytes: OpenPDFBytes};
            that.createStreamCallBack(params);

        } else {
            // 获取签名域，再验证
           NetcaSignAPI.getSignatureFieldInfo(OpenPDFBytes);
        }

    };
    /**
     * signatureVerifierVerifyPDF PDF签名文档进行验证
     * */
    that.signedDataVerify = function(_srcFile, _srcBytes, _level, _onlineVerifyRevoke,streamId){

        var params = {
            srcFile: _srcFile,
            srcBytes: _srcBytes,
			srcStreamId: streamId,
            level: _level,
            onlineVerifyRevoke: _onlineVerifyRevoke
        };
        NetcaPKI.signatureVerifierVerifyPDF(params)
            .Then(function (res) {
                that.SuccessSignedDataVerifyCallBack(res);
            })
            .Catch(function (res) {
                that.FailedSignedDataVerifyCallBack(res);
            });
    };
    that.SuccessSignedDataVerifyCallBack = function(res){

        that.VerifyInfos = res.VerifyInfos; // 验证结果
        that.displaySignedDataVerifyTip( res.VerifyInfos); // toobar下验证提示信息
        that.createSignedDataVerifyInfo(); // 创建左边 签名状态  每个签名信息
        that.displayCert(); // 显示证书信息
        that.displayInfoFeild(); // 每个签名信息伸展或收缩显示


        if(that.verifyCallbackEvent !=null){
            that.verifyCallbackEvent(JSON.stringify(res)) //返回验证的对外信息
        }

        layer.closeAll('loading'); //关闭loading
    };
    that.displaySignedDataVerifyTip = function(info){
        if(info.length){
            if($('#netcasignedDataVerify').css('display') === 'none'){
                $('#netcasignedDataVerify').css({
                    "display":'inline-block'
                })
            }
            var status = NetcaPDFSeal.getVerifySignSuccessFlag(info); //根据verifyResult 1成功 2不确定  3失败
            if(status === 0){ //失败
                $('.netcainvalidInfo').text('至少一个签名验证失败，请点击右方 "详细信息" 查询签名的详细验证信息。');
                $('.netcainvalidIcon img').attr('src','ui/images/icon/certicon_invalid.png');
            }else if(status === 1){ //成功
                $('.netcainvalidInfo').text('签名验证成功，请点击右方 "详细信息" 查询签名的详细验证信息。');
                $('.netcainvalidIcon img').attr('src','ui/images/icon/certicon_valid.png');
            }else{ //-1 不确定
                $('.netcainvalidInfo').text('文档内容自签名以来未被篡改，但至少有一个签名的证书验证不通过。请点击右方 "详细信息" 查询签名的详细验证信息。');
                $('.netcainvalidIcon img').attr('src','ui/images/icon/certicon_known.png');
            }
            if($('#netcainvalidBtn').css('display') === 'none'){
                $('#netcainvalidBtn').css({
                    "display":'inline-block'
                })
            }
            if($('#netcaDisplaySignedDataVerify').css('display') === 'block'){
                $('#netcaDisplaySignedDataVerify').css({"top":"117px",'height':'84%'})
            }
            $('#viewerContainer').css({"margin-top":"47px"});
        } else {
            that.notFoundSignature();
        }

    };
    that.FailedSignedDataVerifyCallBack = function(res){

        if(res.status === -2006){
            if(isDisplayVerifyTips){
                that.notFoundSignature();
            } else {
                $('#netcasignedDataVerify').css('display', 'none');
            }
        } else{
            alert('验证签名失败：'+res.msg);
        }
        if(that.verifyCallbackEvent !=null){
            that.verifyCallbackEvent(JSON.stringify(res))
        }

        layer.closeAll('loading');
    };

    that.getSealConfigInfoFailCallBack = function(res){
        layer.closeAll('loading');
        // alert('获取电子签章客户端配置信息失败：' + res.msg);
        $('.modal-background').show();

    };
    // 本文档找不到可验证的签名
    that.notFoundSignature = function() {
        $('.netcainvalidInfo').text('本文档找不到可验证的签名！');
        $('.netcainvalidIcon img').attr('src','');
        $('#netcasignedDataVerify').css('display', 'block');
        $('#netcainvalidBtn').css('display', 'none');
        $('#netcaDisplaySignedDataVerify').css('display', 'none');
        $('#viewerContainer').css({"margin-top":"47px"});
        that.VerifyInfos = null;
        isDisplayVerifyTips = null;
    };
    /**
     * 动态生成 签名验证 具体信息
     * */
    that.createSignedDataVerifyInfo = function(){

        var icon = '';
        var htmlDOM = '';
        //清空节点内容
        $("div").remove(".netcasignDetail");
        for(var i=0;i<that.VerifyInfos.length;i++){
            (function(i){
                // verifyResult  确定签名状态
                if(that.VerifyInfos[i].verifyResult === 3){
                    icon = 'icon_invalid';
                    that.VerifyInfos[i].status1 = "签名无效"
                }else if(that.VerifyInfos[i].verifyResult === 2){
                    icon = 'icon_know';
                    that.VerifyInfos[i].status1 = "签名不确定"
                } else if(that.VerifyInfos[i].verifyResult === 1){
                    icon = 'icon_valid'; //不确定
                    that.VerifyInfos[i].status1 = "签名有效"
                }
                // 验证文档的有效性
                if(that.VerifyInfos[i].fileIntegrityVerfiy === 1){
                    that.VerifyInfos[i].moreInfo = '文档未被更改或损坏';
                    // 签名证书的路径构建
                    if(that.VerifyInfos[i].signCertPathBuild === 1){
                        // console.log('签名证书链完整')
                    } else if(that.VerifyInfos[i].signCertPathBuild === 0){
                        that.VerifyInfos[i].signCertPathBuildText = '签名证书链未构建'
                    } else {//-1
                        that.VerifyInfos[i].signCertPathBuildText = '签名证书链不完整'
                    }
                    // 从配置信息‘验证’，确定是否验证吊销信息
                    if(isVerifyRevoke){
                        // 如果签名本身存在吊销信息
                        if(that.VerifyInfos[i].hasRevoke){
                            that.VerifyInfos[i].isVerifyRevokeText = '已嵌入吊销信息('+ that.VerifyInfos[i].revokeStatus+')'
                        } else{
                            // 如果不存在，进一步确定是否开启在线验证吊销信息
                            if(isOnlineverifyrevoke){
                                that.VerifyInfos[i].isVerifyRevokeText = '在线验证吊销('+ that.VerifyInfos[i].revokeStatus+')'
                            } else{
                                that.VerifyInfos[i].isVerifyRevokeText = '未执行吊销检查'
                            }
                        }
                    }
                    // 是否验证时间戳
                    if(that.VerifyInfos[i].hasTsa){
                        that.VerifyInfos[i].hasTsaText = that.VerifyInfos[i].isTsaValid?'已嵌入时间戳(有效)':'已嵌入时间戳(无效)';
                        if(!that.VerifyInfos[i].isTsaValid){
                            if(that.VerifyInfos[i].tsaCertPathBuild === 0){
                                that.VerifyInfos[i].tsaCertPathBuildText = '时间戳证书链未构建'
                            } else if(that.VerifyInfos[i].tsaCertPathBuild === -1) {
                                that.VerifyInfos[i].tsaCertPathBuildText =  '时间戳证书链不完整'
                            }
                        }
                    }
                } else if(that.VerifyInfos[i].fileIntegrityVerfiy === 0){
                    that.VerifyInfos[i].moreInfo = '文档完整性未验证'
                } else{
                    that.VerifyInfos[i].moreInfo = '文件自签名后被更改或损坏'
                }

                htmlDOM +=
                    '                        <div class="netcasignDetail" name='+that.VerifyInfos[i].fieldName+'>\n' +
                    '                             <span class="btn_fold"><img class="btn_fold_img" src="ui/images/icon/btn_unfold.png"></span>\n' +
                    '                            <span class="netcasubjectCN"><span><img src="ui/images/icon/'+icon+'.png" alt=""></span>'+that.VerifyInfos[i].signerName+'</span>\n' +
                    '                            <div class="netcasignContent">\n' +
                    '                                <div class="netcasignTip"><span>'+that.VerifyInfos[i].status1+'</span> <input type="button" value="详细" class="netcadetailBtn"><input type="hidden" value="'+that.VerifyInfos[i].certEncode+'" class="netcahiddenBtn"></div>\n' +
                    '                                <div class="netcasignTime">\n' +
                    '                                    <p>'+that.VerifyInfos[i].moreInfo+'</p>\n' +
                    '                                    <p>域名:'+that.VerifyInfos[i].fieldName+'</p>\n' +
                    '                                    <p><span> 签名时间:</span><br><span> '+that.VerifyInfos[i].signDate+'</span></p>\n' +
                    '                                    <p class="signCertPathBuildText">'+that.VerifyInfos[i].signCertPathBuildText+'</p>\n' +
                    '                                    <p class="hasTsa"><span> '+that.VerifyInfos[i].hasTsaText+'</span></br><span>'+that.VerifyInfos[i].tsaDate+'</span></p>\n' +
                    '                                    <p class="hasTsaCertPathBuildText">'+that.VerifyInfos[i].tsaCertPathBuildText+'</p>\n' +
                    '                                    <p class="isVerifyRevokeText">'+that.VerifyInfos[i].isVerifyRevokeText+'</p>\n' +
                    '                                </div>\n' +
                    '                            </div>\n' +
                    '                        </div>';
            })(i);
        }
        $('.netcasignInfo').append(htmlDOM);
        var len = $('.hasTsa').length;
        for(var j=0;j<len;j++){
            if(that.VerifyInfos[j].hasTsa === false){
                $('.hasTsa').eq(j).css({"display":'none'})
            }
            if(!that.VerifyInfos[j].tsaCertPathBuildText){
                $('.hasTsaCertPathBuildText').eq(j).css({"display":'none'})
            }
            if(!that.VerifyInfos[j].signCertPathBuildText){
                $('.signCertPathBuildText').eq(j).css({"display":'none'})
            }
            if(!that.VerifyInfos[j].isVerifyRevokeText){
                $('.isVerifyRevokeText').eq(j).css({"display":'none'})
            }
        }

        that.selectCertField(); // 选中签名状态中的某一个签名信息，显示选中的签名域
        htmlDOM = null;
        len = null;

    };
    that.displayCert = function() {
        var arr = document.getElementsByClassName("netcadetailBtn");
        var arr1 = document.getElementsByClassName('netcahiddenBtn');
        var DeviceOutputId = document.getElementById('DeviceOutputId');
        for (var i = 0; i < arr.length; i++) {
            arr[i].index = i;
            var _arr = arr[i];
            _arr.onclick = function () {
                DeviceOutputId.value = arr1[this.index].value;
                that.uIDisplayCert(DeviceOutputId.value);
                _arr = null;
            }
        }
    };
    that.uIDisplayCert = function(val){
        var certEncode = val;
        var selectType = "Device";
        var selectCondition = "InValidity='True' && CertType='Signature'";

        var params = {
            cert: {
                "encode": certEncode,
                "type": selectType,
                "condition": selectCondition
            }
        };
        NetcaPKI.displayCert(params)
            .Then(function(res){
            })
            .Catch(function (res) {
                alert(res.msg);
            });
    };
    /**
     * 签名状态 切换显示
     * */
    that.displayInfoFeild = function() {
        var btn_fold = document.getElementsByClassName("btn_fold");
        for(var i=0;i<btn_fold.length;i++){
            btn_fold[i].index = i;
            var _btn_fold = btn_fold[i];
            _btn_fold.onclick = function () {
                if($('.netcasignTime').eq(this.index).css('display') === 'none'){
                    $('.netcasignTime').eq(this.index).css({"display":"block"});
                    $('.btn_fold_img').eq(this.index).attr('src','/public/netcasign/ui/images/icon/btn_fold.png')
                }else{
                    $('.netcasignTime').eq(this.index).css({"display":"none"});
                    $('.btn_fold_img').eq(this.index).attr('src','/public/netcasign/ui/images/icon/btn_unfold.png')
                }
                _btn_fold = null;
            }
        }
    };
    /***
     * 获取PDF文档的签名域信息
     * */
    that.getSignatureFieldInfo = function(signBytes,streamId){

        if($(".netcafieldInfo").length){
            $(".netcafieldInfo").remove(); //先删除旧的签名域
        }
        var params = {
            srcFile: '',
            srcBytes: signBytes,
			srcStreamId: streamId
        };
        NetcaPKI.getSignatureFieldInfo(params)
            .Then(function (res) {
                that.getSignatureFieldInfoSuccessCallBack(res,streamId);
            })
            .Catch(function (res) {
                that.getSignatureFieldInfoFailedCallBack(res);
            });
    };
    that.getSignatureFieldInfoSuccessCallBack = function(res,streamId){

        signFields = res.signFields; //签名域信息
        that.describeSignatureField(); //描绘签名域
        that.createRevokeEvent(streamId); //撤章事件

        if(!signFields){
            $('#netcasignedDataVerify').css('display', 'none');
            layer.closeAll('loading');
            return;
        }

        // 缩放pdf，只获取签名域，不需要重新验证
        if(zoom){
            zoom = false;
            layer.closeAll('loading');
            return;
        }


        //打开是否马上验证 和签名后 一定验证
        if(!isVerifyOpen){
            isVerifyOpen = true;
            layer.closeAll('loading');
            return;
        }

        if(isVerifyOpen){
            if(streamId){ //大文件验证
                that.signedDataVerify('', '', verifyLevel, isOnlineverifyrevoke, streamId);
            } else { //小文件验证
                that.signedDataVerify('', NetcaPDFSeal.SetPDFBytes, verifyLevel, isOnlineverifyrevoke);
            }
        }

    };
    // 描绘签名域
    that.describeSignatureField = function() {

        if($('.netcafieldInfo').length){
            $('.netcafieldInfo').remove();
        }
        var viewer_width = $('#viewer').width();
        var newscale = that.getScale();//缩放比例
        var scale = 0.75; // 75% 对应72dpi; 如果不是75%缩放比例，需要对应转换为72dpi的坐标大小
        var page_width;
        var _brank;

        if(signFields){
            for(var i=0;i<signFields.length;i++){
                (function(i){

                    page_width = $('#viewer .page').eq(signFields[i].pageNum-1).width();
                    _brank = (viewer_width - page_width) / 2;

                    signFields[i].xPos = signFields[i].xPos * newscale / scale;
                    signFields[i].yPos = signFields[i].yPos * newscale / scale;

                    if(signFields[i].pageNum > 1){
                        var _height = that.addHeight(signFields[i].pageNum);
                        signFields[i].yPos = _height + signFields[i].yPos;
                    }

                    signFields[i].xPos = signFields[i].xPos + parseInt(_brank);
                    signFields[i].width = signFields[i].width * newscale / scale;
                    signFields[i].height = signFields[i].height * newscale / scale;

                    // 签名域
                    $('#viewerContainer').append(' <div class="netcafieldInfo" name='+ signFields[i].name +' style="position:absolute;z-index:99;width:'+signFields[i].width+'px;height:'+signFields[i].height+'px;left:'+signFields[i].xPos+'px;top:'+signFields[i].yPos+'px;"></div>');
                    if(signFields[i].width === 0){
                        $('.netcafieldInfo').eq(i).css({"display":"none"})
                    }
                })(i);
            }

            that.selectSignatureField(); //选中签名域 显示签名状态中的某一个的签名信息


        } else {
            $('#netcasignedDataVerify').css('display','none');
            $('#viewerContainer').css({"margin-top":"0"});
            $('#netcaDisplaySignedDataVerify').css('display','none');
        }

    };
    that.getSignatureFieldInfoFailedCallBack = function(res){

        layer.closeAll('loading');
        // alert('签名域信息失败:'+res.msg);

    };
    that.zoomPDFBySelectOptionScale = function(){
        // 缩放页面  重新描绘签名域
        $('#scaleSelect').change(function(){
            that.getSignatureFieldInfo(NetcaPDFSeal.SetPDFBytes, unfinishedStreamId);
        })
    };
    that.createRevokeEvent = function(streamId) {

        //  filedFlag 普通签章完成后的  签名/章  才有撤销按钮；批量签章、骑缝章没有撤销按钮
        if(filedFlag){
            $('.netcafieldInfo').eq($('.netcafieldInfo').length-1).append('' +
                '<img id="btn_discard" src="/public/netcasign/ui/images/icon/btn_discard_nor.png" alt="" ' +
                'style="position:absolute;top:-15px;right:-15px;z-index:1000;display: none;">' +
                '');
            $('.netcafieldInfo').eq($('.netcafieldInfo').length-1).hover(function(){
                $('#btn_discard').css({'display':'block'});
            },function(){
                $('#btn_discard').css({'display':'none'});
            });
            $('#btn_discard').click(function(){
                // -1表示最后的一个签名/章
                that.isLoading();
                if(streamId){
                    that.signatureVerifierUndoPDF('',-1, unfinishedStreamId, true);
                } else {
                    that.signatureVerifierUndoPDF(NetcaPDFSeal.SetPDFBytes,-1);
                }
            });

        }

    };
    that.signatureVerifierUndoPDF = function(_signBytes, _index, _streamId, _isReturnStreamId){
        layer.confirm('是否需要撤销选定的签章？',{
            btn: ['是','否'] //按钮
        }, function(index){
            layer.close(index);
            var params = {
                signFile: '',
                signBytes: _signBytes,
                index: _index,
                srcStreamId: _streamId,
                isReturnStreamId: _isReturnStreamId
            };
            NetcaPKI.signatureVerifierUndoPDF(params)
                .Then(function (res) {

                    if(res.srcBytes == null ||res.srcBytes.length ==0 ){
                        that.signatureVerifierUndoPDFReadStreamCallBack(res);
                        return;
                    }

                    that.revokeSignatureSuccessCall(res.srcBytes); //撤章成功回调

                })
                .Catch(function (res) {
                    layer.closeAll('loading');
                    alert('撤销签名/章失败：'+res.msg);
                });
        }, function(){
            layer.closeAll('loading');
        });
    };
    that.revokeSignatureSuccessCall = function(srcBytes) {

        // 撤章成功回调
        // 如果窗口大小改变  还得重绘签名域
        NetcaPDFSeal.setPDFBytes(srcBytes);
        that.openPDF(NetcaPDFSeal.SetPDFBytes);
        filedFlag = false;
        if(signFields.length){
            signFields.pop();
        }
        if(that.VerifyInfos.length){
            that.VerifyInfos.pop();
        }
        that.displaySignedDataVerifyTip(that.VerifyInfos);
        $('.netcafieldInfo').last().remove();
        $('.netcasignDetail').last().remove();
        layer.closeAll('loading');

    };
    that.signatureVerifierUndoPDFReadStreamCallBack = function(signSuccessRes){

        completedStreamId = signSuccessRes.srcBytesStream.streamId;
        signSuccessRes.destFileEncode='';
        var params = {
            streamId: signSuccessRes.srcBytesStream.streamId,
            length: writeLength*1024*1024
        };

        NetcaPKI.readStream(params)
            .Then(function (res) {
                that.SignatureVerifierUndoPDFReadStreamUpdateCallBack(res, signSuccessRes);
            })
            .Catch(function (res) {
                alert('撤销签名/章失败：'+res.msg);
            });

    };
    that.SignatureVerifierUndoPDFReadStreamUpdateCallBack = function(res, signSuccessRes)
    {

        completedStreamId = res.streamId;
        signSuccessRes.destFileEncode = signSuccessRes.destFileEncode + res.data;
        if(!res.hasMoreData)
        {
            that.revokeSignatureSuccessCall(signSuccessRes.destFileEncode);
            return;
        }
        var params = {
            streamId: res.streamId,
            length: writeLength*1024*1024
        };


        NetcaPKI.readStream(params)
            .Then(function (res) {
                that.SignatureVerifierUndoPDFReadStreamUpdateCallBack(res, signSuccessRes);
            })
            .Catch(function (res) {
                alert('撤销签名/章失败：'+res.msg);
            });


    };
    /*** 选中签名域信息* */
    that.selectSignatureField = function(){

        var netcafieldInfo = document.getElementsByClassName("netcafieldInfo");
        for(var i=0;i<netcafieldInfo.length;i++){
            netcafieldInfo[i].index = i;
            var _netcafieldInfo = netcafieldInfo[i];
            _netcafieldInfo.onclick = function () {
                // 通过签名域name 与 验证结果的fieldName 对应上
                var name = $('.netcafieldInfo').eq(this.index).attr('name');
                $('.netcafieldInfo').eq(this.index).css({'border':'4px dashed #426bf6'});
                $('.netcafieldInfo').eq(this.index).siblings().css({'border':''});
                $('.netcasignDetail[name='+name+']').css({"background":"#e2eeff"});
                $('.netcasignDetail[name='+name+']').siblings().css({"background":"none"});
                if(this.index === netcafieldInfo.length - 1){
                    $('#btn_discard').css({'display':'block'});
                    $('.netcafieldInfo').eq(this.index).off('hover');
                }
                _netcafieldInfo = null;
            }
        }
    };
    /**
     * 选中标签信息
     * */
    that.selectCertField = function(){

        var netcasignDetail = document.getElementsByClassName("netcasignDetail");
        for(var i=0;i<netcasignDetail.length;i++){
            netcasignDetail[i].index = i;
            var _netcasignDetail = netcasignDetail[i];
            _netcasignDetail.onclick = function () {
                var name = $('.netcasignDetail').eq(this.index).attr('name');
                $('.netcafieldInfo[name='+name+']').css({'border':'4px dashed #426bf6'});
                $('.netcafieldInfo[name='+name+']').siblings().css({'border':''});
                $('.netcasignDetail').eq(this.index).css({"background":"#e2eeff"});
                $('.netcasignDetail').eq(this.index).siblings().css({"background":"none"});
                var _top = parseFloat($('.netcafieldInfo[name='+name+']').css('top'));
                $('#viewerContainer').scrollTop(_top);
                _netcasignDetail = null;
            }
        }
    };
    /**打印*/
    that.printPDF = function() {
        var params = {
            srcBytes: NetcaPDFSeal.SetPDFBytes
        };
        NetcaPKI.printPDF(params)
            .Then(function(res){
                alert('打印文档成功');
            })
            .Catch(function(res){
                alert('打印文档失败:' + res.msg);
            });
    };
    /**
     * 点击close按钮，关闭签名验证信息
     * */
    that.closeSignedDataVerifyInfo = function(params){

        if(params === 'netcainvalidClose'){
            $('#netcasignedDataVerify').css('display','none');
            $('#viewerContainer').css({"margin-top":"0"});
            $('#netcaDisplaySignedDataVerify').css({"top":'70px','height':'92%'})
        }
        if(params === 'netcaclose2'){
            $('#netcaDisplaySignedDataVerify').css({'display':'none'});
            that.getSignatureFieldInfo(NetcaPDFSeal.SetPDFBytes);
        }

    };
    /**
     * 点击详细信息，显示左侧签名验证详细信息
     * */
    that.displaySignedDataVerifyInfo = function(){

        $('#netcaDisplaySignedDataVerify').css({'display':'block',"top":'117px','height':'84%'});

    };
    // 鼠标移入移除签章菜单背景色变化
    that.transBackground = function(name) {
        $('.'+name).hover(function(){
            $(this).css('background','#DBECFF');
        },function(){
            $(this).css('background','#fff');
        });
    };
    that.setUIVisible = function(obj){

        for (var k in obj) {
            if (!obj[k]) {
                $('#' + k).css({'display': 'none'});
            }else{
                $('#' + k).css({'display': 'inline-block'});
            }
        }
        if(obj.NetcaToolBar === true){

            $('#toolbarViewer').css({'display':'block'});
        }else if(obj.NetcaToolBar === false){
            $('#toolbarViewer').css({'display':'none'});
        }
    };
    that.getWorkTime = function() {
        var date = new Date();
        var time = date.getMinutes() + ":" + date.getSeconds() + ":" + date.getMilliseconds();
        return time;
    };
    that.closeFile = function() {
        $('#viewer').children().css('display', 'none');
        $('#netcasignedDataVerify').css('display', 'none');
        $('#netcaDisplaySignedDataVerify').css('display', 'none');
        $('.netcasignpdf').css('margin-top', '0');
    };
    that.openPDFWithUrl = function(url) {
        var origin = window.location.origin;
        var pathname = window.location.pathname;
        var newUrl = origin + pathname + '?file=' + encodeURIComponent(url);
        window.location = newUrl;
    };
    return that;
})();


var NetcaIESignAPI = (function(){
    'use strict';
    var that = {};
    var readerAx;
    that.openPDF = function(byteBase64){

        if(readerAx == null)
            readerAx = document.getElementById("NetcaReaderAx").object;
        var comObj = null;
        try {
            var  NETCA_PKI_BASE64_NO_NL	= 1;
            comObj = new ActiveXObject("NetcaPki.Utilities");
            var bytesDecode = comObj.Base64Decode(byteBase64, NETCA_PKI_BASE64_NO_NL);

            readerAx.PDFSavePath=":AutoSave:";
            readerAx.AsyncOpenPDFBytes(bytesDecode);

        } catch (e) {
            alert("异常:" + e);
        }
    };
    that.initPreView = function () {
        var obj = {
            'NetcaToolBar': false,
            'navigationBar': false
        };

        that.setUIVisible(obj);
    };
    that.GetPDFBytes = function(){

        if(readerAx == null)
            readerAx = document.getElementById("NetcaReaderAx").object;
        var path = readerAx.GetPDFBytes();
        var comObj = new ActiveXObject("NetcaPki.Utilities");
        var  NETCA_PKI_BASE64_NO_NL	=1;
        NetcaPDFSeal.setPDFBytes(comObj.Base64Encode(path, NETCA_PKI_BASE64_NO_NL));

    };
    that.setUI = function (value,visiable) {

        if (readerAx == null)
            readerAx = document.getElementById("NetcaReaderAx").object;

        readerAx.SetIndividuationUI(value, visiable, "");

    };
    that.initUI = function(){

        var obj = {
            // 'netcaopen':false,
            'netcasave':false,
            'netcasearch':false,
            'netcaFirstSeparator':false,
            'netcaSecondSeparator':false,
            'netcaThirdSeparaor':false,
            // 'netcaVerfity':false,
            'netcaSetting':false,
            'netcaAbout':false,
            'navigationBar': false
        };
        $('#netcasignpdf').css('display','none');
        that.setUIVisible(obj);
    };
    that.setUIVisible = function (obj ) {

        var UI_PDF_TOOLBAR_BUTTON = 0; //工具栏
        var UI_PDF_OPEN_BUTTON = 1; //打开按钮
        var UI_PDF_SAVE_BUTTON = 2;  //保存按钮
        var UI_PDF_SERACH_BUTTON = 3; //搜索按钮
        var UI_PDF_ZOOM_IN_BUTTON = 4; //放大按钮
        var UI_PDF_ZOOM_OUT_BUTTON = 5; //缩小按钮
        var UI_PDF_ZOOM_RATION_COMBO = 6; //放大缩小比例列表框
        var UI_PDF_FIRST_SEPARATOR = 7;//第一个分割符控件
        var UI_PDF_FRONT_PAGE_BUTTON = 8;//上一页按钮
        var UI_PDF_NEXT_PAGE_BUTTON = 9; //下一页按钮
        var UI_PDF_PAGE_NUM_EDIT = 10;//页面数字
        var UI_PDF_SECOND_SEPARATOR = 11; //第二个分割符控件
        var UI_PDF_SIGN_BUTTON = 12; //签章按钮
        var UI_PDF_VERIFY_BUTTON = 13; //验证按钮
        var UI_PDF_THIRD_SEPARATOR = 14;  //第三个分割符控件
        var UI_PDF_SETTING_BUTTON = 15; //设置按钮
        var UI_PDF_ABOUT_BUTTON = 16; //关于按钮
        var UI_PDF_NAVIGATION_BAR =        17 ;//导航栏
        var UI_PDF_MARK_BUTTON	= 		 18 ;//书签按钮
        var UI_PDF_ANNOT_BUTTON  =         19 ;//批注按钮
        var UI_PDF_PRINT_BUTTON = 20;//打印按钮
        var UI_PDF_COMMON_SIGN_MENU = 21; //签章签章
        var UI_PDF_EMPLOYEE_SIGN_MENU = 22; //员工签章
        var UI_PDF_INSTITUTION_SIGN_MENU = 23; //机构签章
        var UI_PDF_ARTIFIFCIAL_SIGN_MENU = 24;//法人签章
        var UI_PDF_CLOSE_BUTTON = 28;//关闭按钮

        if (readerAx == null)
            readerAx = document.getElementById("NetcaReaderAx").object;



        //工具栏
        if(obj.NetcaToolBar === true) {
            readerAx.SetIndividuationUI(UI_PDF_TOOLBAR_BUTTON, true, "");
        } else if (obj.NetcaToolBar === false) {
            readerAx.SetIndividuationUI(UI_PDF_TOOLBAR_BUTTON, false, "");
        }
        //打开按钮
        if(obj.openFile === true) {
            readerAx.SetIndividuationUI(UI_PDF_OPEN_BUTTON, true, "");
        } else if (obj.openFile === false) {
            readerAx.SetIndividuationUI(UI_PDF_OPEN_BUTTON, false, "");
        }

        //关闭按钮
        if(obj.netcasave === true) {
            readerAx.SetIndividuationUI(UI_PDF_SAVE_BUTTON, true, "");
        }else if(obj.netcasave === false){
            readerAx.SetIndividuationUI(UI_PDF_SAVE_BUTTON, false, "");
        }
        //搜索
        if(obj.viewFind === true) {
            readerAx.SetIndividuationUI(UI_PDF_SERACH_BUTTON, true, "");
        }else if(obj.viewFind === false){
            readerAx.SetIndividuationUI(UI_PDF_SERACH_BUTTON, false, "");
        }
        //放大
        if(obj.zoomIn  === true) {
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_IN_BUTTON, true, "");
        }else if( obj.zoomIn === false){
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_IN_BUTTON, false, "");
        }
        //缩小
        if(obj.zoomOut  === true) {
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_OUT_BUTTON, true, "");
        }else if( obj.zoomOut === false){
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_OUT_BUTTON, false, "");
        }
        //缩放select控件
        if(obj.scaleSelectContainer  === true) {
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_RATION_COMBO, true, "");
        }else if( obj.scaleSelectContainer === false){
            readerAx.SetIndividuationUI(UI_PDF_ZOOM_RATION_COMBO, false, "");
        }
        //第一个分割符控件
        if(obj.netcaFirstSeparator === true) {
            readerAx.SetIndividuationUI(UI_PDF_FIRST_SEPARATOR, true, "");
        }else if(obj.netcaFirstSeparator === false){
            readerAx.SetIndividuationUI(UI_PDF_FIRST_SEPARATOR, false, "");
        }
        //上一页
        if(obj.previous  === true) {
            readerAx.SetIndividuationUI(UI_PDF_FRONT_PAGE_BUTTON, true, "");
        }else if( obj.previous === false){
            readerAx.SetIndividuationUI(UI_PDF_FRONT_PAGE_BUTTON, false, "");
        }
        //下一页
        if(obj.next  === true) {
            readerAx.SetIndividuationUI(UI_PDF_NEXT_PAGE_BUTTON, true, "");
        }else if( obj.next === false){
            readerAx.SetIndividuationUI(UI_PDF_NEXT_PAGE_BUTTON, false, "");
        }
        //页面数字
        if(obj.netcapage  === true) {
            readerAx.SetIndividuationUI(UI_PDF_PAGE_NUM_EDIT, true, "");
        }else if( obj.netcapage === false){
            readerAx.SetIndividuationUI(UI_PDF_PAGE_NUM_EDIT, false, "");
        }
        //第二个分割符控件
        if(obj.netcaSecondSeparator === true) {
            readerAx.SetIndividuationUI(UI_PDF_SECOND_SEPARATOR, true, "");
        }else if(obj.netcaSecondSeparator === false){
            readerAx.SetIndividuationUI(UI_PDF_SECOND_SEPARATOR, false, "");
        }
        //关闭
        if(obj.closeFile  === true) {
            readerAx.SetIndividuationUI(UI_PDF_CLOSE_BUTTON, true, "");
        }else if(obj.closeFile === false){
            readerAx.SetIndividuationUI(UI_PDF_CLOSE_BUTTON, false, "");
        }
        //验证
        if(obj.verify === true) {
            readerAx.SetIndividuationUI(UI_PDF_VERIFY_BUTTON, true, "");
        }else if(obj.verify === false){
            readerAx.SetIndividuationUI(UI_PDF_VERIFY_BUTTON, false, "");
        }
        //第三个分割符控件
        if(obj.netcaThirdSeparaor === true) {
            readerAx.SetIndividuationUI(UI_PDF_THIRD_SEPARATOR, true, "");
        }else if(obj.netcaThirdSeparaor === false){
            readerAx.SetIndividuationUI(UI_PDF_THIRD_SEPARATOR, false, "");
        }
        //设置
        if(obj.netcaSetting === true) {
            readerAx.SetIndividuationUI(UI_PDF_SETTING_BUTTON, true, "");
        }else if(obj.netcaSetting === false){
            readerAx.SetIndividuationUI(UI_PDF_SETTING_BUTTON, false, "");
        }
        //关于
        if(obj.netcaAbout === true) {
            readerAx.SetIndividuationUI(UI_PDF_ABOUT_BUTTON, true, "");
        }else if(obj.netcaAbout === false){
            readerAx.SetIndividuationUI(UI_PDF_ABOUT_BUTTON, false, "");
        }


        //普通签章
        if(obj.sign === true) {
            readerAx.SetIndividuationUI(UI_PDF_COMMON_SIGN_MENU, true, "");
        }else if(obj.sign === false){
            readerAx.SetIndividuationUI(UI_PDF_COMMON_SIGN_MENU, false, "");
        }

        //员工签章
        if(obj.netcastaff === true) {
            readerAx.SetIndividuationUI(UI_PDF_EMPLOYEE_SIGN_MENU, true, "");
        }else if(obj.netcastaff === false){
            readerAx.SetIndividuationUI(UI_PDF_EMPLOYEE_SIGN_MENU, false, "");
        }

        //机构签章
        if(obj.netcaorganization === true) {
            readerAx.SetIndividuationUI(UI_PDF_INSTITUTION_SIGN_MENU, true, "");
        }else if(obj.netcaorganization === false){
            readerAx.SetIndividuationUI(UI_PDF_INSTITUTION_SIGN_MENU, false, "");
        }

        //法人签章
        if(obj.netcalegalperson === true) {
            readerAx.SetIndividuationUI(UI_PDF_ARTIFIFCIAL_SIGN_MENU, true, "");
        }else if(obj.netcalegalperson === false){
            readerAx.SetIndividuationUI(UI_PDF_ARTIFIFCIAL_SIGN_MENU, false, "");
        }

        //打印
        if(obj.print === true) {
            readerAx.SetIndividuationUI(UI_PDF_PRINT_BUTTON, true, "");
        }else if(obj.print === false){
            readerAx.SetIndividuationUI(UI_PDF_PRINT_BUTTON, false, "");
        }

        //导航栏
        if(obj.navigationBar === true) {
            readerAx.SetIndividuationUI(UI_PDF_NAVIGATION_BAR, true, "");
        }else if(obj.navigationBar === false){
            readerAx.SetIndividuationUI(UI_PDF_NAVIGATION_BAR, false, "");
        }
    };
    /**初始化页面
     * */
    that.init = function(){

        that.initUI();

    };
    that.signCallbackEvent = function(callback){
        if(callback != null)
        {
            if (readerAx == null)
                readerAx = document.getElementById("NetcaReaderAx").object;
            readerAx.SetSignCallback(callback)
        }
    };
    that.verifyCallbackEvent = function(callback){
        if(callback != null)
        {
            if (readerAx == null)
                readerAx = document.getElementById("NetcaReaderAx").object;
            readerAx.SetVerifyCallback(callback)
        }
    };
    that.openPDFWithUrl = function(url) {
        if (readerAx == null)
            readerAx = document.getElementById("NetcaReaderAx").object;
        try {
            readerAx.PDFSavePath = ":AutoSave:";
            readerAx.AsyncOpenPDFUrl(url);
        } catch(e) {
            alert("异常:" + e);
        }
    };
    return that;
})();


var NetcaPDFSeal = (function(){
    'use strict';
    /**set base64*/
    var that = {
        SetPDFBytes:''
    };
    that.setPDFBytes = function(INPDFbase64){
        that.SetPDFBytes =  INPDFbase64
    };
    /**get base64*/
    that.getSignPDFBytes = function(){

        if (that._isIE()) {
            NetcaIESignAPI.GetPDFBytes();
        }

        return that.SetPDFBytes

    };
    /**判断当前浏览器是否为IE浏览器
     * */
    that._isIE = function(){

        var comObj = null;
        try{
            comObj = new ActiveXObject("NetcaPki.Utilities");
            return true;
        }catch(e){
            return false;
        }

    };
    /**
     * 需要隐藏的功能按钮
     * */
    that.setUIVisible = function(obj){
        if(NetcaPDFSeal._isIE()){
            NetcaIESignAPI.setUIVisible(obj);
        }else{
            NetcaSignAPI.setUIVisible(obj);
        }
    };
    /**初始化页面
     * */
    that.init = function(){

        that.initUI();

    };
    that.initUI = function(){
        if (that._isIE()) {
            NetcaIESignAPI.initUI();
        } else {
            NetcaSignAPI.initUI();
        }
    };
    /**打开pdf
     * */
    that.openPDFBytes = function(OpenPDFBytes){
        var search = window.location.search;
        var reg = new RegExp(/\?file=/);

        if(that._isIE()){
            NetcaIESignAPI.openPDF(OpenPDFBytes);
        }else{
            if(!reg.test(search)){
                // url有file参数说明是使用url打开的，没有file则是使用base64字节流打开
                return;
                if(!OpenPDFBytes){
                    alert('打开文档数据为空');
                    return;
                }
                NetcaSignAPI.getSealConfigInfo(OpenPDFBytes);
                NetcaSignAPI.openPDF(OpenPDFBytes);
                NetcaPDFSeal.setPDFBytes(OpenPDFBytes);
            }else {
                var interval = setInterval(function(){
                    if (globalPDFViewerApplication.pdfDocument == null) {
                        console.info('Loading...');
                    } else {
                        if($('#viewer .page').length>0){
                            clearInterval(interval);
                            globalPDFViewerApplication.pdfDocument.getData().then(function(data){
                                // var PDFBytes = NetcaUtils.arrayBufferToBase64(data);
                                NetcaPDFSeal.setPDFBytes(data);
                                // if (can_netcasign) {
                                //     NetcaSignAPI.getSealConfigInfo(data);
                                // }

                            })
                        }
                    }
                }, 1000);

            }
        }
    };
    that.getVerifySignSuccessFlag = function(arr){
        var invalidArr = [];
        var notSureArr = [];
        for(var i=0;i<arr.length;i++){
            if(arr[i].verifyResult === 3){ //签名无效
                invalidArr.push(arr[i].verifyResult)
            }
            if(arr[i].verifyResult === 2){ //签名不确定
                notSureArr.push(arr[i].verifyResult)
            } // 签名有效
        }
        if(invalidArr.length){
            return 0
        }else{
            if(notSureArr.length){
                return -1
            }else{
                return 1
            }
        }
    };
    /**签章完成后对外提示接口*/
    that.setSignCallbackEvent = function(callback){
        if(that._isIE()){
            NetcaIESignAPI.signCallbackEvent(callback)
        }else{
            NetcaSignAPI.signCallbackEvent = callback
        }
    };
    that.setVerifyCallbackEvent = function(callback){
        if(that._isIE()){
            NetcaIESignAPI.verifyCallbackEvent(callback)
        }else{
            NetcaSignAPI.verifyCallbackEvent = callback
        }
    };
    that.openPDFWithUrl = function(url) {
        if(that._isIE()){
            NetcaIESignAPI.openPDFWithUrl(url);
        } else {
            NetcaSignAPI.openPDFWithUrl(url);
        }
    };
    return that;
})();