/*
 * Copyright (C) 2015 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.messaging.datamodel.action;

import android.app.Activity;
import android.content.Context;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.telephony.PhoneNumberUtils;
import android.telephony.SmsManager;

import com.android.messaging.Factory;
import com.android.messaging.datamodel.BugleDatabaseOperations;
import com.android.messaging.datamodel.BugleNotifications;
import com.android.messaging.datamodel.DataModel;
import com.android.messaging.datamodel.DatabaseWrapper;
import com.android.messaging.datamodel.MmsFileProvider;
import com.android.messaging.datamodel.data.MessageData;
import com.android.messaging.datamodel.data.MessagePartData;
import com.android.messaging.datamodel.data.ParticipantData;
import com.android.messaging.mmslib.pdu.SendConf;
import com.android.messaging.sms.MmsConfig;
import com.android.messaging.sms.MmsSender;
import com.android.messaging.sms.MmsUtils;
import com.android.messaging.util.Assert;
import com.android.messaging.util.LogUtil;

import java.io.File;
import java.util.ArrayList;

/**
* Update message status to reflect success or failure
* Can also update the message itself if a "final" message is now available from telephony db
*/
public class ProcessSentMessageAction extends Action {
    private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;

    // These are always set
    private static final String KEY_SMS = "is_sms";
    private static final String KEY_SENT_BY_PLATFORM = "sent_by_platform";

    // These are set when we're processing a message sent by the user. They are null for messages
    // sent automatically (e.g. a NotifyRespInd/AcknowledgeInd sent in response to a download).
    private static final String KEY_MESSAGE_ID = "message_id";
    private static final String KEY_MESSAGE_URI = "message_uri";
    private static final String KEY_UPDATED_MESSAGE_URI = "updated_message_uri";
    private static final String KEY_SUB_ID = "sub_id";

    // These are set for messages sent by the platform (L+)
    public static final String KEY_RESULT_CODE = "result_code";
    public static final String KEY_HTTP_STATUS_CODE = "http_status_code";
    private static final String KEY_CONTENT_URI = "content_uri";
    private static final String KEY_RESPONSE = "response";
    private static final String KEY_RESPONSE_IMPORTANT = "response_important";

    // These are set for messages we sent ourself (legacy), or which we fast-failed before sending.
    private static final String KEY_STATUS = "status";
    private static final String KEY_RAW_STATUS = "raw_status";

    // This is called when MMS lib API returns via PendingIntent
    public static void processMmsSent(final int resultCode, final Uri messageUri,
            final Bundle extras) {
        final ProcessSentMessageAction action = new ProcessSentMessageAction();
        final Bundle params = action.actionParameters;
        params.putBoolean(KEY_SMS, false);
        params.putBoolean(KEY_SENT_BY_PLATFORM, true);
        params.putString(KEY_MESSAGE_ID, extras.getString(SendMessageAction.EXTRA_MESSAGE_ID));
        params.putParcelable(KEY_MESSAGE_URI, messageUri);
        params.putParcelable(KEY_UPDATED_MESSAGE_URI,
                extras.getParcelable(SendMessageAction.EXTRA_UPDATED_MESSAGE_URI));
        params.putInt(KEY_SUB_ID,
                extras.getInt(SendMessageAction.KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID));
        params.putInt(KEY_RESULT_CODE, resultCode);
        params.putInt(KEY_HTTP_STATUS_CODE, extras.getInt(SmsManager.EXTRA_MMS_HTTP_STATUS, 0));
        params.putParcelable(KEY_CONTENT_URI,
                extras.getParcelable(SendMessageAction.EXTRA_CONTENT_URI));
        params.putByteArray(KEY_RESPONSE, extras.getByteArray(SmsManager.EXTRA_MMS_DATA));
        params.putBoolean(KEY_RESPONSE_IMPORTANT,
                extras.getBoolean(SendMessageAction.EXTRA_RESPONSE_IMPORTANT));
        action.start();
    }

    public static void processMessageSentFastFailed(final String messageId,
            final Uri messageUri, final Uri updatedMessageUri, final int subId, final boolean isSms,
            final int status, final int rawStatus, final int resultCode) {
        final ProcessSentMessageAction action = new ProcessSentMessageAction();
        final Bundle params = action.actionParameters;
        params.putBoolean(KEY_SMS, isSms);
        params.putBoolean(KEY_SENT_BY_PLATFORM, false);
        params.putString(KEY_MESSAGE_ID, messageId);
        params.putParcelable(KEY_MESSAGE_URI, messageUri);
        params.putParcelable(KEY_UPDATED_MESSAGE_URI, updatedMessageUri);
        params.putInt(KEY_SUB_ID, subId);
        params.putInt(KEY_STATUS, status);
        params.putInt(KEY_RAW_STATUS, rawStatus);
        params.putInt(KEY_RESULT_CODE, resultCode);
        action.start();
    }

    private ProcessSentMessageAction() {
        // Callers must use one of the static methods above
    }

    /**
    * Update message status to reflect success or failure
    * Can also update the message itself if a "final" message is now available from telephony db
    */
    @Override
    protected Object executeAction() {
        final Context context = Factory.get().getApplicationContext();
        final String messageId = actionParameters.getString(KEY_MESSAGE_ID);
        final Uri messageUri = actionParameters.getParcelable(KEY_MESSAGE_URI);
        final Uri updatedMessageUri = actionParameters.getParcelable(KEY_UPDATED_MESSAGE_URI);
        final boolean isSms = actionParameters.getBoolean(KEY_SMS);
        final boolean sentByPlatform = actionParameters.getBoolean(KEY_SENT_BY_PLATFORM);

        int status = actionParameters.getInt(KEY_STATUS, MmsUtils.MMS_REQUEST_MANUAL_RETRY);
        int rawStatus = actionParameters.getInt(KEY_RAW_STATUS,
                MmsUtils.PDU_HEADER_VALUE_UNDEFINED);
        final int subId = actionParameters.getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);

        if (sentByPlatform) {
            // Delete temporary file backing the contentUri passed to MMS service
            final Uri contentUri = actionParameters.getParcelable(KEY_CONTENT_URI);
            Assert.isTrue(contentUri != null);
            final File tempFile = MmsFileProvider.getFile(contentUri);
            long messageSize = 0;
            if (tempFile.exists()) {
                messageSize = tempFile.length();
                tempFile.delete();
                if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
                    LogUtil.v(TAG, "ProcessSentMessageAction: Deleted temp file with outgoing "
                            + "MMS pdu: " + contentUri);
                }
            }

            final int resultCode = actionParameters.getInt(KEY_RESULT_CODE);
            final boolean responseImportant = actionParameters.getBoolean(KEY_RESPONSE_IMPORTANT);
            if (resultCode == Activity.RESULT_OK) {
                if (responseImportant) {
                    // Get the status from the response PDU and update telephony
                    final byte[] response = actionParameters.getByteArray(KEY_RESPONSE);
                    final SendConf sendConf = MmsSender.parseSendConf(response, subId);
                    if (sendConf != null) {
                        final MmsUtils.StatusPlusUri result =
                                MmsUtils.updateSentMmsMessageStatus(context, messageUri, sendConf);
                        status = result.status;
                        rawStatus = result.rawStatus;
                    }
                }
            } else {
                String errorMsg = "ProcessSentMessageAction: Platform returned error resultCode: "
                        + resultCode;
                final int httpStatusCode = actionParameters.getInt(KEY_HTTP_STATUS_CODE);
                if (httpStatusCode != 0) {
                    errorMsg += (", HTTP status code: " + httpStatusCode);
                }
                LogUtil.w(TAG, errorMsg);
                status = MmsSender.getErrorResultStatus(resultCode, httpStatusCode);

                // Check for MMS messages that failed because they exceeded the maximum size,
                // indicated by an I/O error from the platform.
                if (resultCode == SmsManager.MMS_ERROR_IO_ERROR) {
                    if (messageSize > MmsConfig.get(subId).getMaxMessageSize()) {
                        rawStatus = MessageData.RAW_TELEPHONY_STATUS_MESSAGE_TOO_BIG;
                    }
                }
            }
        }
        if (messageId != null) {
            final int resultCode = actionParameters.getInt(KEY_RESULT_CODE);
            final int httpStatusCode = actionParameters.getInt(KEY_HTTP_STATUS_CODE);
            processResult(
                    messageId, updatedMessageUri, status, rawStatus, isSms, this, subId,
                    resultCode, httpStatusCode);
        } else {
            if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
                LogUtil.v(TAG, "ProcessSentMessageAction: No sent message to process (it was "
                        + "probably a notify response for an MMS download)");
            }
        }
        return null;
    }

    static void processResult(final String messageId, Uri updatedMessageUri, int status,
            final int rawStatus, final boolean isSms, final Action processingAction,
            final int subId, final int resultCode, final int httpStatusCode) {
        final DatabaseWrapper db = DataModel.get().getDatabase();
        MessageData message = BugleDatabaseOperations.readMessage(db, messageId);
        final MessageData originalMessage = message;
        if (message == null) {
            LogUtil.w(TAG, "ProcessSentMessageAction: Sent message " + messageId
                    + " missing from local database");
            return;
        }
        final String conversationId = message.getConversationId();
        if (updatedMessageUri != null) {
            // Update message if we have newly written final message in the telephony db
            final MessageData update = MmsUtils.readSendingMmsMessage(updatedMessageUri,
                    conversationId, message.getParticipantId(), message.getSelfId());
            if (update != null) {
                // Set message Id of final message to that of the existing place holder.
                update.updateMessageId(message.getMessageId());
                // Update image sizes.
                update.updateSizesForImageParts();
                // Temp attachments are no longer needed
                for (final MessagePartData part : message.getParts()) {
                    part.destroySync();
                }
                message = update;
                // processResult will rewrite the complete message as part of update
            } else {
                updatedMessageUri = null;
                status = MmsUtils.MMS_REQUEST_MANUAL_RETRY;
                LogUtil.e(TAG, "ProcessSentMessageAction: Unable to read sending message");
            }
        }

        final long timestamp = System.currentTimeMillis();
        boolean failed;
        if (status == MmsUtils.MMS_REQUEST_SUCCEEDED) {
            message.markMessageSent(timestamp);
            failed = false;
        } else if (status == MmsUtils.MMS_REQUEST_AUTO_RETRY
                && message.getInResendWindow(timestamp)) {
            message.markMessageNotSent(timestamp);
            message.setRawTelephonyStatus(rawStatus);
            failed = false;
        } else {
            message.markMessageFailed(timestamp);
            message.setRawTelephonyStatus(rawStatus);
            message.setMessageSeen(false);
            failed = true;
        }

        // We have special handling for when a message to an emergency number fails. In this case,
        // we notify immediately of any failure (even if we auto-retry), and instruct the user to
        // try calling the emergency number instead.
        if (status != MmsUtils.MMS_REQUEST_SUCCEEDED) {
            final ArrayList<String> recipients =
                    BugleDatabaseOperations.getRecipientsForConversation(db, conversationId);
            for (final String recipient : recipients) {
                if (PhoneNumberUtils.isEmergencyNumber(recipient)) {
                    BugleNotifications.notifyEmergencySmsFailed(recipient, conversationId);
                    message.markMessageFailedEmergencyNumber(timestamp);
                    failed = true;
                    break;
                }
            }
        }

        // Update the message status and optionally refresh the message with final parts/values.
        if (SendMessageAction.updateMessageAndStatus(isSms, message, updatedMessageUri, failed)) {
            // We shouldn't show any notifications if we're not allowed to modify Telephony for
            // this message.
            if (failed) {
                BugleNotifications.update(false, BugleNotifications.UPDATE_ERRORS);
            }
            BugleActionToasts.onSendMessageOrManualDownloadActionCompleted(
                    conversationId, !failed, status, isSms, subId, true/*isSend*/);
        }

        LogUtil.i(TAG, "ProcessSentMessageAction: Done sending " + (isSms ? "SMS" : "MMS")
                + " message " + message.getMessageId()
                + " in conversation " + conversationId
                + "; status is " + MmsUtils.getRequestStatusDescription(status));

        // Whether we succeeded or failed we will check and maybe schedule some more work
        ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(
                status != MmsUtils.MMS_REQUEST_SUCCEEDED, processingAction);
    }

    private ProcessSentMessageAction(final Parcel in) {
        super(in);
    }

    public static final Parcelable.Creator<ProcessSentMessageAction> CREATOR
            = new Parcelable.Creator<ProcessSentMessageAction>() {
        @Override
        public ProcessSentMessageAction createFromParcel(final Parcel in) {
            return new ProcessSentMessageAction(in);
        }

        @Override
        public ProcessSentMessageAction[] newArray(final int size) {
            return new ProcessSentMessageAction[size];
        }
    };

    @Override
    public void writeToParcel(final Parcel parcel, final int flags) {
        writeActionToParcel(parcel, flags);
    }
}