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

import android.app.Activity;
import android.app.AlertDialog;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.Context;
import android.content.DialogInterface;
import android.media.MediaPlayer;
import android.os.Environment;
import android.telephony.SmsMessage;
import android.text.TextUtils;
import android.widget.ArrayAdapter;

import com.android.messaging.R;
import com.android.messaging.datamodel.SyncManager;
import com.android.messaging.datamodel.action.DumpDatabaseAction;
import com.android.messaging.datamodel.action.LogTelephonyDatabaseAction;
import com.android.messaging.sms.MmsUtils;
import com.android.messaging.ui.UIIntents;
import com.android.messaging.ui.debug.DebugSmsMmsFromDumpFileDialogFragment;
import com.google.common.io.ByteStreams;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.StreamCorruptedException;

public class DebugUtils {
    private static final String TAG = "bugle.util.DebugUtils";

    private static boolean sDebugNoise;
    private static boolean sDebugClassZeroSms;
    private static MediaPlayer [] sMediaPlayer;
    private static final Object sLock = new Object();

    public static final int DEBUG_SOUND_SERVER_REQUEST = 0;
    public static final int DEBUG_SOUND_DB_OP = 1;

    public static void maybePlayDebugNoise(final Context context, final int sound) {
        if (sDebugNoise) {
            synchronized (sLock) {
                try {
                    if (sMediaPlayer == null) {
                        sMediaPlayer = new MediaPlayer[2];
                        sMediaPlayer[DEBUG_SOUND_SERVER_REQUEST] =
                                MediaPlayer.create(context, R.raw.server_request_debug);
                        sMediaPlayer[DEBUG_SOUND_DB_OP] =
                                MediaPlayer.create(context, R.raw.db_op_debug);
                        sMediaPlayer[DEBUG_SOUND_DB_OP].setVolume(1.0F, 1.0F);
                        sMediaPlayer[DEBUG_SOUND_SERVER_REQUEST].setVolume(0.3F, 0.3F);
                    }
                    if (sMediaPlayer[sound] != null) {
                        sMediaPlayer[sound].start();
                    }
                } catch (final IllegalArgumentException e) {
                    LogUtil.e(TAG, "MediaPlayer exception", e);
                } catch (final SecurityException e) {
                    LogUtil.e(TAG, "MediaPlayer exception", e);
                } catch (final IllegalStateException e) {
                    LogUtil.e(TAG, "MediaPlayer exception", e);
                }
            }
        }
    }

    public static boolean isDebugEnabled() {
        return BugleGservices.get().getBoolean(BugleGservicesKeys.ENABLE_DEBUGGING_FEATURES,
                BugleGservicesKeys.ENABLE_DEBUGGING_FEATURES_DEFAULT);
    }

    public abstract static class DebugAction {
        String mTitle;
        public DebugAction(final String title) {
            mTitle = title;
        }

        @Override
        public String toString() {
            return mTitle;
        }

        public abstract void run();
    }

    public static void showDebugOptions(final Activity host) {
        final AlertDialog.Builder builder = new AlertDialog.Builder(host);

        final ArrayAdapter<DebugAction> arrayAdapter = new ArrayAdapter<DebugAction>(
                host, android.R.layout.simple_list_item_1);

        arrayAdapter.add(new DebugAction("Dump Database") {
            @Override
            public void run() {
                DumpDatabaseAction.dumpDatabase();
            }
        });

        arrayAdapter.add(new DebugAction("Log Telephony Data") {
            @Override
            public void run() {
                LogTelephonyDatabaseAction.dumpDatabase();
            }
        });

        arrayAdapter.add(new DebugAction("Toggle Noise") {
            @Override
            public void run() {
                sDebugNoise = !sDebugNoise;
            }
        });

        arrayAdapter.add(new DebugAction("Force sync SMS") {
            @Override
            public void run() {
                final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
                prefs.putLong(BuglePrefsKeys.LAST_FULL_SYNC_TIME, -1);
                SyncManager.forceSync();
            }
        });

        arrayAdapter.add(new DebugAction("Sync SMS") {
            @Override
            public void run() {
                SyncManager.sync();
            }
        });

        arrayAdapter.add(new DebugAction("Load SMS/MMS from dump file") {
            @Override
            public void run() {
                new DebugSmsMmsDumpTask(host,
                        DebugSmsMmsFromDumpFileDialogFragment.ACTION_LOAD).executeOnThreadPool();
            }
        });

        arrayAdapter.add(new DebugAction("Email SMS/MMS dump file") {
            @Override
            public void run() {
                new DebugSmsMmsDumpTask(host,
                        DebugSmsMmsFromDumpFileDialogFragment.ACTION_EMAIL).executeOnThreadPool();
            }
        });

        arrayAdapter.add(new DebugAction("MMS Config...") {
            @Override
            public void run() {
                UIIntents.get().launchDebugMmsConfigActivity(host);
            }
        });

        arrayAdapter.add(new DebugAction(sDebugClassZeroSms ? "Turn off Class 0 sms test" :
                "Turn on Class Zero test") {
            @Override
            public void run() {
                sDebugClassZeroSms = !sDebugClassZeroSms;
            }
        });

        builder.setAdapter(arrayAdapter,
                new android.content.DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface arg0, final int pos) {
                arrayAdapter.getItem(pos).run();
            }
        });

        builder.create().show();
    }

    /**
     * Task to list all the dump files and perform an action on it
     */
    private static class DebugSmsMmsDumpTask extends SafeAsyncTask<Void, Void, String[]> {
        private final String mAction;
        private final Activity mHost;

        public DebugSmsMmsDumpTask(final Activity host, final String action) {
            mHost = host;
            mAction = action;
        }

        @Override
        protected void onPostExecute(final String[] result) {
            if (result == null || result.length < 1) {
                return;
            }
            final FragmentManager fragmentManager = mHost.getFragmentManager();
            final FragmentTransaction ft = fragmentManager.beginTransaction();
            final DebugSmsMmsFromDumpFileDialogFragment dialog =
                    DebugSmsMmsFromDumpFileDialogFragment.newInstance(result, mAction);
            dialog.show(fragmentManager, ""/*tag*/);
        }

        @Override
        protected String[] doInBackgroundTimed(final Void... params) {
            final File dir = DebugUtils.getDebugFilesDir();
            return dir.list(new FilenameFilter() {
                @Override
                public boolean accept(final File dir, final String filename) {
                    return filename != null
                            && ((mAction == DebugSmsMmsFromDumpFileDialogFragment.ACTION_EMAIL
                            && filename.equals(DumpDatabaseAction.DUMP_NAME))
                            || filename.startsWith(MmsUtils.MMS_DUMP_PREFIX)
                            || filename.startsWith(MmsUtils.SMS_DUMP_PREFIX));
                }
            });
        }
    }

    /**
     * Dump the received raw SMS data into a file on external storage
     *
     * @param id The ID to use as part of the dump file name
     * @param messages The raw SMS data
     */
    public static void dumpSms(final long id, final android.telephony.SmsMessage[] messages,
            final String format) {
        try {
            final String dumpFileName = MmsUtils.SMS_DUMP_PREFIX + Long.toString(id);
            final File dumpFile = DebugUtils.getDebugFile(dumpFileName, true);
            if (dumpFile != null) {
                final FileOutputStream fos = new FileOutputStream(dumpFile);
                final DataOutputStream dos = new DataOutputStream(fos);
                try {
                    final int chars = (TextUtils.isEmpty(format) ? 0 : format.length());
                    dos.writeInt(chars);
                    if (chars > 0) {
                        dos.writeUTF(format);
                    }
                    dos.writeInt(messages.length);
                    for (final android.telephony.SmsMessage message : messages) {
                        final byte[] pdu = message.getPdu();
                        dos.writeInt(pdu.length);
                        dos.write(pdu, 0, pdu.length);
                    }
                    dos.flush();
                } finally {
                    dos.close();
                    ensureReadable(dumpFile);
                }
            }
        } catch (final IOException e) {
            LogUtil.e(LogUtil.BUGLE_TAG, "dumpSms: " + e, e);
        }
    }

    /**
     * Load MMS/SMS from the dump file
     */
    public static SmsMessage[] retreiveSmsFromDumpFile(final String dumpFileName) {
        SmsMessage[] messages = null;
        final File inputFile = DebugUtils.getDebugFile(dumpFileName, false);
        if (inputFile != null) {
            FileInputStream fis = null;
            DataInputStream dis = null;
            try {
                fis = new FileInputStream(inputFile);
                dis = new DataInputStream(fis);

                // SMS dump
                final int chars = dis.readInt();
                if (chars > 0) {
                    final String format = dis.readUTF();
                }
                final int count = dis.readInt();
                final SmsMessage[] messagesTemp = new SmsMessage[count];
                for (int i = 0; i < count; i++) {
                    final int length = dis.readInt();
                    final byte[] pdu = new byte[length];
                    dis.read(pdu, 0, length);
                    messagesTemp[i] = SmsMessage.createFromPdu(pdu);
                }
                messages = messagesTemp;
            } catch (final FileNotFoundException e) {
                // Nothing to do
            } catch (final StreamCorruptedException e) {
                // Nothing to do
            } catch (final IOException e) {
                // Nothing to do
            } finally {
                if (dis != null) {
                    try {
                        dis.close();
                    } catch (final IOException e) {
                        // Nothing to do
                    }
                }
            }
        }
        return messages;
    }

    public static File getDebugFile(final String fileName, final boolean create) {
        final File dir = getDebugFilesDir();
        final File file = new File(dir, fileName);
        if (create && file.exists()) {
            file.delete();
        }
        return file;
    }

    public static File getDebugFilesDir() {
        final File dir = Environment.getExternalStorageDirectory();
        return dir;
    }

    /**
     * Load MMS/SMS from the dump file
     */
    public static byte[] receiveFromDumpFile(final String dumpFileName) {
        byte[] data = null;
        try {
            final File inputFile = getDebugFile(dumpFileName, false);
            if (inputFile != null) {
                final FileInputStream fis = new FileInputStream(inputFile);
                final BufferedInputStream bis = new BufferedInputStream(fis);
                try {
                    // dump file
                    data = ByteStreams.toByteArray(bis);
                    if (data == null || data.length < 1) {
                        LogUtil.e(LogUtil.BUGLE_TAG, "receiveFromDumpFile: empty data");
                    }
                } finally {
                    bis.close();
                }
            }
        } catch (final IOException e) {
            LogUtil.e(LogUtil.BUGLE_TAG, "receiveFromDumpFile: " + e, e);
        }
        return data;
    }

    public static void ensureReadable(final File file) {
        if (file.exists()){
            file.setReadable(true, false);
        }
    }

    /**
     * Logs the name of the method that is currently executing, e.g. "MyActivity.onCreate". This is
     * useful for surgically adding logs for tracing execution while debugging.
     * <p>
     * NOTE: This method retrieves the current thread's stack trace, which adds runtime overhead.
     * However, this method is only executed on eng builds if DEBUG logs are loggable.
     */
    public static void logCurrentMethod(String tag) {
        if (!LogUtil.isLoggable(tag, LogUtil.DEBUG)) {
            return;
        }
        StackTraceElement caller = getCaller(1);
        if (caller == null) {
            return;
        }
        String className = caller.getClassName();
        // Strip off the package name
        int lastDot = className.lastIndexOf('.');
        if (lastDot > -1) {
            className = className.substring(lastDot + 1);
        }
        LogUtil.d(tag, className + "." + caller.getMethodName());
    }

    /**
     * Returns info about the calling method. The {@code depth} parameter controls how far back to
     * go. For example, if foo() calls bar(), and bar() calls getCaller(0), it returns info about
     * bar(). If bar() instead called getCaller(1), it would return info about foo(). And so on.
     * <p>
     * NOTE: This method retrieves the current thread's stack trace, which adds runtime overhead.
     * It should only be used in production where necessary to gather context about an error or
     * unexpected event (e.g. the {@link Assert} class uses it).
     *
     * @return stack frame information for the caller (if found); otherwise {@code null}.
     */
    public static StackTraceElement getCaller(int depth) {
        // If the signature of this method is changed, proguard.flags must be updated!
        if (depth < 0) {
            throw new IllegalArgumentException("depth cannot be negative");
        }
        StackTraceElement[] trace = Thread.currentThread().getStackTrace();
        if (trace == null || trace.length < (depth + 2)) {
            return null;
        }
        // The stack trace includes some methods we don't care about (e.g. this method).
        // Walk down until we find this method, and then back up to the caller we're looking for.
        for (int i = 0; i < trace.length - 1; i++) {
            String methodName = trace[i].getMethodName();
            if ("getCaller".equals(methodName)) {
                return trace[i + depth + 1];
            }
        }
        // Never found ourself in the stack?!
        return null;
    }

    /**
     * Returns a boolean indicating whether ClassZero debugging is enabled. If enabled, any received
     * sms is treated as if it were a class zero message and displayed by the ClassZeroActivity.
     */
    public static boolean debugClassZeroSmsEnabled() {
        return sDebugClassZeroSms;
    }
}