/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.email.provider;

import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.CursorWrapper;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.text.util.Rfc822Token;
import android.text.util.Rfc822Tokenizer;

import com.android.emailcommon.Logging;
import com.android.emailcommon.mail.Address;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.Mailbox;
import com.android.mail.browse.ConversationCursorOperationListener;
import com.android.mail.providers.ConversationInfo;
import com.android.mail.providers.Folder;
import com.android.mail.providers.FolderList;
import com.android.mail.providers.ParticipantInfo;
import com.android.mail.providers.UIProvider;
import com.android.mail.providers.UIProvider.ConversationColumns;
import com.android.mail.utils.LogUtils;
import com.google.common.collect.Lists;

/**
 * Wrapper that handles the visibility feature (i.e. the conversation list is visible, so
 * any pending notifications for the corresponding mailbox should be canceled). We also handle
 * getExtras() to provide a snapshot of the mailbox's status
 */
public class EmailConversationCursor extends CursorWrapper implements
        ConversationCursorOperationListener {
    private final long mMailboxId;
    private final int mMailboxTypeId;
    private final Context mContext;
    private final FolderList mFolderList;
    private final Bundle mExtras = new Bundle();

    /**
     * When showing a folder, if it's been at least this long since the last sync,
     * force a folder refresh.
     */
    private static final long AUTO_REFRESH_INTERVAL_MS = 5 * DateUtils.MINUTE_IN_MILLIS;

    public EmailConversationCursor(final Context context, final Cursor cursor,
            final Folder folder, final long mailboxId) {
        super(cursor);
        mMailboxId = mailboxId;
        mContext = context;
        mFolderList = FolderList.copyOf(Lists.newArrayList(folder));
        Mailbox mailbox = Mailbox.restoreMailboxWithId(context, mailboxId);

        if (mailbox != null) {
            mMailboxTypeId = mailbox.mType;

            mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_TOTAL_COUNT, mailbox.mTotalCount);
            if (mailbox.mUiSyncStatus == EmailContent.SYNC_STATUS_BACKGROUND
                    || mailbox.mUiSyncStatus == EmailContent.SYNC_STATUS_USER
                    || mailbox.mUiSyncStatus == EmailContent.SYNC_STATUS_LIVE
                    || mailbox.mUiSyncStatus == EmailContent.SYNC_STATUS_INITIAL_SYNC_NEEDED) {
                mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_STATUS,
                        UIProvider.CursorStatus.LOADING);
            } else if (mailbox.mUiSyncStatus == EmailContent.SYNC_STATUS_NONE) {
                if (mailbox.mSyncInterval == 0
                        && (Mailbox.isSyncableType(mailbox.mType)
                        || mailbox.mType == Mailbox.TYPE_SEARCH)
                        && !TextUtils.isEmpty(mailbox.mServerId) &&
                        // TODO: There's potentially a race condition here.
                        // Consider merging this check with the auto-sync code in respond.
                        System.currentTimeMillis() - mailbox.mSyncTime
                                > AUTO_REFRESH_INTERVAL_MS) {
                    // This will be syncing momentarily
                    mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_STATUS,
                            UIProvider.CursorStatus.LOADING);
                } else {
                    mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_STATUS,
                            UIProvider.CursorStatus.COMPLETE);
                }
            } else {
                LogUtils.d(Logging.LOG_TAG,
                        "Unknown mailbox sync status" + mailbox.mUiSyncStatus);
                mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_STATUS,
                        UIProvider.CursorStatus.COMPLETE);
            }
        } else {
            mMailboxTypeId = -1;
            // TODO for virtual mailboxes, we may want to do something besides just fake it
            mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_TOTAL_COUNT,
                    cursor != null ? cursor.getCount() : 0);
            mExtras.putInt(UIProvider.CursorExtraKeys.EXTRA_STATUS,
                    UIProvider.CursorStatus.COMPLETE);
        }
    }

    @Override
    public Bundle getExtras() {
        return mExtras;
    }

    @Override
    public Bundle respond(Bundle params) {
        final String setVisibilityKey =
                UIProvider.ConversationCursorCommand.COMMAND_KEY_SET_VISIBILITY;
        if (params.containsKey(setVisibilityKey)) {
            final boolean visible = params.getBoolean(setVisibilityKey);
            if (visible) {
                // Mark all messages as seen
                markContentsSeen();
                if (params.containsKey(
                        UIProvider.ConversationCursorCommand.COMMAND_KEY_ENTERED_FOLDER)) {
                    Mailbox mailbox = Mailbox.restoreMailboxWithId(mContext, mMailboxId);
                    if (mailbox != null) {
                        // For non-push mailboxes, if it's stale (i.e. last sync was a while
                        // ago), force a sync.
                        // TODO: Fix the check for whether we're non-push? Right now it checks
                        // whether we are participating in account sync rules.
                        if (mailbox.mSyncInterval == 0) {
                            final long timeSinceLastSync =
                                    System.currentTimeMillis() - mailbox.mSyncTime;
                            if (timeSinceLastSync > AUTO_REFRESH_INTERVAL_MS) {
                                final ContentResolver resolver = mContext.getContentResolver();
                                final Uri refreshUri = Uri.parse(EmailContent.CONTENT_URI +
                                        "/" + EmailProvider.QUERY_UIREFRESH + "/" + mailbox.mId);
                                resolver.query(refreshUri, null, null, null, null);
                            }
                        }
                    }
                }
            }
        }
        // Return success
        final Bundle response = new Bundle(2);

        response.putString(setVisibilityKey,
                UIProvider.ConversationCursorCommand.COMMAND_RESPONSE_OK);

        final String rawFoldersKey =
                UIProvider.ConversationCursorCommand.COMMAND_GET_RAW_FOLDERS;
        if (params.containsKey(rawFoldersKey)) {
            response.putParcelable(rawFoldersKey, mFolderList);
        }

        final String convInfoKey =
                UIProvider.ConversationCursorCommand.COMMAND_GET_CONVERSATION_INFO;
        if (params.containsKey(convInfoKey)) {
            response.putParcelable(convInfoKey, generateConversationInfo());
        }

        return response;
    }

    private ConversationInfo generateConversationInfo() {
        final int numMessages = getInt(getColumnIndex(ConversationColumns.NUM_MESSAGES));
        final ConversationInfo conversationInfo = new ConversationInfo(numMessages);

        conversationInfo.firstSnippet = getString(getColumnIndex(ConversationColumns.SNIPPET));
        conversationInfo.lastSnippet = conversationInfo.firstSnippet;
        conversationInfo.firstUnreadSnippet = conversationInfo.firstSnippet;

        final boolean isRead = getInt(getColumnIndex(ConversationColumns.READ)) != 0;
        final String senderString = getString(getColumnIndex(EmailContent.MessageColumns.DISPLAY_NAME));

        final String fromString = getString(getColumnIndex(EmailContent.MessageColumns.FROM_LIST));
        final String senderEmail;

        if (fromString != null) {
            final Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(fromString);
            if (tokens.length > 0) {
                senderEmail = tokens[0].getAddress();
            } else {
                LogUtils.d(LogUtils.TAG, "Couldn't parse sender email address");
                senderEmail = fromString;
            }
        } else {
            senderEmail = null;
        }

        // we *intentionally* report no participants for Draft emails so that the UI always
        // displays the single word "Draft" as per b/13304929
        if (mMailboxTypeId == Mailbox.TYPE_DRAFTS) {
            // the UI displays "Draft" in the conversation list based on this count
            conversationInfo.draftCount = 1;
        } else if (mMailboxTypeId == Mailbox.TYPE_SENT ||
                mMailboxTypeId == Mailbox.TYPE_OUTBOX) {
            // for conversations in outgoing mail mailboxes return a list of recipients
            final String recipientsString = getString(getColumnIndex(
                    EmailContent.MessageColumns.TO_LIST));
            final Address[] recipientAddresses = Address.parse(recipientsString);
            for (Address recipientAddress : recipientAddresses) {
                final String name = recipientAddress.getSimplifiedName();
                final String email = recipientAddress.getAddress();

                // all recipients are said to have read all messages in the conversation
                conversationInfo.addParticipant(new ParticipantInfo(name, email, 0, isRead));
            }
        } else {
            // for conversations in incoming mail mailboxes return the sender
            conversationInfo.addParticipant(new ParticipantInfo(senderString, senderEmail, 0,
                    isRead));
        }

        return conversationInfo;
    }

    @Override
    public void markContentsSeen() {
        final ContentResolver resolver = mContext.getContentResolver();
        final ContentValues contentValues = new ContentValues(1);
        contentValues.put(EmailContent.MessageColumns.FLAG_SEEN, true);
        final Uri uri = EmailContent.Message.CONTENT_URI;
        final String where = EmailContent.MessageColumns.MAILBOX_KEY + " = ? AND " +
                EmailContent.MessageColumns.FLAG_SEEN + " != ?";
        final String[] selectionArgs = {String.valueOf(mMailboxId), "1"};
        resolver.update(uri, contentValues, where, selectionArgs);
    }

    @Override
    public void emptyFolder() {
        final ContentResolver resolver = mContext.getContentResolver();
        final Uri purgeUri = EmailProvider.uiUri("uipurgefolder", mMailboxId);
        resolver.delete(purgeUri, null, null);
    }
}