package com.android.exchange.service;

import android.content.ContentProviderOperation;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.OperationApplicationException;
import android.content.SyncResult;
import android.database.Cursor;
import android.os.Bundle;
import android.os.RemoteException;
import android.text.format.DateUtils;

import com.android.emailcommon.TrafficFlags;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.EmailContent.MessageColumns;
import com.android.emailcommon.provider.EmailContent.SyncColumns;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.service.SyncWindow;
import com.android.exchange.Eas;
import com.android.exchange.EasAuthenticationException;
import com.android.exchange.EasResponse;
import com.android.exchange.adapter.AbstractSyncParser;
import com.android.exchange.adapter.EmailSyncAdapter.EasEmailSyncParser;
import com.android.exchange.adapter.MoveItemsParser;
import com.android.exchange.adapter.Serializer;
import com.android.exchange.adapter.Tags;
import com.android.mail.utils.LogUtils;

import org.apache.http.HttpStatus;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;

/**
 * Performs an Exchange mailbox sync for "normal" mailboxes.
 */
public class EasMailboxSyncHandler extends EasSyncHandler {
    private static final String TAG = "EasMailboxSyncHandler";

    /**
     * The projection used for building the fetch request list.
     */
    private static final String[] FETCH_REQUEST_PROJECTION = { SyncColumns.SERVER_ID };
    private static final int FETCH_REQUEST_SERVER_ID = 0;

    /**
     * The projection used for querying message tables for the purpose of determining what needs
     * to be set as a sync update.
     */
    private static final String[] UPDATES_PROJECTION = { MessageColumns.ID,
            MessageColumns.MAILBOX_KEY, SyncColumns.SERVER_ID,
            MessageColumns.FLAGS, MessageColumns.FLAG_READ, MessageColumns.FLAG_FAVORITE };
    private static final int UPDATES_ID_COLUMN = 0;
    private static final int UPDATES_MAILBOX_KEY_COLUMN = 1;
    private static final int UPDATES_SERVER_ID_COLUMN = 2;
    private static final int UPDATES_FLAG_COLUMN = 3;
    private static final int UPDATES_READ_COLUMN = 4;
    private static final int UPDATES_FAVORITE_COLUMN = 5;

    /**
     * Message flags value to signify that the message has been moved, and eventually needs to be
     * deleted.
     */
    public static final int MESSAGE_FLAG_MOVED_MESSAGE = 1 << Message.FLAG_SYNC_ADAPTER_SHIFT;

    /**
     * The selection for moved messages that get deleted after a successful sync.
     */
    private static final String WHERE_MAILBOX_KEY_AND_MOVED =
            MessageColumns.MAILBOX_KEY + "=? AND (" + MessageColumns.FLAGS + "&" +
            MESSAGE_FLAG_MOVED_MESSAGE + ")!=0";

    private static final String EMAIL_WINDOW_SIZE = "5";

    private static final String WHERE_BODY_SOURCE_MESSAGE_KEY =
            EmailContent.Body.SOURCE_MESSAGE_KEY + "=?";

    // State needed across multiple functions during a Sync.
    // TODO: We should perhaps invert the meaning of mDeletedMessages & mUpdatedMessages and
    // store the values we want to *retain* after a successful upsync.

    /**
     * List of message ids that were read from Message_Deletes and were sent in the Commands section
     * of the current sync.
     */
    private final ArrayList<Long> mDeletedMessages = new ArrayList<Long>();

    /**
     * List of message ids that were read from Message_Updates and were sent in the Commands section
     * of the current sync.
     */
    private final ArrayList<Long> mUpdatedMessages = new ArrayList<Long>();

    /**
     * List of server ids for messages to fetch from the server.
     */
    private final ArrayList<String> mMessagesToFetch = new ArrayList<String>();

    /**
     * Holds all the data needed to process a MoveItems request.
     */
    private static class MoveRequest {
        public final long messageId;
        public final String messageServerId;
        public final int messageFlags;
        public final long sourceFolderId;
        public final String sourceFolderServerId;
        public final String destFolderServerId;

        public MoveRequest(final long _messageId, final String _messageServerId,
                final int _messageFlags,
                final long _sourceFolderId, final String _sourceFolderServerId,
                final String _destFolderServerId) {
            messageId = _messageId;
            messageServerId = _messageServerId;
            messageFlags = _messageFlags;
            sourceFolderId = _sourceFolderId;
            sourceFolderServerId = _sourceFolderServerId;
            destFolderServerId = _destFolderServerId;
        }
    }

    /**
     * List of all MoveRequests, i.e. all messages which have different mailboxes than they used to.
     */
    private final ArrayList<MoveRequest> mMessagesToMove = new ArrayList<MoveRequest>();

    public EasMailboxSyncHandler(final Context context, final ContentResolver contentResolver,
            final Account account, final Mailbox mailbox, final Bundle syncExtras,
            final SyncResult syncResult) {
        super(context, contentResolver, account, mailbox, syncExtras, syncResult);
    }

    private String getEmailFilter() {
        int syncLookback = mMailbox.mSyncLookback;
        if (syncLookback == SyncWindow.SYNC_WINDOW_UNKNOWN
                || mMailbox.mType == Mailbox.TYPE_INBOX) {
            syncLookback = mAccount.mSyncLookback;
        }
        switch (syncLookback) {
            case SyncWindow.SYNC_WINDOW_1_DAY:
                return Eas.FILTER_1_DAY;
            case SyncWindow.SYNC_WINDOW_3_DAYS:
                return Eas.FILTER_3_DAYS;
            case SyncWindow.SYNC_WINDOW_1_WEEK:
                return Eas.FILTER_1_WEEK;
            case SyncWindow.SYNC_WINDOW_2_WEEKS:
                return Eas.FILTER_2_WEEKS;
            case SyncWindow.SYNC_WINDOW_1_MONTH:
                return Eas.FILTER_1_MONTH;
            case SyncWindow.SYNC_WINDOW_ALL:
                return Eas.FILTER_ALL;
            default:
                // Auto window is deprecated and will also use the default.
                return Eas.FILTER_1_WEEK;
        }
    }

    /**
     * Find partially loaded messages and add their server ids to {@link #mMessagesToFetch}.
     */
    private void addToFetchRequestList() {
        final Cursor c = mContentResolver.query(Message.CONTENT_URI, FETCH_REQUEST_PROJECTION,
                MessageColumns.FLAG_LOADED + "=" + Message.FLAG_LOADED_PARTIAL + " AND " +
                MessageColumns.MAILBOX_KEY + "=?", new String[] {Long.toString(mMailbox.mId)},
                null);
        if (c != null) {
            try {
                while (c.moveToNext()) {
                    mMessagesToFetch.add(c.getString(FETCH_REQUEST_SERVER_ID));
                }
            } finally {
                c.close();
            }
        }
    }

    @Override
    protected int getTrafficFlag() {
        return TrafficFlags.DATA_EMAIL;
    }

    @Override
    protected String getSyncKey() {
        if (mMailbox == null) {
            return null;
        }
        if (mMailbox.mSyncKey == null) {
            // TODO: Write to DB? Probably not, and just let successful sync do that.
            mMailbox.mSyncKey = "0";
        }
        return mMailbox.mSyncKey;
    }

    @Override
    protected String getFolderClassName() {
        return "Email";
    }

    @Override
    protected AbstractSyncParser getParser(final InputStream is) throws IOException {
        return new EasEmailSyncParser(mContext, mContentResolver, is, mMailbox, mAccount);
    }

    @Override
    protected void setInitialSyncOptions(final Serializer s) {
        // No-op.
    }

    @Override
    protected void setNonInitialSyncOptions(final Serializer s) throws IOException {
        // Check for messages that aren't fully loaded.
        addToFetchRequestList();
        // The "empty" case is typical; we send a request for changes, and also specify a sync
        // window, body preference type (HTML for EAS 12.0 and later; MIME for EAS 2.5), and
        // truncation
        // If there are fetch requests, we only want the fetches (i.e. no changes from the server)
        // so we turn MIME support off.  Note that we are always using EAS 2.5 if there are fetch
        // requests
        if (mMessagesToFetch.isEmpty()) {
            // Permanently delete if in trash mailbox
            // In Exchange 2003, deletes-as-moves tag = true; no tag = false
            // In Exchange 2007 and up, deletes-as-moves tag is "0" (false) or "1" (true)
            final boolean isTrashMailbox = mMailbox.mType == Mailbox.TYPE_TRASH;
            if (getProtocolVersion() < Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE) {
                if (!isTrashMailbox) {
                    s.tag(Tags.SYNC_DELETES_AS_MOVES);
                }
            } else {
                s.data(Tags.SYNC_DELETES_AS_MOVES, isTrashMailbox ? "0" : "1");
            }
            s.tag(Tags.SYNC_GET_CHANGES);
            s.data(Tags.SYNC_WINDOW_SIZE, EMAIL_WINDOW_SIZE);
            s.start(Tags.SYNC_OPTIONS);
            // Set the lookback appropriately (EAS calls this a "filter")
            s.data(Tags.SYNC_FILTER_TYPE, getEmailFilter());
            // Set the truncation amount for all classes
            if (getProtocolVersion() >= Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE) {
                s.start(Tags.BASE_BODY_PREFERENCE);
                // HTML for email
                s.data(Tags.BASE_TYPE, Eas.BODY_PREFERENCE_HTML);
                s.data(Tags.BASE_TRUNCATION_SIZE, Eas.EAS12_TRUNCATION_SIZE);
                s.end();
            } else {
                // Use MIME data for EAS 2.5
                s.data(Tags.SYNC_MIME_SUPPORT, Eas.MIME_BODY_PREFERENCE_MIME);
                s.data(Tags.SYNC_MIME_TRUNCATION, Eas.EAS2_5_TRUNCATION_SIZE);
            }
            s.end();
        } else {
            // If we have any messages that are not fully loaded, ask for plain text rather than
            // MIME, to guarantee we'll get usable text body. This also means we should NOT ask for
            // new messages -- we only want data for the message explicitly fetched.
            s.start(Tags.SYNC_OPTIONS);
            s.data(Tags.SYNC_MIME_SUPPORT, Eas.MIME_BODY_PREFERENCE_TEXT);
            s.data(Tags.SYNC_TRUNCATION, Eas.EAS2_5_TRUNCATION_SIZE);
            s.end();
        }
    }

    /**
     * Check whether a message is referenced by another (and therefore must be kept around).
     * @param messageId The id of the message to check.
     * @return Whether the message in question is referenced by another message.
     */
    private boolean messageReferenced(final long messageId) {
        final Cursor c = mContentResolver.query(EmailContent.Body.CONTENT_URI,
                EmailContent.Body.ID_PROJECTION, WHERE_BODY_SOURCE_MESSAGE_KEY,
                new String[] {Long.toString(messageId)}, null);
        if (c != null) {
            try {
                return c.moveToFirst();
            } finally {
                c.close();
            }
        }
        return false;
    }

    /**
     * Write the command to delete a message to the {@link Serializer}.
     * @param s The {@link Serializer} for this sync command.
     * @param serverId The server id for the message to delete.
     * @param firstCommand Whether any sync commands have already been written to s.
     * @throws IOException
     */
    private void addDeleteMessageCommand(final Serializer s, final String serverId,
            final boolean firstCommand) throws IOException {
        if (firstCommand) {
            s.start(Tags.SYNC_COMMANDS);
        }
        s.start(Tags.SYNC_DELETE).data(Tags.SYNC_SERVER_ID, serverId).end();
    }

    /**
     * Adds a sync delete command for all messages in the Message_Deletes table.
     * @param s The {@link Serializer} for this sync command.
     * @param hasCommands Whether any Commands have already been written to s.
     * @return Whether this function wrote any commands to s.
     * @throws IOException
     */
    private boolean addDeletedCommands(final Serializer s, final boolean hasCommands)
            throws IOException {
        boolean wroteCommands = false;
        final Cursor c = mContentResolver.query(Message.DELETED_CONTENT_URI,
                Message.ID_COLUMNS_PROJECTION, MessageColumns.MAILBOX_KEY + '=' + mMailbox.mId,
                null, null);
        if (c != null) {
            try {
                while (c.moveToNext()) {
                    final String serverId = c.getString(Message.ID_COLUMNS_SYNC_SERVER_ID);
                    final long messageId = c.getLong(Message.ID_COLUMNS_ID_COLUMN);
                    // Only upsync delete commands for messages that have server ids and are not
                    // referenced by other messages.
                    if (serverId != null && !messageReferenced(messageId)) {
                        addDeleteMessageCommand(s, serverId, wroteCommands || hasCommands);
                        wroteCommands = true;
                        mDeletedMessages.add(messageId);
                    }
                }
            } finally {
                c.close();
            }
        }

        return wroteCommands;
    }

    /**
     * Create date/time in RFC8601 format.  Oddly enough, for calendar date/time, Microsoft uses
     * a different format that excludes the punctuation (this is why I'm not putting this in a
     * parent class)
     */
    private static String formatDateTime(final Calendar calendar) {
        final StringBuilder sb = new StringBuilder();
        //YYYY-MM-DDTHH:MM:SS.MSSZ
        sb.append(calendar.get(Calendar.YEAR));
        sb.append('-');
        sb.append(String.format(Locale.US, "%02d", calendar.get(Calendar.MONTH) + 1));
        sb.append('-');
        sb.append(String.format(Locale.US, "%02d", calendar.get(Calendar.DAY_OF_MONTH)));
        sb.append('T');
        sb.append(String.format(Locale.US, "%02d", calendar.get(Calendar.HOUR_OF_DAY)));
        sb.append(':');
        sb.append(String.format(Locale.US, "%02d", calendar.get(Calendar.MINUTE)));
        sb.append(':');
        sb.append(String.format(Locale.US, "%02d", calendar.get(Calendar.SECOND)));
        sb.append(".000Z");
        return sb.toString();
    }

    /**
     * Get the server id for a mailbox from the content provider.
     * @param mailboxId The id of the mailbox we're interested in.
     * @return The server id for the mailbox.
     */
    private String getServerIdForMailbox(final long mailboxId) {
        final Cursor c = mContentResolver.query(
                ContentUris.withAppendedId(Mailbox.CONTENT_URI, mailboxId),
                new String [] { EmailContent.MailboxColumns.SERVER_ID }, null, null, null);
        if (c != null) {
            try {
                if (c.moveToNext()) {
                    return c.getString(0);
                }
            } finally {
                c.close();
            }
        }
        return null;
    }

    /**
     * For a message that's in the Message_Updates table, add a sync command to the
     * {@link Serializer} if appropriate, and add the message to a list if it should be removed from
     * Message_Updates.
     * @param updatedMessageCursor The {@link Cursor} positioned at the message from Message_Updates
     *                             that we're processing.
     * @param s The {@link Serializer} for this sync command.
     * @param hasCommands Whether the {@link Serializer} already has sync commands added to it.
     * @param trashMailboxId The id for the trash mailbox.
     * @return Whether we added a sync command to s.
     * @throws IOException
     */
    private boolean handleOneUpdatedMessage(final Cursor updatedMessageCursor, final Serializer s,
            final boolean hasCommands, final long trashMailboxId) throws IOException {
        final long messageId = updatedMessageCursor.getLong(UPDATES_ID_COLUMN);
        // Get the current state of this message (updated table has original state).
        final Cursor currentCursor = mContentResolver.query(
                ContentUris.withAppendedId(Message.CONTENT_URI, messageId),
                UPDATES_PROJECTION, null, null, null);
        if (currentCursor == null) {
            // If, somehow, the message isn't still around, we still want to handle it as having
            // been updated so that it gets removed from the updated table.
            mUpdatedMessages.add(messageId);
            return false;
        }

        try {
            if (currentCursor.moveToFirst()) {
                final String serverId = currentCursor.getString(UPDATES_SERVER_ID_COLUMN);
                if (serverId == null) {
                    // No serverId means there's nothing to do, but we should still remove from the
                    // updated table.
                    mUpdatedMessages.add(messageId);
                    return false;
                }

                final long currentMailboxId = currentCursor.getLong(UPDATES_MAILBOX_KEY_COLUMN);
                final int currentFlags = currentCursor.getInt(UPDATES_FLAG_COLUMN);

                // Handle message deletion (i.e. move to trash).
                if (currentMailboxId == trashMailboxId) {
                    mUpdatedMessages.add(messageId);
                    addDeleteMessageCommand(s, serverId, !hasCommands);
                    // Also mark the message as moved in the DB (so the copy will be deleted if/when
                    // the server version is synced)
                    final ContentValues cv = new ContentValues(1);
                    cv.put(MessageColumns.FLAGS, currentFlags | MESSAGE_FLAG_MOVED_MESSAGE);
                    mContentResolver.update(
                            ContentUris.withAppendedId(Message.CONTENT_URI, messageId),
                            cv, null, null);
                    return true;
                }

                // Handle message moved.
                final long originalMailboxId =
                        updatedMessageCursor.getLong(UPDATES_MAILBOX_KEY_COLUMN);
                if (currentMailboxId != originalMailboxId) {
                    final String sourceMailboxId = getServerIdForMailbox(originalMailboxId);
                    final String destMailboxId;
                    if (sourceMailboxId != null) {
                        destMailboxId = getServerIdForMailbox(currentMailboxId);
                    } else {
                        destMailboxId = null;
                    }
                    if (destMailboxId != null) {
                        mMessagesToMove.add(
                                new MoveRequest(messageId, serverId, currentFlags,
                                        originalMailboxId, sourceMailboxId, destMailboxId));
                        // Since we don't want to remove this message from updated table until it
                        // downsyncs, we do not add it to updatedIds.
                    } else {
                        // TODO: If the message's mailboxes aren't there, handle it better.
                    }
                } else {
                    mUpdatedMessages.add(messageId);
                }

                final int favorite;
                final boolean favoriteChanged;
                // We can only send flag changes to the server in 12.0 or later
                if (getProtocolVersion() >= Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE) {
                    favorite = currentCursor.getInt(UPDATES_FAVORITE_COLUMN);
                    favoriteChanged =
                            favorite != updatedMessageCursor.getInt(UPDATES_FAVORITE_COLUMN);
                } else {
                    favorite = 0;
                    favoriteChanged = false;
                }

                final int read = currentCursor.getInt(UPDATES_READ_COLUMN);
                final boolean readChanged =
                        read != updatedMessageCursor.getInt(UPDATES_READ_COLUMN);

                if (favoriteChanged || readChanged) {
                    if (!hasCommands) {
                        s.start(Tags.SYNC_COMMANDS);
                    }
                    s.start(Tags.SYNC_CHANGE);
                    s.data(Tags.SYNC_SERVER_ID, serverId);
                    s.start(Tags.SYNC_APPLICATION_DATA);
                    if (readChanged) {
                        s.data(Tags.EMAIL_READ, Integer.toString(read));
                    }

                    // "Flag" is a relatively complex concept in EAS 12.0 and above.  It is not only
                    // the boolean "favorite" that we think of in Gmail, but it also represents a
                    // follow up action, which can include a subject, start and due dates, and even
                    // recurrences.  We don't support any of this as yet, but EAS 12.0 and higher
                    // require that a flag contain a status, a type, and four date fields, two each
                    // for start date and end (due) date.
                    if (favoriteChanged) {
                        if (favorite != 0) {
                            // Status 2 = set flag
                            s.start(Tags.EMAIL_FLAG).data(Tags.EMAIL_FLAG_STATUS, "2");
                            // "FollowUp" is the standard type
                            s.data(Tags.EMAIL_FLAG_TYPE, "FollowUp");
                            final long now = System.currentTimeMillis();
                            final Calendar calendar =
                                GregorianCalendar.getInstance(TimeZone.getTimeZone("GMT"));
                            calendar.setTimeInMillis(now);
                            // Flags are required to have a start date and end date (duplicated)
                            // First, we'll set the current date/time in GMT as the start time
                            String utc = formatDateTime(calendar);
                            s.data(Tags.TASK_START_DATE, utc).data(Tags.TASK_UTC_START_DATE, utc);
                            // And then we'll use one week from today for completion date
                            calendar.setTimeInMillis(now + DateUtils.WEEK_IN_MILLIS);
                            utc = formatDateTime(calendar);
                            s.data(Tags.TASK_DUE_DATE, utc).data(Tags.TASK_UTC_DUE_DATE, utc);
                            s.end();
                        } else {
                            s.tag(Tags.EMAIL_FLAG);
                        }
                    }
                    s.end().end();  // SYNC_APPLICATION_DATA, SYNC_CHANGE
                    return true;
                }
            }
        } finally {
            currentCursor.close();
        }
        return false;
    }

    /**
     * Send all message move requests and process responses.
     * TODO: Make this just one request/response, which requires changes to the parser.
     * @throws IOException
     */
    private void performMessageMove() throws IOException {

        for (final MoveRequest req : mMessagesToMove) {
            final Serializer s = new Serializer();
            s.start(Tags.MOVE_MOVE_ITEMS);
            s.start(Tags.MOVE_MOVE);
            s.data(Tags.MOVE_SRCMSGID, req.messageServerId);
            s.data(Tags.MOVE_SRCFLDID, req.sourceFolderServerId);
            s.data(Tags.MOVE_DSTFLDID, req.destFolderServerId);
            s.end();
            s.end().done();
            final EasResponse resp = sendHttpClientPost("MoveItems", s.toByteArray());
            try {
                final int status = resp.getStatus();
                if (status == HttpStatus.SC_OK) {
                    if (!resp.isEmpty()) {
                        final MoveItemsParser p = new MoveItemsParser(resp.getInputStream());
                        p.parse();
                        final int statusCode = p.getStatusCode();
                        final ContentValues cv = new ContentValues();
                        if (statusCode == MoveItemsParser.STATUS_CODE_REVERT) {
                            // Restore the old mailbox id
                            cv.put(MessageColumns.MAILBOX_KEY, req.sourceFolderId);
                            mContentResolver.update(
                                    ContentUris.withAppendedId(Message.CONTENT_URI, req.messageId),
                                    cv, null, null);
                        } else if (statusCode == MoveItemsParser.STATUS_CODE_SUCCESS) {
                            // Update with the new server id
                            cv.put(SyncColumns.SERVER_ID, p.getNewServerId());
                            cv.put(Message.FLAGS, req.messageFlags | MESSAGE_FLAG_MOVED_MESSAGE);
                            mContentResolver.update(
                                    ContentUris.withAppendedId(Message.CONTENT_URI, req.messageId),
                                    cv, null, null);
                        }
                        if (statusCode == MoveItemsParser.STATUS_CODE_SUCCESS
                                || statusCode == MoveItemsParser.STATUS_CODE_REVERT) {
                            // If we revert or succeed, we no longer need the update information
                            // OR the now-duplicate email (the new copy will be synced down)
                            mContentResolver.delete(ContentUris.withAppendedId(
                                    Message.UPDATED_CONTENT_URI, req.messageId), null, null);
                        } else {
                            // In this case, we're retrying, so do nothing.  The request will be
                            // handled next sync
                        }
                    }
                } else if (EasResponse.isAuthError(status)) {
                    throw new EasAuthenticationException();
                } else {
                    LogUtils.i(TAG, "Move items request failed, code: %d", status);
                    throw new IOException();
                }
            } finally {
                resp.close();
            }
        }
    }

    /**
     * For each message in Message_Updates, add a sync command if appropriate, and add its id to
     * our list of processed messages if appropriate.
     * @param s The {@link Serializer} for this sync request.
     * @param hasCommands Whether sync commands have already been written to s.
     * @return Whether this function added any sync commands to s.
     * @throws IOException
     */
    private boolean addUpdatedCommands(final Serializer s, final boolean hasCommands)
            throws IOException {
        // Find our trash mailbox, since deletions will have been moved there.
        final long trashMailboxId =
                Mailbox.findMailboxOfType(mContext, mMailbox.mAccountKey, Mailbox.TYPE_TRASH);
        final Cursor c = mContentResolver.query(Message.UPDATED_CONTENT_URI, UPDATES_PROJECTION,
                MessageColumns.MAILBOX_KEY + '=' + mMailbox.mId, null, null);
        boolean addedCommands = false;
        if (c != null) {
            try {
                while (c.moveToNext()) {
                    addedCommands |= handleOneUpdatedMessage(c, s, hasCommands || addedCommands,
                            trashMailboxId);
                }
            } finally {
                c.close();
            }
        }

        // mMessagesToMove is now populated. If it's non-empty, let's send the move request now.
        if (!mMessagesToMove.isEmpty()) {
            performMessageMove();
        }

        return addedCommands;
    }

    /**
     * Add FETCH commands for messages that need a body (i.e. we didn't find it during our earlier
     * sync; this happens only in EAS 2.5 where the body couldn't be found after parsing the
     * message's MIME data).
     * @param s The {@link Serializer} for this sync request.
     * @param hasCommands Whether sync commands have already been written to s.
     * @return Whether this function added any sync commands to s.
     * @throws IOException
     */
    private boolean addFetchCommands(final Serializer s, final boolean hasCommands)
            throws IOException {
        if (!hasCommands && !mMessagesToFetch.isEmpty()) {
            s.start(Tags.SYNC_COMMANDS);
        }
        for (final String serverId : mMessagesToFetch) {
            s.start(Tags.SYNC_FETCH).data(Tags.SYNC_SERVER_ID, serverId).end();
        }

        return !mMessagesToFetch.isEmpty();
    }

    @Override
    protected void setUpsyncCommands(final Serializer s) throws IOException {
        boolean addedCommands = addDeletedCommands(s, false);
        addedCommands = addFetchCommands(s, addedCommands);
        addedCommands = addUpdatedCommands(s, addedCommands);
        if (addedCommands) {
            s.end();
        }
    }

    @Override
    protected void cleanup(final int syncResult) {
        // After a successful sync, we have things to delete from the DB.
        if (syncResult != SYNC_RESULT_FAILED) {
            ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
            // Delete any moved messages (since we've just synced the mailbox, and no longer need
            // the placeholder message); this prevents duplicates from appearing in the mailbox.
            // TODO: Verify this still makes sense.
            ops.add(ContentProviderOperation.newDelete(Message.CONTENT_URI)
                    .withSelection(WHERE_MAILBOX_KEY_AND_MOVED,
                            new String[] {Long.toString(mMailbox.mId)}).build());
            // Delete any entries in Message_Updates and Message_Deletes that were upsynced.
            for (final long id: mDeletedMessages) {
                ops.add(ContentProviderOperation.newDelete(
                        ContentUris.withAppendedId(Message.DELETED_CONTENT_URI, id)).build());
            }
            for (final long id: mUpdatedMessages) {
                ops.add(ContentProviderOperation.newDelete(
                        ContentUris.withAppendedId(Message.UPDATED_CONTENT_URI, id)).build());
            }
            try {
                mContentResolver.applyBatch(EmailContent.AUTHORITY, ops);
            } catch (final RemoteException e) {
                // TODO: Improve handling.
            } catch (final OperationApplicationException e) {
                // TODO: Improve handing.
            }
        }

        if (syncResult == SYNC_RESULT_MORE_AVAILABLE) {
            // Prepare our member variables for another sync request.
            mDeletedMessages.clear();
            mUpdatedMessages.clear();
            mMessagesToFetch.clear();
            mMessagesToMove.clear();
        }
    }
}