/* global storage: false */
/* global textsecure: false */
/* global Whisper: false */
/* global Backbone: false */
/* global _: false */
/* global ConversationController: false */
/* global libphonenumber: false */
/* global wrapDeferred: false */
/* global dcodeIO: false */
/* global libsignal: false */

/* eslint-disable more/no-then */

// eslint-disable-next-line func-names
(function () {
  'use strict';

  window.Whisper = window.Whisper || {};

  const { Message, MIME } = window.Signal.Types;
  const { upgradeMessageSchema, loadAttachmentData } = window.Signal.Migrations;

  // TODO: Factor out private and group subclasses of Conversation

  const COLORS = [
    'red',
    'pink',
    'purple',
    'deep_purple',
    'indigo',
    'blue',
    'light_blue',
    'cyan',
    'teal',
    'green',
    'light_green',
    'orange',
    'deep_orange',
    'amber',
    'blue_grey',
  ];

  function constantTimeEqualArrayBuffers(ab1, ab2) {
    if (!(ab1 instanceof ArrayBuffer && ab2 instanceof ArrayBuffer)) {
      return false;
    }
    if (ab1.byteLength !== ab2.byteLength) {
      return false;
    }
    let result = 0;
    const ta1 = new Uint8Array(ab1);
    const ta2 = new Uint8Array(ab2);
    for (let i = 0; i < ab1.byteLength; i += 1) {
      // eslint-disable-next-line no-bitwise
      result |= ta1[i] ^ ta2[i];
    }
    return result === 0;
  }

  Whisper.Conversation = Backbone.Model.extend({
    database: Whisper.Database,
    storeName: 'conversations',
    defaults() {
      return {
        unreadCount: 0,
        verified: textsecure.storage.protocol.VerifiedStatus.DEFAULT,
      };
    },

    idForLogging() {
      if (this.isPrivate()) {
        return this.id;
      }

      return `group(${this.id})`;
    },

    handleMessageError(message, errors) {
      this.trigger('messageError', message, errors);
    },

    initialize() {
      this.ourNumber = textsecure.storage.user.getNumber();
      this.verifiedEnum = textsecure.storage.protocol.VerifiedStatus;

      // This may be overridden by ConversationController.getOrCreate, and signify
      //   our first save to the database. Or first fetch from the database.
      this.initialPromise = Promise.resolve();

      this.contactCollection = new Backbone.Collection();
      const collator = new Intl.Collator();
      this.contactCollection.comparator = (left, right) => {
        const leftLower = left.getTitle().toLowerCase();
        const rightLower = right.getTitle().toLowerCase();
        return collator.compare(leftLower, rightLower);
      };
      this.messageCollection = new Whisper.MessageCollection([], {
        conversation: this,
      });

      this.messageCollection.on('change:errors', this.handleMessageError, this);
      this.messageCollection.on('send-error', this.onMessageError, this);

      this.on('change:avatar', this.updateAvatarUrl);
      this.on('change:profileAvatar', this.updateAvatarUrl);
      this.on('change:profileKey', this.onChangeProfileKey);
      this.on('destroy', this.revokeAvatarUrl);
    },

    isMe() {
      return this.id === this.ourNumber;
    },

    addSingleMessage(message) {
      const model = this.messageCollection.add(message, { merge: true });
      this.processQuotes(this.messageCollection);
      return model;
    },

    onMessageError() {
      this.updateVerified();
    },
    safeGetVerified() {
      const promise = textsecure.storage.protocol.getVerified(this.id);
      return promise.catch(() => textsecure.storage.protocol.VerifiedStatus.DEFAULT);
    },
    updateVerified() {
      if (this.isPrivate()) {
        return Promise.all([
          this.safeGetVerified(),
          this.initialPromise,
        ]).then((results) => {
          const trust = results[0];
          // we don't return here because we don't need to wait for this to finish
          this.save({ verified: trust });
        });
      }
      const promise = this.fetchContacts();

      return promise.then(() => Promise.all(this.contactCollection.map((contact) => {
        if (!contact.isMe()) {
          return contact.updateVerified();
        }
        return Promise.resolve();
      }))).then(this.onMemberVerifiedChange.bind(this));
    },
    setVerifiedDefault(options) {
      const { DEFAULT } = this.verifiedEnum;
      return this.queueJob(() => this._setVerified(DEFAULT, options));
    },
    setVerified(options) {
      const { VERIFIED } = this.verifiedEnum;
      return this.queueJob(() => this._setVerified(VERIFIED, options));
    },
    setUnverified(options) {
      const { UNVERIFIED } = this.verifiedEnum;
      return this.queueJob(() => this._setVerified(UNVERIFIED, options));
    },
    _setVerified(verified, providedOptions) {
      const options = providedOptions || {};
      _.defaults(options, { viaSyncMessage: false, viaContactSync: false, key: null });

      const {
        VERIFIED,
        UNVERIFIED,
      } = this.verifiedEnum;

      if (!this.isPrivate()) {
        throw new Error('You cannot verify a group conversation. ' +
                            'You must verify individual contacts.');
      }

      const beginningVerified = this.get('verified');
      let promise;
      if (options.viaSyncMessage) {
        // handle the incoming key from the sync messages - need different
        // behavior if that key doesn't match the current key
        promise = textsecure.storage.protocol.processVerifiedMessage(
          this.id,
          verified,
          options.key
        );
      } else {
        promise = textsecure.storage.protocol.setVerified(this.id, verified);
      }

      let keychange;
      return promise.then((updatedKey) => {
        keychange = updatedKey;
        return new Promise((resolve => this.save({ verified }).always(resolve)));
      }).then(() => {
        // Three situations result in a verification notice in the conversation:
        //   1) The message came from an explicit verification in another client (not
        //      a contact sync)
        //   2) The verification value received by the contact sync is different
        //      from what we have on record (and it's not a transition to UNVERIFIED)
        //   3) Our local verification status is VERIFIED and it hasn't changed,
        //      but the key did change (Key1/VERIFIED to Key2/VERIFIED - but we don't
        //      want to show DEFAULT->DEFAULT or UNVERIFIED->UNVERIFIED)
        if (!options.viaContactSync ||
                (beginningVerified !== verified && verified !== UNVERIFIED) ||
                (keychange && verified === VERIFIED)) {
          return this.addVerifiedChange(
            this.id,
            verified === VERIFIED,
            { local: !options.viaSyncMessage }
          );
        }
        if (!options.viaSyncMessage) {
          return this.sendVerifySyncMessage(this.id, verified);
        }
        return Promise.resolve();
      });
    },
    sendVerifySyncMessage(number, state) {
      const promise = textsecure.storage.protocol.loadIdentityKey(number);
      return promise.then(key => textsecure.messaging.syncVerification(
        number,
        state,
        key
      ));
    },
    getIdentityKeys() {
      const lookup = {};

      if (this.isPrivate()) {
        return textsecure.storage.protocol.loadIdentityKey(this.id).then((key) => {
          lookup[this.id] = key;
          return lookup;
        }).catch((error) => {
          console.log(
            'getIdentityKeys error for conversation',
            this.idForLogging(),
            error && error.stack ? error.stack : error
          );
          return lookup;
        });
      }
      const promises = this.contactCollection.map(contact =>
        textsecure.storage.protocol.loadIdentityKey(contact.id).then(
          (key) => {
            lookup[contact.id] = key;
          },
          (error) => {
            console.log(
              'getIdentityKeys error for group member',
              contact.idForLogging(),
              error && error.stack ? error.stack : error
            );
          }
        ));

      return Promise.all(promises).then(() => lookup);
    },
    replay(error, message) {
      const replayable = new textsecure.ReplayableError(error);
      return replayable.replay(message.attributes).catch((e) => {
        console.log(
          'replay error:',
          e && e.stack ? e.stack : e
        );
      });
    },
    decryptOldIncomingKeyErrors() {
      // We want to run just once per conversation
      if (this.get('decryptedOldIncomingKeyErrors')) {
        return Promise.resolve();
      }
      console.log('decryptOldIncomingKeyErrors start for', this.idForLogging());

      const messages = this.messageCollection.filter((message) => {
        const errors = message.get('errors');
        if (!errors || !errors[0]) {
          return false;
        }
        const error = _.find(errors, e => e.name === 'IncomingIdentityKeyError');

        return Boolean(error);
      });

      const markComplete = () => {
        console.log('decryptOldIncomingKeyErrors complete for', this.idForLogging());
        return new Promise((resolve) => {
          this.save({ decryptedOldIncomingKeyErrors: true }).always(resolve);
        });
      };

      if (!messages.length) {
        return markComplete();
      }

      console.log(
        'decryptOldIncomingKeyErrors found',
        messages.length,
        'messages to process'
      );
      const safeDelete = message => new Promise((resolve) => {
        message.destroy().always(resolve);
      });

      const promise = this.getIdentityKeys();
      return promise.then(lookup => Promise.all(_.map(messages, (message) => {
        const source = message.get('source');
        const error = _.find(
          message.get('errors'),
          e => e.name === 'IncomingIdentityKeyError'
        );

        const key = lookup[source];
        if (!key) {
          return Promise.resolve();
        }

        if (constantTimeEqualArrayBuffers(key, error.identityKey)) {
          return this.replay(error, message).then(() => safeDelete(message));
        }

        return Promise.resolve();
      }))).catch((error) => {
        console.log(
          'decryptOldIncomingKeyErrors error:',
          error && error.stack ? error.stack : error
        );
      }).then(markComplete);
    },
    isVerified() {
      if (this.isPrivate()) {
        return this.get('verified') === this.verifiedEnum.VERIFIED;
      }
      if (!this.contactCollection.length) {
        return false;
      }

      return this.contactCollection.every((contact) => {
        if (contact.isMe()) {
          return true;
        }
        return contact.isVerified();
      });
    },
    isUnverified() {
      if (this.isPrivate()) {
        const verified = this.get('verified');
        return verified !== this.verifiedEnum.VERIFIED &&
          verified !== this.verifiedEnum.DEFAULT;
      }
      if (!this.contactCollection.length) {
        return true;
      }

      return this.contactCollection.any((contact) => {
        if (contact.isMe()) {
          return false;
        }
        return contact.isUnverified();
      });
    },
    getUnverified() {
      if (this.isPrivate()) {
        return this.isUnverified()
          ? new Backbone.Collection([this])
          : new Backbone.Collection();
      }
      return new Backbone.Collection(this.contactCollection.filter((contact) => {
        if (contact.isMe()) {
          return false;
        }
        return contact.isUnverified();
      }));
    },
    setApproved() {
      if (!this.isPrivate()) {
        throw new Error('You cannot set a group conversation as trusted. ' +
                            'You must set individual contacts as trusted.');
      }

      return textsecure.storage.protocol.setApproval(this.id, true);
    },
    safeIsUntrusted() {
      return textsecure.storage.protocol.isUntrusted(this.id).catch(() => false);
    },
    isUntrusted() {
      if (this.isPrivate()) {
        return this.safeIsUntrusted();
      }
      if (!this.contactCollection.length) {
        return Promise.resolve(false);
      }

      return Promise.all(this.contactCollection.map((contact) => {
        if (contact.isMe()) {
          return false;
        }
        return contact.safeIsUntrusted();
      })).then(results => _.any(results, result => result));
    },
    getUntrusted() {
      // This is a bit ugly because isUntrusted() is async. Could do the work to cache
      //   it locally, but we really only need it for this call.
      if (this.isPrivate()) {
        return this.isUntrusted().then((untrusted) => {
          if (untrusted) {
            return new Backbone.Collection([this]);
          }

          return new Backbone.Collection();
        });
      }
      return Promise.all(this.contactCollection.map((contact) => {
        if (contact.isMe()) {
          return [false, contact];
        }
        return Promise.all([contact.isUntrusted(), contact]);
      })).then((results) => {
        const filtered = _.filter(results, (result) => {
          const untrusted = result[0];
          return untrusted;
        });
        return new Backbone.Collection(_.map(filtered, (result) => {
          const contact = result[1];
          return contact;
        }));
      });
    },
    onMemberVerifiedChange() {
      // If the verified state of a member changes, our aggregate state changes.
      // We trigger both events to replicate the behavior of Backbone.Model.set()
      this.trigger('change:verified');
      this.trigger('change');
    },
    toggleVerified() {
      if (this.isVerified()) {
        return this.setVerifiedDefault();
      }
      return this.setVerified();
    },

    addKeyChange(id) {
      console.log(
        'adding key change advisory for',
        this.idForLogging(),
        id,
        this.get('timestamp')
      );

      const timestamp = Date.now();
      const message = new Whisper.Message({
        conversationId: this.id,
        type: 'keychange',
        sent_at: this.get('timestamp'),
        received_at: timestamp,
        key_changed: id,
        unread: 1,
      });
      message.save().then(this.trigger.bind(this, 'newmessage', message));
    },
    addVerifiedChange(id, verified, providedOptions) {
      const options = providedOptions || {};
      _.defaults(options, { local: true });

      if (this.isMe()) {
        console.log('refusing to add verified change advisory for our own number');
        return;
      }

      const lastMessage = this.get('timestamp') || Date.now();

      console.log(
        'adding verified change advisory for',
        this.idForLogging(),
        id,
        lastMessage
      );

      const timestamp = Date.now();
      const message = new Whisper.Message({
        conversationId: this.id,
        type: 'verified-change',
        sent_at: lastMessage,
        received_at: timestamp,
        verifiedChanged: id,
        verified,
        local: options.local,
        unread: 1,
      });
      message.save().then(this.trigger.bind(this, 'newmessage', message));

      if (this.isPrivate()) {
        ConversationController.getAllGroupsInvolvingId(id).then((groups) => {
          _.forEach(groups, (group) => {
            group.addVerifiedChange(id, verified, options);
          });
        });
      }
    },

    onReadMessage(message) {
      if (this.messageCollection.get(message.id)) {
        this.messageCollection.get(message.id).fetch();
      }

      // We mark as read everything older than this message - to clean up old stuff
      //   still marked unread in the database. If the user generally doesn't read in
      //   the desktop app, so the desktop app only gets read syncs, we can very
      //   easily end up with messages never marked as read (our previous early read
      //   sync handling, read syncs never sent because app was offline)

      // We queue it because we often get a whole lot of read syncs at once, and
      //   their markRead calls could very easily overlap given the async pull from DB.

      // Lastly, we don't send read syncs for any message marked read due to a read
      //   sync. That's a notification explosion we don't need.
      return this.queueJob(() => this.markRead(
        message.get('received_at'),
        { sendReadReceipts: false }
      ));
    },

    getUnread() {
      const conversationId = this.id;
      const unreadMessages = new Whisper.MessageCollection();
      return new Promise((resolve => unreadMessages.fetch({
        index: {
          // 'unread' index
          name: 'unread',
          lower: [conversationId],
          upper: [conversationId, Number.MAX_VALUE],
        },
      }).always(() => {
        resolve(unreadMessages);
      })));
    },

    validate(attributes) {
      const required = ['id', 'type'];
      const missing = _.filter(required, attr => !attributes[attr]);
      if (missing.length) { return `Conversation must have ${missing}`; }

      if (attributes.type !== 'private' && attributes.type !== 'group') {
        return `Invalid conversation type: ${attributes.type}`;
      }

      const error = this.validateNumber();
      if (error) {
        return error;
      }

      this.updateTokens();

      return null;
    },

    validateNumber() {
      if (this.isPrivate()) {
        const regionCode = storage.get('regionCode');
        const number = libphonenumber.util.parseNumber(this.id, regionCode);
        if (number.isValidNumber) {
          this.set({ id: number.e164 });
          return null;
        }

        return number.error || 'Invalid phone number';
      }

      return null;
    },

    updateTokens() {
      let tokens = [];
      const name = this.get('name');
      if (typeof name === 'string') {
        tokens.push(name.toLowerCase());
        tokens = tokens.concat(name.trim().toLowerCase().split(/[\s\-_()+]+/));
      }
      if (this.isPrivate()) {
        const regionCode = storage.get('regionCode');
        const number = libphonenumber.util.parseNumber(this.id, regionCode);
        tokens.push(
          number.nationalNumber,
          number.countryCode + number.nationalNumber
        );
      }
      this.set({ tokens });
    },

    queueJob(callback) {
      const previous = this.pending || Promise.resolve();

      const taskWithTimeout = textsecure.createTaskWithTimeout(
        callback,
        `conversation ${this.idForLogging()}`
      );

      this.pending = previous.then(taskWithTimeout, taskWithTimeout);
      const current = this.pending;

      current.then(() => {
        if (this.pending === current) {
          delete this.pending;
        }
      });

      return current;
    },

    getRecipients() {
      if (this.isPrivate()) {
        return [this.id];
      }
      const me = textsecure.storage.user.getNumber();
      return _.without(this.get('members'), me);
    },

    blobToArrayBuffer(blob) {
      return new Promise((resolve, reject) => {
        const fileReader = new FileReader();

        fileReader.onload = e => resolve(e.target.result);
        fileReader.onerror = reject;
        fileReader.onabort = reject;

        fileReader.readAsArrayBuffer(blob);
      });
    },

    async makeThumbnailAttachment(attachment) {
      const attachmentWithData = await loadAttachmentData(attachment);
      const { data, contentType } = attachmentWithData;
      const objectUrl = this.makeObjectUrl(data, contentType);
      const thumbnail = await Whisper.FileInputView.makeThumbnail(128, objectUrl);
      URL.revokeObjectURL(objectUrl);

      const arrayBuffer = await this.blobToArrayBuffer(thumbnail);
      const finalContentType = 'image/png';
      const finalObjectUrl = this.makeObjectUrl(arrayBuffer, finalContentType);

      return {
        data: arrayBuffer,
        objectUrl: finalObjectUrl,
        contentType: finalContentType,
      };
    },

    async makeQuote(quotedMessage) {
      const contact = quotedMessage.getContact();
      const attachments = quotedMessage.get('attachments');

      return {
        author: contact.id,
        id: quotedMessage.get('sent_at'),
        text: quotedMessage.get('body'),
        attachments: await Promise.all((attachments || []).map(async (attachment) => {
          const { contentType } = attachment;
          const willMakeThumbnail = MIME.isImage(contentType);

          return {
            contentType,
            fileName: attachment.fileName,
            thumbnail: willMakeThumbnail
              ? await this.makeThumbnailAttachment(attachment)
              : null,
          };
        })),
      };
    },

    sendMessage(body, attachments, quote) {
      this.queueJob(async () => {
        const now = Date.now();

        console.log(
          'Sending message to conversation',
          this.idForLogging(),
          'with timestamp',
          now
        );

        const messageWithSchema = await upgradeMessageSchema({
          type: 'outgoing',
          body,
          conversationId: this.id,
          quote,
          attachments,
          sent_at: now,
          received_at: now,
          expireTimer: this.get('expireTimer'),
          recipients: this.getRecipients(),
        });
        const message = this.addSingleMessage(messageWithSchema);

        if (this.isPrivate()) {
          message.set({ destination: this.id });
        }
        message.save();

        this.save({
          active_at: now,
          timestamp: now,
          lastMessage: message.getNotificationText(),
        });

        const conversationType = this.get('type');
        const sendFunction = (() => {
          switch (conversationType) {
            case Message.PRIVATE:
              return textsecure.messaging.sendMessageToNumber;
            case Message.GROUP:
              return textsecure.messaging.sendMessageToGroup;
            default:
              throw new TypeError(`Invalid conversation type: '${conversationType}'`);
          }
        })();

        let profileKey;
        if (this.get('profileSharing')) {
          profileKey = storage.get('profileKey');
        }

        const attachmentsWithData =
            await Promise.all(messageWithSchema.attachments.map(loadAttachmentData));
        message.send(sendFunction(
          this.get('id'),
          body,
          attachmentsWithData,
          quote,
          now,
          this.get('expireTimer'),
          profileKey
        ));
      });
    },

    async updateLastMessage() {
      const collection = new Whisper.MessageCollection();
      await collection.fetchConversation(this.id, 1);
      const lastMessage = collection.at(0);

      const lastMessageUpdate = window.Signal.Types.Conversation.createLastMessageUpdate({
        currentLastMessageText: this.get('lastMessage') || null,
        currentTimestamp: this.get('timestamp') || null,
        lastMessage: lastMessage ? lastMessage.toJSON() : null,
        lastMessageNotificationText: lastMessage
          ? lastMessage.getNotificationText() : null,
      });

      this.set(lastMessageUpdate);

      if (this.hasChanged('lastMessage') || this.hasChanged('timestamp')) {
        this.save();
      }
    },

    updateExpirationTimer(
      providedExpireTimer,
      providedSource,
      receivedAt,
      providedOptions
    ) {
      const options = providedOptions || {};
      let expireTimer = providedExpireTimer;
      let source = providedSource;

      _.defaults(options, { fromSync: false });

      if (!expireTimer) {
        expireTimer = null;
      }
      if (this.get('expireTimer') === expireTimer ||
            (!expireTimer && !this.get('expireTimer'))) {
        return Promise.resolve();
      }

      console.log(
        'Updating expireTimer for conversation',
        this.idForLogging(),
        'to',
        expireTimer,
        'via',
        source
      );
      source = source || textsecure.storage.user.getNumber();
      const timestamp = receivedAt || Date.now();

      const message = this.messageCollection.add({
        conversationId: this.id,
        type: receivedAt ? 'incoming' : 'outgoing',
        sent_at: timestamp,
        received_at: timestamp,
        flags: textsecure.protobuf.DataMessage.Flags.EXPIRATION_TIMER_UPDATE,
        expirationTimerUpdate: {
          expireTimer,
          source,
          fromSync: options.fromSync,
        },
      });
      if (this.isPrivate()) {
        message.set({ destination: this.id });
      }
      if (message.isOutgoing()) {
        message.set({ recipients: this.getRecipients() });
      }

      return Promise.all([
        wrapDeferred(message.save()),
        wrapDeferred(this.save({ expireTimer })),
      ]).then(() => {
        if (message.isIncoming()) {
          return message;
        }

        // change was made locally, send it to the number/group
        let sendFunc;
        if (this.get('type') === 'private') {
          sendFunc = textsecure.messaging.sendExpirationTimerUpdateToNumber;
        } else {
          sendFunc = textsecure.messaging.sendExpirationTimerUpdateToGroup;
        }
        let profileKey;
        if (this.get('profileSharing')) {
          profileKey = storage.get('profileKey');
        }
        const promise = sendFunc(
          this.get('id'),
          this.get('expireTimer'),
          message.get('sent_at'),
          profileKey
        );

        return message.send(promise).then(() => message);
      });
    },

    isSearchable() {
      return !this.get('left') || !!this.get('lastMessage');
    },

    endSession() {
      if (this.isPrivate()) {
        const now = Date.now();
        const message = this.messageCollection.create({
          conversationId: this.id,
          type: 'outgoing',
          sent_at: now,
          received_at: now,
          destination: this.id,
          recipients: this.getRecipients(),
          flags: textsecure.protobuf.DataMessage.Flags.END_SESSION,
        });
        message.send(textsecure.messaging.resetSession(this.id, now));
      }
    },

    updateGroup(providedGroupUpdate) {
      let groupUpdate = providedGroupUpdate;

      if (this.isPrivate()) {
        throw new Error('Called update group on private conversation');
      }
      if (groupUpdate === undefined) {
        groupUpdate = this.pick(['name', 'avatar', 'members']);
      }
      const now = Date.now();
      const message = this.messageCollection.create({
        conversationId: this.id,
        type: 'outgoing',
        sent_at: now,
        received_at: now,
        group_update: groupUpdate,
      });
      message.send(textsecure.messaging.updateGroup(
        this.id,
        this.get('name'),
        this.get('avatar'),
        this.get('members')
      ));
    },

    leaveGroup() {
      const now = Date.now();
      if (this.get('type') === 'group') {
        this.save({ left: true });
        const message = this.messageCollection.create({
          group_update: { left: 'You' },
          conversationId: this.id,
          type: 'outgoing',
          sent_at: now,
          received_at: now,
        });
        message.send(textsecure.messaging.leaveGroup(this.id));
      }
    },

    markRead(newestUnreadDate, providedOptions) {
      const options = providedOptions || {};
      _.defaults(options, { sendReadReceipts: true });

      const conversationId = this.id;
      Whisper.Notifications.remove(Whisper.Notifications.where({
        conversationId,
      }));

      return this.getUnread().then((providedUnreadMessages) => {
        let unreadMessages = providedUnreadMessages;

        const promises = [];
        const oldUnread = unreadMessages.filter(message =>
          message.get('received_at') <= newestUnreadDate);

        let read = _.map(oldUnread, (providedM) => {
          let m = providedM;

          if (this.messageCollection.get(m.id)) {
            m = this.messageCollection.get(m.id);
          } else {
            console.log('Marked a message as read in the database, but ' +
                                'it was not in messageCollection.');
          }
          promises.push(m.markRead());
          const errors = m.get('errors');
          return {
            sender: m.get('source'),
            timestamp: m.get('sent_at'),
            hasErrors: Boolean(errors && errors.length),
          };
        });

        // Some messages we're marking read are local notifications with no sender
        read = _.filter(read, m => Boolean(m.sender));
        unreadMessages = unreadMessages.filter(m => Boolean(m.isIncoming()));

        const unreadCount = unreadMessages.length - read.length;
        const promise = new Promise((resolve, reject) => {
          this.save({ unreadCount }).then(resolve, reject);
        });
        promises.push(promise);

        // If a message has errors, we don't want to send anything out about it.
        //   read syncs - let's wait for a client that really understands the message
        //      to mark it read. we'll mark our local error read locally, though.
        //   read receipts - here we can run into infinite loops, where each time the
        //      conversation is viewed, another error message shows up for the contact
        read = read.filter(item => !item.hasErrors);

        if (read.length && options.sendReadReceipts) {
          console.log('Sending', read.length, 'read receipts');
          promises.push(textsecure.messaging.syncReadMessages(read));

          if (storage.get('read-receipt-setting')) {
            _.each(_.groupBy(read, 'sender'), (receipts, sender) => {
              const timestamps = _.map(receipts, 'timestamp');
              promises.push(textsecure.messaging.sendReadReceipts(sender, timestamps));
            });
          }
        }

        return Promise.all(promises);
      });
    },

    onChangeProfileKey() {
      if (this.isPrivate()) {
        this.getProfiles();
      }
    },

    getProfiles() {
      // request all conversation members' keys
      let ids = [];
      if (this.isPrivate()) {
        ids = [this.id];
      } else {
        ids = this.get('members');
      }
      return Promise.all(_.map(ids, this.getProfile));
    },

    getProfile(id) {
      if (!textsecure.messaging) {
        const message = 'Conversation.getProfile: textsecure.messaging not available';
        return Promise.reject(new Error(message));
      }

      return textsecure.messaging.getProfile(id).then((profile) => {
        const identityKey = dcodeIO.ByteBuffer.wrap(
          profile.identityKey,
          'base64'
        ).toArrayBuffer();

        return textsecure.storage.protocol.saveIdentity(
          `${id}.1`,
          identityKey,
          false
        ).then((changed) => {
          if (changed) {
            // save identity will close all sessions except for .1, so we
            // must close that one manually.
            const address = new libsignal.SignalProtocolAddress(id, 1);
            console.log('closing session for', address.toString());
            const sessionCipher = new libsignal.SessionCipher(
              textsecure.storage.protocol,
              address
            );
            return sessionCipher.closeOpenSessionForDevice();
          }
          return Promise.resolve();
        }).then(() => {
          const c = ConversationController.get(id);
          return Promise.all([
            c.setProfileName(profile.name),
            c.setProfileAvatar(profile.avatar),
          ]).then(
            // success
            () => new Promise((resolve, reject) => {
              c.save().then(resolve, reject);
            }),
            // fail
            (e) => {
              if (e.name === 'ProfileDecryptError') {
              // probably the profile key has changed.
                console.log(
                  'decryptProfile error:',
                  id,
                  profile,
                  e && e.stack ? e.stack : e
                );
              }
            }
          );
        });
      }).catch((error) => {
        console.log(
          'getProfile error:',
          error && error.stack ? error.stack : error
        );
      });
    },
    setProfileName(encryptedName) {
      const key = this.get('profileKey');
      if (!key) {
        return Promise.resolve();
      }

      try {
        // decode
        const data = dcodeIO.ByteBuffer.wrap(encryptedName, 'base64').toArrayBuffer();

        // decrypt
        return textsecure.crypto.decryptProfileName(data, key).then((decrypted) => {
          // encode
          const name = dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8');

          // set
          this.set({ profileName: name });
        });
      } catch (e) {
        return Promise.reject(e);
      }
    },
    setProfileAvatar(avatarPath) {
      if (!avatarPath) {
        return Promise.resolve();
      }

      return textsecure.messaging.getAvatar(avatarPath).then((avatar) => {
        const key = this.get('profileKey');
        if (!key) {
          return Promise.resolve();
        }
        // decrypt
        return textsecure.crypto.decryptProfile(avatar, key).then((decrypted) => {
          // set
          this.set({
            profileAvatar: {
              data: decrypted,
              contentType: 'image/jpeg',
              size: decrypted.byteLength,
            },
          });
        });
      });
    },
    setProfileKey(key) {
      return new Promise((resolve, reject) => {
        if (!constantTimeEqualArrayBuffers(this.get('profileKey'), key)) {
          this.save({ profileKey: key }).then(resolve, reject);
        } else {
          resolve();
        }
      });
    },

    makeKey(author, id) {
      return `${author}-${id}`;
    },
    doesMessageMatch(id, author, message) {
      const messageAuthor = message.getContact().id;

      if (author !== messageAuthor) {
        return false;
      }
      if (id !== message.get('sent_at')) {
        return false;
      }
      return true;
    },
    needData(attachments) {
      if (!attachments || attachments.length === 0) {
        return false;
      }

      const first = attachments[0];
      const { thumbnail, contentType } = first;

      return thumbnail || MIME.isVideo(contentType) || MIME.isImage(contentType);
    },
    forceRender(message) {
      message.trigger('change', message);
    },
    makeObjectUrl(data, contentType) {
      const blob = new Blob([data], {
        type: contentType,
      });
      return URL.createObjectURL(blob);
    },
    makeMessagesLookup(messages) {
      return messages.reduce((acc, message) => {
        const { source, sent_at: sentAt } = message.attributes;

        // Checking for notification messages (safety number change, timer change)
        if (!source && message.isIncoming()) {
          return acc;
        }

        const contact = message.getContact();
        if (!contact) {
          return acc;
        }

        const author = contact.id;
        const key = this.makeKey(author, sentAt);

        acc[key] = message;

        return acc;
      }, {});
    },
    async loadQuotedMessageFromDatabase(message) {
      const { quote } = message.attributes;
      const { attachments, id, author } = quote;
      const first = attachments[0];

      // Maybe in the future we could try to pull the thumbnail from a video ourselves,
      //   but for now we will rely on incoming thumbnails only.
      if (!MIME.isImage(first.contentType)) {
        return false;
      }

      const collection = new Whisper.MessageCollection();
      await collection.fetchSentAt(id);
      const queryMessage = collection.find(m => this.doesMessageMatch(id, author, m));

      if (!queryMessage) {
        return false;
      }

      const queryAttachments = queryMessage.attachments || [];
      if (queryAttachments.length === 0) {
        return false;
      }

      const queryFirst = queryAttachments[0];
      try {
        // eslint-disable-next-line no-param-reassign
        message.quoteThumbnail = await this.makeThumbnailAttachment(queryFirst);
        return true;
      } catch (error) {
        console.log(
          'Problem loading attachment data for quoted message from database',
          error && error.stack ? error.stack : error
        );
        return false;
      }
    },
    async loadQuotedMessage(message, quotedMessage) {
      // eslint-disable-next-line no-param-reassign
      message.quotedMessage = quotedMessage;

      const { quote } = message.attributes;
      const { attachments } = quote;
      const first = attachments[0];

      // Maybe in the future we could try to pull thumbnails video ourselves,
      //   but for now we will rely on incoming thumbnails only.
      if (!first || !MIME.isImage(first.contentType)) {
        return;
      }

      const quotedAttachments = quotedMessage.get('attachments') || [];
      if (quotedAttachments.length === 0) {
        return;
      }

      try {
        const queryFirst = quotedAttachments[0];

        // eslint-disable-next-line no-param-reassign
        message.quoteThumbnail = await this.makeThumbnailAttachment(queryFirst);
      } catch (error) {
        console.log(
          'Problem loading attachment data for quoted message',
          error && error.stack ? error.stack : error
        );
      }
    },
    async loadQuoteThumbnail(message) {
      const { quote } = message.attributes;
      const { attachments } = quote;
      const first = attachments[0];
      if (!first) {
        return false;
      }

      const { thumbnail } = first;

      if (!thumbnail) {
        return false;
      }
      const thumbnailWithData = await loadAttachmentData(thumbnail);
      thumbnailWithData.objectUrl = this.makeObjectUrl(
        thumbnailWithData.data,
        thumbnailWithData.contentType
      );

      // If we update this data in place, there's the risk that this data could be
      //   saved back to the database
      // eslint-disable-next-line no-param-reassign
      message.quoteThumbnail = thumbnailWithData;

      return true;
    },
    async processQuotes(messages) {
      const lookup = this.makeMessagesLookup(messages);

      const promises = messages.map(async (message) => {
        const { quote } = message.attributes;
        if (!quote) {
          return;
        }

        // If we already have a quoted message, then we exit early. If we don't have it,
        //   then we'll continue to look again for an in-memory message to use. Why? This
        //   will enable us to scroll to it when the user clicks.
        if (messages.quotedMessage) {
          return;
        }

        // 1. Check to see if we've already loaded the target message into memory
        const { author, id } = quote;
        const key = this.makeKey(author, id);
        const quotedMessage = lookup[key];

        if (quotedMessage) {
          // eslint-disable-next-line no-param-reassign
          await this.loadQuotedMessage(message, quotedMessage);

          // Note: in the future when we generate our own thumbnail we won't need to rely
          //   on incoming thumbnail if we have our local message in hand.
          if (!message.quotedMessage.imageUrl) {
            await this.loadQuoteThumbnail(message, quote);
          }

          this.forceRender(message);
          return;
        }

        // We only go further if we need more data for this message. It's always important
        //   to grab the quoted message to allow for navigating to it by clicking.
        const { attachments } = quote;
        if (!this.needData(attachments)) {
          return;
        }

        // We've don't want to go to the database or load thumbnails a second time.
        if (message.quoteIsProcessed) {
          return;
        }
        // eslint-disable-next-line no-param-reassign
        message.quoteIsProcessed = true;

        // 2. Go to the database for the real referenced attachment
        const loaded = await this.loadQuotedMessageFromDatabase(message, id);
        if (loaded) {
          // Note: in the future when we generate our own thumbnail we won't need to rely
          //   on incoming thumbnail if we have our local message in hand.
          if (!message.quotedMessageFromDatabase.imageUrl) {
            await this.loadQuoteThumbnail(message, quote);
          }

          this.forceRender(message);
          return;
        }

        // 3. Finally, use the provided thumbnail
        const gotThumbnail = await this.loadQuoteThumbnail(message, quote);
        if (gotThumbnail) {
          this.forceRender(message);
        }
      });

      return Promise.all(promises);
    },

    async fetchMessages() {
      if (!this.id) {
        throw new Error('This conversation has no id!');
      }

      await this.messageCollection.fetchConversation(
        this.id,
        null,
        this.get('unreadCount')
      );

      // We kick this process off, but don't wait for it. If async updates happen on a
      //   given Message, 'change' will be triggered
      this.processQuotes(this.messageCollection);
    },

    hasMember(number) {
      return _.contains(this.get('members'), number);
    },
    fetchContacts() {
      if (this.isPrivate()) {
        this.contactCollection.reset([this]);
        return Promise.resolve();
      }
      const members = this.get('members') || [];
      const promises = members.map(number =>
        ConversationController.getOrCreateAndWait(number, 'private'));

      return Promise.all(promises).then((contacts) => {
        _.forEach(contacts, (contact) => {
          this.listenTo(contact, 'change:verified', this.onMemberVerifiedChange);
        });

        this.contactCollection.reset(contacts);
      });
    },

    destroyMessages() {
      this.messageCollection.fetch({
        index: {
          // 'conversation' index on [conversationId, received_at]
          name: 'conversation',
          lower: [this.id],
          upper: [this.id, Number.MAX_VALUE],
        },
      }).then(() => {
        const { models } = this.messageCollection;
        this.messageCollection.reset([]);
        _.each(models, (message) => {
          message.destroy();
        });
        this.save({
          lastMessage: null,
          timestamp: null,
          active_at: null,
        });
      });
    },

    getName() {
      if (this.isPrivate()) {
        return this.get('name');
      }
      return this.get('name') || 'Unknown group';
    },

    getTitle() {
      if (this.isPrivate()) {
        return this.get('name') || this.getNumber();
      }
      return this.get('name') || 'Unknown group';
    },

    getProfileName() {
      if (this.isPrivate() && !this.get('name')) {
        return this.get('profileName');
      }
      return null;
    },

    getDisplayName() {
      if (!this.isPrivate()) {
        return this.getTitle();
      }

      const name = this.get('name');
      if (name) {
        return name;
      }

      const profileName = this.get('profileName');
      if (profileName) {
        return `${this.getNumber()} ~${profileName}`;
      }

      return this.getNumber();
    },

    getNumber() {
      if (!this.isPrivate()) {
        return '';
      }
      const number = this.id;
      try {
        const parsedNumber = libphonenumber.parse(number);
        const regionCode = libphonenumber.getRegionCodeForNumber(parsedNumber);
        if (regionCode === storage.get('regionCode')) {
          return libphonenumber.format(
            parsedNumber,
            libphonenumber.PhoneNumberFormat.NATIONAL
          );
        }
        return libphonenumber.format(
          parsedNumber,
          libphonenumber.PhoneNumberFormat.INTERNATIONAL
        );
      } catch (e) {
        return number;
      }
    },

    isPrivate() {
      return this.get('type') === 'private';
    },

    revokeAvatarUrl() {
      if (this.avatarUrl) {
        URL.revokeObjectURL(this.avatarUrl);
        this.avatarUrl = null;
      }
    },

    updateAvatarUrl(silent) {
      this.revokeAvatarUrl();
      const avatar = this.get('avatar') || this.get('profileAvatar');
      if (avatar) {
        this.avatarUrl = URL.createObjectURL(new Blob(
          [avatar.data],
          { type: avatar.contentType }
        ));
      } else {
        this.avatarUrl = null;
      }
      if (!silent) {
        this.trigger('change');
      }
    },
    getColor() {
      const title = this.get('name');
      let color = this.get('color');
      if (!color) {
        if (this.isPrivate()) {
          if (title) {
            color = COLORS[Math.abs(this.hashCode()) % 15];
          } else {
            color = 'grey';
          }
        } else {
          color = 'default';
        }
      }
      return color;
    },
    getAvatar() {
      if (this.avatarUrl === undefined) {
        this.updateAvatarUrl(true);
      }

      const title = this.get('name');
      const color = this.getColor();

      if (this.avatarUrl) {
        return { url: this.avatarUrl, color };
      } else if (this.isPrivate()) {
        return {
          color,
          content: title ? title.trim()[0] : '#',
        };
      }
      return { url: 'images/group_default.png', color };
    },

    getNotificationIcon() {
      return new Promise((resolve) => {
        const avatar = this.getAvatar();
        if (avatar.url) {
          resolve(avatar.url);
        } else {
          resolve(new Whisper.IdenticonSVGView(avatar).getDataUrl());
        }
      });
    },

    notify(message) {
      if (!message.isIncoming()) {
        return Promise.resolve();
      }
      const conversationId = this.id;

      return ConversationController.getOrCreateAndWait(message.get('source'), 'private')
        .then(sender => sender.getNotificationIcon().then((iconUrl) => {
          console.log('adding notification');
          Whisper.Notifications.add({
            title: sender.getTitle(),
            message: message.getNotificationText(),
            iconUrl,
            imageUrl: message.getImageUrl(),
            conversationId,
            messageId: message.id,
          });
        }));
    },
    hashCode() {
      if (this.hash === undefined) {
        const string = this.getTitle() || '';
        if (string.length === 0) {
          return 0;
        }
        let hash = 0;
        for (let i = 0; i < string.length; i += 1) {
          // eslint-disable-next-line no-bitwise
          hash = ((hash << 5) - hash) + string.charCodeAt(i);
          // eslint-disable-next-line no-bitwise
          hash &= hash; // Convert to 32bit integer
        }

        this.hash = hash;
      }
      return this.hash;
    },
  });

  Whisper.ConversationCollection = Backbone.Collection.extend({
    database: Whisper.Database,
    storeName: 'conversations',
    model: Whisper.Conversation,

    comparator(m) {
      return -m.get('timestamp');
    },

    destroyAll() {
      return Promise.all(this.models.map(m => new Promise((resolve, reject) => {
        m.destroy().then(resolve).fail(reject);
      })));
    },

    search(providedQuery) {
      let query = providedQuery.trim().toLowerCase();
      if (query.length > 0) {
        query = query.replace(/[-.()]*/g, '').replace(/^\+(\d*)$/, '$1');
        const lastCharCode = query.charCodeAt(query.length - 1);
        const nextChar = String.fromCharCode(lastCharCode + 1);
        const upper = query.slice(0, -1) + nextChar;
        return new Promise((resolve) => {
          this.fetch({
            index: {
              name: 'search', // 'search' index on tokens array
              lower: query,
              upper,
              excludeUpper: true,
            },
          }).always(resolve);
        });
      }
      return Promise.resolve();
    },

    fetchAlphabetical() {
      return new Promise((resolve) => {
        this.fetch({
          index: {
            name: 'search', // 'search' index on tokens array
          },
          limit: 100,
        }).always(resolve);
      });
    },

    fetchGroups(number) {
      return new Promise((resolve) => {
        this.fetch({
          index: {
            name: 'group',
            only: number,
          },
        }).always(resolve);
      });
    },
  });

  Whisper.Conversation.COLORS = COLORS.concat(['grey', 'default']).join(' ');

  // Special collection for fetching all the groups a certain number appears in
  Whisper.GroupCollection = Backbone.Collection.extend({
    database: Whisper.Database,
    storeName: 'conversations',
    model: Whisper.Conversation,
    fetchGroups(number) {
      return new Promise((resolve) => {
        this.fetch({
          index: {
            name: 'group',
            only: number,
          },
        }).always(resolve);
      });
    },
  });
}());