/**
 * Plugin helper API. 
 */

/*! This is eparaksts-hwcrypto.js 1.2.0 generated on 2017-02-20 */
/* DO NOT EDIT (use src/eparaksts-hwcrypto.js) */
var SC_NO_IMPLEMENTATION eparakstshwcrypto = "no_implementation";
var SC_FAILING_CHROME = "failing_chrome";
var SC_FAILING_NPAPI = "failing_npapi";
var SC_FAILING_BACKEND = "failing_backend";
var SC_NEW_VERSION = "new_version";
var SC_USER_CANCEL = "user_cancel";

//return version array [MAJOR, MINOR, BUILD]
function parseVersion(value) {
        eparakstshwcrypto() {
    "use strict";
    var version consoleDebug = [0, 0, 0];
        false;
    var parts _debug = value.split(".");
        function(x) {
        if (consoleDebug) console.log(x);
    };
    _debug("eparaksts-hwcrypto.js activated");
    window.addEventListener = window.addEventListener || window.attachEvent;
    function hasPluginFor(mime) {
        return navigator.mimeTypes && mime in navigator.mimeTypes;
    }
    function hasExtension(cls) {
        return typeof window[cls] === "function";
    }
    function _hex2array(str) {
        if (typeof str == "string") {
            var maxLength len = Math.min(version.length, parts.length);
        floor(str.length / 2);
            var ret = new Uint8Array(len);
            for (i (var i = 0; i < maxLength; len; i++) {
                {
                ret[i] = parseInt(str.substr(i * 2, 2), 16);
            }
            return ret;
        }
    }
    function _array2hex(args) {
        var part ret = '';
                var partChars = parts[i].split('');
                "";
        for (j (var i = 0; j i < partChars.args.length; j++) {
                        //collect numbers only
                        i++) ret += (args[i] < 16 ? "0" : "") + args[i].toString(16);
        return ret.toLowerCase();
    }
    function _mimeid(mime) {
        return "hwc" + mime.replace("/", "").replace("-", "");
    }
    function loadPluginFor(mime) {
        var element = _mimeid(mime);
        if (!isNaN(parseInt(partChars[j], 10))) {
                                part += partChars[j];

                        } else if (part.length > 0) {
                                //invalid number
                                break;
                        (document.getElementById(element)) {
            _debug("Plugin element already loaded");
            return document.getElementById(element);
        }
        }

                //
                _debug("Loading plugin for " + mime + " into " + element);
        var partVersion objectTag = parseInt(part, 10);
                if (!isNaN(partVersion)) {
                        version[i] '<object id="' + element + '" type="' + mime + '" style="width: 1px; height: 1px; position: absolute; visibility: hidden;"></object>';
        var div = partVersion;
                }
        }

        document.createElement("div");
        div.setAttribute("id", "pluginLocation" + element);
        document.body.appendChild(div);
        document.getElementById("pluginLocation" + element).innerHTML = objectTag;
        return version;
document.getElementById(element);
    }
    var signing_plugin_mime = "application/x-eparaksts";
    var signing_extension = "eParakstsTokenSigning";
    var USER_CANCEL = "user_cancel";
    var NO_CERTIFICATES = "no_certificates";
    var INVALID_ARGUMENT = "invalid_argument";
    var TECHNICAL_ERROR = "technical_error";
    var NO_IMPLEMENTATION = "no_implementation";
    var NOT_ALLOWED = "not_allowed";
    function probe() {
        var msg = "probe() detected ";
        if (hasExtension(signing_extension)) {
            _debug(msg + signing_extension);
        }
        if (hasPluginFor(signing_plugin_mime)) {
            _debug(msg + signing_plugin_mime);
        }
    }
    window.addEventListener("load", function(event) {
        probe();
    });
    function SigningPlugin() {
        this._name = "NPAPI/BHO for " + signing_plugin_mime;
        var p = loadPluginFor(signing_plugin_mime);
        var certificate_ids = {};
        function code2str(err) {
            _debug("Error: " + err + " with: " + p.errorMessage);
            switch (parseInt(err)) {
              case 1:
                return USER_CANCEL;

              case 2:
                return NO_CERTIFICATES;

              case 17:
                return INVALID_ARGUMENT;

              case 19:
                return NOT_ALLOWED;

              default:
                _debug("Unknown error: " + err + " with: " + p.errorMessage);
                return TECHNICAL_ERROR;
            }
        }
        function code2err(err) {
            return new Error(code2str(err));
        }
        this.check = function() {
            return new Promise(function(resolve, reject) {
                setTimeout(function() {
                    resolve(typeof p.version !== "undefined");
                }, 0);
            });
        };
        this.getVersion = function() {
            return new Promise(function(resolve, reject) {
                var v = p.version;
                resolve(v);
            });
        };
        this.getCertificate = function(options) {
            var operation = options.operation || "sign";
            var language = options.lang || "en";
            p.pluginLanguage = language;
            return new Promise(function(resolve, reject) {
                try {
                    var v;
                    if (typeof p.getCertificateWithOperation !== "undefined") {
                        v = p.getCertificateWithOperation(operation);
                    } else {
                        v = p.getCertificate();
                    }
                    if (parseInt(p.errorCode) !== 0) {
                        reject(code2err(p.errorCode));
                    } else {
                        certificate_ids[v.cert] = v.id;
                        resolve({
                            hex: v.cert
                        });
                    }
                } catch (ex) {
                    _debug(ex);
                    reject(code2err(p.errorCode));
                }
            });
        };
        this.sign = function(cert, hash, options) {
            return new Promise(function(resolve, reject) {
                var cid = certificate_ids[cert.hex];
                if (cid) {
                    try {
                        var language = options.lang || "en";
                        var operation = options.operation || "sign";
                        var v;
                        if (typeof p.signWithOperation !== "undefined") {
                            v = p.signWithOperation(cid, hash.hex, language, operation);
                        } else {
                            v = p.sign(cid, hash.hex, language);
                        }
                        resolve({
                            hex: v
                        });
                    } catch (ex) {
                        _debug(JSON.stringify(ex));
                        reject(code2err(p.errorCode));
                    }
                } else {
                    _debug("invalid certificate: " + cert);
                    reject(new Error(INVALID_ARGUMENT));
                }
            });
        };
    }
    function SigningExtension() {
        this._name = "Native Messaging extension";
        var p = null;
        this.check = function() {
            return new Promise(function(resolve, reject) {
                if (!hasExtension(signing_extension)) {
                    return resolve(false);
                }
                p = new window[signing_extension]();
                if (p) {
                    resolve(true);
                } else {
                    resolve(false);
                }
            });
        };
        this.getVersion = function() {
            return p.getVersion();
        };
        this.getCertificate = function(options) {
            return p.getCertificate(options);
        };
        this.sign = function(cert, hash, options) {
            return p.sign(cert, hash, options);
        };
    }
    function NoBackend() {
        this._name = "No implementation";
        this.check = function() {
            return new Promise(function(resolve, reject) {
                resolve(true);
            });
        };
        this.getVersion = function() {
            return Promise.reject(new Error(NO_IMPLEMENTATION));
        };
        this.getCertificate = function() {
            return Promise.reject(new Error(NO_IMPLEMENTATION));
        };
        this.sign = function() {
            return Promise.reject(new Error(NO_IMPLEMENTATION));
        };
    }
    var _backend = null;
    var fields = {};
    function _testAndUse(Backend) {
        return new Promise(function(resolve, reject) {
            var b = new Backend();
            b.check().then(function(isLoaded) {
                if (isLoaded) {
                    _debug("Using backend: " + b._name);
                    _backend = b;
                    resolve(true);
                } else {
                    _debug(b._name + " check() failed");
                    resolve(false);
                }
            });
        });
    }
    function _autodetect(force) {
        return new Promise(function(resolve, reject) {
            _debug("Autodetecting best backend");
            if (typeof force === "undefined") {
                force = false;
            }
            if (_backend !== null && !force) {
                return resolve(true);
            }
            function trySigningPlugin() {
                _testAndUse(SigningPlugin).then(function(result) {
                    if (result) {
                        resolve(true);
                    } else {
                        resolve(_testAndUse(NoBackend));
                    }
                });
            }
            if (navigator.userAgent.indexOf("MSIE") != -1 || navigator.userAgent.indexOf("Trident") != -1) {
                _debug("Assuming IE BHO, testing");
                return trySigningPlugin();
            }
            if (hasExtension(signing_extension)) {
                _testAndUse(SigningExtension).then(function(result) {
                    if (result) {
                        resolve(true);
                    } else {
                        trySigningPlugin();
                    }
                });
                return;
            }
            if (hasPluginFor(signing_plugin_mime)) {
                return trySigningPlugin();
            }
            resolve(_testAndUse(NoBackend));
        });
    }
    fields.use = function(backend) {
        return new Promise(function(resolve, reject) {
            if (typeof backend === "undefined" || backend === "auto") {
                _autodetect().then(function(result) {
                    resolve(result);
                });
            } else {
                if (backend === "chrome") {
                    resolve(_testAndUse(SigningExtension));
                } else if (backend === "npapi") {
                    resolve(_testAndUse(SigningPlugin));
                } else {
                    resolve(false);
                }
            }
        });
    };
    fields.getBackendInfo = function() {
        return new Promise(function(resolve, reject) {
            _autodetect().then(function(result) {
                _backend.getVersion().then(function(version) {
                    resolve({
                        type: _backend._name,
                        version: version
                    });
                }, function(error) {
                    if (hasExtension(signing_extension)) {
                        resolve({
                            type: "FAILING_NATIVE_MESSAGING"
                        });
                    } else if (hasPluginFor(signing_plugin_mime)) {
                        resolve({
                            type: "FAILING_NPAPI"
                        });
                    } else {
                        resolve({
                            type: "NO_IMPLEMENTATION"
                        });
                    }
                });
            });
        });
    };
    fields.getBackendType = function() {
        return new Promise(function(resolve, reject) {
            _autodetect().then(function(result) {
                _backend.getVersion().then(function(version) {
                    resolve(_backend._name);
                }, function(error) {
                    if (hasExtension(signing_extension)) {
                        resolve("FAILING_NATIVE_MESSAGING");
                    } else if (hasPluginFor(signing_plugin_mime)) {
                        resolve("FAILING_NPAPI");
                    } else {
                        resolve("NO_IMPLEMENTATION");
                    }
                });
            });
        });
    };
    fields.setConsoleDebug = function(x) {
        consoleDebug = x;
    };
    fields.debug = function() {
        return new Promise(function(resolve, reject) {
            var hwversion = "eparakstshwcrypto 1.2.0";
            _autodetect().then(function(result) {
                _backend.getVersion().then(function(version) {
                    resolve(hwversion + " with " + _backend._name + " " + version);
                }, function(error) {
                    resolve(hwversion + " with failing backend " + _backend._name);
                });
            });
        });
    };
    fields.getCertificate = function(options) {
        if (typeof options !== "object") {
            _debug("getCertificate options parameter must be an object");
            return Promise.reject(new Error(INVALID_ARGUMENT));
        }
        if (options && !options.operation) {
            options.operation = "sign";
        }
        if (options && !options.lang) {
            options.lang = "en";
        }
        return _autodetect().then(function(result) {
            if (location.protocol !== "https:" && location.protocol !== "file:") {
                return Promise.reject(new Error(NOT_ALLOWED));
            }
            return _backend.getCertificate(options).then(function(certificate) {
                if (certificate.hex && !certificate.encoded) certificate.encoded = _hex2array(certificate.hex);
                return certificate;
            });
        });
    };
    fields.sign = function(cert, hash, options) {
        if (arguments.length < 2) return Promise.reject(new Error(INVALID_ARGUMENT));
        if (options && !options.operation) {
            options.operation = "sign";
        }
        if (options && !options.lang) {
            options.lang = "en";
        }
        if (!hash.type || !hash.value && !hash.hex) return Promise.reject(new Error(INVALID_ARGUMENT));
        if (hash.hex && !hash.value) {
            _debug("DEPRECATED: hash.hex as argument to sign() is deprecated, use hash.value instead");
            hash.value = _hex2array(hash.hex);
        }
        if (hash.value && !hash.hex) hash.hex = _array2hex(hash.value);
        return _autodetect().then(function(result) {
            if (location.protocol !== "https:" && location.protocol !== "file:") {
                return Promise.reject(new Error(NOT_ALLOWED));
            }
            return _backend.sign(cert, hash, options).then(function(signature) {
                if (signature.hex && !signature.value) signature.value = _hex2array(signature.hex);
                return signature;
            });
        });
    };
    fields.NO_IMPLEMENTATION = NO_IMPLEMENTATION;
    fields.USER_CANCEL = USER_CANCEL;
    fields.NOT_ALLOWED = NOT_ALLOWED;
    fields.NO_CERTIFICATES = NO_CERTIFICATES;
    fields.TECHNICAL_ERROR = TECHNICAL_ERROR;
    fields.INVALID_ARGUMENT = INVALID_ARGUMENT;
    return fields;
}();// FIXME: origin unknown
if (!window.atob) {
  var tableStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var table = tableStr.split("");

  window.atob = function (base64) {
    if (/(=[^=]+|={3,})$/.test(base64)) throw new Error("String contains an invalid character");
    base64 = base64.replace(/=/g, "");
    var n = base64.length & 3;
    if (n === 1) throw new Error("String contains an invalid character");
    for (var i = 0, j = 0, len = base64.length / 4, bin = []; i < len; ++i) {
      var a = tableStr.indexOf(base64[j++] || "A"), b = tableStr.indexOf(base64[j++] || "A");
      var c = tableStr.indexOf(base64[j++] || "A"), d = tableStr.indexOf(base64[j++] || "A");
      if ((a | b | c | d) < 0) throw new Error("String contains an invalid character");
      bin[bin.length] = ((a << 2) | (b >> 4)) & 255;
      bin[bin.length] = ((b << 4) | (c >> 2)) & 255;
      bin[bin.length] = ((c << 6) | d) & 255;
    };
    return String.fromCharCode.apply(null, bin).substr(0, bin.length + n - 4);
  };

  window.btoa = function (bin) {
    for (var i = 0, j = 0, len = bin.length / 3, base64 = []; i < len; ++i) {
      var a = bin.charCodeAt(j++), b = bin.charCodeAt(j++), c = bin.charCodeAt(j++);
      if ((a | b | c) > 255) throw new Error("String contains an invalid character");
      base64[base64.length] = table[a >> 2] + table[((a << 4) & 63) | (b >> 4)] +
                              (isNaN(b) ? "=" : table[((b << 2) & 63) | (c >> 6)]) +
                              (isNaN(b + c) ? "=" : table[c & 63]);
    }
    return base64.join("");
  };

}

//returns -1, 0, 1
function compareVersion(oldVersion, newVersion) {
        //compare MAJOR value
        var majorOld = (oldVersion.length >= 1) ? oldVersion[0] : 0;
        var majorNew = (newVersion.length >= 1) ? newVersion[0] : 0;
        if (majorNew > majorOld) {
                //true
                hexToBase64(str) {
  return 1;

        } else if (majorNew == majorOld) {
                //compare MINOR value
                var minorOld = (oldVersion.length >= 2) ? oldVersion[1] : 0;
                var minorNew = (newVersion.length >= 2) ? newVersion[1] : 0;
                if (minorNew > minorOld) {
                        //true
                        return 1;

                } else if (minorNew == minorOld) {
                        //compare BUILD value
                        var revOld = (oldVersion.length >= 3) ? oldVersion[2] : 0;
                        var revNew = (newVersion.length >= 3) ? newVersion[2] : 0;
                        if (revNew > revOld) {
                                //true
                                return 1;

                        } else if (revNew == revOld) {
                                //equal
                                return 0;
                        }
                }
        }

        //false
        return -1;
btoa(String.fromCharCode.apply(null,
    str.replace(/\r|\n/g, "").replace(/([\da-fA-F]{2}) ?/g, "0x$1 ").replace(/ +$/, "").split(" "))
  );
}

function getBackendError(type, resolvedVersion, requiredVersion) {
        if ((type === null) || (typeof type !== "string")) {
                //string expected, invalid implementation
                hexToPem(s) {
   var b = hexToBase64(s);
   var pem = b.match(/.{1,64}/g).join("\n");
   return SC_NO_IMPLEMENTATION;
        }

        //
        var typeLower = type.toLowerCase();
        if (typeLower === SC_NO_IMPLEMENTATION) {
                return SC_NO_IMPLEMENTATION;

        } else if ((typeLower === SC_FAILING_CHROME) || (typeLower === SC_FAILING_NPAPI)) {
                return SC_FAILING_BACKEND;

        } else {
                var resolvedVersionArray = parseVersion(resolvedVersion);
                var requiredVersionArray = parseVersion(requiredVersion);
                if (compareVersion(resolvedVersionArray, requiredVersionArray) > 0) {
                        return SC_NEW_VERSION;
                }
        }

        //
        return null;
"-----BEGIN CERTIFICATE-----\n" + pem + "\n-----END CERTIFICATE-----"; 
}