ChatEngine = ChatEngineCore.create({
    publishKey: 'pub-c-9b914983-9487-4be5-a0e4-0c27a20e6572',
    subscribeKey: 'sub-c-acc8e784-cd70-11e8-b02a-a6a8b6327be1'
});

// use a helper function to generate a new profile
let newPerson = generatePerson(true);

// create a bucket to store our ChatEngine Chat object
let myChat;

// create a bucket to store 
let me;

// compile handlebars templates and store them for use later
let peopleTemplate = Handlebars.compile($("#person-template").html());
let meTemplate = Handlebars.compile($("#message-template").html());
let userTemplate = Handlebars.compile($("#message-response-template").html());

const source_language = "en";
const target_language = "es";

const virgilCrypto = new VirgilCrypto.VirgilCrypto();
let channelKeyPair;

// Identity of the pre-defined "signle" user of the chat
const USER_IDENTITY = 'chatengine-demo-e2ee-user';
// The key under which the user's encrypted private key is stored in 
// the Virgil Keyknox service
const USER_KEY_ID = 'chatengine-demo-e2ee-user-key';
// Prefix we will prepend to the ciphertext before sending the encrypted 
// message to be able to tell the encrypted and plaintext messages apart
const ENC_MESSAGE_PREFIX = 'e2ee_by_virgil';

const initVirgil = async () => {

  // Get the JWT for authentication in Virgil APIs. Makes a request to the 
  // server we've deployed for this demo. The Subject of the returned JWT will 
  // always be equal to `USER_IDENTITY`
  const fetchVirgilJwt = async () => {
    const res = await fetch('https://virgil-pubnub-demo-chat-server.herokuapp.com/virgil-jwt');
    if (!res.ok) throw new Error('Failed to get Virgil access token');
    return await res.text();
  };

  // Get the pre-defined private key of the Chat Channel encrypted with the 
  // user's public key.
  const fetchEncryptedChannelKey = async () => {
    const res = await fetch('https://virgil-pubnub-demo-chat-server.herokuapp.com/channel-private-key');
    if (!res.ok) throw new Error('Failed to get encrypted channel key');
    return await res.text();
  };
  
  const jwtProvider = new Virgil.CachingJwtProvider(fetchVirgilJwt);

  const brainKey = VirgilPythia.createBrainKey({
    virgilCrypto,
    virgilPythiaCrypto: new VirgilCrypto.VirgilPythiaCrypto(),
    accessTokenProvider: jwtProvider
  });

  // Derive the key pair from password. The password is hard-coded for demo 
  // purposes only, it must be provided by the user in a real app.
  const passwordKeyPair = await brainKey.generateKeyPair('PubNubD3m0o');
  
  // Setup the private keys storage.
  const syncKeyStorage = Keyknox.SyncKeyStorage.create({
    // this key will be used to decrypt the Cloud-stored keys
    privateKey: passwordKeyPair.privateKey,
    // this key is used to encrypt the Cloud-stored keys
    publicKeys: passwordKeyPair.publicKey,
    keyEntryStorage: new Virgil.KeyEntryStorage(),
    accessTokenProvider: jwtProvider
  });

  // Synchronize the keys between the Virgil Cloud and local storage (IndexedDB)
  await syncKeyStorage.sync();

  // Retrieve the pre-defined private key of the user
  const userPrivateKeyEntry = await syncKeyStorage.retrieveEntry(USER_KEY_ID);
  // Import to make it usable with `virgilCrypto` methods
  const userPrivateKey = virgilCrypto.importPrivateKey(userPrivateKeyEntry.value);

  // Retrieve the Chat Channel private key encrypted with the user's public key
  const encryptedChannelPrivateKeyData = await fetchEncryptedChannelKey();
  // Decrypt with user's private key
  const channelPrivateKeyData = virgilCrypto.decrypt(encryptedChannelPrivateKeyData, userPrivateKey);
  // Import to make it usable with `virgilCrypto` methods
  const channelPrivateKey = virgilCrypto.importPrivateKey(channelPrivateKeyData);

  channelKeyPair = {
    privateKey: channelPrivateKey,
    publicKey: virgilCrypto.extractPublicKey(channelPrivateKey)
  };
};

// this is our main function that starts our chat app
const init = () => {
  
  // connect to ChatEngine with our generated user
  ChatEngine.connect(newPerson.uuid, newPerson);

  // when ChatEngine is booted, it returns your new User as `data.me`
  ChatEngine.on('$.ready', function(data) {

      // store my new user as `me`
      me = data.me;

      // create a new ChatEngine Chat
      myChat = new ChatEngine.Chat('chatengine-demo-chat');

      // when we recieve messages in this chat, render them
      myChat.on('message', (message) => {
          renderMessage(message);
      });

      // when a user comes online, render them in the online list
      myChat.on('$.online.*', (data) => {
        $('#people-list ul').append(peopleTemplate(data.user));
      });

      // when a user goes offline, remove them from the online list
      myChat.on('$.offline.*', (data) => {
        $('#people-list ul').find('#' + data.user.uuid).remove();
      });

      // wait for our chat to be connected to the internet
      myChat.on('$.connected', () => {

          // search for 50 old `message` events
          myChat.search({
            event: 'message',
            limit: 50
          }).on('message', (data) => {
            // when messages are returned, render them like normal messages
            renderMessage(data, true);
            
          });
        
      });

      // bind our "send" button and return key to send message
      $('#sendMessage').on('submit', sendMessage)

  });

};

// send a message to the Chat
const sendMessage = () => {

    // get the message text from the text input
    let message = $('#message-to-send').val().trim();
  
    // if the message isn't empty
    if (message.length) {
      
        // Encrypt the message with the Channel's public key
        message = virgilCrypto.encrypt(message, channelKeyPair.publicKey).toString('base64');
        // Add prefix so the receiver can tell this message is encrypted
        message = [ ENC_MESSAGE_PREFIX, message].join(':');

        // emit the `message` event to everyone in the Chat
        myChat.emit( 'message', {
            text: message,
            translate: {
                text: message,
                source: source_language,
                target: target_language
            }
        } );

        // clear out the text input
        $('#message-to-send').val('');
    }
    
    // stop form submit from bubbling
    return false;
  
};

// render messages in the list
const renderMessage = (message, isHistory = false) => {

    // use the generic user template by default
    let template = userTemplate;

    // if I happened to send the message, use the special template for myself
    if (message.sender.uuid == me.uuid) {
        template = meTemplate;
    }

    let el = template({
        // Try to decrypt the message
        messageOutput: tryDecrypt(message.data.text),
        time: getCurrentTime(),
        user: message.sender.state
    });
  
    // render the message
    if(isHistory) {
      $('.chat-history ul').prepend(el); 
    } else {
      $('.chat-history ul').append(el); 
    }
  
    // scroll to the bottom of the chat
    scrollToBottom();

    function tryDecrypt (message) {
      const [ prefix, ciphertext ] = message.split(':');
      if (prefix === ENC_MESSAGE_PREFIX) {
        // The message seems to be encrypted
        try {
          // Decrypt and convert to string
          return virgilCrypto.decrypt(ciphertext, channelKeyPair.privateKey).toString('utf8')
        } catch (e) {
          // Return as is
          return message;
        }
      }

      // Return as is
      return message;
    }

};

// scroll to the bottom of the window
const scrollToBottom = () => {
    $('.chat-history').scrollTop($('.chat-history')[0].scrollHeight);
};

// get the current time in a nice format
const getCurrentTime = () => {
    return new Date().toLocaleTimeString().replace(/([\d]+:[\d]{2})(:[\d]{2})(.*)/, "$1$3");
};

// boot the app
initVirgil()
  .then(() => init())
  .catch(err => console.error(err.message));