/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

/* globals ContactPhotoHelper,
           Dialog,
           Notification,
           Settings
*/

(function(exports) {
  'use strict';
  var rdashes = /-(.)/g;
  var rescape = /[.?*+^$[\]\\(){}|-]/g;
  var rparams = /([^?=&]+)(?:=([^&]*))?/g;
  var rnondialablechars = /[^,#+\*\d]/g;
  var rmail = /[\w-]+@[\w\-]/;

  var Utils = {
    date: {
      shared: new Date(),
      formatters: {
        'time': {
          options: {
            hour: 'numeric',
            minute: 'numeric',
          },
          formatter: null
        },
        'full': {
          options: {
            month: '2-digit',
            day: '2-digit',
            year: 'numeric',
          },
          formatter: null
        },
        'full-wt': {
          options: {
            month: '2-digit',
            day: '2-digit',
            year: 'numeric',
            hour: 'numeric',
            minute: 'numeric',
          },
          formatter: null
        },
        'day': {
          options: {
            weekday: 'long',
          },
          formatter: null
        },
        'day-wt': {
          options: {
            weekday: 'long',
            hour: 'numeric',
            minute: 'numeric',
          },
          formatter: null
        },
      },
    },
    escapeRegex: function ut_escapeRegex(str) {
      if (typeof str !== 'string') {
        return '';
      }
      return str.replace(rescape, '\\$&');
    },
    getFormattedHour: function ut_getFormattedHour(time) {
      this.date.shared.setTime(+time);
      return this._getFormatter('time', false).format(this.date.shared);
    },
    getDayDate: function re_getDayDate(time) {
      this.date.shared.setTime(+time);
      this.date.shared.setHours(0, 0, 0, 0);
      return this.date.shared.getTime();
    },
    resetDateFormatters: function ut_resetDateFormatters() {
      // remove cached formatters.
      // It should happen on timeformatchange and languagechange
      for (var type in this.date.formatters) {
        this.date.formatters[type].formatter = null;
      }
    },
    _getFormatter: function ut_getFormatter(type, withTime) {
      if (withTime) {
        type += '-wt';
      }

      // Cache the formatter for better performance
      if (!this.date.formatters[type].formatter) {
        var options = Object.assign(
          {},
          this.date.formatters[type].options
        );
        if (options.hour) {
          options.hour12 = navigator.mozHour12;
        }
        this.date.formatters[type].formatter = Intl.DateTimeFormat(
          navigator.languages,
          options
        );
      }
      return this.date.formatters[type].formatter;
    },
    setHeaderDate: function ut_setHeaderDate({time, element, withTime}) {

      var formatter;
      var today = Utils.getDayDate(Date.now());
      var otherDay = Utils.getDayDate(time);
      var dayDiff = (today - otherDay) / 86400000;
      this.date.shared.setTime(+time);

      if (isNaN(dayDiff)) {
        element.setAttribute('data-l10n-id', 'incorrectDate');
        return;
      }

      if (dayDiff < 0) {
        // future time
        formatter = this._getFormatter('full', withTime);
        element.removeAttribute('data-l10n-id');
        element.textContent = formatter.format(this.date.shared);
        return;
      }

      if (dayDiff === 0) {
        if (withTime) {
          document.l10n.setAttributes(
            element, 'todayWithTime', {
              time: this.getFormattedHour(this.date.shared)
            });
        } else {
          element.setAttribute('data-l10n-id', 'today');
        }
      } else if (dayDiff === 1) {
        if (withTime) {
          document.l10n.setAttributes(
            element, 'yesterdayWithTime', {
              time: this.getFormattedHour(this.date.shared)
            });
        } else {
          element.setAttribute('data-l10n-id', 'yesterday');
        }
      } else if (dayDiff < 6) {
        // day
        formatter = this._getFormatter('day', withTime);
        element.removeAttribute('data-l10n-id');
        element.textContent = formatter.format(this.date.shared);
      } else {
        formatter = this._getFormatter('full', withTime);
        element.removeAttribute('data-l10n-id');
        element.textContent = formatter.format(this.date.shared);
      }
    },

    // We will apply createObjectURL for details.photoURL if contact image exist
    // Please remember to revoke the photoURL after utilizing it.
    getContactDetails:
      function ut_getContactDetails(number, contacts, include) {
      var details = {};

      include = include || {};

      function updateDetails(contact) {
        var name, phone, i, length, subscriber, org;
        name = contact.name[0];
        org = contact.org && contact.org[0];
        length = contact.tel ? contact.tel.length : 0;
        subscriber = number.length > 7 ? number.substr(-8) : number;

        // Check which of the contacts phone number are we using
        for (i = 0; i < length; i++) {
          // Based on E.164 (http://en.wikipedia.org/wiki/E.164)
          if (contact.tel[i].value.indexOf(subscriber) !== -1) {
            phone = contact.tel[i];
            break;
          }
        }

        // Add data values for contact activity interaction
        details.isContact = true;

        // Add photo
        if (include.photoURL) {
          var photo = ContactPhotoHelper.getThumbnail(contact);
          if (photo) {
            details.photoURL = window.URL.createObjectURL(photo);
          }
        }

        details.name = name;
        // We pick the first discovered org name as the phone number's detail
        // org information.
        details.org = details.org || org;
      }

      // In no contact or contact with empty information cases, we will leave
      // the title as the empty string and let caller to decide the title.
      if (!contacts || (Array.isArray(contacts) && contacts.length === 0)) {
        details.title = '';
      } else if (!Array.isArray(contacts)) {
        updateDetails(contacts);
        details.title = details.name || details.org;
      } else {
        // Rule for fetching details with multiple contact entries:
        // 1) If we got more than 1 contact entry, find another entry if
        //    current entry got no name/company.
        // 2) If we could not get any information from all the entries,
        //    just display phone number.
        for (var i = 0, l = contacts.length; i < l; i++) {
          updateDetails(contacts[i]);
          if (details.name) {
            break;
          }
        }
        details.title = details.name || details.org;
      }

      return details;
    },

    /**
     * Based on input number tries to extract more phone details like phone
     * type, full phone number and phone carrier.
     * 1. If a phone number has carrier associated with it then both "type" and
     * "carrier" will be returned;
     *
     * 2. If there is no carrier associated with the phone number then "type"
     *  and "phone number" will be returned;
     *
     * 3. If for some reason a single contact has two phone numbers with the
     * same type and the same carrier then "type" and "phone number" will be
     * returned;
     *
     * note: The argument "tels" can actually contain "emails" too.
     *
     */
    getPhoneDetails: function ut_getPhoneDetails(input, tels) {
      var length = tels.length;
      var hasUniqueCarriers = true;
      var hasUniqueTypes = true;
      var found, tel, type, carrier;

      for (var i = 0; i < length; i++) {
        tel = tels[i];

        if (tel.value && Utils.probablyMatches(tel.value, input)) {
          found = tel;
        }

        if (carrier && carrier === tel.carrier) {
          hasUniqueCarriers = false;
        }

        if (type && type === tel.type[0]) {
          hasUniqueTypes = false;
        }

        carrier = tel.carrier;
        type = (tel.type && tel.type[0]) || '';
      }

      if (!found) {
        return null;
      }

      return {
        type: (found.type && found.type[0]) || '',
        carrier: hasUniqueCarriers || hasUniqueTypes ? found.carrier : '',
        number: found.value
      };
    },

    // Based on "non-dialables" in https://github.com/andreasgal/PhoneNumber.js
    //
    // @param {String} input Value to remove nondialiable chars from.
    //
    removeNonDialables: function ut_removeNonDialables(input) {
      return input.replace(rnondialablechars, '');
    },
    // @param {String} a First recipient field.
    // @param {String} b Second recipient field
    //
    // Based on...
    //  - ITU-T E.123 (http://www.itu.int/rec/T-REC-E.123-200102-I/)
    //  - ITU-T E.164 (http://www.itu.int/rec/T-REC-E.164-201011-I/)
    //
    // ...It would appear that a maximally-minimal
    // 7 digit comparison is safe.
    probablyMatches: function ut_probablyMatches(a, b) {
      var service = navigator.mozPhoneNumberService;

      // String comparison starts here
      if (typeof a !== 'string' || typeof b !== 'string') {
        return false;
      }

      if (Settings.supportEmailRecipient &&
          Utils.isEmailAddress(a) &&
          Utils.isEmailAddress(b)) {
        return a === b;
      }

      if (service && service.normalize) {
        a = service.normalize(a);
        b = service.normalize(b);
      } else {
        a = Utils.removeNonDialables(a);
        b = Utils.removeNonDialables(b);
      }

      return a === b || a.slice(-7) === b.slice(-7);
    },

    /**
     * multiRecipientMatch
     *
     * Check multi-repients without regard to order
     *
     * @param {(String|string[])} a First recipient field.
     * @param {(String|string[])} b Second recipient field.
     *
     * @return {Boolean} Return true if all recipients match.
     */
    multiRecipientMatch: function ut_multiRecipientMatch(a, b) {
      // When ES6 syntax is allowed, replace with
      // multiRecipientMatch([...a], [...b])
      a = [].concat(a);
      b = [].concat(b);
      var blen = b.length;
      if (a.length !== blen) {
        return false;
      }
      // Check each recipient in a against each in b
      // Allows for any order (and fails early)
      return a.every(function(number) {
        for (var i = 0; i < blen; i++) {
          if (Utils.probablyMatches(number, b[i])) {
            return true;
          }
        }
      });
    },

    // Default image size limitation is set to 295KB for MMS user story.
    // If limit is not given or bigger than default 295KB, default value need
    // to be applied here for size checking. Parameters could be:
    // (blob, callback) : Resizing image to default limit 295k.
    // (blob, limit, callback) : Resizing image to given limitation.
    getResizedImgBlob: function ut_getResizedImgBlob(blob, limit, callback) {
      var defaultLimit = 295 * 1024;
      if (typeof limit === 'function') {
        callback = limit;
        limit = defaultLimit;
      }
      limit = limit === 0 ? defaultLimit : Math.min(limit, defaultLimit);

      if (blob.size < limit) {
        setTimeout(function blobCb() {
          callback(blob);
        });
        return;
      }

      var ratio = Math.sqrt(blob.size / limit);
      Utils._resizeImageBlobWithRatio({
        blob: blob,
        limit: limit,
        ratio: ratio,
        callback: callback
      });
    },

    /**
    * Gets localization details for attachment size label.
    * @param size Attachment blob size in bytes.
    * @returns {{l10nId: string, l10nArgs: {n: string}}}
    */
    getSizeForL10n: function ut_getSizeForL10n(size) {
      // blob size with unit (B or KB or MB)
      var sizeKB = size / 1024;
      var sizeMB = sizeKB / 1024;
      if (size < 1000) {
        return {
          l10nId: 'attachmentSizeB',
          l10nArgs: { n: size }
        };
      } else if (sizeKB < 1000) {
        return {
          l10nId: 'attachmentSizeKB',
          l10nArgs: { n: sizeKB.toFixed(1) }
        };
      }
      return {
        l10nId: 'attachmentSizeMB',
        l10nArgs: { n: sizeMB.toFixed(1) }
      };
    },

    //  resizeImageBlobWithRatio have additional ratio to force image
    //  resize to smaller size to avoid edge case about quality adjustment
    //  not working.
    //  For JPG images, a ratio between 2 and 8 will be set to a close
    //  power of 2. A ratio between 1 and 2 will be set to 2. A ratio bigger
    //  than 8 will be rounded to the closest bigger integer.
    //
    _resizeImageBlobWithRatio: function ut_resizeImageBlobWithRatio(obj) {
      var blob = obj.blob;
      var callback = obj.callback;
      var limit = obj.limit;
      var ratio = Math.ceil(obj.ratio);
      var qualities = [0.65, 0.5, 0.25];

      var sampleSize = 1;
      var sampleSizeHash = '';

      if (blob.size < limit || ratio <= 1) {
        setTimeout(function blobCb() {
          callback(blob);
        });
        return;
      }

      if (blob.type === 'image/jpeg') {
        if (ratio >= 8) {
          sampleSize = 8;
        } else {
          sampleSize = ratio = Utils.getClosestSampleSize(ratio);
        }

        sampleSizeHash = '#-moz-samplesize=' + sampleSize;
      }

      var img = document.createElement('img');
      var url = window.URL.createObjectURL(blob);
      img.src = url + sampleSizeHash;

      img.onload = function onBlobLoaded() {
        window.URL.revokeObjectURL(url);
        var targetWidth = img.width * sampleSize / ratio;
        var targetHeight = img.height * sampleSize / ratio;

        var canvas = document.createElement('canvas');
        canvas.width = targetWidth;
        canvas.height = targetHeight;
        var context = canvas.getContext('2d', { willReadFrequently: true });

        context.drawImage(img, 0, 0, targetWidth, targetHeight);
        img.src = '';
        // Bug 889765: Since we couldn't know the quality of the original jpg
        // The 'resized' image might have a bigger size because it was saved
        // with quality or dpi. Here we will adjust the jpg quality(or resize
        // blob again if low quality blob size still exceed limit) to make
        // sure the size won't exceed the limitation.
        var level = 0;

        function cleanup() {
          canvas.width = canvas.height = 0;
          canvas = null;
        }

        function ensureSizeLimit(resizedBlob) {
          if (resizedBlob.size < limit) {
            cleanup();

            // using a setTimeout so that used objects can be garbage collected
            // right now
            setTimeout(callback.bind(null, resizedBlob));
          } else {
            resizedBlob = null; // we don't need it anymore
            // Reduce image quality for match limitation. Here we set quality
            // to 0.65, 0.5 and 0.25 for image blob resizing.
            // (Default image quality is 0.92 for jpeg)
            if (level < qualities.length) {
              canvas.toBlob(ensureSizeLimit, 'image/jpeg',
                qualities[level++]);
            } else {
              // We will resize the blob if image quality = 0.25 still exceed
              // size limitation.
              cleanup();

              // using a setTimeout so that used objects can be garbage
              // collected right now
              setTimeout(
                Utils._resizeImageBlobWithRatio.bind(Utils, {
                  blob: blob,
                  limit: limit,
                  ratio: ratio * 2,
                  callback: callback
                })
              );
            }
          }
        }

        canvas.toBlob(ensureSizeLimit, blob.type);
      };
    },

    getClosestSampleSize: function ut_getClosestSampleSize(ratio) {
      if (ratio >= 8) {
        return 8;
      }

      if (ratio >= 4) {
        return 4;
      }

      if (ratio >= 2) {
        return 2;
      }

      return 1;
    },

    camelCase: function ut_camelCase(str) {
      return str.replace(rdashes, function replacer(str, p1) {
        return p1.toUpperCase();
      });
    },
    typeFromMimeType: function ut_typeFromMimeType(mime) {
      var MAX_MIME_TYPE_LENGTH = 256; // ought to be enough for anybody
      if (typeof mime !== 'string' || mime.length > MAX_MIME_TYPE_LENGTH) {
        return null;
      }

      var index = mime.indexOf('/');
      if (index === -1) {
        return null;
      }
      var mainPart = mime.slice(0, index);
      var secondPart = mime.substr(index + 1).toLowerCase();

      switch (mainPart) {
        case 'image':
          return 'img';
        case 'text':
          if(secondPart.indexOf('vcard') !== -1) {
            return 'vcard';
          }
          if (secondPart !== 'plain') {
            return 'ref';
          }
          return mainPart;
        case 'video':
        case 'audio':
        case 'application':
          return mainPart;
        default:
          return null;
      }
    },
    params: function(input) {
      var parsed = {};
      input.replace(rparams, function($0, $1, $2) {
        if ($2 === 'true') {
          $2 = true;
        } else if ($2 === 'false') {
          $2 = false;
        }
        parsed[$1] = $2;
      });
      return parsed;
    },
    url(base, params) {
      if (base.indexOf('?') === -1) {
        base += '?';
      } else {
        base += '&';
      }

      for (var key in params) {
        if (params[key] == null) { // null or undefined
          continue;
        }

        base +=
          encodeURIComponent(key) + '=' +
          encodeURIComponent(params[key]) + '&';
      }

      return base.slice(0, -1);
    },
    basicContact: function(number, records) {
      var record;
      if (Array.isArray(records)) {
        if (records.length > 0) {
          record = records[0];
        }
      } else if (records !== null) {
        record = records;
      }

      // Only exit when no record and no phone number case.
      if (!record && !number) {
        return;
      }

      var telLength = (record && record.tel) ? record.tel.length : 0;
      var tel;
      // Look for the right tel. A record can contains more than
      // one record, so we need to identify which one is the right one.
      for (var i = 0; i < telLength; i++) {
        if (record.tel[i].value === number) {
          tel = record.tel[i];
          break;
        }
      }
      // If after looking there is no tel. matching, we apply
      // directly the number
      if (!tel) {
        tel = {type: [''], value: number, carrier: ''};
      }
      // Get the title in the standard way
      var details = Utils.getContactDetails(tel, record);
      var info = Utils.getDisplayObject(details.title || null, tel);

      return info;
    },

    /*
      Given a title for a contact, a the current information for
      an specific phone, of that contact, creates an object with
      all the information needed to display data.
    */
    getDisplayObject: function(theTitle, tel) {
      var number = tel.value;
      var type = tel.type && tel.type.length ? tel.type[0] : '';
      var data = {
        name: theTitle || number,
        number: number,
        type: type,
        carrier: tel.carrier || ''
       };

      if (Settings.supportEmailRecipient) {
        data.email = number;
        data.emailHTML = '';
       }
      return data;
    },

    /*
      TODO: It's workaround to avoid url revoke bug. Need platform fixing
            to remove the async load/remove.(Please ref bug 972245)
    */
    asyncLoadRevokeURL: function(url) {
      setTimeout(function() {
        var image = new Image();
        image.src = url;
        image.onload = image.onerror = function revokePhotoURL() {
          window.URL.revokeObjectURL(this.src);
        };
      });
    },
    /*
       TODO: Email Address check.
     */
    isEmailAddress: function(email) {
      return rmail.test(email);
    },
    /**
     * Helper function for removing notifications. It will fetch notification
     * using threadId, and close them from the returned list.
     * @param {String|Number} threadId of the target message.
     * @returns {Promise.<undefined>} Return always successfully resolved
     *  Promise with notification.close method called or console.error message.
     */
    closeNotificationsForThread: function(threadId) {
      var targetTag = 'threadId:' + threadId;

      return Notification.get({tag: targetTag})
        .then(
          function onSuccess(notifications) {
            for (var i = 0; i < notifications.length; i++) {
              notifications[i].close();
            }
          }
        ).catch(function onError(reason) {
          console.error('Notification.get(tag: ' + targetTag + '): ', reason);
        });
    },

    /**
     * Returns a function that will call specified "func" function only after it
     * stops being called for a specified wait time.
     * @param {function} func Function to call.
     * @param {number} waitTime Number of milliseconds to wait before calling
     * actual "func" function once debounced function stops being called.
     * @returns {function}
     */
    debounce: function(func, waitTime) {
      var timeout, args, context;

      var executeLater = function() {
        func.apply(context, args);
        timeout = context = args = null;
      };

      return function() {
        context = this;
        args = arguments;

        if (timeout) {
          clearTimeout(timeout);
        }

        timeout = setTimeout(executeLater, waitTime);
      };
    },

    /**
     * Returns a rate limited function, useful to reduce the number of function
     * calls when listening to user input (keypress) or browser events.
     * @params {function} func - The function that should be rate-limited
     * @params {number=300} delay - Min amount of time (ms) between two calls
     * @params {Object} options - Parameters for managing edge calls.
     * Attention : when both preventFirstCall and preventLastCall are set to
     * true, `func` may never be called.
     * @param {Boolean=false} options.preventFirstCall - Prevent first
     * call when true.
     * @param {Boolean=false} options.preventLastCall - Prevent last trailing
     * call when true.
     * @returns {function} - The rate limited function that will call the
     *  original function
     */
    throttle: function(func, delay = 300, options = {}) {
      var timeout = null;
      var previous = 0;
      var preventFirstCall = !!options.preventFirstCall;
      var preventLastCall = !!options.preventLastCall;

      if(typeof func !== 'function'){
        throw new Error('func must be a Function');
      }

      if(typeof delay !== 'number' || delay < 0){
        throw new Error('delay must be a positive number');
      }

      return function(...args) {
        var now = Date.now();
        if (!previous && preventFirstCall){
          previous = now;
        }
        var remaining = delay - (now - previous);
        if (remaining <= 0) {
          if (timeout) {
            clearTimeout(timeout);
            timeout = null;
          }
          previous = now;
          func.apply(this, args);
        } else if (!timeout && !preventLastCall) {
          timeout = setTimeout(() => {
            previous = preventFirstCall ? 0 : Date.now();
            timeout = null;

            func.apply(this, args);
          }, remaining);
        }
      };
    },

    /**
     * Shows modal alert dialog with single OK button to dismiss it.
     * @param {string|{ raw: string|Node }|{id: string, args: Object }} message
     * Message displayed in the alert. 1. If "message" is string then it's
     * considered as l10n identifier; 2. if "message" is object with "raw"
     * property then "raw" property is used as non-localizable string or as a
     * complete Node; 3. If "message" is object with "id" and/or "args"
     * properties then "id" is considered as l10n identifier and "args" as l10n
     * string arguments.
     * @param {string|{ raw: string|Node }|{id: string, args: Object }} title
     * Optional dialog title, if not passed - default title is used. For
     * possible parameter value see "message" parameter description above.
     * @returns {Promise} Return promise is always successfully resolved.
     */
    alert: function (message, title) {
      var deferred = this.Promise.defer();

      var dialog = new Dialog({
        title: title || 'modal-dialog-default-title',
        body: message,
        options: {
          cancel: {
            text: 'modal-dialog-ok-button',
            method: deferred.resolve
          }
        }
      });
      dialog.show();

      return deferred.promise;
    },

    /**
     * Shows modal confirm dialog with two buttons, first acts as cancel action,
     * second one - as confirm action.
     * @param {string|{ raw: string|Node }|{id: string, args: Object }} message
     * Message displayed in the confirm. 1. If "message" is string then it's
     * considered as l10n identifier; 2. if "message" is object with "raw"
     * property then "raw" property is used as non-localizable string or as a
     * complete Node; 3. If "message" is object with "id" and/or "args"
     * properties then "id" is considered as l10n identifier and "args" as l10n
     * string arguments.
     * @param {string|{ raw: string|Node }|{id: string, args: Object }} title
     * Optional dialog title, if not passed - default title is used. For
     * possible parameter value see "message" parameter description above.
     * @param {{ text: string|{ raw: string|Node }|{id: string, args: Object },
     * className: string}} confirmOptions Optional customizations for confirm
     * button, custom text(for possible parameter values see "message"
     * parameter description above) and custom class name.
     * @returns {Promise} Returned promise is resolved when user tap on confirm
     * button and rejected when user taps on cancel button.
     */
    confirm: function (message, title, confirmOptions) {
      var confirmButtonText = confirmOptions && confirmOptions.text ||
        'modal-dialog-ok-button';
      var confirmButtonClassName = confirmOptions && confirmOptions.className ||
        'recommend';

      var deferred = this.Promise.defer();
      var dialog = new Dialog({
        title: title || 'modal-dialog-default-title',
        body: message,
        options: {
          cancel: {
            text: 'modal-dialog-cancel-button',
            method: deferred.reject
          },

          confirm: {
            text: confirmButtonText,
            className: confirmButtonClassName,
            method: deferred.resolve
          }
        }
      });
      dialog.show();

      return deferred.promise;
    },

    /**
     * Promise related utilities
     */
    Promise: {
      /**
       * The Defer type is useful when creating promises.
       * @typedef {Object} Defer
       * @property {function(*)} resolve The Promise's resolve function.
       * @property {function(*)} reject The Promise's reject function.
       * @property {Promise} promise The actual promise.
       */

      /**
       * Returns object that contains promise and related resolve\reject methods
       * to avoid wrapping long or complex code into single Promise constructor.
       * @returns {Defer}
       */
      defer: function() {
        var deferred = {};

        deferred.promise = new Promise(function(resolve, reject) {
          deferred.resolve = resolve;
          deferred.reject = reject;
        });

        return deferred;
      },

      /**
       * Wraps a generator function that yields Promises in a way that generator
       * flow is paused until yielded Promise is resolved, so that consumer gets
       * Promise result instead of Promise instance itself.
       * See https://www.promisejs.org/generators/ as the reference.
       * @param {function(...*): Iterator} generatorFunction Generator function
       * that yields Promises.
       * @return {function}
       */
      async: function(generatorFunction) {
        return function asyncGenerator() {
          var generator = generatorFunction.apply(this, arguments);

          function handle(result) {
            if (result.done) {
              return Promise.resolve(result.value);
            }

            return Promise.resolve(result.value).then(
              (result) => handle(generator.next(result)),
              (error) => handle(generator.throw(error))
            );
          }

          try {
            return handle(generator.next());
          } catch (error) {
            return Promise.reject(error);
          }
        };
      }
    },

    /**
     * Return the localized SIM name for multi-SIM scenario or empty string for
     * single-SIM scenario
     * @param {Number} iccId Integrate circuit card identity for SIM.
     * @return {Promise} Return the async translation result like SIM1 or SIM2
     *  (locale dependent) depending on the iccId or empty string for single-sim
     *  scenario.
     */
    getSimNameByIccId(iccId) {
      var index = Settings.getServiceIdByIccId(iccId);

      if (index === null) {
        return Promise.resolve('');
      }

      return document.l10n.formatValue('sim-id-label', { id: index + 1 });
    },

    /**
     * Initializes shim host iframe with the current app instance id.
     * @param {string} appInstanceId Unique identifier of the app instance.
     * @return {Promise.<void>} Resolves once shim host is initialized.
     */
    initializeShimHost(appInstanceId) {
      var shimHostIframe = document.querySelector('.shim-host');

      var promise = typeof shimHostIframe.contentWindow.bootstrap === 'function' ?
        Promise.resolve() :
        new Promise((resolve) => {
          shimHostIframe.addEventListener('load', function onLoad() {
            shimHostIframe.removeEventListener('load', onLoad);
            resolve();
          });
        });

      return promise.then(
        () => {
          // Workaround for the Gecko XPCOM issue discussed in bug 1233552, in
          // short if we pass handler function created inside nested iframe
          // to the mozSetMessageHandler from the main window, then the handler
          // could never be called in some cases (e.g. slow environment).
          window.mozSetMessageHandler = function(type, handler) {
            navigator.mozSetMessageHandler(type, (request) => handler(request));
          };
          shimHostIframe.contentWindow.bootstrap(appInstanceId);
        }
      );
    },

    /**
     * Returns Promise instance that is resolved instantly if document is
     * visible (document.hidden === false), othewise it's resolved only once
     * `visibilitychange` event is fired.
     * @returns {Promise.<void>}
     */
    onceDocumentIsVisible() {
      if (!document.hidden) {
        return Promise.resolve();
      }

      var defer = this.Promise.defer();

      document.addEventListener('visibilitychange', function waitVisibility() {
        document.removeEventListener('visibilitychange', waitVisibility);
        defer.resolve();
      });

      return defer.promise;
    }
  };

  exports.Utils = Utils;

}(this));