private MessageManager.MetaData selectMailbox(MailboxPath mailboxPath, ImapSession session)
      throws MailboxException {
    final MailboxManager mailboxManager = getMailboxManager();
    final MailboxSession mailboxSession = ImapSessionUtils.getMailboxSession(session);
    final MessageManager mailbox = mailboxManager.getMailbox(mailboxPath, mailboxSession);

    final SelectedMailbox sessionMailbox;
    final SelectedMailbox currentMailbox = session.getSelected();
    if (currentMailbox == null || !currentMailbox.getPath().equals(mailboxPath)) {

      // QRESYNC EXTENSION
      //
      // Response with the CLOSE return-code when the currently selected mailbox is closed
      // implicitly using the SELECT/EXAMINE command on another mailbox
      //
      // See rfc5162 3.7. CLOSED Response Code
      if (currentMailbox != null) {
        getStatusResponseFactory()
            .untaggedOk(HumanReadableText.QRESYNC_CLOSED, ResponseCode.closed());
      }
      session.selected(new SelectedMailboxImpl(getMailboxManager(), session, mailboxPath));

      sessionMailbox = session.getSelected();

    } else {
      // TODO: Check if we need to handle CONDSTORE there too
      sessionMailbox = currentMailbox;
    }
    final MessageManager.MetaData metaData =
        mailbox.getMetaData(
            !openReadOnly, mailboxSession, MessageManager.MetaData.FetchGroup.FIRST_UNSEEN);
    addRecent(metaData, sessionMailbox);
    return metaData;
  }
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
    getLogger(ctx.getChannel()).debug("Error while processing imap request", e.getCause());

    if (e.getCause() instanceof TooLongFrameException) {

      // Max line length exceeded
      // See RFC 2683 section 3.2.1
      //
      // "For its part, a server should allow for a command line of at
      // least
      // 8000 octets. This provides plenty of leeway for accepting
      // reasonable
      // length commands from clients. The server should send a BAD
      // response
      // to a command that does not end within the server's maximum
      // accepted
      // command length."
      //
      // See also JAMES-1190
      ImapResponseComposer composer = (ImapResponseComposer) ctx.getAttachment();
      composer.untaggedResponse(
          ImapConstants.BAD + " failed. Maximum command line length exceeded");
    } else {
      // logout on error not sure if that is the best way to handle it
      final ImapSession imapSession = (ImapSession) attributes.get(ctx.getChannel());
      if (imapSession != null) imapSession.logout();

      // Make sure we close the channel after all the buffers were flushed out
      Channel channel = ctx.getChannel();
      if (channel.isConnected()) {
        channel.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
      }
    }
  }
  @Override
  public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    InetSocketAddress address = (InetSocketAddress) ctx.getChannel().getRemoteAddress();
    getLogger(ctx.getChannel())
        .info("Connection closed for " + address.getAddress().getHostAddress());

    // remove the stored attribute for the channel to free up resources
    // See JAMES-1195
    ImapSession imapSession = (ImapSession) attributes.remove(ctx.getChannel());
    if (imapSession != null) imapSession.logout();

    super.channelClosed(ctx, e);
  }
  /**
   * @see
   *     org.apache.james.imap.processor.PermitEnableCapabilityProcessor#enable(org.apache.james.imap.api.ImapMessage,
   *     org.apache.james.imap.api.process.ImapProcessor.Responder,
   *     org.apache.james.imap.api.process.ImapSession, java.lang.String)
   */
  public void enable(
      ImapMessage message, Responder responder, ImapSession session, String capability)
      throws EnableException {

    if (EnableProcessor.getEnabledCapabilities(session).contains(capability) == false) {
      SelectedMailbox sm = session.getSelected();
      // Send a HIGHESTMODSEQ response if the there was a select mailbox before and the client just
      // enabled
      // QRESYNC or CONDSTORE
      //
      // See http://www.dovecot.org/list/dovecot/2008-March/029561.html
      if (capability.equalsIgnoreCase(ImapConstants.SUPPORTS_CONDSTORE)
          || capability.equalsIgnoreCase(ImapConstants.SUPPORTS_QRESYNC)) {
        try {
          MetaData metaData = null;
          boolean send = false;
          if (sm != null) {
            MessageManager mailbox = getSelectedMailbox(session);
            metaData =
                mailbox.getMetaData(
                    false, ImapSessionUtils.getMailboxSession(session), FetchGroup.NO_COUNT);
            send = true;
          }
          condstoreEnablingCommand(session, responder, metaData, send);
        } catch (MailboxException e) {
          throw new EnableException("Unable to enable " + capability, e);
        }
      }
    }
  }
  /**
   * @see
   *     org.apache.james.imap.processor.AbstractMailboxProcessor#doProcess(org.apache.james.imap.api.message.request.ImapRequest,
   *     org.apache.james.imap.api.process.ImapSession, java.lang.String,
   *     org.apache.james.imap.api.ImapCommand,
   *     org.apache.james.imap.api.process.ImapProcessor.Responder)
   */
  protected void doProcess(
      M request, ImapSession session, String tag, ImapCommand command, Responder responder) {
    final String mailboxName = request.getMailboxName();
    try {
      final MailboxPath fullMailboxPath =
          PathConverter.forSession(session).buildFullPath(mailboxName);

      respond(tag, command, session, fullMailboxPath, request, responder);

    } catch (MailboxNotFoundException e) {
      session.getLog().debug("Select failed as mailbox does not exist " + mailboxName, e);
      responder.respond(
          statusResponseFactory.taggedNo(tag, command, HumanReadableText.FAILURE_NO_SUCH_MAILBOX));
    } catch (MailboxException e) {
      session.getLog().info("Select failed for mailbox " + mailboxName, e);
      no(command, tag, responder, HumanReadableText.SELECT);
    }
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    ImapSession session = (ImapSession) attributes.get(ctx.getChannel());
    ImapResponseComposer response = (ImapResponseComposer) ctx.getAttachment();
    ImapMessage message = (ImapMessage) e.getMessage();
    ChannelPipeline cp = ctx.getPipeline();

    try {
      if (cp.get(NettyConstants.EXECUTION_HANDLER) != null) {
        cp.addBefore(
            NettyConstants.EXECUTION_HANDLER, NettyConstants.HEARTBEAT_HANDLER, heartbeatHandler);
      } else {
        cp.addBefore(
            NettyConstants.CORE_HANDLER, NettyConstants.HEARTBEAT_HANDLER, heartbeatHandler);
      }
      final ResponseEncoder responseEncoder = new ResponseEncoder(encoder, response, session);
      processor.process(message, responseEncoder, session);

      if (session.getState() == ImapSessionState.LOGOUT) {
        // Make sure we close the channel after all the buffers were flushed out
        Channel channel = ctx.getChannel();
        if (channel.isConnected()) {
          channel.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        }
      }
      final IOException failure = responseEncoder.getFailure();

      if (failure != null) {
        final Logger logger = session.getLog();
        logger.info(failure.getMessage());
        if (logger.isDebugEnabled()) {
          logger.debug("Failed to write " + message, failure);
        }
        throw failure;
      }
    } finally {
      ctx.getPipeline().remove(NettyConstants.HEARTBEAT_HANDLER);
    }

    super.messageReceived(ctx, e);
  }
  private void respond(
      String tag,
      ImapCommand command,
      ImapSession session,
      MailboxPath fullMailboxPath,
      AbstractMailboxSelectionRequest request,
      Responder responder)
      throws MailboxException, MessageRangeException {

    Long lastKnownUidValidity = request.getLastKnownUidValidity();
    Long modSeq = request.getKnownModSeq();
    IdRange[] knownSequences = request.getKnownSequenceSet();
    UidRange[] knownUids = request.getKnownUidSet();

    // Check if a QRESYNC parameter was used and if so if QRESYNC was enabled before.
    // If it was not enabled before its needed to return a BAD response
    //
    // From RFC5162 3.1. QRESYNC Parameter to SELECT/EXAMINE
    //
    //    A server MUST respond with a tagged BAD response if the Quick
    //    Resynchronization parameter to SELECT/EXAMINE command is specified
    //    and the client hasn't issued "ENABLE QRESYNC" in the current
    //    connection.
    if (lastKnownUidValidity != null
        && !EnableProcessor.getEnabledCapabilities(session)
            .contains(ImapConstants.SUPPORTS_QRESYNC)) {
      taggedBad(command, tag, responder, HumanReadableText.QRESYNC_NOT_ENABLED);
      return;
    }

    final MessageManager.MetaData metaData = selectMailbox(fullMailboxPath, session);
    final SelectedMailbox selected = session.getSelected();
    MessageUid firstUnseen = metaData.getFirstUnseen();

    flags(responder, selected);
    exists(responder, metaData);
    recent(responder, selected);
    uidValidity(responder, metaData);

    // try to write the UNSEEN message to the client and retry if we fail because of concurrent
    // sessions.
    //
    // See IMAP-345
    int retryCount = 0;
    while (unseen(responder, firstUnseen, selected, ImapSessionUtils.getMailboxSession(session))
        == false) {
      // if we not was able to get find the unseen within 5 retries we should just not send it
      if (retryCount == 5) {
        if (session.getLog().isInfoEnabled()) {
          session
              .getLog()
              .info(
                  "Unable to uid for unseen message "
                      + firstUnseen
                      + " in mailbox "
                      + selected.getPath());
        }
        break;
      }
      firstUnseen = selectMailbox(fullMailboxPath, session).getFirstUnseen();
      retryCount++;
    }

    permanentFlags(responder, metaData, selected);
    highestModSeq(responder, metaData, selected);
    uidNext(responder, metaData);

    if (request.getCondstore()) {
      condstoreEnablingCommand(session, responder, metaData, false);
    }

    // Now do the QRESYNC processing if necessary
    //
    // If the mailbox does not store the mod-sequence in a permanent way its needed to not process
    // the QRESYNC paramters
    // The same is true if none are given ;)
    if (metaData.isModSeqPermanent() && lastKnownUidValidity != null) {
      if (lastKnownUidValidity == metaData.getUidValidity()) {

        final MailboxManager mailboxManager = getMailboxManager();
        final MailboxSession mailboxSession = ImapSessionUtils.getMailboxSession(session);
        final MessageManager mailbox = mailboxManager.getMailbox(fullMailboxPath, mailboxSession);

        //  If the provided UIDVALIDITY matches that of the selected mailbox, the
        //  server then checks the last known modification sequence.
        //
        //  The server sends the client any pending flag changes (using FETCH
        //  responses that MUST contain UIDs) and expunges those that have
        //  occurred in this mailbox since the provided modification sequence.
        SearchQuery sq = new SearchQuery();
        sq.andCriteria(SearchQuery.modSeqGreaterThan(request.getKnownModSeq()));

        UidRange[] uidSet = request.getUidSet();

        if (uidSet == null) {
          // See mailbox had some messages stored before, if not we don't need to query at all
          MessageUid uidNext = metaData.getUidNext();
          if (!uidNext.isFirst()) {
            // Use UIDNEXT -1 as max uid as stated in the QRESYNC RFC
            uidSet = new UidRange[] {new UidRange(MessageUid.MIN_VALUE, uidNext.previous())};
          }
        }

        if (uidSet != null) {
          // RFC5162 3.1. QRESYNC Parameter to SELECT/EXAMINE
          //
          // Message sequence match data:
          //
          //      A client MAY provide a parenthesized list of a message sequence set
          //      and the corresponding UID sets.  Both MUST be provided in ascending
          //      order.  The server uses this data to restrict the range for which it
          //      provides expunged message information.
          //
          //
          //      Conceptually, the client provides a small sample of sequence numbers
          //      for which it knows the corresponding UIDs.  The server then compares
          //      each sequence number and UID pair the client provides with the
          //      current state of the mailbox.  If a pair matches, then the client
          //      knows of any expunges up to, and including, the message, and thus
          //      will not include that range in the VANISHED response, even if the
          //      "mod-sequence-value" provided by the client is too old for the server
          //      to have data of when those messages were expunged.
          //
          //      Thus, if the Nth message number in the first set in the list is 4,
          //      and the Nth UID in the second set in the list is 8, and the mailbox's
          //      fourth message has UID 8, then no UIDs equal to or less than 8 are
          //      present in the VANISHED response.  If the (N+1)th message number is
          //      12, and the (N+1)th UID is 24, and the (N+1)th message in the mailbox
          //      has UID 25, then the lowest UID included in the VANISHED response
          //      would be 9.
          if (knownSequences != null && knownUids != null) {

            // Add all uids which are contained in the knownuidsset to a List so we can later access
            // them via the index
            List<MessageUid> knownUidsList = new ArrayList<MessageUid>();
            for (UidRange range : knownUids) {
              for (MessageUid uid : range) {
                knownUidsList.add(uid);
              }
            }

            // loop over the known sequences and check the UID for MSN X again the known UID X
            MessageUid firstUid = MessageUid.MIN_VALUE;
            int index = 0;
            for (IdRange knownSequence : knownSequences) {
              boolean done = false;
              for (Long uid : knownSequence) {

                // Check if we have uids left to check against
                if (knownUidsList.size() > index++) {
                  int msn = uid.intValue();
                  MessageUid knownUid = knownUidsList.get(index);

                  // Check if the uid mathc if not we are done here
                  if (selected.uid(msn).asSet().contains(knownUid)) {
                    done = true;
                    break;
                  } else {
                    firstUid = knownUid;
                  }

                } else {
                  done = true;
                  break;
                }
              }

              // We found the first uid to start with
              if (done) {
                firstUid = firstUid.next();

                // Ok now its time to filter out the IdRanges which we are not interested in
                List<UidRange> filteredUidSet = new ArrayList<UidRange>();
                for (UidRange r : uidSet) {
                  if (r.getLowVal().compareTo(firstUid) < 0) {
                    if (r.getHighVal().compareTo(firstUid) > 0) {
                      filteredUidSet.add(new UidRange(firstUid, r.getHighVal()));
                    }
                  } else {
                    filteredUidSet.add(r);
                  }
                }
                uidSet = filteredUidSet.toArray(new UidRange[0]);

                break;
              }
            }
          }

          List<MessageRange> ranges = new ArrayList<MessageRange>();
          for (UidRange range : uidSet) {
            MessageRange messageSet = range.toMessageRange();
            if (messageSet != null) {
              MessageRange normalizedMessageSet =
                  normalizeMessageRange(session.getSelected(), messageSet);
              ranges.add(normalizedMessageSet);
            }
          }

          // TODO: Reconsider if we can do something to make the handling better. Maybe at least
          // cache the triplets for the expunged
          //       while have the server running. This could maybe allow us to not return every
          // expunged message all the time
          //
          //      As we don't store the <<MSN, UID>, <MODSEQ>> in a permanent way its the best to
          // just ignore it here.
          //
          //      From RFC5162 4.1. Server Implementations That Don't Store Extra State
          //
          //
          //          Strictly speaking, a server implementation that doesn't remember mod-
          //          sequences associated with expunged messages can be considered
          //          compliant with this specification.  Such implementations return all
          //          expunged messages specified in the UID set of the UID FETCH
          //          (VANISHED) command every time, without paying attention to the
          //          specified CHANGEDSINCE mod-sequence.  Such implementations are
          //          discouraged, as they can end up returning VANISHED responses that are
          //          bigger than the result of a UID SEARCH command for the same UID set.
          //
          //          Clients that use the message sequence match data can reduce the scope
          //          of this VANISHED response substantially in the typical case where
          //          expunges have not happened, or happen only toward the end of the
          //          mailbox.
          //
          respondVanished(mailboxSession, mailbox, ranges, modSeq, metaData, responder);
        }
        taggedOk(responder, tag, command, metaData, HumanReadableText.SELECT);
      } else {

        taggedOk(responder, tag, command, metaData, HumanReadableText.QRESYNC_UIDVALIDITY_MISMATCH);
      }
    } else {
      taggedOk(responder, tag, command, metaData, HumanReadableText.SELECT);
    }

    // Reset the saved sequence-set after successful SELECT / EXAMINE
    // See RFC 5812 2.1. Normative Description of the SEARCHRES Extension
    SearchResUtil.resetSavedSequenceSet(session);
  }