/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

const EXPORTED_SYMBOLS = ["ImapClient"];

var { AppConstants } = ChromeUtils.importESModule(
  "resource://gre/modules/AppConstants.sys.mjs"
);
var { clearTimeout, setTimeout } = ChromeUtils.importESModule(
  "resource://gre/modules/Timer.sys.mjs"
);
var { MailStringUtils } = ChromeUtils.import(
  "resource:///modules/MailStringUtils.jsm"
);
var { ImapAuthenticator } = ChromeUtils.import(
  "resource:///modules/MailAuthenticator.jsm"
);
var { ImapResponse } = ChromeUtils.import(
  "resource:///modules/ImapResponse.jsm"
);
var { ImapUtils } = ChromeUtils.import("resource:///modules/ImapUtils.jsm");

// There can be multiple ImapClient running concurrently, assign each logger a
// unique prefix.
let loggerInstanceId = 0;

const PR_UINT32_MAX = 0xffffffff;

/**
 * A class to interact with IMAP server.
 */
class ImapClient {
  _logger = console.createInstance({
    prefix: `mailnews.imap.${loggerInstanceId++}`,
    maxLogLevel: "Warn",
    maxLogLevelPref: "mailnews.imap.loglevel",
  });

  /**
   * @param {nsIImapIncomingServer} server - The associated server instance.
   */
  constructor(server) {
    this._server = server.QueryInterface(Ci.nsIMsgIncomingServer);
    this._serverSink = this._server.QueryInterface(Ci.nsIImapServerSink);
    this._authenticator = new ImapAuthenticator(server);

    // Auth methods detected from the CAPABILITY response.
    this._supportedAuthMethods = [];
    // Subset of _supportedAuthMethods that are allowed by user preference.
    this._possibleAuthMethods = [];
    // Auth methods set by user preference.
    this._preferredAuthMethods =
      {
        [Ci.nsMsgAuthMethod.passwordCleartext]: ["PLAIN", "LOGIN"],
        [Ci.nsMsgAuthMethod.passwordEncrypted]: ["CRAM-MD5"],
        [Ci.nsMsgAuthMethod.GSSAPI]: ["GSSAPI"],
        [Ci.nsMsgAuthMethod.NTLM]: ["NTLM"],
        [Ci.nsMsgAuthMethod.OAuth2]: ["XOAUTH2"],
        [Ci.nsMsgAuthMethod.External]: ["EXTERNAL"],
      }[server.authMethod] || [];
    // The next auth method to try if the current failed.
    this._nextAuthMethod = null;

    this._tag = Math.floor(100 * Math.random());
    this._charsetManager = Cc[
      "@mozilla.org/charset-converter-manager;1"
    ].getService(Ci.nsICharsetConverterManager);

    this._messageUids = [];
    this._messages = new Map();

    this._loadPrefs();
  }

  /**
   * @type {boolean} - Whether the socket is open.
   */
  get isOnline() {
    return this._socket?.readyState == "open";
  }

  /**
   * Load imap related preferences, many behaviors depend on these pref values.
   */
  _loadPrefs() {
    this._prefs = {
      tcpTimeout: Services.prefs.getIntPref("mailnews.tcptimeout"),
    };
  }

  /**
   * Reset some internal states to be safely reused.
   */
  _reset() {
    this.onData = () => {};
    this.onDone = () => {};

    this._actionAfterDiscoverAllFolders = null;
    this.channel = null;
    this._urlListener = null;
    this._msgWindow = null;
    this._authenticating = false;
    this.verifyLogon = false;
    this._idling = false;
    if (this._idleTimer) {
      clearTimeout(this._idleTimer);
      this._idleTimer = null;
    }
  }

  /**
   * Initiate a connection to the server
   */
  connect() {
    if (this.isOnline) {
      // Reuse the connection.
      this.onReady();
      this._setSocketTimeout(this._prefs.tcpTimeout);
    } else {
      let hostname = this._server.hostName.toLowerCase();
      this._logger.debug(`Connecting to ${hostname}:${this._server.port}`);
      this._greeted = false;
      this._capabilities = null;
      this._secureTransport = this._server.socketType == Ci.nsMsgSocketType.SSL;
      this._socket = new TCPSocket(hostname, this._server.port, {
        binaryType: "arraybuffer",
        useSecureTransport: this._secureTransport,
      });
      this._socket.onopen = this._onOpen;
      this._socket.onerror = this._onError;
    }
  }

  /**
   * Set socket timeout in seconds.
   *
   * @param {number} timeout - The timeout in seconds.
   */
  _setSocketTimeout(timeout) {
    this._socket.transport?.setTimeout(
      Ci.nsISocketTransport.TIMEOUT_READ_WRITE,
      timeout
    );
  }

  /**
   * Construct an nsIMsgMailNewsUrl instance, setup urlListener to notify when
   * the current request is finished.
   *
   * @param {nsIUrlListener} urlListener - Callback for the request.
   * @param {nsIMsgWindow} msgWindow - The associated msg window.
   * @param {nsIMsgMailNewsUrl} [runningUri] - The url to run, if provided.
   * @returns {nsIMsgMailNewsUrl}
   */
  startRunningUrl(urlListener, msgWindow, runningUri) {
    this._urlListener = urlListener;
    this._msgWindow = msgWindow;
    this.runningUri = runningUri;
    if (!this.runningUri) {
      this.runningUri = Services.io.newURI(
        `imap://${this._server.hostName}:${this._server.port}`
      );
    }
    this._urlListener?.OnStartRunningUrl(this.runningUri, Cr.NS_OK);
    this.runningUri
      .QueryInterface(Ci.nsIMsgMailNewsUrl)
      .SetUrlState(true, Cr.NS_OK);
    return this.runningUri;
  }

  /**
   * Discover all folders if the current server hasn't already discovered.
   */
  _discoverAllFoldersIfNecessary = () => {
    if (this._server.hasDiscoveredFolders) {
      this.onReady();
      return;
    }
    this._actionAfterDiscoverAllFolders = this.onReady;
    this.discoverAllFolders(this._server.rootFolder);
  };

  /**
   * Discover all folders.
   *
   * @param {nsIMsgFolder} folder - The associated folder.
   */
  discoverAllFolders(folder) {
    this._logger.debug("discoverAllFolders", folder.URI);

    let handleListResponse = res => {
      this._hasTrash = res.mailboxes.some(
        mailbox => mailbox.flags & ImapUtils.FLAG_IMAP_TRASH
      );
      if (!this._hasTrash) {
        let trashFolderName = this._server.trashFolderName.toLowerCase();
        let trashMailbox = res.mailboxes.find(
          mailbox => mailbox.name.toLowerCase() == trashFolderName
        );
        if (trashMailbox) {
          this._hasTrash = true;
          trashMailbox.flags |= ImapUtils.FLAG_IMAP_TRASH;
        }
      }
      for (let mailbox of res.mailboxes) {
        this._serverSink.possibleImapMailbox(
          mailbox.name.replaceAll(mailbox.delimiter, "/"),
          mailbox.delimiter,
          mailbox.flags
        );
      }
    };

    if (this._capabilities.includes("LIST-EXTENDED")) {
      this._nextAction = res => {
        handleListResponse(res);
        this._actionFinishFolderDiscovery();
      };
      let command = 'LIST (SUBSCRIBED) "" "*"';
      if (this._capabilities.includes("SPECIAL-USE")) {
        command += " RETURN (SPECIAL-USE)"; // rfc6154
      }
      this._sendTagged(command);
      return;
    }

    this._nextAction = res => {
      this._nextAction = res2 => {
        // Per rfc3501#section-6.3.9, if LSUB returns different flags from LIST,
        // use the LIST responses.
        for (let mailbox of res2.mailboxes) {
          let mailboxFromList = res.mailboxes.find(x => x.name == mailbox.name);
          if (
            mailboxFromList?.flags &&
            mailboxFromList?.flags != mailbox.flags
          ) {
            mailbox.flags = mailboxFromList.flags;
          }
        }
        handleListResponse(res2);
        this._actionFinishFolderDiscovery();
      };
      this._sendTagged('LSUB "" "*"');
    };
    let command = 'LIST "" "*"';
    if (this._capabilities.includes("SPECIAL-USE")) {
      command += " RETURN (SPECIAL-USE)"; // rfc6154
    }
    this._sendTagged(command);
  }

  /**
   * Discover all folders for the subscribe dialog.
   *
   * @param {nsIMsgFolder} folder - The associated folder.
   */
  discoverAllAndSubscribedFolders(folder) {
    this._logger.debug("discoverAllAndSubscribedFolders", folder.URI);
    let handleListResponse = res => {
      for (let mailbox of res.mailboxes) {
        this._serverSink.possibleImapMailbox(
          mailbox.name.replaceAll(mailbox.delimiter, "/"),
          mailbox.delimiter,
          mailbox.flags
        );
      }
    };

    this._nextAction = res => {
      handleListResponse(res);
      this._server.doingLsub = false;
      this._nextAction = res2 => {
        // Per rfc3501#section-6.3.9, if LSUB returns different flags from LIST,
        // use the LIST responses.
        for (let mailbox of res2.mailboxes) {
          let mailboxFromList = res.mailboxes.find(x => x.name == mailbox.name);
          if (
            mailboxFromList?.flags &&
            mailboxFromList?.flags != mailbox.flags
          ) {
            mailbox.flags = mailboxFromList.flags;
          }
        }
        handleListResponse(res2);
        this._actionDone();
      };
      this._sendTagged('LIST "" "*"');
    };
    this._sendTagged('LSUB "" "*"');
    this._server.doingLsub = true;
  }

  /**
   * Select a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to select.
   */
  selectFolder(folder) {
    this._logger.debug("selectFolder", folder.URI);
    if (this.folder == folder) {
      this._actionNoop();
      return;
    }
    this._actionAfterSelectFolder = this._actionUidFetch;
    this._nextAction = this._actionSelectResponse(folder);
    this._sendTagged(`SELECT "${this._getServerFolderName(folder)}"`);
  }

  /**
   * Rename a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to rename.
   * @param {string} newName - The new folder name.
   */
  renameFolder(folder, newName) {
    this._logger.debug("renameFolder", folder.URI, newName);
    let delimiter =
      folder.QueryInterface(Ci.nsIMsgImapMailFolder).hierarchyDelimiter || "/";
    let names = this._getAncestorFolderNames(folder);
    let oldName = this._getServerFolderName(folder);
    newName = this._encodeMailboxName([...names, newName].join(delimiter));

    this._nextAction = this._actionRenameResponse(oldName, newName);
    this._sendTagged(`RENAME "${oldName}" "${newName}"`);
  }

  /**
   * Move a source folder to be a child of another folder.
   *
   * @param {nsIMsgFolder} srcFolder - The source folder to move.
   * @param {nsIMsgFolder} dstFolder - The target parent folder.
   */
  moveFolder(srcFolder, dstFolder) {
    this._logger.debug("moveFolder", srcFolder.URI, dstFolder.URI);
    let oldName = this._getServerFolderName(srcFolder);
    let newName = this._getServerSubFolderName(dstFolder, srcFolder.name);
    this._nextAction = this._actionRenameResponse(oldName, newName, true);
    this._sendTagged(`RENAME "${oldName}" "${newName}"`);
  }

  /**
   * Send LIST command for a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to list.
   */
  listFolder(folder) {
    this._logger.debug("listFolder", folder.URI);
    this._actionList(this._getServerFolderName(folder), () => {
      this._actionDone();
    });
  }

  /**
   * Send DELETE command for a folder and all subfolders.
   *
   * @param {nsIMsgFolder} folder - The folder to delete.
   */
  deleteFolder(folder) {
    this._logger.debug("deleteFolder", folder.URI);
    this._nextAction = res => {
      // Leaves have longer names than parent mailbox, sort them by the name
      // length, so that leaf mailbox will be deleted first.
      let mailboxes = res.mailboxes.sort(
        (x, y) => y.name.length - x.name.length
      );
      let selfName = this._getServerFolderName(folder);
      let selfIncluded = false;
      this._nextAction = () => {
        let mailbox = mailboxes.shift();
        if (mailbox) {
          this._sendTagged(`DELETE "${mailbox.name}"`);
          if (!selfIncluded && selfName == mailbox.name) {
            selfIncluded = true;
          }
        } else if (!selfIncluded) {
          this._nextAction = () => this._actionDone();
          this._sendTagged(`DELETE "${this._getServerFolderName(folder)}"`);
        } else {
          this._actionDone();
        }
      };
      this._nextAction();
    };
    this._sendTagged(`LIST "" "${this._getServerFolderName(folder)}"`);
  }

  /**
   * Ensure a folder exists on the server. Create one if not already exists.
   *
   * @param {nsIMsgFolder} parent - The parent folder to check.
   * @param {string} folderName - The folder name.
   */
  ensureFolderExists(parent, folderName) {
    this._logger.debug("ensureFolderExists", parent.URI, folderName);
    let mailboxName = this._getServerSubFolderName(parent, folderName);
    this._nextAction = res => {
      if (res.mailboxes.length) {
        // Already exists.
        this._actionDone();
        return;
      }
      // Create one and subscribe to it.
      this._actionCreateAndSubscribe(mailboxName, res => {
        this._actionList(mailboxName, () => this._actionDone());
      });
    };
    this._sendTagged(`LIST "" "${mailboxName}"`);
  }

  /**
   * Create a folder on the server.
   *
   * @param {nsIMsgFolder} parent - The parent folder to check.
   * @param {string} folderName - The folder name.
   */
  createFolder(parent, folderName) {
    this._logger.debug("createFolder", parent.URI, folderName);
    let mailboxName = this._getServerSubFolderName(parent, folderName);
    this._actionCreateAndSubscribe(mailboxName, res => {
      this._actionList(mailboxName, () => this._actionDone());
    });
  }

  /**
   * Subscribe a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to subscribe.
   * @param {string} folderName - The folder name.
   */
  subscribeFolder(folder, folderName) {
    this._logger.debug("subscribeFolder", folder.URI, folderName);
    this._nextAction = () => this._server.performExpand();
    this._sendTagged(`SUBSCRIBE "${folderName}"`);
  }

  /**
   * Unsubscribe a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to unsubscribe.
   * @param {string} folderName - The folder name.
   */
  unsubscribeFolder(folder, folderName) {
    this._logger.debug("unsubscribeFolder", folder.URI, folderName);
    this._nextAction = () => this._server.performExpand();
    this._sendTagged(`UNSUBSCRIBE "${folderName}"`);
  }

  /**
   * Fetch the attribute of messages.
   *
   * @param {nsIMsgFolder} folder - The folder to check.
   * @param {string} uids - The message uids.
   * @param {string} attribute - The message attribute to fetch
   */
  fetchMsgAttribute(folder, uids, attribute) {
    this._logger.debug("fetchMsgAttribute", folder.URI, uids, attribute);
    this._nextAction = res => {
      if (res.done) {
        let resultAttributes = res.messages
          .map(m => m.customAttributes[attribute])
          .flat();
        this.runningUri.QueryInterface(Ci.nsIImapUrl).customAttributeResult =
          resultAttributes.length > 1
            ? `(${resultAttributes.join(" ")})`
            : resultAttributes[0];
        this._actionDone();
      }
    };
    this._sendTagged(`UID FETCH ${uids} (${attribute})`);
  }

  /**
   * Delete all the messages in a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to delete messages.
   */
  deleteAllMessages(folder) {
    this._logger.debug("deleteAllMessages", folder.URI);
    this._actionInFolder(folder, () => {
      if (!this._messages.size) {
        this._actionDone();
        return;
      }

      this._nextAction = () => this.expunge(folder);
      this._sendTagged("UID STORE 1:* +FLAGS.SILENT (\\Deleted)");
    });
  }

  /**
   * Search in a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to delete messages.
   * @param {string} searchCommand - The SEARCH command together with the search
   *   criteria.
   */
  search(folder, searchCommand) {
    this._logger.debug("search", folder.URI);
    this._actionInFolder(folder, () => {
      this._nextAction = res => {
        this.onData(res.search);
        this._actionDone();
      };
      this._sendTagged(`UID ${searchCommand}`);
    });
  }

  /**
   * Get the names of all ancestor folders. For example,
   *   folder a/b/c will return ['a', 'b'].
   *
   * @param {nsIMsgFolder} folder - The input folder.
   * @returns {string[]}
   */
  _getAncestorFolderNames(folder) {
    let matches = /imap:\/\/[^/]+\/(.+)/.exec(folder.URI);
    return matches[1].split("/").slice(0, -1);
  }

  /**
   * When UTF8 is enabled, use the name directly. Otherwise, encode to mUTF-7.
   *
   * @param {string} name - The mailbox name.
   */
  _encodeMailboxName(name) {
    return this._utf8Enabled ? name : this._charsetManager.unicodeToMutf7(name);
  }

  /**
   * Get the server name of a msg folder.
   *
   * @param {nsIMsgFolder} folder - The input folder.
   * @returns {string}
   */
  _getServerFolderName(folder) {
    if (folder.isServer) {
      return "";
    }

    if (folder.onlineName) {
      return folder.onlineName.replaceAll('"', '\\"');
    }
    let delimiter =
      folder.QueryInterface(Ci.nsIMsgImapMailFolder).hierarchyDelimiter || "/";
    let names = this._getAncestorFolderNames(folder);
    return this._encodeMailboxName(
      [...names, folder.name].join(delimiter)
    ).replaceAll('"', '\\"');
  }

  /**
   * Get the server name of a sub folder. The sub folder may or may not exist on
   * the server.
   *
   * @param {nsIMsgFolder} parent - The parent folder.
   * @param {string} folderName - The sub folder name.
   * @returns {string}
   */
  _getServerSubFolderName(parent, folderName) {
    folderName = this._encodeMailboxName(folderName);
    let mailboxName = this._getServerFolderName(parent);
    if (mailboxName) {
      let delimiter = parent.QueryInterface(
        Ci.nsIMsgImapMailFolder
      ).hierarchyDelimiter;
      // @see nsImapCore.h.
      const ONLINE_HIERARCHY_SEPARATOR_UNKNOWN = "^";
      if (!delimiter || delimiter == ONLINE_HIERARCHY_SEPARATOR_UNKNOWN) {
        delimiter = "/";
      }
      return mailboxName + delimiter + folderName;
    }
    return folderName;
  }

  /**
   * Fetch the full content of a message by UID.
   *
   * @param {nsIMsgFolder} folder - The associated folder.
   * @param {number} uid - The message uid.
   * @param {number} [size] - The body size to fetch.
   */
  fetchMessage(folder, uid, size) {
    this._logger.debug(`fetchMessage folder=${folder.name} uid=${uid}`);
    if (folder.hasMsgOffline(uid, null, 10)) {
      this.onDone = () => {};
      this.channel?.readFromLocalCache();
      this._actionDone();
      return;
    }
    this._actionInFolder(folder, () => {
      this._nextAction = this._actionUidFetchBodyResponse;
      let command;
      if (size) {
        command = `UID FETCH ${uid} (UID RFC822.SIZE FLAGS BODY.PEEK[HEADER.FIELDS (Content-Type Content-Transfer-Encoding)] BODY.PEEK[TEXT]<0.${size}>)`;
      } else {
        command = `UID FETCH ${uid} (UID RFC822.SIZE FLAGS BODY.PEEK[])`;
      }
      this._sendTagged(command);
    });
  }

  /**
   * Add, remove or replace flags of specified messages.
   *
   * @param {string} action - "+" means add, "-" means remove, "" means replace.
   * @param {nsIMsgFolder} folder - The target folder.
   * @param {string} messageIds - Message UIDs, e.g. "23,30:33".
   * @param {number} flags - The internal flags number to update.
   */
  updateMessageFlags(action, folder, messageIds, flags) {
    this._actionInFolder(folder, () => {
      this._nextAction = () => this._actionDone();
      // _supportedFlags is available after _actionSelectResponse.
      let flagsStr = ImapUtils.flagsToString(flags, this._supportedFlags);
      this._sendTagged(`UID STORE ${messageIds} ${action}FLAGS (${flagsStr})`);
    });
  }

  /**
   * Send EXPUNGE command to a folder.
   *
   * @param {nsIMsgFolder} folder - The associated folder.
   */
  expunge(folder) {
    this._actionInFolder(folder, () => {
      this._nextAction = () => this._actionDone();
      this._sendTagged("EXPUNGE");
    });
  }

  /**
   * Move or copy messages from a folder to another folder.
   *
   * @param {nsIMsgFolder} folder - The source folder.
   * @param {nsIMsgFolder} folder - The target folder.
   * @param {string} messageIds - The message identifiers.
   * @param {boolean} idsAreUids - If true messageIds are UIDs, otherwise,
   *   messageIds are sequences.
   * @param {boolean} isMove - If true, use MOVE command when supported.
   */
  copy(folder, dstFolder, messageIds, idsAreUids, isMove) {
    let command = idsAreUids ? "UID " : "";
    command +=
      isMove && this._capabilities.includes("MOVE")
        ? "MOVE " // rfc6851
        : "COPY ";
    command += messageIds + ` "${this._getServerFolderName(dstFolder)}"`;
    this._actionInFolder(folder, () => {
      this._nextAction = this._actionNoopResponse;
      this._sendTagged(command);
    });
  }

  /**
   * Upload a message file to a folder.
   *
   * @param {nsIFile} file - The message file to upload.
   * @param {nsIMsgFolder} dstFolder - The target folder.
   * @param {nsImapMailCopyState} copyState - A state used by nsImapMailFolder.
   * @param {boolean} isDraft - Is the uploaded file a draft.
   */
  async uploadMessageFromFile(file, dstFolder, copyState, isDraft) {
    this._logger.debug("uploadMessageFromFile", file.path, dstFolder.URI);
    let mailbox = this._getServerFolderName(dstFolder);
    let content = MailStringUtils.uint8ArrayToByteString(
      await IOUtils.read(file.path)
    );
    this._nextAction = res => {
      if (res.tag != "+") {
        this._actionDone(Cr.NS_ERROR_FAILURE);
        return;
      }
      this._nextAction = res => {
        this._folderSink = dstFolder.QueryInterface(Ci.nsIImapMailFolderSink);
        if (
          // See rfc4315.
          this._capabilities.includes("UIDPLUS") &&
          res.attributes.appenduid
        ) {
          // The response is like `<tag> OK [APPENDUID <uidvalidity> <uid>]`.
          this._folderSink.setAppendMsgUid(
            res.attributes.appenduid[1],
            this.runningUri
          );
        }
        this._actionDone();
        if (res.exists) {
          // FIXME: _actionNoopResponse should be enough here, but it breaks
          // test_imapAttachmentSaves.js.
          this.folder = null;
        }
        try {
          this._folderSink.copyNextStreamMessage(true, copyState);
        } catch (e) {
          this._logger.warn("copyNextStreamMessage failed", e);
        }
      };
      this._send(content + (this._utf8Enabled ? ")" : ""));
    };
    let outKeywords = {};
    let flags = dstFolder
      .QueryInterface(Ci.nsIImapMessageSink)
      .getCurMoveCopyMessageInfo(this.runningUri, {}, outKeywords);
    let flagString = ImapUtils.flagsToString(flags, this._supportedFlags);
    if (isDraft && !/\b\Draft\b/.test(flagString)) {
      flagString += " \\Draft";
    }
    if (outKeywords.value) {
      flagString += " " + outKeywords.value;
    }
    let open = this._utf8Enabled ? "UTF8 (~{" : "{";
    let command = `APPEND "${mailbox}" (${flagString.trim()}) ${open}${
      content.length
    }}`;
    this._sendTagged(command);
  }

  /**
   * Check the status of a folder.
   *
   * @param {nsIMsgFolder} folder - The folder to check.
   */
  updateFolderStatus(folder) {
    this._logger.debug("updateFolderStatus", folder.URI);
    if (this._folder == folder) {
      // According to rfc3501, "the STATUS command SHOULD NOT be used on the
      // currently selected mailbox", so use NOOP instead.
      this._actionNoop();
      return;
    }

    this._nextAction = res => {
      if (res.status == "OK") {
        folder
          .QueryInterface(Ci.nsIImapMailFolderSink)
          .UpdateImapMailboxStatus(this, {
            QueryInterface: ChromeUtils.generateQI(["nsIMailboxSpec"]),
            nextUID: res.attributes.uidnext,
            numMessages: res.attributes.messages.length,
            numUnseenMessages: res.attributes.unseen,
          });
        folder.msgDatabase = null;
      }
      this._actionDone();
    };
    this._sendTagged(
      `STATUS "${this._getServerFolderName(folder)}" (UIDNEXT MESSAGES UNSEEN)`
    );
  }

  /**
   * Update message flags.
   *
   * @param {nsIMsgFolder} folder - The associated folder.
   * @param {string} flagsToAdd - The flags to add.
   * @param {string} flagsToSubtract - The flags to subtract.
   * @param {string} uids - The message uids.
   */
  storeCustomKeywords(folder, flagsToAdd, flagsToSubtract, uids) {
    this._logger.debug(
      "storeCustomKeywords",
      folder.URI,
      flagsToAdd,
      flagsToSubtract,
      uids
    );
    let subtractFlags = () => {
      if (flagsToSubtract) {
        this._nextAction = () => {
          this._actionDone();
        };
        this._sendTagged(`UID STORE ${uids} -FLAGS (${flagsToSubtract})`);
      } else {
        this._actionDone();
      }
    };
    this._actionInFolder(folder, () => {
      if (flagsToAdd) {
        this._nextAction = () => {
          subtractFlags();
        };
        this._sendTagged(`UID STORE ${uids} +FLAGS (${flagsToAdd})`);
      } else {
        subtractFlags();
      }
    });
  }

  /**
   * Get message headers by the specified uids.
   *
   * @param {nsIMsgFolder} folder - The folder of the messages.
   * @param {string[]} uids - The message uids.
   */
  getHeaders(folder, uids) {
    this._logger.debug("getHeaders", folder.URI, uids);
    this._actionInFolder(folder, () => {
      this._nextAction = this._actionUidFetchHeaderResponse;
      let extraItems = "";
      if (this._server.isGMailServer) {
        extraItems += "X-GM-MSGID X-GM-THRID X-GM-LABELS ";
      }
      this._sendTagged(
        `UID FETCH ${uids} (UID ${extraItems}RFC822.SIZE FLAGS BODY.PEEK[HEADER])`
      );
    });
  }

  /**
   * Send IDLE command to the server.
   */
  idle() {
    if (!this.folder) {
      this._actionDone();
      return;
    }
    this._nextAction = res => {
      if (res.tag == "*") {
        this.folder.performingBiff = true;
        this._actionNoopResponse(res);
      }
    };
    this._sendTagged("IDLE");
    this._setSocketTimeout(PR_UINT32_MAX);
    this._idling = true;
    this._idleTimer = setTimeout(() => {
      this.endIdle(() => {
        this._actionNoop();
      });
      // Per rfc2177, should terminate the IDLE and re-issue it at least every
      // 29 minutes. But in practice many servers timeout before that. A noop
      // every 5min is better than timeout.
    }, 5 * 60 * 1000);
    this._logger.debug(`Idling in ${this.folder.URI}`);
  }

  /**
   * Send DONE to end the IDLE command.
   *
   * @param {Function} nextAction - Callback function after IDLE is ended.
   */
  endIdle(nextAction) {
    this._nextAction = res => {
      if (res.status == "OK") {
        nextAction();
      }
    };
    this._send("DONE");
    this._idling = false;
    this.busy = true;
    clearTimeout(this._idleTimer);
    this._idleTimer = null;
  }

  /**
   * Send LOGOUT and close the socket.
   */
  logout() {
    this._sendTagged("LOGOUT");
    this._socket.close();
  }

  /**
   * The open event handler.
   */
  _onOpen = () => {
    this._logger.debug("Connected");
    this._socket.ondata = this._onData;
    this._socket.onclose = this._onClose;
    this._nextAction = res => {
      this._greeted = true;
      this._actionCapabilityResponse(res);
    };

    this._setSocketTimeout(this._prefs.tcpTimeout);
  };

  /**
   * The data event handler.
   *
   * @param {TCPSocketEvent} event - The data event.
   */
  _onData = async event => {
    // Without this, some tests are blocked waiting for response from Maild.jsm.
    // Don't know the real cause, but possibly because ImapClient and Maild runs
    // on the same process. We also have this in Pop3Client.
    await new Promise(resolve => setTimeout(resolve));

    let stringPayload = this._utf8Enabled
      ? new TextDecoder().decode(event.data)
      : MailStringUtils.uint8ArrayToByteString(new Uint8Array(event.data));
    this._logger.debug(`S: ${stringPayload}`);
    if (!this._response || this._idling || this._response.done) {
      this._response = new ImapResponse();
      this._response.onMessage = this._onMessage;
    }
    this._response.parse(stringPayload);
    if (
      !this._authenticating &&
      this._response.done &&
      this._response.status &&
      this._response.tag != "+" &&
      !["OK", "+"].includes(this._response.status)
    ) {
      this._actionDone(ImapUtils.NS_MSG_ERROR_IMAP_COMMAND_FAILED);
      return;
    }
    if (!this._greeted || this._idling || this._response.done) {
      this._nextAction?.(this._response);
    }
  };

  /**
   * The error event handler.
   *
   * @param {TCPSocketErrorEvent} event - The error event.
   */
  _onError = async event => {
    this._logger.error(`${event.name}: a ${event.message} error occurred`);
    if (event.errorCode == Cr.NS_ERROR_NET_TIMEOUT) {
      this._actionError("imapNetTimeoutError");
      this._actionDone(event.errorCode);
      return;
    }

    let secInfo =
      await event.target.transport?.tlsSocketControl?.asyncGetSecurityInfo();
    if (secInfo) {
      this._logger.error(`SecurityError info: ${secInfo.errorCodeString}`);
      if (secInfo.failedCertChain.length) {
        let chain = secInfo.failedCertChain.map(c => {
          return c.commonName + "; serial# " + c.serialNumber;
        });
        this._logger.error(`SecurityError cert chain: ${chain.join(" <- ")}`);
      }
      this.runningUri.failedSecInfo = secInfo;
      this._server.closeCachedConnections();
    } else {
      this.logout();
    }

    this._actionDone(event.errorCode);
  };

  /**
   * The close event handler.
   */
  _onClose = () => {
    this._logger.debug("Connection closed.");
    this.folder = null;
  };

  /**
   * Send a command to the server.
   *
   * @param {string} str - The command string to send.
   * @param {boolean} [suppressLogging=false] - Whether to suppress logging the str.
   */
  _send(str, suppressLogging) {
    if (suppressLogging && AppConstants.MOZ_UPDATE_CHANNEL != "default") {
      this._logger.debug(
        "C: Logging suppressed (it probably contained auth information)"
      );
    } else {
      // Do not suppress for non-release builds, so that debugging auth problems
      // is easier.
      this._logger.debug(`C: ${str}`);
    }

    if (!this.isOnline) {
      if (!str.includes("LOGOUT")) {
        this._logger.warn(
          `Failed to send because socket state is ${this._socket?.readyState}`
        );
      }
      return;
    }

    let encode = this._utf8Enabled
      ? x => new TextEncoder().encode(x)
      : MailStringUtils.byteStringToUint8Array;
    this._socket.send(encode(str + "\r\n").buffer);
  }

  /**
   * Same as _send, but prepend a tag to the command.
   */
  _sendTagged(str, suppressLogging) {
    if (this._idling) {
      let nextAction = this._nextAction;
      this.endIdle(() => {
        this._nextAction = nextAction;
        this._sendTagged(str, suppressLogging);
      });
    } else {
      this._send(`${this._getNextTag()} ${str}`, suppressLogging);
    }
  }

  /**
   * Get the next command tag.
   *
   * @returns {number}
   */
  _getNextTag() {
    this._tag = (this._tag + 1) % 100;
    return this._tag;
  }

  /**
   * Send CAPABILITY command to the server.
   */
  _actionCapability() {
    this._nextAction = this._actionCapabilityResponse;
    this._sendTagged("CAPABILITY");
  }

  /**
   * Handle the capability response.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionCapabilityResponse = res => {
    if (res.capabilities) {
      this._capabilities = res.capabilities;
      this._server.wrappedJSObject.capabilities = res.capabilities;
      if (this._capabilities.includes("X-GM-EXT-1")) {
        this._server.isGMailServer = true;
      }

      this._supportedAuthMethods = res.authMethods;
      this._actionChooseFirstAuthMethod();
    } else {
      this._actionCapability();
    }
  };

  /**
   * Decide the first auth method to try.
   */
  _actionChooseFirstAuthMethod = () => {
    if (
      [
        Ci.nsMsgSocketType.trySTARTTLS,
        Ci.nsMsgSocketType.alwaysSTARTTLS,
      ].includes(this._server.socketType) &&
      !this._secureTransport
    ) {
      if (this._capabilities.includes("STARTTLS")) {
        // Init STARTTLS negotiation if required by user pref and supported.
        this._nextAction = this._actionStarttlsResponse;
        this._sendTagged("STARTTLS");
      } else {
        // Abort if not supported.
        this._logger.error("Server doesn't support STARTTLS. Aborting.");
        this._actionError("imapServerDisconnected");
        this._actionDone(Cr.NS_ERROR_FAILURE);
      }
      return;
    }

    this._possibleAuthMethods = this._preferredAuthMethods.filter(x =>
      this._supportedAuthMethods.includes(x)
    );
    if (
      !this._possibleAuthMethods.length &&
      this._server.authMethod == Ci.nsMsgAuthMethod.passwordCleartext &&
      !this._capabilities.includes("LOGINDISABLED")
    ) {
      this._possibleAuthMethods = ["OLDLOGIN"];
    }
    this._logger.debug(`Possible auth methods: ${this._possibleAuthMethods}`);
    this._nextAuthMethod = this._possibleAuthMethods[0];
    if (this._capabilities.includes("CLIENTID") && this._server.clientid) {
      this._nextAction = res => {
        if (res.status == "OK") {
          this._actionAuth();
        } else {
          this._actionDone(Cr.NS_ERROR_FAILURE);
        }
      };
      this._sendTagged(`CLIENTID UUID ${this._server.clientid}`);
    } else {
      this._actionAuth();
    }
  };

  /**
   * Handle the STARTTLS response.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionStarttlsResponse(res) {
    if (!res.status == "OK") {
      this._actionDone(Cr.NS_ERROR_FAILURE);
      return;
    }
    this._socket.upgradeToSecure();
    this._secureTransport = true;
    this._actionCapability();
  }

  /**
   * Init authentication depending on server capabilities and user prefs.
   */
  _actionAuth = async () => {
    if (!this._nextAuthMethod) {
      this._socket.close();
      this._actionDone(Cr.NS_ERROR_FAILURE);
      return;
    }

    this._authenticating = true;

    this._currentAuthMethod = this._nextAuthMethod;
    this._nextAuthMethod =
      this._possibleAuthMethods[
        this._possibleAuthMethods.indexOf(this._currentAuthMethod) + 1
      ];

    switch (this._currentAuthMethod) {
      case "OLDLOGIN":
        this._nextAction = this._actionAuthResponse;
        let password = await this._getPassword();
        this._sendTagged(
          `LOGIN ${this._authenticator.username} ${password}`,
          true
        );
        break;
      case "PLAIN":
        this._nextAction = this._actionAuthPlain;
        this._sendTagged("AUTHENTICATE PLAIN");
        break;
      case "LOGIN":
        this._nextAction = this._actionAuthLoginUser;
        this._sendTagged("AUTHENTICATE LOGIN");
        break;
      case "CRAM-MD5":
        this._nextAction = this._actionAuthCramMd5;
        this._sendTagged("AUTHENTICATE CRAM-MD5");
        break;
      case "GSSAPI": {
        this._nextAction = this._actionAuthGssapi;
        this._authenticator.initGssapiAuth("imap");
        let token;
        try {
          token = this._authenticator.getNextGssapiToken("");
        } catch (e) {
          this._logger.error(e);
          this._actionDone(Cr.NS_ERROR_FAILURE);
          return;
        }
        this._sendTagged(`AUTHENTICATE GSSAPI ${token}`, true);
        break;
      }
      case "NTLM": {
        this._nextAction = this._actionAuthNtlm;
        this._authenticator.initNtlmAuth("imap");
        let token;
        try {
          token = this._authenticator.getNextNtlmToken("");
        } catch (e) {
          this._logger.error(e);
          this._actionDone(Cr.NS_ERROR_FAILURE);
          return;
        }
        this._sendTagged(`AUTHENTICATE NTLM ${token}`, true);
        break;
      }
      case "XOAUTH2":
        this._nextAction = this._actionAuthResponse;
        let token = await this._authenticator.getOAuthToken();
        this._sendTagged(`AUTHENTICATE XOAUTH2 ${token}`, true);
        break;
      case "EXTERNAL":
        this._nextAction = this._actionAuthResponse;
        this._sendTagged(
          `AUTHENTICATE EXTERNAL ${this._authenticator.username}`
        );
        break;
      default:
        this._actionDone();
    }
  };

  /**
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionAuthResponse = res => {
    this._authenticating = false;

    if (this.verifyLogon) {
      this._actionDone(res.status == "OK" ? Cr.NS_OK : Cr.NS_ERROR_FAILURE);
      return;
    }
    if (res.status == "OK") {
      this._serverSink.userAuthenticated = true;
      if (res.capabilities) {
        this._capabilities = res.capabilities;
        this._server.wrappedJSObject.capabilities = res.capabilities;
        this._actionId();
      } else {
        this._nextAction = res => {
          this._capabilities = res.capabilities;
          this._server.wrappedJSObject.capabilities = res.capabilities;
          this._actionId();
        };
        this._sendTagged("CAPABILITY");
      }
      return;
    }
    if (
      ["OLDLOGIN", "PLAIN", "LOGIN", "CRAM-MD5"].includes(
        this._currentAuthMethod
      )
    ) {
      // Ask user what to do.
      let action = this._authenticator.promptAuthFailed();
      if (action == 1) {
        // Cancel button pressed.
        this._socket.close();
        this._actionDone(Cr.NS_ERROR_FAILURE);
        return;
      }
      if (action == 2) {
        // 'New password' button pressed.
        this._authenticator.forgetPassword();
      }

      // Retry.
      this._nextAuthMethod = this._possibleAuthMethods[0];
      this._actionAuth();
      return;
    }
    this._logger.error("Authentication failed.");
    this._actionDone(Cr.NS_ERROR_FAILURE);
  };

  /**
   * Returns the saved/cached server password, or show a password dialog. If the
   * user cancels the dialog, stop the process.
   *
   * @returns {string} The server password.
   */
  async _getPassword() {
    try {
      let password = await this._authenticator.getPassword();
      return password;
    } catch (e) {
      if (e.result == Cr.NS_ERROR_ABORT) {
        this._actionDone(e.result);
      }
      throw e;
    }
  }

  /**
   * The second step of PLAIN auth. Send the auth token to the server.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionAuthPlain = async res => {
    this._nextAction = this._actionAuthResponse;
    this._send(await this._authenticator.getPlainToken(), true);
  };

  /**
   * The second step of LOGIN auth. Send the username to the server.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionAuthLoginUser = res => {
    this._nextAction = this._actionAuthLoginPass;
    this._send(btoa(this._authenticator.username), true);
  };

  /**
   * The third step of LOGIN auth. Send the password to the server.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionAuthLoginPass = async res => {
    this._nextAction = this._actionAuthResponse;
    let password = MailStringUtils.stringToByteString(
      await this._getPassword()
    );
    this._send(btoa(password), true);
  };

  /**
   * The second step of CRAM-MD5 auth, send a HMAC-MD5 signature to the server.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionAuthCramMd5 = async res => {
    this._nextAction = this._actionAuthResponse;
    let password = await this._getPassword();
    this._send(
      this._authenticator.getCramMd5Token(password, res.statusText),
      true
    );
  };

  /**
   * The second and next step of GSSAPI auth.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionAuthGssapi = res => {
    if (res.tag != "+") {
      this._actionAuthResponse(res);
      return;
    }

    // Server returns a challenge, we send a new token. Can happen multiple times.
    let token;
    try {
      token = this._authenticator.getNextGssapiToken(res.statusText);
    } catch (e) {
      this._logger.error(e);
      this._actionAuthResponse(res);
      return;
    }
    this._send(token, true);
  };

  /**
   * The second and next step of NTLM auth.
   *
   * @param {ImapResponse} res - The server response.
   */
  _actionAuthNtlm = res => {
    if (res.tag != "+") {
      this._actionAuthResponse(res);
      return;
    }

    // Server returns a challenge, we send a new token. Can happen multiple times.
    let token;
    try {
      token = this._authenticator.getNextNtlmToken(res.statusText);
    } catch (e) {
      this._logger.error(e);
      this._actionAuthResponse(res);
      return;
    }
    this._send(token, true);
  };

  /**
   * Send ID command to the server.
   *
   * @param {Function} [actionAfter] - A callback after processing ID command.
   */
  _actionId = (actionAfter = this._actionEnableUtf8) => {
    if (this._capabilities.includes("ID") && Services.appinfo.name) {
      this._nextAction = res => {
        this._server.serverIDPref = res.id;
        actionAfter();
      };
      this._sendTagged(
        `ID ("name" "${Services.appinfo.name}" "version" "${Services.appinfo.version}")`
      );
    } else {
      actionAfter();
    }
  };

  /**
   * Enable UTF8 if supported by the server.
   *
   * @param {Function} [actionAfter] - A callback after processing ENABLE UTF8.
   */
  _actionEnableUtf8 = (actionAfter = this._discoverAllFoldersIfNecessary) => {
    if (
      this._server.allowUTF8Accept &&
      (this._capabilities.includes("UTF8=ACCEPT") ||
        this._capabilities.includes("UTF8=ONLY"))
    ) {
      this._nextAction = res => {
        this._utf8Enabled = res.status == "OK";
        this._server.utf8AcceptEnabled = this._utf8Enabled;
        actionAfter();
      };
      this._sendTagged("ENABLE UTF8=ACCEPT");
    } else {
      this._utf8Enabled = false;
      actionAfter();
    }
  };

  /**
   * Execute an action with a folder selected.
   *
   * @param {nsIMsgFolder} folder - The folder to select.
   * @param {Function} actionInFolder - The action to execute.
   */
  _actionInFolder(folder, actionInFolder) {
    if (this.folder == folder) {
      // If already in the folder, execute the action now.
      actionInFolder();
    } else {
      // Send the SELECT command and queue the action.
      this._actionAfterSelectFolder = actionInFolder;
      this._nextAction = this._actionSelectResponse(folder);
      this._sendTagged(`SELECT "${this._getServerFolderName(folder)}"`);
    }
  }

  /**
   * Send LSUB or LIST command depending on the server capabilities.
   *
   * @param {string} [mailbox="*"] - The mailbox to list, default to list all.
   */
  _actionListOrLsub(mailbox = "*") {
    this._nextAction = this._actionListResponse();
    let command = this._capabilities.includes("LIST-EXTENDED")
      ? "LIST (SUBSCRIBED)" // rfc5258
      : "LSUB";
    command += ` "" "${mailbox}"`;
    if (this._capabilities.includes("SPECIAL-USE")) {
      command += " RETURN (SPECIAL-USE)"; // rfc6154
    }
    this._sendTagged(command);
    this._listInboxSent = false;
  }

  /**
   * Handle LIST response.
   *
   * @param {Function} actionAfterResponse - A callback after handling the response.
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionListResponse =
    (actionAfterResponse = this._actionFinishFolderDiscovery) =>
    res => {
      if (!this._hasInbox) {
        this._hasInbox = res.mailboxes.some(
          mailbox => mailbox.flags & ImapUtils.FLAG_IMAP_INBOX
        );
      }
      for (let mailbox of res.mailboxes) {
        this._serverSink.possibleImapMailbox(
          mailbox.name.replaceAll(mailbox.delimiter, "/"),
          mailbox.delimiter,
          mailbox.flags
        );
      }

      actionAfterResponse(res);
    };

  /**
   * Send LIST command.
   *
   * @param {string} folderName - The name of the folder to list.
   * @param {Function} actionAfterResponse - A callback after handling the response.
   */
  _actionList(folderName, actionAfterResponse) {
    this._nextAction = this._actionListResponse(actionAfterResponse);
    this._sendTagged(`LIST "" "${folderName}"`);
  }

  /**
   * Finish folder discovery after checking Inbox and Trash folders.
   */
  _actionFinishFolderDiscovery = () => {
    if (!this._hasInbox && !this._listInboxSent) {
      this._actionList("INBOX");
      this._listInboxSent = true;
      return;
    }
    if (!this._hasTrash && !this._listTrashSent) {
      this._actionCreateTrashFolderIfNeeded();
      return;
    }
    this._serverSink.discoveryDone();
    this._actionAfterDiscoverAllFolders
      ? this._actionAfterDiscoverAllFolders()
      : this._actionDone();
  };

  /**
   * If Trash folder is not found on server, create one and subscribe to it.
   */
  _actionCreateTrashFolderIfNeeded() {
    let trashFolderName = this._server.trashFolderName;
    this._actionList(trashFolderName, res => {
      this._hasTrash = res.mailboxes.length > 0;
      if (this._hasTrash) {
        // Trash folder exists.
        this._actionFinishFolderDiscovery();
      } else {
        // Trash folder doesn't exist, create one and subscribe to it.
        this._nextAction = res => {
          this._actionList(trashFolderName, () => {
            // After subscribing, finish folder discovery.
            this._nextAction = this._actionFinishFolderDiscovery;
            this._sendTagged(`SUBSCRIBE "${trashFolderName}"`);
          });
        };
        this._sendTagged(`CREATE "${trashFolderName}"`);
      }
    });
    this._listTrashSent = true;
  }

  /**
   * Create and subscribe to a folder.
   *
   * @param {string} folderName - The folder name.
   * @param {Function} callbackAfterSubscribe - The action after the subscribe
   *   command.
   */
  _actionCreateAndSubscribe(folderName, callbackAfterSubscribe) {
    this._nextAction = res => {
      this._nextAction = callbackAfterSubscribe;
      this._sendTagged(`SUBSCRIBE "${folderName}"`);
    };
    this._sendTagged(`CREATE "${folderName}"`);
  }

  /**
   * Handle SELECT response.
   */
  _actionSelectResponse = folder => res => {
    if (folder) {
      this.folder = folder;
    }
    this._supportedFlags = res.permanentflags || res.flags;
    this._folderState = res;
    if (this._capabilities.includes("QUOTA")) {
      this._actionGetQuotaData();
    } else {
      this._actionAfterSelectFolder();
    }
  };

  /**
   * Send GETQUOTAROOT command and handle the response.
   */
  _actionGetQuotaData() {
    this._folderSink = this.folder.QueryInterface(Ci.nsIImapMailFolderSink);
    this._nextAction = res => {
      const INVALIDATE_QUOTA = 0;
      const STORE_QUOTA = 1;
      const VALIDATE_QUOTA = 2;
      for (let root of res.quotaRoots || []) {
        this._folderSink.setFolderQuotaData(INVALIDATE_QUOTA, root, 0, 0);
      }
      for (let [mailbox, resource, usage, limit] of res.quotas || []) {
        this._folderSink.setFolderQuotaData(
          STORE_QUOTA,
          mailbox ? `${mailbox} / ${resource}` : resource,
          usage,
          limit
        );
      }
      this._folderSink.setFolderQuotaData(VALIDATE_QUOTA, "", 0, 0);
      this._actionAfterSelectFolder();
    };
    this._sendTagged(
      `GETQUOTAROOT "${this._getServerFolderName(this.folder)}"`
    );
    this._folderSink.folderQuotaCommandIssued = true;
  }

  /**
   * Handle RENAME response. Three steps are involved.
   *
   * @param {string} oldName - The old folder name.
   * @param {string} newName - The new folder name.
   * @param {boolean} [isMove] - Is it response to MOVE command.
   * @param {ImapResponse} res - The server response.
   */
  _actionRenameResponse = (oldName, newName, isMove) => res => {
    // Step 3: Rename the local folder and send LIST command to re-sync folders.
    let actionAfterUnsubscribe = () => {
      this._serverSink.onlineFolderRename(this._msgWindow, oldName, newName);
      if (isMove) {
        this._actionDone();
      } else {
        this._actionListOrLsub(newName);
      }
    };
    // Step 2: unsubscribe to the oldName.
    this._nextAction = () => {
      this._nextAction = actionAfterUnsubscribe;
      this._sendTagged(`UNSUBSCRIBE "${oldName}"`);
    };
    // Step 1: subscribe to the newName.
    this._sendTagged(`SUBSCRIBE "${newName}"`);
  };

  /**
   * Send UID FETCH request to the server.
   */
  _actionUidFetch() {
    if (this.runningUri.imapAction == Ci.nsIImapUrl.nsImapLiteSelectFolder) {
      this._nextAction = () => this._actionDone();
    } else {
      this._nextAction = this._actionUidFetchResponse;
    }
    this._sendTagged("UID FETCH 1:* (FLAGS)");
  }

  /**
   * Handle UID FETCH response.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionUidFetchResponse(res) {
    let outFolderInfo = {};
    this.folder.getDBFolderInfoAndDB(outFolderInfo);
    let highestUid = outFolderInfo.value.getUint32Property(
      "highestRecordedUID",
      0
    );
    this._folderSink = this.folder.QueryInterface(Ci.nsIImapMailFolderSink);
    this._folderSink.UpdateImapMailboxInfo(this, this._getMailboxSpec());
    let latestUid = this._messageUids.at(-1);
    if (latestUid > highestUid) {
      let extraItems = "";
      if (this._server.isGMailServer) {
        extraItems += "X-GM-MSGID X-GM-THRID X-GM-LABELS ";
      }
      this._nextAction = this._actionUidFetchHeaderResponse;
      this._sendTagged(
        `UID FETCH ${
          highestUid + 1
        }:${latestUid} (UID ${extraItems}RFC822.SIZE FLAGS BODY.PEEK[HEADER])`
      );
    } else {
      this._folderSink.headerFetchCompleted(this);
      if (this._bodysToDownload.length) {
        let uids = this._bodysToDownload.join(",");
        this._nextAction = this._actionUidFetchBodyResponse;
        this._sendTagged(
          `UID FETCH ${uids} (UID RFC822.SIZE FLAGS BODY.PEEK[])`
        );
        return;
      }
      this._actionDone();
    }
  }

  /**
   * Make an nsIMailboxSpec instance to interact with nsIImapMailFolderSink.
   *
   * @returns {nsIMailboxSpec}
   */
  _getMailboxSpec() {
    return {
      QueryInterface: ChromeUtils.generateQI(["nsIMailboxSpec"]),
      folder_UIDVALIDITY: this._folderState.uidvalidity,
      box_flags: this._folderState.flags,
      supportedUserFlags: this._folderState.supportedUserFlags,
      nextUID: this._folderState.attributes.uidnext,
      numMessages: this._messages.size,
      numUnseenMessages: this._folderState.attributes.unseen,
      flagState: this.flagAndUidState,
    };
  }

  /**
   * Handle UID FETCH BODY.PEEK[HEADER] response.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionUidFetchHeaderResponse(res) {
    this.folder
      .QueryInterface(Ci.nsIImapMailFolderSink)
      .headerFetchCompleted(this);
    if (this._bodysToDownload.length) {
      // nsImapMailFolder decides to fetch the full body by calling
      // NotifyBodysToDownload.
      let uids = this._bodysToDownload.join(",");
      this._nextAction = this._actionUidFetchBodyResponse;
      this._sendTagged(`UID FETCH ${uids} (UID RFC822.SIZE FLAGS BODY.PEEK[])`);
      return;
    }
    this._actionDone();
  }

  /**
   * Handle UID FETCH BODY response.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionUidFetchBodyResponse(res) {
    this._actionDone();
  }

  /**
   * Handle a single message data response.
   *
   * @param {MessageData} msg - Message data parsed in ImapResponse.
   */
  _onMessage = msg => {
    this._msgSink = this.folder.QueryInterface(Ci.nsIImapMessageSink);
    this._folderSink = this.folder.QueryInterface(Ci.nsIImapMailFolderSink);

    // Handle message flags.
    if ((msg.uid || msg.sequence) && msg.flags != undefined) {
      let uid = msg.uid;
      if (uid && msg.sequence) {
        this._messageUids[msg.sequence] = uid;
        this._messages.set(uid, msg);
      } else if (msg.sequence) {
        uid = this._messageUids[msg.sequence];
      }
      if (uid) {
        this.folder
          .QueryInterface(Ci.nsIImapMessageSink)
          .notifyMessageFlags(
            msg.flags,
            msg.keywords,
            uid,
            this._folderState.highestmodseq
          );
      }
    }

    if (msg.body) {
      if (!msg.body.endsWith("\r\n")) {
        msg.body += "\r\n";
      }
      if (msg.bodySection.length == 1 && msg.bodySection[0] == "HEADER") {
        // Handle message headers.
        this._messageUids[msg.sequence] = msg.uid;
        this._messages.set(msg.uid, msg);
        this._folderSink.StartMessage(this.runningUri);
        let hdrXferInfo = {
          numHeaders: 1,
          getHeader() {
            return {
              msgUid: msg.uid,
              msgSize: msg.size,
              get msgHdrs() {
                let sepIndex = msg.body.indexOf("\r\n\r\n");
                return sepIndex == -1
                  ? msg.body + "\r\n"
                  : msg.body.slice(0, sepIndex + 2);
              },
            };
          },
        };
        this._folderSink.parseMsgHdrs(this, hdrXferInfo);
      } else {
        // Handle message body.
        let shouldStoreMsgOffline = false;
        try {
          shouldStoreMsgOffline = this.folder.shouldStoreMsgOffline(msg.uid);
        } catch (e) {}
        if (
          (shouldStoreMsgOffline ||
            this.runningUri.QueryInterface(Ci.nsIImapUrl)
              .storeResultsOffline) &&
          msg.body
        ) {
          this._folderSink.StartMessage(this.runningUri);
          this._msgSink.parseAdoptedMsgLine(msg.body, msg.uid, this.runningUri);
          this._msgSink.normalEndMsgWriteStream(
            msg.uid,
            true,
            this.runningUri,
            msg.body.length
          );
          this._folderSink.EndMessage(this.runningUri, msg.uid);
        }

        this.onData?.(msg.body);
        // Release some memory.
        msg.body = "";
      }
    }
  };

  /**
   * Send NOOP command.
   */
  _actionNoop() {
    this._nextAction = this._actionNoopResponse;
    this._sendTagged("NOOP");
  }

  /**
   * Handle NOOP response.
   *
   * @param {ImapResponse} res - Response received from the server.
   */
  _actionNoopResponse(res) {
    if (
      (res.exists && res.exists != this._folderState.exists) ||
      res.expunged.length
    ) {
      // Handle messages number changes, re-sync the folder.
      this._folderState.exists = res.exists;
      this._actionAfterSelectFolder = this._actionUidFetch;
      this._nextAction = this._actionSelectResponse();
      if (res.expunged.length) {
        this._messageUids = [];
        this._messages.clear();
      }
      let folder = this.folder;
      this.folder = null;
      this.selectFolder(folder);
    } else if (res.messages.length || res.exists) {
      let outFolderInfo = {};
      this.folder.getDBFolderInfoAndDB(outFolderInfo);
      let highestUid = outFolderInfo.value.getUint32Property(
        "highestRecordedUID",
        0
      );
      this._nextAction = this._actionUidFetchResponse;
      this._sendTagged(`UID FETCH ${highestUid + 1}:* (FLAGS)`);
    } else {
      if (res.exists == 0) {
        this._messageUids = [];
        this._messages.clear();
        this.folder
          .QueryInterface(Ci.nsIImapMailFolderSink)
          .UpdateImapMailboxInfo(this, this._getMailboxSpec());
      }
      if (!this._idling) {
        this._actionDone();
      }
    }
  }

  /**
   * Show an error prompt.
   *
   * @param {string} errorName - An error name corresponds to an entry of
   *   imapMsgs.properties.
   */
  _actionError(errorName) {
    if (!this._msgWindow) {
      return;
    }
    let bundle = Services.strings.createBundle(
      "chrome://messenger/locale/imapMsgs.properties"
    );
    let errorMsg = bundle.formatStringFromName(errorName, [
      this._server.hostName,
    ]);
    Services.prompt.alert(this._msgWindow.domWindow, null, errorMsg);
  }

  /**
   * Finish a request and do necessary cleanup.
   */
  _actionDone = (status = Cr.NS_OK) => {
    this._logger.debug(`Done with status=${status}`);
    this._nextAction = null;
    this._urlListener?.OnStopRunningUrl(this.runningUri, status);
    this.runningUri.SetUrlState(false, status);
    this.onDone?.(status);
    this._reset();
    // Tell ImapIncomingServer this client can be reused now.
    this.onFree?.();
  };

  /** @see nsIImapProtocol */
  NotifyBodysToDownload(keys) {
    this._logger.debug("NotifyBodysToDownload", keys);
    this._bodysToDownload = keys;
  }

  GetRunningUrl() {
    this._logger.debug("GetRunningUrl");
  }

  get flagAndUidState() {
    // The server sequence is 1 based, nsIImapFlagAndUidState sequence is 0 based.
    let getUidOfMessage = index => this._messageUids[index + 1];
    let getMessageFlagsByUid = uid => this._messages.get(uid)?.flags;

    return {
      QueryInterface: ChromeUtils.generateQI(["nsIImapFlagAndUidState"]),
      numberOfMessages: this._messages.size,
      getUidOfMessage,
      getMessageFlags: index => getMessageFlagsByUid(getUidOfMessage(index)),
      hasMessage: uid => this._messages.has(uid),
      getMessageFlagsByUid,
      getCustomFlags: uid => this._messages.get(uid)?.keywords,
      getCustomAttribute: (uid, name) => {
        let value = this._messages.get(uid)?.customAttributes[name];
        return Array.isArray(value) ? value.join(" ") : value;
      },
    };
  }
}