function SoftUKey(SoftKey3W) {
    this.SoftKey3W = SoftKey3W;
}

/**
 * uKey写入用户名
 * @param userName 用户名
 * @param callback 回调函数
 */
SoftUKey.prototype.setUserName = function (userName, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UK类
        let DevicePath, PriKey, PubKeyX, PubKeyY;
        // 开启监听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // 监听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // 根据收到的序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    break;
                case 1:
                    if(UK_Data.LastError!=0) {
                        window.alert ( "未发现加密锁，请插入加密锁");
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // 设置路径
                    DevicePath=UK_Data.return_value;//获得返回的UK的路径

                    //产生密钥对
                    s_simnew1.StarGenKeyPair(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("产生密钥对出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }

                    //获取生成的私钥
                    s_simnew1.GenPriKey();
                    break;
                case 3:
                    if(UK_Data.LastError!=0){
                        window.alert("获取生成的私钥时错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    PriKey = UK_Data.return_value;
                    //获取生成的公钥X
                    s_simnew1.GenPubKeyX();
                    break;
                case 4:
                    if(UK_Data.LastError!=0){
                        window.alert("获取生成的公钥X时错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    PubKeyX = UK_Data.return_value;

                    //获取生成的公钥Y
                    s_simnew1.GenPubKeyY();
                    break;
                case 5:
                    if(UK_Data.LastError!=0){
                        window.alert("获取生成的公钥Y时错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    PubKeyY = UK_Data.return_value;

                    //设置密钥对及用户身份到锁中
                    s_simnew1.Set_SM2_KeyPair(PriKey,PubKeyX,PubKeyY,userName,DevicePath);
                    break;
                case 6:
                    if(UK_Data.LastError!=0){
                        window.alert("设置密钥对及用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // 执行回调函数
                    if(typeof callback == 'function') {
                        callback({
                            PriKey,
                            PubKeyX,
                            PubKeyY,
                            userName,
                            DevicePath
                        });
                    }

                    //所有工作处理完成后，关掉Socket
                    s_simnew1.Socket_UK.close();
                    break;
            }
        }

        // 关闭监听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭设置用户名称")
        }
        return true;
    }catch(e) {
        console.log("设置用户名称异常："+e);
    }
}

/**
 * 读取uKey中的用户名
 * @param callback
 * @return {boolean}
 */
SoftUKey.prototype.getUserName = function(callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UK类
        let DevicePath, userName;
        // 开启监听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // 监听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // 根据收到的序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    break;
                case 1:
                    if(UK_Data.LastError!=0) {
                        window.alert ( "未发现加密锁，请插入加密锁");
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // 设置路径
                    DevicePath=UK_Data.return_value;//获得返回的UK的路径

                    //返回设置在锁中的身份
                    s_simnew1.GetSm2UserName(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回设置在锁中的用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    userName = UK_Data.return_value;

                    // 执行回调函数
                    if(typeof callback == 'function') {
                        callback({
                            userName,
                        });
                    }

                    //所有工作处理完成后，关掉Socket
                    s_simnew1.Socket_UK.close();
                    break;
            }
        }

        // 关闭监听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭读取用户名称")
        }
        return true;
    }catch (e) {
        console.log("读取用户名称异常："+e);
    }
}
/**
 * 获取ukey的签名
 * @param randomNumber
 * @param callback
 */
SoftUKey.prototype.getSign = function(randomNumber, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UK类
        let inPath, sign, uKeyId, publicX, publicY;
        // 开启监听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // 监听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // 根据收到的序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    break;
                case 1:
                    if(UK_Data.LastError!=0) {
                        window.alert ( "未发现加密锁，请插入加密锁");
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // 设置路径
                    inPath=UK_Data.return_value;//获得返回的UK的路径

                    s_simnew1.GetProduceDate(inPath);//返回芯片唯一ID
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回芯片唯一ID时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    uKeyId = UK_Data.return_value;

                    //返回设置在锁中的公钥X
                    s_simnew1.GetPubKeyX(inPath);
                    break;
                case 3:
                    if(UK_Data.LastError!=0){
                        window.alert("返回设置在锁中的公钥X时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    publicX = UK_Data.return_value;

                    // 返回设置在锁中的公钥Y
                    s_simnew1.GetPubKeyY(inPath);
                    break;
                case 4:
                    if(UK_Data.LastError!=0){
                        window.alert("返回设置在锁中的公钥Y时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    publicY = UK_Data.return_value;

                    // 对数据进行签名
                    s_simnew1.YtSign(randomNumber,"123", inPath);
                    break;
                case 5:
                    if(UK_Data.LastError!=0){
                        window.alert("对数据进行签名时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    sign = UK_Data.return_value;

                    // 执行回调函数
                    if(typeof callback == 'function') {
                        callback({
                            inPath,
                            sign,
                            uKeyId,
                            publicX,
                            publicY,
                        });
                    }

                    //所有工作处理完成后，关掉Socket
                    s_simnew1.Socket_UK.close();
                    break;
            }
        }

        // 关闭监听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭获取签名")
        }
    }catch (e) {
        console.log("获取签名异常："+e)
    }
}

export default SoftUKey;