/* 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/. */

#include "nsAutoSyncState.h"
#include "nsImapMailFolder.h"
#include "nsIImapService.h"
#include "nsIMsgMailNewsUrl.h"
#include "nsIMsgMailSession.h"
#include "nsMsgFolderFlags.h"
#include "nsIAutoSyncManager.h"
#include "nsIAutoSyncMsgStrategy.h"
#include "nsServiceManagerUtils.h"
#include "nsComponentManagerUtils.h"
#include "mozilla/Logging.h"

using namespace mozilla;

extern LazyLogModule gAutoSyncLog;  // defined in nsAutoSyncManager.cpp

MsgStrategyComparatorAdaptor::MsgStrategyComparatorAdaptor(
    nsIAutoSyncMsgStrategy* aStrategy, nsIMsgFolder* aFolder,
    nsIMsgDatabase* aDatabase)
    : mStrategy(aStrategy), mFolder(aFolder), mDatabase(aDatabase) {}

/** @return True if the elements are equals; false otherwise. */
bool MsgStrategyComparatorAdaptor::Equals(const nsMsgKey& a,
                                          const nsMsgKey& b) const {
  nsCOMPtr<nsIMsgDBHdr> hdrA;
  nsCOMPtr<nsIMsgDBHdr> hdrB;

  mDatabase->GetMsgHdrForKey(a, getter_AddRefs(hdrA));
  mDatabase->GetMsgHdrForKey(b, getter_AddRefs(hdrB));

  if (hdrA && hdrB) {
    nsresult rv = NS_OK;
    nsAutoSyncStrategyDecisionType decision = nsAutoSyncStrategyDecisions::Same;

    if (mStrategy) rv = mStrategy->Sort(mFolder, hdrA, hdrB, &decision);

    if (NS_SUCCEEDED(rv))
      return (decision == nsAutoSyncStrategyDecisions::Same);
  }

  return false;
}

/** @return True if (a < b); false otherwise. */
bool MsgStrategyComparatorAdaptor::LessThan(const nsMsgKey& a,
                                            const nsMsgKey& b) const {
  nsCOMPtr<nsIMsgDBHdr> hdrA;
  nsCOMPtr<nsIMsgDBHdr> hdrB;

  mDatabase->GetMsgHdrForKey(a, getter_AddRefs(hdrA));
  mDatabase->GetMsgHdrForKey(b, getter_AddRefs(hdrB));

  if (hdrA && hdrB) {
    nsresult rv = NS_OK;
    nsAutoSyncStrategyDecisionType decision = nsAutoSyncStrategyDecisions::Same;

    if (mStrategy) rv = mStrategy->Sort(mFolder, hdrA, hdrB, &decision);

    if (NS_SUCCEEDED(rv))
      return (decision == nsAutoSyncStrategyDecisions::Lower);
  }

  return false;
}

nsAutoSyncState::nsAutoSyncState(nsImapMailFolder* aOwnerFolder,
                                 PRTime aLastSyncTime)
    : mSyncState(stCompletedIdle),
      mOffset(0U),
      mLastOffset(0U),
      mLastServerTotal(0),
      mLastServerRecent(0),
      mLastServerUnseen(0),
      mLastNextUID(0),
      mLastSyncTime(aLastSyncTime),
      mLastUpdateTime(0UL),
      mProcessPointer(0U),
      mIsDownloadQChanged(false),
      mRetryCounter(0U) {
  mOwnerFolder =
      do_GetWeakReference(static_cast<nsIMsgImapMailFolder*>(aOwnerFolder));
  mHaveAStatusResponse = false;
}

nsAutoSyncState::~nsAutoSyncState() {}

// TODO:XXXemre should be implemented when we start
// doing space management
nsresult nsAutoSyncState::ManageStorageSpace() { return NS_OK; }

nsresult nsAutoSyncState::PlaceIntoDownloadQ(
    const nsTArray<nsMsgKey>& aMsgKeyList) {
  nsresult rv = NS_OK;
  if (!aMsgKeyList.IsEmpty()) {
    nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
    NS_ENSURE_SUCCESS(rv, rv);

    nsCOMPtr<nsIMsgDatabase> database;
    rv = folder->GetMsgDatabase(getter_AddRefs(database));
    if (!database) return NS_ERROR_FAILURE;

    nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
        do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);

    nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
    autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));

    // increase the array size
    mDownloadQ.SetCapacity(mDownloadQ.Length() + aMsgKeyList.Length());

    // remove excluded messages
    int32_t elemCount = aMsgKeyList.Length();
    for (int32_t idx = 0; idx < elemCount; idx++) {
      nsCOMPtr<nsIMsgDBHdr> hdr;
      bool containsKey;
      database->ContainsKey(aMsgKeyList[idx], &containsKey);
      if (!containsKey) continue;
      rv = database->GetMsgHdrForKey(aMsgKeyList[idx], getter_AddRefs(hdr));
      if (!hdr)
        continue;  // can't get message header, continue with the next one

      bool doesFit = true;
      rv = autoSyncMgr->DoesMsgFitDownloadCriteria(hdr, &doesFit);
      if (NS_SUCCEEDED(rv) && !mDownloadSet.Contains(aMsgKeyList[idx]) &&
          doesFit) {
        bool excluded = false;
        if (msgStrategy) {
          rv = msgStrategy->IsExcluded(folder, hdr, &excluded);

          if (NS_SUCCEEDED(rv) && !excluded) {
            mIsDownloadQChanged = true;
            mDownloadSet.PutEntry(aMsgKeyList[idx]);
            mDownloadQ.AppendElement(aMsgKeyList[idx]);
          }
        }
      }
    }  // endfor

    if (mIsDownloadQChanged) {
      LogOwnerFolderName("Download Q is created for ");
      LogQWithSize(mDownloadQ, 0);
      rv = autoSyncMgr->OnDownloadQChanged(this);
    }
  }
  return rv;
}

nsresult nsAutoSyncState::SortQueueBasedOnStrategy(nsTArray<nsMsgKey>& aQueue) {
  nsresult rv;
  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIMsgDatabase> database;
  rv = folder->GetMsgDatabase(getter_AddRefs(database));
  if (!database) return NS_ERROR_FAILURE;

  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
  rv = autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));
  NS_ENSURE_SUCCESS(rv, rv);

  MsgStrategyComparatorAdaptor strategyComp(msgStrategy, folder, database);
  aQueue.Sort(strategyComp);

  return rv;
}

// This method is a hack to prioritize newly inserted messages,
// without changing the size of the queue. It is required since
// we cannot sort ranges in nsTArray.
nsresult nsAutoSyncState::SortSubQueueBasedOnStrategy(
    nsTArray<nsMsgKey>& aQueue, uint32_t aStartingOffset) {
  NS_ASSERTION(aStartingOffset < aQueue.Length(),
               "*** Starting offset is out of range");

  // Copy already downloaded messages into a temporary queue,
  // we want to exclude them from the sort.
  nsTArray<nsMsgKey> tmpQ;
  tmpQ.AppendElements(aQueue.Elements(), aStartingOffset);

  // Remove already downloaded messages and sort the resulting queue
  aQueue.RemoveElementsAt(0, aStartingOffset);

  nsresult rv = SortQueueBasedOnStrategy(aQueue);

  // copy excluded messages back
  aQueue.InsertElementsAt(0, tmpQ);

  return rv;
}

NS_IMETHODIMP nsAutoSyncState::GetNextGroupOfMessages(
    uint32_t aSuggestedGroupSizeLimit, uint32_t* aActualGroupSize,
    nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages) {
  NS_ENSURE_ARG_POINTER(aActualGroupSize);

  aMessages.Clear();
  *aActualGroupSize = 0;

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIMsgDatabase> database;
  folder->GetMsgDatabase(getter_AddRefs(database));

  if (database) {
    if (!mDownloadQ.IsEmpty()) {
      // sort the download queue if new items are added since the last time
      if (mIsDownloadQChanged) {
        // we want to sort only pending messages. mOffset is
        // the position of the first pending message in the download queue
        rv = (mOffset > 0) ? SortSubQueueBasedOnStrategy(mDownloadQ, mOffset)
                           : SortQueueBasedOnStrategy(mDownloadQ);

        if (NS_SUCCEEDED(rv)) mIsDownloadQChanged = false;
      }

      nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
          do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
      NS_ENSURE_SUCCESS(rv, rv);

      uint32_t msgCount = mDownloadQ.Length();
      uint32_t idx = mOffset;

      nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
      autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));

      for (; idx < msgCount; idx++) {
        bool containsKey = false;
        database->ContainsKey(mDownloadQ[idx], &containsKey);
        if (!containsKey) {
          mDownloadSet.RemoveEntry(mDownloadQ[idx]);
          mDownloadQ.RemoveElementAt(idx--);
          msgCount--;
          continue;
        }
        nsCOMPtr<nsIMsgDBHdr> qhdr;
        database->GetMsgHdrForKey(mDownloadQ[idx], getter_AddRefs(qhdr));
        if (!qhdr) continue;  // maybe deleted, skip it!

        // ensure that we don't have this message body offline already,
        // possible if the user explicitly selects this message prior
        // to auto-sync kicks in
        bool hasMessageOffline;
        folder->HasMsgOffline(mDownloadQ[idx], &hasMessageOffline);
        if (hasMessageOffline) continue;

        // this check point allows msg strategy function
        // to do last minute decisions based on the current
        // state of TB such as the size of the message store etc.
        if (msgStrategy) {
          bool excluded = false;
          if (NS_SUCCEEDED(msgStrategy->IsExcluded(folder, qhdr, &excluded)) &&
              excluded)
            continue;
        }

        uint32_t msgSize;
        qhdr->GetMessageSize(&msgSize);
        // ignore 0 byte messages; the imap parser asserts when we try
        // to download them, and there's no point anyway.
        if (!msgSize) continue;

        if (!*aActualGroupSize && msgSize >= aSuggestedGroupSizeLimit) {
          *aActualGroupSize = msgSize;
          aMessages.AppendElement(qhdr);
          idx++;
          break;
        }
        if ((*aActualGroupSize) + msgSize > aSuggestedGroupSizeLimit) break;

        aMessages.AppendElement(qhdr);
        *aActualGroupSize += msgSize;
      }  // endfor

      mLastOffset = mOffset;
      mOffset = idx;
    }

    LogOwnerFolderName("Next group of messages to be downloaded.");
    LogQWithSize(aMessages, 0);
  }  // endif

  return NS_OK;
}

/**
 * Called by nsAutoSyncManager::TimerCallback to process message headers for a
 * folder in the discovery queue. The queue is created on the kAutoSyncFreq
 * time base (1 hour). Headers lacking offline store are placed in download
 * queue.
 */
NS_IMETHODIMP nsAutoSyncState::ProcessExistingHeaders(
    uint32_t aNumOfHdrsToProcess, uint32_t* aLeftToProcess) {
  NS_ENSURE_ARG_POINTER(aLeftToProcess);

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIMsgDatabase> database;
  rv = folder->GetMsgDatabase(getter_AddRefs(database));
  if (!database) return NS_ERROR_FAILURE;

  // create a queue to process existing headers for the first time
  if (mExistingHeadersQ.IsEmpty()) {
    nsTArray<nsMsgKey> keys;
    rv = database->ListAllKeys(keys);
    NS_ENSURE_SUCCESS(rv, rv);
    keys.Sort();
    mExistingHeadersQ.AppendElements(keys);
    mProcessPointer = 0;
  }

  // process the existing headers and find the messages not downloaded yet
  uint32_t lastIdx = mProcessPointer;
  nsTArray<nsMsgKey> msgKeys;
  uint32_t keyCount = mExistingHeadersQ.Length();
  for (; mProcessPointer < (lastIdx + aNumOfHdrsToProcess) &&
         mProcessPointer < keyCount;
       mProcessPointer++) {
    bool hasMessageOffline;
    folder->HasMsgOffline(mExistingHeadersQ[mProcessPointer],
                          &hasMessageOffline);
    if (!hasMessageOffline)
      msgKeys.AppendElement(mExistingHeadersQ[mProcessPointer]);
  }
  if (!msgKeys.IsEmpty()) {
    nsCString folderName;
    folder->GetURI(folderName);
    MOZ_LOG(
        gAutoSyncLog, LogLevel::Debug,
        ("%s: %zu messages will be added into the download q of folder %s\n",
         __func__, msgKeys.Length(), folderName.get()));

    rv = PlaceIntoDownloadQ(msgKeys);
    if (NS_FAILED(rv)) mProcessPointer = lastIdx;
  }

  *aLeftToProcess = keyCount - mProcessPointer;

  // cleanup if we are done processing
  if (0 == *aLeftToProcess) {
    mLastSyncTime = PR_Now();
    mExistingHeadersQ.Clear();
    mProcessPointer = 0;
    folder->SetMsgDatabase(nullptr);
  }

  return rv;
}

void nsAutoSyncState::OnNewHeaderFetchCompleted(
    const nsTArray<nsMsgKey>& aMsgKeyList) {
  SetLastUpdateTime(PR_Now());
  if (!aMsgKeyList.IsEmpty()) PlaceIntoDownloadQ(aMsgKeyList);
  MOZ_LOG(
      gAutoSyncLog, LogLevel::Debug,
      ("%s: %zu msg keys put into download q", __func__, aMsgKeyList.Length()));
}

NS_IMETHODIMP nsAutoSyncState::UpdateFolder() {
  nsresult rv;
  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIUrlListener> autoSyncMgrListener =
      do_QueryInterface(autoSyncMgr, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIMsgImapMailFolder> imapFolder =
      do_QueryReferent(mOwnerFolder, &rv);
  SetState(nsAutoSyncState::stUpdateIssued);
  return imapFolder->UpdateFolderWithListener(nullptr, autoSyncMgrListener);
}

NS_IMETHODIMP nsAutoSyncState::OnStartRunningUrl(nsIURI* aUrl) {
  nsresult rv = NS_OK;

  // if there is a problem to start the download, set rv with the
  // corresponding error code. In that case, AutoSyncManager is going to
  // set the autosync state to nsAutoSyncState::stReadyToDownload
  // to resume downloading another time

  // TODO: is there a way to make sure that download started without
  // problem through nsIURI interface?

  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  return autoSyncMgr->OnDownloadStarted(this, rv);
}

/**
 * This is called when a folder status URL finishes. It is also called when
 * needed message downloads (imap fetch) for a folder completes.
 */
NS_IMETHODIMP nsAutoSyncState::OnStopRunningUrl(nsIURI* aUrl,
                                                nsresult aExitCode) {
  nsresult rv;
  nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIUrlListener> autoSyncMgrListener =
      do_QueryInterface(autoSyncMgr, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  if (mSyncState == stStatusIssued) {
    nsCOMPtr<nsIMsgImapMailFolder> imapFolder =
        do_QueryReferent(mOwnerFolder, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    int32_t serverTotal, serverUnseen, serverRecent, serverNextUID;
    imapFolder->GetServerTotal(&serverTotal);
    imapFolder->GetServerUnseen(&serverUnseen);
    imapFolder->GetServerRecent(&serverRecent);
    imapFolder->GetServerNextUID(&serverNextUID);
    // Note: UNSEEN often shows a change when nothing else changes. This is
    // because UNSEEN produced by SELECT is not the number of unseen messages.
    // So ignore change to UNSEEN to avoid spurious folder updates. Commented
    // out below.
    MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
            ("%s: serverUnseen=%d lastServerUnseen=%d", __func__, serverUnseen,
             mLastServerUnseen));
    if (serverNextUID != mLastNextUID || serverTotal != mLastServerTotal ||
        serverRecent != mLastServerRecent  //||
        /*(serverUnseen != mLastServerUnseen)*/) {
      if (MOZ_LOG_TEST(gAutoSyncLog, LogLevel::Debug)) {
        nsCString folderName;
        ownerFolder->GetURI(folderName);
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("%s: folder %s status changed serverNextUID=%d lastNextUID=%d",
                 __func__, folderName.get(), serverNextUID, mLastNextUID));
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("%s: serverTotal = %d lastServerTotal = %d serverRecent = %d "
                 "lastServerRecent = %d\n",
                 __func__, serverTotal, mLastServerTotal, serverRecent,
                 mLastServerRecent));
      }
      SetServerCounts(serverTotal, serverRecent, serverUnseen, serverNextUID);
      SetState(nsAutoSyncState::stUpdateIssued);
      rv = imapFolder->UpdateFolderWithListener(nullptr, autoSyncMgrListener);
    } else  // folderstatus detected no change
    {
      if (MOZ_LOG_TEST(gAutoSyncLog, LogLevel::Debug)) {
        nsCString folderName;
        ownerFolder->GetURI(folderName);
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("%s: folder %s status or noop issued, no change", __func__,
                 folderName.get()));
      }
      // Status detected no change. This may be due to an previously deleted and
      // now empty database so change compares above could be invalid. If so,
      // force an update which will re-populate the database (.msf) and download
      // all the message to mbox/maildir store. This check is only done on the
      // first imap STATUS response after start-up and if the server response
      // reports that the folder is not empty.
      if (!mHaveAStatusResponse && serverTotal != 0) {
        nsCOMPtr<nsIMsgDatabase> database;
        ownerFolder->GetMsgDatabase(getter_AddRefs(database));
        bool hasHeader = false;
        if (database) {
          nsCOMPtr<nsIMsgEnumerator> hdrs;
          database->EnumerateMessages(getter_AddRefs(hdrs));
          if (hdrs) hdrs->HasMoreElements(&hasHeader);
        }
        if (!hasHeader) {
          if (MOZ_LOG_TEST(gAutoSyncLog, LogLevel::Debug)) {
            nsCString folderName;
            ownerFolder->GetURI(folderName);
            MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                    ("%s: folder %s has empty DB, force an update", __func__,
                     folderName.get()));
          }
          SetServerCounts(serverTotal, serverRecent, serverUnseen,
                          serverNextUID);
          SetState(nsAutoSyncState::stUpdateIssued);
          rv = imapFolder->UpdateFolderWithListener(nullptr,
                                                    autoSyncMgrListener);
        }
      }
      if (mSyncState == stStatusIssued) {
        // Didn't force an update above so transition back to stCompletedIdle
        ownerFolder->SetMsgDatabase(nullptr);
        // nothing more to do.
        SetState(nsAutoSyncState::stCompletedIdle);
        // autoSyncMgr needs this notification, so manufacture it.
        rv = autoSyncMgrListener->OnStopRunningUrl(aUrl, NS_OK);
      }
    }  // end no change detected
    mHaveAStatusResponse = true;
  } else  // URL not folderstatus but FETCH of message body
  {
    // XXXemre how we recover from this error?
    rv = ownerFolder->ReleaseSemaphore(ownerFolder);
    NS_ASSERTION(NS_SUCCEEDED(rv), "*** Cannot release folder semaphore");

    nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
    if (mailUrl) rv = mailUrl->UnRegisterListener(this);

    if (MOZ_LOG_TEST(gAutoSyncLog, LogLevel::Debug)) {
      nsCString folderName;
      ownerFolder->GetURI(folderName);
      MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
              ("%s: URL for FETCH of msg body/bodies complete, folder %s",
               __func__, folderName.get()));
    }
    rv = autoSyncMgr->OnDownloadCompleted(this, aExitCode);
  }
  return rv;
}

NS_IMETHODIMP nsAutoSyncState::GetState(int32_t* aState) {
  NS_ENSURE_ARG_POINTER(aState);
  *aState = mSyncState;
  return NS_OK;
}

// clang-format off
const char* stateStrings[] = {
  "stCompletedIdle:0",       // Initial state
  "stStatusIssued:1",        // Imap STATUS or NOOP to occur to detect new msgs
  "stUpdateNeeded:2",        // Imap SELECT to occur due to "pending" msgs
  "stUpdateIssued:3",        // Imap SELECT to occur then fetch new headers
  "stReadyToDownload:4",     // Ready to download a group of new messages
  "stDownloadInProgress:5"   // Download, go to 4 if more msgs then 0 when all done
};
// clang-format on

NS_IMETHODIMP nsAutoSyncState::SetState(int32_t aState) {
  mSyncState = aState;
  if (aState == stCompletedIdle) {
    ResetDownloadQ();
    // tell folder to let go of its cached msg db pointer
    nsresult rv;
    nsCOMPtr<nsIMsgMailSession> session =
        do_GetService("@mozilla.org/messenger/services/session;1", &rv);
    if (NS_SUCCEEDED(rv) && session) {
      nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
      NS_ENSURE_SUCCESS(rv, rv);

      bool folderOpen;
      uint32_t folderFlags;
      ownerFolder->GetFlags(&folderFlags);
      session->IsFolderOpenInWindow(ownerFolder, &folderOpen);
      if (!folderOpen && !(folderFlags & nsMsgFolderFlags::Inbox))
        ownerFolder->SetMsgDatabase(nullptr);
    }
  }
  nsCString logStr("Sync State set to |");
  logStr.Append(stateStrings[aState]);
  logStr.AppendLiteral("| for ");
  LogOwnerFolderName(logStr.get());
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::TryCurrentGroupAgain(uint32_t aRetryCount) {
  SetState(stReadyToDownload);

  nsresult rv;
  if (++mRetryCounter > aRetryCount) {
    ResetRetryCounter();
    rv = NS_ERROR_FAILURE;
  } else
    rv = Rollback();

  return rv;
}

NS_IMETHODIMP nsAutoSyncState::ResetRetryCounter() {
  mRetryCounter = 0;
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::GetPendingMessageCount(int32_t* aMsgCount) {
  NS_ENSURE_ARG_POINTER(aMsgCount);
  *aMsgCount = mDownloadQ.Length() - mOffset;
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::GetTotalMessageCount(int32_t* aMsgCount) {
  NS_ENSURE_ARG_POINTER(aMsgCount);
  *aMsgCount = mDownloadQ.Length();
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::GetOwnerFolder(nsIMsgFolder** aFolder) {
  NS_ENSURE_ARG_POINTER(aFolder);

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  ownerFolder.forget(aFolder);
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::Rollback() {
  mOffset = mLastOffset;
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::ResetDownloadQ() {
  mOffset = mLastOffset = 0;
  mDownloadSet.Clear();
  mDownloadQ.Clear();
  mDownloadQ.Compact();

  return NS_OK;
}

/**
 * Tests whether the given folder is owned by the same imap server
 * or not.
 */
NS_IMETHODIMP nsAutoSyncState::IsSibling(nsIAutoSyncState* aAnotherStateObj,
                                         bool* aResult) {
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = false;

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> folderA, folderB;

  rv = GetOwnerFolder(getter_AddRefs(folderA));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = aAnotherStateObj->GetOwnerFolder(getter_AddRefs(folderB));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIMsgIncomingServer> serverA, serverB;
  rv = folderA->GetServer(getter_AddRefs(serverA));
  NS_ENSURE_SUCCESS(rv, rv);
  rv = folderB->GetServer(getter_AddRefs(serverB));
  NS_ENSURE_SUCCESS(rv, rv);

  bool isSibling;
  rv = serverA->Equals(serverB, &isSibling);

  if (NS_SUCCEEDED(rv)) *aResult = isSibling;

  return rv;
}

/**
 * Test whether the download queue is empty.
 */
NS_IMETHODIMP nsAutoSyncState::IsDownloadQEmpty(bool* aResult) {
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = mDownloadQ.IsEmpty();
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::DownloadMessagesForOffline(
    nsTArray<RefPtr<nsIMsgDBHdr>> const& messages) {
  nsresult rv;
  nsCOMPtr<nsIImapService> imapService =
      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsAutoCString messageIds;
  nsTArray<nsMsgKey> msgKeys;

  rv = nsImapMailFolder::BuildIdsAndKeyArray(messages, messageIds, msgKeys);
  if (NS_FAILED(rv) || messageIds.IsEmpty()) return rv;

  // acquire semaphore for offline store. If it fails, we won't download
  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = folder->AcquireSemaphore(folder);
  NS_ENSURE_SUCCESS(rv, rv);

  if (MOZ_LOG_TEST(gAutoSyncLog, LogLevel::Debug)) {
    nsCString folderName;
    folder->GetURI(folderName);
    MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
            ("%s: downloading UIDs %s for folder %s", __func__,
             messageIds.get(), folderName.get()));
  }
  // start downloading
  rv = imapService->DownloadMessagesForOffline(messageIds, folder, this,
                                               nullptr);
  if (NS_SUCCEEDED(rv)) SetState(stDownloadInProgress);

  return rv;
}

NS_IMETHODIMP nsAutoSyncState::GetLastSyncTime(PRTime* aLastSyncTime) {
  NS_ENSURE_ARG_POINTER(aLastSyncTime);
  *aLastSyncTime = mLastSyncTime;
  return NS_OK;
}

void nsAutoSyncState::SetLastSyncTimeInSec(int32_t aLastSyncTime) {
  mLastSyncTime = ((PRTime)aLastSyncTime * PR_USEC_PER_SEC);
}

NS_IMETHODIMP nsAutoSyncState::GetLastUpdateTime(PRTime* aLastUpdateTime) {
  NS_ENSURE_ARG_POINTER(aLastUpdateTime);
  *aLastUpdateTime = mLastUpdateTime;
  return NS_OK;
}

NS_IMETHODIMP nsAutoSyncState::SetLastUpdateTime(PRTime aLastUpdateTime) {
  mLastUpdateTime = aLastUpdateTime;
  return NS_OK;
}

void nsAutoSyncState::SetServerCounts(int32_t total, int32_t recent,
                                      int32_t unseen, int32_t nextUID) {
  mLastServerTotal = total;
  mLastServerRecent = recent;
  mLastServerUnseen = unseen;
  mLastNextUID = nextUID;
}

NS_IMPL_ISUPPORTS(nsAutoSyncState, nsIAutoSyncState, nsIUrlListener)

void nsAutoSyncState::LogQWithSize(nsTArray<nsMsgKey>& q, uint32_t toOffset) {
  nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
  if (ownerFolder) {
    nsCOMPtr<nsIMsgDatabase> database;
    ownerFolder->GetMsgDatabase(getter_AddRefs(database));

    uint32_t x = q.Length();
    while (x > toOffset && database) {
      x--;
      nsCOMPtr<nsIMsgDBHdr> h;
      database->GetMsgHdrForKey(q[x], getter_AddRefs(h));
      uint32_t s;
      if (h) {
        h->GetMessageSize(&s);
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("Elem #%d, size: %u bytes\n", x + 1, s));
      } else
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("unable to get header for key %ul", q[x]));
    }
  }
}

void nsAutoSyncState::LogQWithSize(nsTArray<RefPtr<nsIMsgDBHdr>> const& q,
                                   uint32_t toOffset) {
  nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
  if (ownerFolder) {
    nsCOMPtr<nsIMsgDatabase> database;
    ownerFolder->GetMsgDatabase(getter_AddRefs(database));

    uint32_t x = q.Length();
    while (x > toOffset && database) {
      x--;
      if (q[x]) {
        uint32_t s;
        q[x]->GetMessageSize(&s);
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("Elem #%d, size: %u bytes\n", x + 1, s));
      } else
        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
                ("null header in q at index %ul", x));
    }
  }
}

void nsAutoSyncState::LogOwnerFolderName(const char* s) {
  nsCOMPtr<nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
  if (ownerFolder) {
    nsCString folderName;
    ownerFolder->GetURI(folderName);
    MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
            ("*** %s Folder: %s ***\n", s, folderName.get()));
  }
}