window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
   
if (!window.indexedDB) {
     window.alert("Your browser doesn't support a stable version of IndexedDB.")
}

const adminID = "FMabh7gTSyKPAb2Wi9sK5CBhV8nVFk783i"; 

if(blockchain == "FLO")
  var api_url = `https://flosight.duckdns.org/`;
else if(blockchain == "FLO_TEST")
  var api_url = `https://testnet-flosight.duckdns.org/`;

var supernodeKBucket;
var superNodeList;
var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];

var encrypt = {

            p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),

            exponent1: function () {
                return this.p.add(BigInteger.ONE).divide(BigInteger("4"))
            },

            calculateY: function (x) {
                let p = this.p;
                let exp = this.exponent1();
                // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
                return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
            },

            // Insert a compressed public key
            getUncompressedPublicKey: function (compressedPublicKey) {

                const p = this.p;

                // Fetch x from compressedPublicKey
                let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
                const prefix = pubKeyBytes.shift() // remove prefix
                let prefix_modulus = prefix % 2;
                pubKeyBytes.unshift(0) // add prefix 0
                let x = new BigInteger(pubKeyBytes)
                let xDecimalValue = x.toString()

                // Fetch y
                let y = this.calculateY(x);
                let yDecimalValue = y.toString();

                // verify y value
                let resultBigInt = y.mod(BigInteger("2"));

                let check = resultBigInt.toString() % 2;

                if (prefix_modulus !== check) {
                    yDecimalValue = y.negate().mod(p).toString();
                }

                return {
                    x: xDecimalValue,
                    y: yDecimalValue
                };
            },

            getSenderPublicKeyString: function () {
                privateKey = ellipticCurveEncryption.senderRandom();
                senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
                return {
                    privateKey: privateKey,
                    senderPublicKeyString: senderPublicKeyString
                }
            },

            deriveSharedKeySender: function (receiverCompressedPublicKey, senderPrivateKey) {
                try {
                    let receiverPublicKeyString = this.getUncompressedPublicKey(
                        receiverCompressedPublicKey);
                    var senderDerivedKey = {
                        XValue: "",
                        YValue: ""
                    };
                    senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
                        receiverPublicKeyString.x,
                        receiverPublicKeyString.y, senderPrivateKey);
                    return senderDerivedKey;
                } catch (error) {
                    return new Error(error);
                }
            },

            deriveReceiverSharedKey: function (senderPublicKeyString, receiverPrivateKey) {
                return ellipticCurveEncryption.receiverSharedKeyDerivation(
                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString,
                    receiverPrivateKey);
            },

            getReceiverPublicKeyString: function (privateKey) {
                return ellipticCurveEncryption.receiverPublicString(privateKey);
            },

            deriveSharedKeyReceiver: function (senderPublicKeyString, receiverPrivateKey) {
                try {
                    return ellipticCurveEncryption.receiverSharedKeyDerivation(senderPublicKeyString.XValuePublicString,
                        senderPublicKeyString.YValuePublicString, receiverPrivateKey);

                } catch (error) {
                    return new Error(error);
                }
            },

            encryptMessage: function (data, receiverCompressedPublicKey) {
                var senderECKeyData = this.getSenderPublicKeyString();
                var senderDerivedKey = {
                    XValue: "",
                    YValue: ""
                };
                var senderPublicKeyString = {};
                senderDerivedKey = this.deriveSharedKeySender(
                    receiverCompressedPublicKey, senderECKeyData.privateKey);
                //console.log("senderDerivedKey", senderDerivedKey);
                let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
                let secret = Crypto.AES.encrypt(data, senderKey);
                return {
                    secret: secret,
                    senderPublicKeyString: senderECKeyData.senderPublicKeyString
                };
            },

            decryptMessage: function (secret, senderPublicKeyString) {
                var receiverDerivedKey = {
                    XValue: "",
                    YValue: ""
                };
                var receiverECKeyData = {};
                var myPrivateKey = privKey;
                if (typeof myPrivateKey !== "string") throw new Error("No private key found.");

                let privateKey = this.wifToDecimal(myPrivateKey, true);
                if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
                    "Failed to detremine your private key.");
                receiverECKeyData.privateKey = privateKey.privateKeyDecimal;

                receiverDerivedKey = this.deriveReceiverSharedKey(senderPublicKeyString,
                    receiverECKeyData.privateKey);
                //console.log("receiverDerivedKey", receiverDerivedKey);

                let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
                let decryptMsg = Crypto.AES.decrypt(secret, receiverKey);
                return decryptMsg;
            },

        ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
        getPubKeyHex: function(privateKeyHex){
          var key = new Bitcoin.ECKey(privateKeyHex);
          if(key.priv == null){
            console.log("Invalid Private key");
            return;
          }
          key.setCompressed(true);
          var pubkeyHex = key.getPubKeyHex();
          return pubkeyHex;
        },
        getFLOIDfromPubkeyHex: function(pubkeyHex){
          var key =  new Bitcoin.ECKey().setPub(pubkeyHex);
          var floID = key.getBitcoinAddress();
          return floID;
        },
        validateAddr: function (value) {
            try{
                var addr = new Bitcoin.Address(value);
                if (addr == value)
                    return true;
                else
                    return false;
            }catch(error){
                return false;
            }
        },
        verifyWIF: function (wif,addr){
            try {
                var key = new Bitcoin.ECKey(wif);
                if(key.priv == null){
                    return false;
                }
                key.setCompressed(true);
                var bitcoinAddress = key.getBitcoinAddress();
                if (addr == bitcoinAddress)
                    return true;
                else
                    return false;
            }
            catch (error) {
                console.log(error);
            }
        },
        sign: function (msg, privateKeyHex) {
            var key = new Bitcoin.ECKey(privateKeyHex);
            key.setCompressed(true);

            var privateKeyArr = key.getBitcoinPrivateKeyByteArray();
            privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
            var messageHash = Crypto.SHA256(msg);

            var messageHashBigInteger = new BigInteger(messageHash);
            var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, key.priv);

            var sighex = Crypto.util.bytesToHex(messageSign);
            return sighex;
        },
        verify: function (msg, signatureHex, publicKeyHex) {
            var msgHash = Crypto.SHA256(msg);
            var messageHashBigInteger = new BigInteger(msgHash);

            var sigBytes = Crypto.util.hexToBytes(signatureHex);
            var signature = Bitcoin.ECDSA.parseSig(sigBytes);

            var publicKeyPoint = this.ecparams.getCurve().decodePointHex(publicKeyHex);

            var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger, signature.r, signature.s,
                publicKeyPoint);
            return verify;
        },
        wifToDecimal: function(pk_wif, isPubKeyCompressed = false) {
                let pk = Bitcoin.Base58.decode(pk_wif)
                pk.shift()
                pk.splice(-4, 4)
                //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
                if (isPubKeyCompressed == true) pk.pop()
                pk.unshift(0)
                privateKeyDecimal = BigInteger(pk).toString()
                privateKeyHex = Crypto.util.bytesToHex(pk)
                return {
                    privateKeyDecimal: privateKeyDecimal,
                    privateKeyHex: privateKeyHex
                }
        },
        createShamirsSecretShares: function (str, total_shares, threshold_limit) {
                if (str.length > 0) {
                    // convert the text into a hex string
                    var strHex = shamirSecretShare.str2hex(str);
                    // split into total_shares shares, with a threshold of threshold_limit
                    var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
                    return shares;
                }
                return false;
        },
        verifyShamirsSecret: function (sharesArray, str) {
                // combine sharesArray:
                var comb = shamirSecretShare.combine(sharesArray);
                //convert back to UTF string:
                comb = shamirSecretShare.hex2str(comb);
                return comb === str;
        },
        retrieveShamirSecret: function (sharesArray) {
                if (sharesArray.length > 0) {
                    // combine sharesArray:
                    var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
                    //convert back to UTF string:
                    comb = shamirSecretShare.hex2str(comb);
                    return comb;
                }
                return false;
        }
      }

function convertStringToInt(string){
  return parseInt(string,10);
}

function arrayToObject(array){
      obj = {};
      array.forEach(element => {
        obj[element.floID] = {onionAddr : element.onionAddr, name : element.name, pubKey : element.pubKey};
      });
      return obj;
}

function getTime(time){
  var t = new Date(time);
  var fn = function(n){
    if(n<10)
      return '0'+n;
    else
      return n;
  };
  var tmp = `${months[t.getMonth()]} ${fn(t.getDate())} ${t.getFullYear()} ${fn(t.getHours())}:${fn(t.getMinutes())}`;
  return tmp;
}

function logout(){
  sessionStorage.clear();
  window.location.href = "index.html";
}

/*Refresh profile and superNode data from API */
function ajax(method, uri){
    var request = new XMLHttpRequest();
    var url = `${api_url}/${uri}`
    console.log(url)
    var result;
    request.open(method,url , false);
    request.onload = function () {
      if (request.readyState == 4 && request.status == 200)
        result = this.response;
      else {
        console.log('error');
        result = false;
      }
    };
    request.send();
    console.log(result);
    return result;
}

function reloadInitData(){
    refreshAPIdata().then(result => {
        console.log(result);
        sessionStorage.profiles = JSON.stringify(profiles);
        sessionStorage.superNodeList = JSON.stringify(Array.from(superNodeList));
        kBucketObj.launchKBucket().then(result => {
            console.log(result)
        }).catch(error => {
            console.log(error);
        });
    }).catch(error => {
        console.log(error);
    });
}

function refreshAPIdata(){
    return new Promise((resolve,reject) => {
        var addr = adminID;
        var idb = indexedDB.open("FLO_Tweet");
        idb.onerror = (event) => { reject("Error in opening IndexedDB!") };
        idb.onsuccess = (event) => {
            var db = event.target.result;
            var lastTx = db.transaction('lastTx', "readwrite").objectStore('lastTx');
            console.log(addr);
            new Promise((res,rej) => {
                var lastTxReq = lastTx.get(addr);
                lastTxReq.onsuccess = (event) => {
                    var lasttx = event.target.result;
                    if(lasttx === undefined){
                        lasttx = 0;
                    }
                    res(lasttx);
                }
            }).then(lasttx => {
                var response = ajax("GET",`api/addrs/${addr}/txs`);
                var nRequired = JSON.parse(response).totalItems - lasttx;
                console.log(nRequired);
                while(true && nRequired){
                    var response = ajax("GET",`api/addrs/${addr}/txs?from=0&to=${nRequired}`);
                    response = JSON.parse(response);
                    if (nRequired + lasttx != response.totalItems ){
                        nRequired = response.totalItems - lasttx;
                        continue;
                    }
                    response.items.reverse().forEach(tx => {
                        try {
                            if (tx.vin[0].addr == addr){
                                var data = JSON.parse(tx.floData).FLO_Tweet_SuperNode;
                                if(data !== undefined){
                                    if(data.addNodes)
                                        for(var i=0; i<data.addNodes.length; i++)
                                            superNodeList.add(data.addNodes[i])
                                    if(data.removeNodes)
                                        for(var i=0; i<data.removeNodes.length; i++)
                                            superNodeList.delete(data.removeNodes[i])
                                    storeSuperNodeData(data).then(function (response) {
                                    }).catch(error => {
                                        console.log(error);
                                    });
                                }
                            }else{
                                var data = JSON.parse(tx.floData).FLO_Tweet;
                                if(data !== undefined){
                                    if(encrypt.getFLOIDfromPubkeyHex(data.pubKey)!=tx.vin[0].addr)
                                        throw("PublicKey doesnot match with floID")
                                    data = {floID : tx.vin[0].addr, onionAddr : data.onionAddr, name : data.name, pubKey:data.pubKey};
                                    profiles[data.floID] = {onionAddr : data.onionAddr, name : data.name, pubKey : data.pubKey};
                                    storeProfile(data).then(function (response) {
                                    }).catch(error => {
                                        console.log(error);
                                    });
                                }  
                            }
                        } catch (error) {
                            //console.log(error)
                        }
                    });
                    var obs = db.transaction('lastTx', "readwrite").objectStore('lastTx');
                    obs.put(response.totalItems,addr);
                    break;
                }
                db.close();
                resolve('retrived data from API');
            });                    
        };
    });
}

/* Common IDB functions */
function storeProfile(data){
    return new Promise((resolve,reject) =>  {
          var idb = indexedDB.open("FLO_Tweet");
          idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
          idb.onsuccess = (event) => {
              var db = event.target.result;
              var obs = db.transaction('profiles', "readwrite").objectStore('profiles');
              objectRequest = obs.put(data);
              objectRequest.onerror = (event) => { reject(Error('Error occured: Unable to store data'))};
              objectRequest.onsuccess = (event) => { resolve('Data saved OK') };
              db.close();
          };
    });
}

function storeSuperNodeData(data){
    return new Promise((resolve,reject) => {
        var idb = indexedDB.open("FLO_Tweet");
        idb.onerror = (event) => { reject("Error in opening IndexedDB!"); };
        idb.onsuccess = (event) => {
            var db = event.target.result;
            var obs = db.transaction('superNodes', "readwrite").objectStore('superNodes');
            if(data.addNodes)
              for(var i=0; i<data.addNodes.length; i++)
                obs.add(true,data.addNodes[i])
            if(data.removeNodes)
              for(var i=0; i<data.removeNodes.length; i++)
                obs.delete(data.removeNodes[i])
            db.close();
            resolve('Updated superNodes list in IDB');
          };
    });
}

function storeTweet(data,tid){
  var idb = indexedDB.open("FLO_Tweet");
  idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
  idb.onsuccess = (event) => {
    var db = event.target.result;
    var obs = db.transaction("tweets", "readwrite").objectStore("tweets");
    data.tweetID = `${data.time}_${data.floID}`;
    data.tid = tid;
    obs.add(data);
    var obsL = db.transaction("lastTweet", "readwrite").objectStore("lastTweet");
    obsL.put(tid,data.floID);
    db.close();
  };
}

function storeMsg(data){
  var idb = indexedDB.open("FLO_Tweet");
  idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
  idb.onsuccess = (event) => {
    var db = event.target.result;
    var obs = db.transaction("messages", "readwrite").objectStore("messages");
    data.msgID = `${data.time}_${data.floID}`;
    obs.add(data);
    db.close();
  };
}

/* SuperNode functions */
function sendDataToSuperNode(floID,data){
    kBucketObj.determineClosestSupernode(floID).then(result=>{
      var superNodeWS = new WebSocket("ws://"+profiles[result[0].floID].onionAddr+"/ws");
      superNodeWS.onopen = function(ev){ 
          console.log(`Connected to ${floID}'s SuperNode!`);
          superNodeWS.send(data);
      };
      superNodeWS.onerror = function(ev) {console.log(`${floid}'s SuperNode is offline!`);};
      superNodeWS.onclose = function(ev) {console.log(`Disconnected from ${floid}'s SuperNode!`);};
    }).catch(e => {
      console.log(e.message);
    }); 
}

function superNodeMode(data){
    if(data.reqNewTweets){
        kBucketObj.determineClosestSupernode(data.floID).then(result => {
          if(result[0].floID == selfID)
            SuperNode_sendTweetsFromIDB(data.floID,data.tid,data.requestor);
        }).catch(error => {
          console.log(error);
        }); 
    }else if(data.newSuperNodeTweet){
        kBucketObj.determineClosestSupernode(data.floID).then(result => {
          if(result[0].floID == selfID)
          SuperNode_storeSuperNodeTweet(data.data,data.tid);
        }).catch(error => {
          console.log(error);
        }); 
    }else if(data.viaSuperNodeMsg){
        kBucketObj.determineClosestSupernode(data.to).then(result => {
          if(result[0].floID == selfID)
            SuperNode_storeViaSuperNodeMsg(data.from,data.to,data.data);
        }).catch(error => {
          console.log(error);
        }); 
    }else if(data.viaMsgreq){
        kBucketObj.determineClosestSupernode(data.floID).then(result => {
          if(result[0].floID == selfID)
          SuperNode_sendviaMsgFromIDB(data.floID);
        }).catch(error => {
          console.log(error);
        }); 
    }
}

function SuperNode_sendTweetsFromIDB(floID,tid,requestor){
  return new Promise((resolve,reject) => {
      var requestorWS = new WebSocket("ws://"+profiles[requestor].onionAddr+"/ws");
      requestorWS.onopen = (event) => { 
        console.log(`sending ${floID} tweets to ${requestor} Server!`);
        var idb = indexedDB.open("FLO_Tweet",2);
        idb.onerror = (event) => { reject("Error in opening IndexedDB!") };
        idb.onupgradeneeded = (event) => {
          var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
          objectStore1.createIndex('floID', 'floID', { unique: false });
          objectStore1.createIndex('tid', 'tid', { unique: false });
          objectStore1.createIndex('data', 'data', { unique: false });
          var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
          objectStore2.createIndex('from', 'from', { unique: false });
          objectStore2.createIndex('to', 'to', { unique: false });
          objectStore2.createIndex('data', 'data', { unique: false });
        }
        idb.onsuccess = (event) => {
          var db = event.target.result;
          var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
          var curReq = obs.openCursor();
          curReq.onsuccess = (event) => {
            var cursor = event.target.result;
            if(cursor) {
              if(cursor.value.floID == floID && cursor.value.tid > tid){
                data = JSON.stringify({fromSuperNode:true, floID:cursor.value.floID,tid:cursor.value.tid,data:cursor.value.data})
                requestorWS.send(data);
              }
              cursor.continue();
            }else{
              resolve("Displayed Tweets from IDB!");
            }
          }
          curReq.onerror = (event) => { reject("Error in Reading tweets from IDB!") }
          db.close();
        };
      };
      requestorWS.onerror = (event) => { console.log(`${requestor} Server is offline!`) };
      requestorWS.onclose = (event) => { console.log(`Disconnected from ${requestor} Server!`) };
  });
}        

function SuperNode_storeSuperNodeTweet(data,tid){
  var idb = indexedDB.open("FLO_Tweet",2);
  idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
  idb.onupgradeneeded = (event) => {
    var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
    objectStore1.createIndex('floID', 'floID', { unique: false });
    objectStore1.createIndex('tid', 'tid', { unique: false });
    objectStore1.createIndex('data', 'data', { unique: false });
    var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
    objectStore2.createIndex('from', 'from', { unique: false });
    objectStore2.createIndex('to', 'to', { unique: false });
    objectStore2.createIndex('data', 'data', { unique: false });
  }
  idb.onsuccess = (event) => {
    var db = event.target.result;
    var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
    var parsedData = JSON.parse(data);
    var tweetID = ''+parsedData.floID+'_'+parsedData.time; 
    obs.add({tweetID:tweetID,floID:parsedData.floID,tid:tid,data:data});
    db.close();
  };
}

function SuperNode_storeViaSuperNodeMsg(from,to,data){
    var idb = indexedDB.open("FLO_Tweet",2);
    idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
    idb.onupgradeneeded = (event) => {
      var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
      objectStore1.createIndex('floID', 'floID', { unique: false });
      objectStore1.createIndex('tid', 'tid', { unique: false });
      objectStore1.createIndex('data', 'data', { unique: false });
      var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement :true });
      objectStore2.createIndex('from', 'from', { unique: false });
      objectStore2.createIndex('to', 'to', { unique: false });
      objectStore2.createIndex('data', 'data', { unique: false });
    }
    idb.onsuccess = (event) => {
      var db = event.target.result;
      var obs = db.transaction("viaSuperNodeMsg", "readwrite").objectStore("viaSuperNodeMsg");
      obs.add({from:from,to:to,data:data});
      db.close();
    };
  }
  
function SuperNode_sendviaMsgFromIDB(floID){
  var receiverWS = new WebSocket("ws://"+profiles[floID].onionAddr+"/ws");
  receiverWS.onopen = (event) => { 
    var idb = indexedDB.open("FLO_Tweet",2);
    idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
    idb.onupgradeneeded = (event) => {
      var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
      objectStore1.createIndex('floID', 'floID', { unique: false });
      objectStore1.createIndex('tid', 'tid', { unique: false });
      objectStore1.createIndex('data', 'data', { unique: false });
      var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
      objectStore2.createIndex('from', 'from', { unique: false });
      objectStore2.createIndex('to', 'to', { unique: false });
      objectStore2.createIndex('data', 'data', { unique: false });
    };
    idb.onsuccess = (event) => {
      var db = event.target.result;
      var obs = db.transaction("viaSuperNodeMsg", "readwrite").objectStore("viaSuperNodeMsg");
      obs.openCursor().onsuccess = (event) => {
        var cursor = event.target.result;
        if(cursor) {
          if(cursor.value.to == floID){
            receiverWS.send(cursor.value.data);
            cursor.delete();
          }
          cursor.continue();
        }else{
          console.log('Sent All messages to '+floID)
        }
      }
      db.close();
    };
  };
  receiverWS.onerror = (event) => { console.log('Connection Error to '+floID) };
  receiverWS.onclose = (event) => { console.log('Disconnected from '+floID) };
}

/* ---end of app.js --- */

/*Kademlia DHT K-bucket implementation as a binary tree.*/

if (typeof reactor == "undefined" || !reactor) {
    (function () {

        function Event(name) {
            this.name = name;
            this.callbacks = [];
        }
        Event.prototype.registerCallback = function (callback) {
            this.callbacks.push(callback);
        };

        function Reactor() {
            this.events = {};
        }

        Reactor.prototype.registerEvent = function (eventName) {
            var event = new Event(eventName);
            this.events[eventName] = event;
        };

        Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
            this.events[eventName].callbacks.forEach(function (callback) {
                callback(eventArgs);
            });
        };

        Reactor.prototype.addEventListener = function (eventName, callback) {
            this.events[eventName].registerCallback(callback);
        };

        window.reactor = new Reactor();

    })();
}

reactor.registerEvent('added');
reactor.addEventListener('added', function (someObject) {
    console.log('Added fired with data ' + someObject);
});

reactor.registerEvent('removed');
reactor.addEventListener('removed', function (someObject) {
    console.log('Removed fired with data ' + someObject);
});

reactor.registerEvent('updated');
reactor.addEventListener('updated', function (someObject) {
    console.log('Updated fired with data ' + someObject);
});

reactor.registerEvent('bucket_full');
reactor.addEventListener('bucket_full', function (someObject) {
    console.log('Bucket full ' + someObject);
});


    /**
    * @param  {Uint8Array} array1
    * @param  {Uint8Array} array2
    * @return {Boolean}
    */
    function arrayEquals(array1, array2) {
        if (array1 === array2) {
            return true
        }
        if (array1.length !== array2.length) {
            return false
        }
        for (let i = 0, length = array1.length; i < length; ++i) {
            if (array1[i] !== array2[i]) {
                return false
            }
        }
        return true
    }

    function createNode() {
        return {
            contacts: [],
            dontSplit: false,
            left: null,
            right: null
        }
    }

    function ensureInt8(name, val) {
        if (!(val instanceof Uint8Array)) {
            throw new TypeError(name + ' is not a Uint8Array')
        }
    }

    /**
    * Implementation of a Kademlia DHT k-bucket used for storing
    * contact (peer node) information.
    *
    * @extends EventEmitter
    */
    function BuildKBucket(options = {}) {
        /**
        * `options`:
        *   `distance`: Function
        *     `function (firstId, secondId) { return distance }` An optional
        *     `distance` function that gets two `id` Uint8Arrays
        *     and return distance (as number) between them.
        *   `arbiter`: Function (Default: vectorClock arbiter)
        *     `function (incumbent, candidate) { return contact; }` An optional
        *     `arbiter` function that givent two `contact` objects with the same `id`
        *     returns the desired object to be used for updating the k-bucket. For
        *     more details, see [arbiter function](#arbiter-function).
        *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
        *     If not provided, a local node id will be created via `randomBytes(20)`.
        *     `metadata`: Object (Default: {}) Optional satellite data to include
        *     with the k-bucket. `metadata` property is guaranteed not be altered by,
        *     it is provided as an explicit container for users of k-bucket to store
        *     implementation-specific data.
        *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
        *     that a k-bucket can contain before being full or split.
        *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
        *     ping when a bucket that should not be split becomes full. KBucket will
        *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
        *     not been contacted the longest.
        *
        * @param {Object=} options optional
        */

        this.localNodeId = options.localNodeId || window.crypto.getRandomValues(new Uint8Array(20))
        this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
        this.numberOfNodesToPing = options.numberOfNodesToPing || 3
        this.distance = options.distance || this.distance
        // use an arbiter from options or vectorClock arbiter by default
        this.arbiter = options.arbiter || this.arbiter
        this.metadata = Object.assign({}, options.metadata)

        ensureInt8('option.localNodeId as parameter 1', this.localNodeId)

        this.root = createNode()


        /**
        * Default arbiter function for contacts with the same id. Uses
        * contact.vectorClock to select which contact to update the k-bucket with.
        * Contact with larger vectorClock field will be selected. If vectorClock is
        * the same, candidat will be selected.
        *
        * @param  {Object} incumbent Contact currently stored in the k-bucket.
        * @param  {Object} candidate Contact being added to the k-bucket.
        * @return {Object}           Contact to updated the k-bucket with.
        */
        this.arbiter = function (incumbent, candidate) {
            return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
        }

        /**
        * Default distance function. Finds the XOR
        * distance between firstId and secondId.
        *
        * @param  {Uint8Array} firstId  Uint8Array containing first id.
        * @param  {Uint8Array} secondId Uint8Array containing second id.
        * @return {Number}              Integer The XOR distance between firstId
        *                               and secondId.
        */
        this.distance = function (firstId, secondId) {
            let distance = 0
            let i = 0
            const min = Math.min(firstId.length, secondId.length)
            const max = Math.max(firstId.length, secondId.length)
            for (; i < min; ++i) {
                distance = distance * 256 + (firstId[i] ^ secondId[i])
            }
            for (; i < max; ++i) distance = distance * 256 + 255
            return distance
        }

        /**
        * Adds a contact to the k-bucket.
        *
        * @param {Object} contact the contact object to add
        */
        this.add = function (contact) {
            ensureInt8('contact.id', (contact || {}).id)

            let bitIndex = 0
            let node = this.root

            while (node.contacts === null) {
                // this is not a leaf node but an inner node with 'low' and 'high'
                // branches; we will check the appropriate bit of the identifier and
                // delegate to the appropriate node for further processing
                node = this._determineNode(node, contact.id, bitIndex++)
            }

            // check if the contact already exists
            const index = this._indexOf(node, contact.id)
            if (index >= 0) {
                this._update(node, index, contact)
                return this
            }

            if (node.contacts.length < this.numberOfNodesPerKBucket) {
                node.contacts.push(contact)
                reactor.dispatchEvent('added', contact)
                return this
            }

            // the bucket is full
            if (node.dontSplit) {
                // we are not allowed to split the bucket
                // we need to ping the first this.numberOfNodesToPing
                // in order to determine if they are alive
                // only if one of the pinged nodes does not respond, can the new contact
                // be added (this prevents DoS flodding with new invalid contacts)
                reactor.dispatchEvent('bucket_full', {1: node.contacts.slice(0, this.numberOfNodesToPing),2: contact})
                return this
            }

            this._split(node, bitIndex)
            return this.add(contact)
        }

        /**
        * Get the n closest contacts to the provided node id. "Closest" here means:
        * closest according to the XOR metric of the contact node id.
        *
        * @param  {Uint8Array} id  Contact node id
        * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
        *                          closest contacts to return
        * @return {Array}          Array Maximum of n closest contacts to the node id
        */
        this.closest = function (id, n = Infinity) {
            ensureInt8('id', id)

            if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
                throw new TypeError('n is not positive number')
            }

            let contacts = []

            for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
                const node = nodes.pop()
                if (node.contacts === null) {
                    const detNode = this._determineNode(node, id, bitIndex++)
                    nodes.push(node.left === detNode ? node.right : node.left)
                    nodes.push(detNode)
                } else {
                    contacts = contacts.concat(node.contacts)
                }
            }

            return contacts
                .map(a => [this.distance(a.id, id), a])
                .sort((a, b) => a[0] - b[0])
                .slice(0, n)
                .map(a => a[1])
        }

        /**
        * Counts the total number of contacts in the tree.
        *
        * @return {Number} The number of contacts held in the tree
        */
        this.count = function () {
            // return this.toArray().length
            let count = 0
            for (const nodes = [this.root]; nodes.length > 0;) {
                const node = nodes.pop()
                if (node.contacts === null) nodes.push(node.right, node.left)
                else count += node.contacts.length
            }
            return count
        }

        /**
        * Determines whether the id at the bitIndex is 0 or 1.
        * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
        *
        * @param  {Object} node     internal object that has 2 leafs: left and right
        * @param  {Uint8Array} id   Id to compare localNodeId with.
        * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
        *                           to check in the id Uint8Array.
        * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
        */
        this._determineNode = function (node, id, bitIndex) {
            // *NOTE* remember that id is a Uint8Array and has granularity of
            // bytes (8 bits), whereas the bitIndex is the bit index (not byte)

            // id's that are too short are put in low bucket (1 byte = 8 bits)
            // (bitIndex >> 3) finds how many bytes the bitIndex describes
            // bitIndex % 8 checks if we have extra bits beyond byte multiples
            // if number of bytes is <= no. of bytes described by bitIndex and there
            // are extra bits to consider, this means id has less bits than what
            // bitIndex describes, id therefore is too short, and will be put in low
            // bucket
            const bytesDescribedByBitIndex = bitIndex >> 3
            const bitIndexWithinByte = bitIndex % 8
            if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
                return node.left
            }

            const byteUnderConsideration = id[bytesDescribedByBitIndex]

            // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
            // where 255 is 11111111 and 0 is 00000000
            // in order to find out whether the bit at bitIndexWithinByte is set
            // we construct (1 << (7 - bitIndexWithinByte)) which will consist
            // of all bits being 0, with only one bit set to 1
            // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
            // (1 << (7 - 3)) -> (1 << 4) -> 16
            if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
                return node.right
            }

            return node.left
        }

        /**
        * Get a contact by its exact ID.
        * If this is a leaf, loop through the bucket contents and return the correct
        * contact if we have it or null if not. If this is an inner node, determine
        * which branch of the tree to traverse and repeat.
        *
        * @param  {Uint8Array} id The ID of the contact to fetch.
        * @return {Object|Null}   The contact if available, otherwise null
        */
        this.get = function (id) {
            ensureInt8('id', id)

            let bitIndex = 0

            let node = this.root
            while (node.contacts === null) {
                node = this._determineNode(node, id, bitIndex++)
            }

            // index of uses contact id for matching
            const index = this._indexOf(node, id)
            return index >= 0 ? node.contacts[index] : null
        }

        /**
        * Returns the index of the contact with provided
        * id if it exists, returns -1 otherwise.
        *
        * @param  {Object} node    internal object that has 2 leafs: left and right
        * @param  {Uint8Array} id  Contact node id.
        * @return {Number}         Integer Index of contact with provided id if it
        *                          exists, -1 otherwise.
        */
        this._indexOf = function (node, id) {
            for (let i = 0; i < node.contacts.length; ++i) {
                if (arrayEquals(node.contacts[i].id, id)) return i
            }

            return -1
        }

        /**
        * Removes contact with the provided id.
        *
        * @param  {Uint8Array} id The ID of the contact to remove.
        * @return {Object}        The k-bucket itself.
        */
        this.remove = function (id) {
            ensureInt8('the id as parameter 1', id)

            let bitIndex = 0
            let node = this.root

            while (node.contacts === null) {
                node = this._determineNode(node, id, bitIndex++)
            }

            const index = this._indexOf(node, id)
            if (index >= 0) {
                const contact = node.contacts.splice(index, 1)[0]
                reactor.dispatchEvent('removed', contact)
            }

            return this
        }

        /**
        * Splits the node, redistributes contacts to the new nodes, and marks the
        * node that was split as an inner node of the binary tree of nodes by
        * setting this.root.contacts = null
        *
        * @param  {Object} node     node for splitting
        * @param  {Number} bitIndex the bitIndex to which byte to check in the
        *                           Uint8Array for navigating the binary tree
        */
        this._split = function (node, bitIndex) {
            node.left = createNode()
            node.right = createNode()

            // redistribute existing contacts amongst the two newly created nodes
            for (const contact of node.contacts) {
                this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
            }

            node.contacts = null // mark as inner tree node

            // don't split the "far away" node
            // we check where the local node would end up and mark the other one as
            // "dontSplit" (i.e. "far away")
            const detNode = this._determineNode(node, this.localNodeId, bitIndex)
            const otherNode = node.left === detNode ? node.right : node.left
            otherNode.dontSplit = true
        }

        /**
        * Returns all the contacts contained in the tree as an array.
        * If this is a leaf, return a copy of the bucket. `slice` is used so that we
        * don't accidentally leak an internal reference out that might be
        * accidentally misused. If this is not a leaf, return the union of the low
        * and high branches (themselves also as arrays).
        *
        * @return {Array} All of the contacts in the tree, as an array
        */
        this.toArray = function () {
            let result = []
            for (const nodes = [this.root]; nodes.length > 0;) {
                const node = nodes.pop()
                if (node.contacts === null) nodes.push(node.right, node.left)
                else result = result.concat(node.contacts)
            }
            return result
        }

        /**
        * Updates the contact selected by the arbiter.
        * If the selection is our old contact and the candidate is some new contact
        * then the new contact is abandoned (not added).
        * If the selection is our old contact and the candidate is our old contact
        * then we are refreshing the contact and it is marked as most recently
        * contacted (by being moved to the right/end of the bucket array).
        * If the selection is our new contact, the old contact is removed and the new
        * contact is marked as most recently contacted.
        *
        * @param  {Object} node    internal object that has 2 leafs: left and right
        * @param  {Number} index   the index in the bucket where contact exists
        *                          (index has already been computed in a previous
        *                          calculation)
        * @param  {Object} contact The contact object to update.
        */
        this._update = function (node, index, contact) {
            // sanity check
            if (!arrayEquals(node.contacts[index].id, contact.id)) {
                throw new Error('wrong index for _update')
            }

            const incumbent = node.contacts[index]

            /***************Change made by Abhishek*************/
            const selection = this.arbiter(incumbent, contact)
            //const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
            // if the selection is our old contact and the candidate is some new
            // contact, then there is nothing to do
            if (selection === incumbent && incumbent !== contact) return

            node.contacts.splice(index, 1) // remove old contact
            node.contacts.push(selection) // add more recent contact version
            /***************Change made by Abhishek*************/
            reactor.dispatchEvent('updated', {
                ...incumbent,
                ...selection
            })
            //reactor.dispatchEvent('updated', incumbent.concat(selection))
        }
    }
  

kBucketObj = {

    decodeBase58Address: function (address) {
        let k = bitjs.Base58.decode(address)
        k.shift()
        k.splice(-4, 4)
        return Crypto.util.bytesToHex(k)
    },
    launchKBucket: function() {
        return new Promise((resolve, reject)=>{
            try {
                //const master_flo_pubKey = localbitcoinplusplus.master_configurations.masterFLOPubKey;
                const master_flo_addr = adminID;
                const SuKBucketId = this.floIdToKbucketId(master_flo_addr);
                const SukbOptions = { localNodeId: SuKBucketId }
                supernodeKBucket = new BuildKBucket(SukbOptions);
                var SNArray = Array.from(superNodeList);
                for(var i=0; i<SNArray.length ; i++)
                    this.addNewUserNodeInKbucket(SNArray[i],supernodeKBucket)
                resolve('SuperNode KBucket formed');
            } catch (error) {
                reject(error);
            }
        });
    },
    launchSupernodesKBucket: function() {
        
        localbitcoinplusplus.master_configurations.supernodesPubKeys.map(pubKey=>{
            return new Promise((resolve, reject)=>{
                try {
                    let flo_id = bitjs.pubkey2address(pubKey);
                    let kname = `SKBucket_${pubKey}`;
                    const KBucketId = this.floIdToKbucketId(flo_id)
                    const kbOptions = { localNodeId: KBucketId }
                    window[kname] = new BuildKBucket(kbOptions);
                    resolve(true);
                } catch (error) {
                    reject(error);
                }
            })
        })
    },
    addContact: function (id, floID, KB=supernodeKBucket) {
        const contact = {
            id: id,
            floID: floID
        };
        KB.add(contact)
    },
    addNewUserNodeInKbucket: function(address, KB=supernodeKBucket) {
        let decodedId = address;   
        try { 
            decodedId = this.floIdToKbucketId(address);
        } catch(e) {
            decodedId = address;
        } 
        const addNewUserNode = this.addContact(decodedId, address, KB);
        return {decodedId:decodedId, address:address};
    },
    floIdToKbucketId: function (address) {
        const decodedId = this.decodeBase58Address(address);
        const nodeIdBigInt =  new BigInteger(decodedId, 16);
        const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
        const nodeIdNewInt8Array =  new Uint8Array(nodeIdBytes);
        return nodeIdNewInt8Array;
    },
    arbiter: function (incumbent, candidate) {
        // we create a new object so that our selection is guaranteed to replace
        // the incumbent
        const merged = {
            id: incumbent.id, // incumbent.id === candidate.id within an arbiter
            data: incumbent.data
        }

        Object.keys(candidate.data).forEach(workerNodeId => {
            merged.data[workerNodeId] = candidate.data[workerNodeId];
        })

        return merged;
    },
    newBase64DiscoverId: function (pubKey) {
        let pubKeyBytes = Crypto.util.hexToBytes(pubKey);
        return Crypto.util.bytesToBase64(pubKeyBytes);
    },
    restoreKbucket: function(flo_addr, KB=KBucket) {
        return new Promise((resolve, reject)=>{
            readAllDB('kBucketStore')
            .then(dbObject => {
                if (typeof dbObject=="object") {
                    let su_flo_addr_array = localbitcoinplusplus.master_configurations.supernodesPubKeys  
                            .map(pubk=>bitjs.pubkey2address(pubk));
                    // Prevent supernode to re-added in kbucket
                    dbObject
                    .filter(f=>!su_flo_addr_array.includes(f.data.id))
                    .map(dbObj=>{
                        this.addNewUserNodeInKbucket(flo_addr, dbObj.data, KB);
                    });
                } else {
                    reject(`Failed to restore kBucket.`);
                }
                resolve(dbObject);
            });
        })
    },
    restoreSupernodeKBucket: function() {
        return new Promise((resolve, reject)=>{
            const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
            if (typeof supernodeSeeds !== "object") reject("Failed to get supernode seeds.");
            let supernodeSeedsObj = JSON.parse(supernodeSeeds);
            
            Object.entries(supernodeSeedsObj).map(seedObj=>{
                let kbuck = this.addNewUserNodeInKbucket(seedObj[1].kbucketId, 
                    { id: seedObj[1].kbucketId }, supernodeKBucket);
            });

            resolve(true);
        })
    },
    updateClosestSupernodeSeeds: function(flo_addr) {
        return new Promise(async (resolve, reject) => {
            await removeAllinDB('myClosestSupernodes');
            let nearestSupernodeAddresslist = await this.addClosestSupernodeInDB(flo_addr);
            nearestSupernodeAddresslist.map((nearestSupernodeAddress, index)=>{
                updateinDB('myClosestSupernodes', {
                    id: index+1,
                    ip: nearestSupernodeAddress.ip,
                    port: nearestSupernodeAddress.port,
                    trader_flo_address: nearestSupernodeAddress.kbucketId,
                    is_live: null
                }).then(updatedClosestSupernodes=>{
                    readAllDB('myClosestSupernodes').then(nearestSupernodeAddresslist=>{
                        showMessage(`INFO: Updated closest supernodes list successfully.`);
                        resolve(nearestSupernodeAddresslist);
                    });
                });
            });
        });
    },
    getSupernodeSeed: function (flo_addr) {
        return new Promise(async (resolve, reject) => {
            let nearestSupernodeAddresslist = await readAllDB('myClosestSupernodes');
            if (nearestSupernodeAddresslist.length<1) {
                nearestSupernodeAddresslist = await this.updateClosestSupernodeSeeds(flo_addr);
            }
            resolve(nearestSupernodeAddresslist);
        });
    },
    isNodePresentInMyKbucket: function(flo_id, KB=KBucket) {
        return new Promise((resolve, reject)=>{
            let kArray = KB.toArray();
            let kArrayFloIds = kArray.map(k=>k.data.id);
            if (kArrayFloIds.includes(flo_id)) {
                resolve(true);
            } else {
                reject(false);
            }
        });
    },
    determineClosestSupernode: function(flo_addr="", n=1, KB=supernodeKBucket, su="") {
        return new Promise((resolve, reject)=>{
            let msg = ``;
            if (typeof supernodeKBucket !== "object") {
                msg = `ERROR: Supernode KBucket not found.`;
                showMessage(msg);
                reject(msg);
                return false;
            }

            if (su.length>0) {
                try {
                    let closestSupernodeMasterList = supernodeKBucket.closest(supernodeKBucket.localNodeId);
                    const index = closestSupernodeMasterList.findIndex(f=>f.data.id==su);
                    let tail = closestSupernodeMasterList.splice(0, index);
                    const newClosestSupernodeMasterList = closestSupernodeMasterList.concat(tail);
                    resolve(newClosestSupernodeMasterList);
                    return true;
                } catch (error) {
                    reject(error);
                }
                return false;
            }
            
            try {
                if(flo_addr.length < 0) {
                    showMessage(`WARNING: No Flo Id provided to determine closest Supenode.`);
                    return;
                }
                let isFloIdUint8 = flo_addr instanceof Uint8Array;
                if (!isFloIdUint8) {
                    flo_addr = this.floIdToKbucketId(flo_addr);
                }
                const closestSupernode = supernodeKBucket.closest(flo_addr, n);
                resolve(closestSupernode);
                return true;
            } catch (error) {
                showMessage(error);
                reject(error);
                return false;
            }
        })
    }
}