
package org.wordpress.android;

import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.annotation.NonNull;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationManagerCompat;
import android.support.v4.util.ArrayMap;
import android.text.TextUtils;

import com.google.android.gms.gcm.GcmListenerService;
import com.simperium.client.BucketObjectMissingException;

import org.apache.commons.lang.StringEscapeUtils;
import org.wordpress.android.analytics.AnalyticsTracker;
import org.wordpress.android.analytics.AnalyticsTracker.Stat;
import org.wordpress.android.analytics.AnalyticsTrackerMixpanel;
import org.wordpress.android.models.AccountHelper;
import org.wordpress.android.models.CommentStatus;
import org.wordpress.android.models.Note;
import org.wordpress.android.ui.main.WPMainActivity;
import org.wordpress.android.ui.notifications.NotificationDismissBroadcastReceiver;
import org.wordpress.android.ui.notifications.NotificationEvents;
import org.wordpress.android.ui.notifications.NotificationsListFragment;
import org.wordpress.android.ui.notifications.utils.NotificationsUtils;
import org.wordpress.android.ui.notifications.utils.SimperiumUtils;
import org.wordpress.android.util.AppLog;
import org.wordpress.android.util.AppLog.T;
import org.wordpress.android.util.HelpshiftHelper;
import org.wordpress.android.util.ImageUtils;
import org.wordpress.android.util.PhotonUtils;
import org.wordpress.android.util.StringUtils;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import de.greenrobot.event.EventBus;

public class GCMMessageService extends GcmListenerService {
    private static final ArrayMap<Integer, Bundle> sActiveNotificationsMap = new ArrayMap<>();
    private static String sPreviousNoteId = null;
    private static long sPreviousNoteTime = 0L;

    private static final String NOTIFICATION_GROUP_KEY = "notification_group_key";
    private static final int PUSH_NOTIFICATION_ID = 10000;
    private static final int AUTH_PUSH_NOTIFICATION_ID = 20000;
    public static final int GROUP_NOTIFICATION_ID = 30000;
    private static final int MAX_INBOX_ITEMS = 5;

    private static final String PUSH_ARG_USER = "user";
    private static final String PUSH_ARG_TYPE = "type";
    private static final String PUSH_ARG_TITLE = "title";
    private static final String PUSH_ARG_MSG = "msg";
    private static final String PUSH_ARG_NOTE_ID = "note_id";

    private static final String PUSH_TYPE_COMMENT = "c";
    private static final String PUSH_TYPE_LIKE = "like";
    private static final String PUSH_TYPE_COMMENT_LIKE = "comment_like";
    private static final String PUSH_TYPE_AUTOMATTCHER = "automattcher";
    private static final String PUSH_TYPE_FOLLOW = "follow";
    private static final String PUSH_TYPE_REBLOG = "reblog";
    private static final String PUSH_TYPE_PUSH_AUTH = "push_auth";
    private static final String PUSH_TYPE_BADGE_RESET = "badge-reset";

    private static final String KEY_CATEGORY_COMMENT_LIKE = "comment-like";
    private static final String KEY_CATEGORY_COMMENT_REPLY = "comment-reply";
    private static final String KEY_CATEGORY_COMMENT_MODERATE = "comment-moderate";


    // Add to the analytics properties map a subset of the push notification payload.
    private static String[] propertiesToCopyIntoAnalytics = {PUSH_ARG_NOTE_ID, PUSH_ARG_TYPE, "blog_id", "post_id",
            "comment_id"};

    private void synchronizedHandleDefaultPush(String from, @NonNull Bundle data) {
        // sActiveNotificationsMap being static, we can't just synchronize the method
        synchronized (GCMMessageService.class) {
            handleDefaultPush(from, data);
        }
    }

    private void handleDefaultPush(String from, @NonNull Bundle data) {
        // Ensure Simperium is running so that notes sync
        SimperiumUtils.configureSimperium(this, AccountHelper.getDefaultAccount().getAccessToken());

        long wpcomUserId = AccountHelper.getDefaultAccount().getUserId();
        String pushUserId = data.getString(PUSH_ARG_USER);
        // pushUserId is always set server side, but better to double check it here.
        if (!String.valueOf(wpcomUserId).equals(pushUserId)) {
            AppLog.e(T.NOTIFS, "wpcom userId found in the app doesn't match with the ID in the PN. Aborting.");
            return;
        }

        String noteType = StringUtils.notNullStr(data.getString(PUSH_ARG_TYPE));

        // Check for wpcom auth push, if so we will process this push differently
        if (noteType.equals(PUSH_TYPE_PUSH_AUTH)) {
            handlePushAuth(from, data);
            return;
        }

        if (noteType.equals(PUSH_TYPE_BADGE_RESET)) {
            handleBadgeResetPN(data);
            return;
        }

        buildAndShowNotificationFromNoteData(data);

        EventBus.getDefault().post(new NotificationEvents.NotificationsChanged());
    }

    private void buildAndShowNotificationFromNoteData(Bundle data) {

        if (data == null)
            return;

        String noteType = StringUtils.notNullStr(data.getString(PUSH_ARG_TYPE));

        String title = StringEscapeUtils.unescapeHtml(data.getString(PUSH_ARG_TITLE));
        if (title == null) {
            title = getString(R.string.app_name);
        }
        String message = StringEscapeUtils.unescapeHtml(data.getString(PUSH_ARG_MSG));
        String noteId = data.getString(PUSH_ARG_NOTE_ID, "");

        /*
         * if this has the same note_id as the previous notification, and the previous notification
         * was received within the last second, then skip showing it - this handles duplicate
         * notifications being shown due to the device being registered multiple times with different tokens.
         * (still investigating how this could happen - 21-Oct-13)
         *
         * this also handles the (rare) case where the user receives rapid-fire sub-second like notifications
         * due to sudden popularity (post gets added to FP and is liked by many people all at once, etc.),
         * which we also want to avoid since it would drain the battery and annoy the user
         *
         * NOTE: different comments on the same post will have a different note_id, but different likes
         * on the same post will have the same note_id, so don't assume that the note_id is unique
         */
        long thisTime = System.currentTimeMillis();
        if (sPreviousNoteId != null && sPreviousNoteId.equals(noteId)) {
            long seconds = TimeUnit.MILLISECONDS.toSeconds(thisTime - sPreviousNoteTime);
            if (seconds <= 1) {
                AppLog.w(T.NOTIFS, "skipped potential duplicate notification");
                return;
            }
        }

        sPreviousNoteId = noteId;
        sPreviousNoteTime = thisTime;

        // Update notification content for the same noteId if it is already showing
        int pushId = 0;
        for (Integer id : sActiveNotificationsMap.keySet()) {
            if (id == null) {
                continue;
            }
            Bundle noteBundle = sActiveNotificationsMap.get(id);
            if (noteBundle != null && noteBundle.getString(PUSH_ARG_NOTE_ID, "").equals(noteId)) {
                pushId = id;
                sActiveNotificationsMap.put(pushId, data);
                break;
            }
        }

        if (pushId == 0) {
            pushId = PUSH_NOTIFICATION_ID + sActiveNotificationsMap.size();
            sActiveNotificationsMap.put(pushId, data);
        }

        // Bump Analytics for PNs if "Show notifications" setting is checked (default). Skip otherwise.
        if (NotificationsUtils.isNotificationsEnabled(this)) {
            Map<String, Object> properties = new HashMap<>();
            if (!TextUtils.isEmpty(noteType)) {
                // 'comment' and 'comment_pingback' types are sent in PN as type = "c"
                if (noteType.equals(PUSH_TYPE_COMMENT)) {
                    properties.put("notification_type", "comment");
                } else {
                    properties.put("notification_type", noteType);
                }
            }

            bumpPushNotificationsAnalytics(Stat.PUSH_NOTIFICATION_RECEIVED, data, properties);
            AnalyticsTracker.flush();
        }

        showGroupNotificationForActiveNotificationsMap(pushId, noteId, noteType, data.getString("icon"), title, message);
    }

    private void showGroupNotificationForActiveNotificationsMap(int pushId, String noteId, String noteType,
                                                                String largeIconUri, String title, String message) {

        // Build the new notification, add group to support wearable stacking
        NotificationCompat.Builder builder = getNotificationBuilder(title, message);

        Bitmap largeIconBitmap = getLargeIconBitmap(largeIconUri, shouldCircularizeNoteIcon(noteType));
        if (largeIconBitmap != null) {
            builder.setLargeIcon(largeIconBitmap);
        }

        showIndividualNotificationForBuilder(builder, noteType, noteId, pushId);

        // Also add a group summary notification, which is required for non-wearable devices
        showGroupNotificationForBuilder(builder, message);
    }

    private void addActionsForCommentNotification(NotificationCompat.Builder builder, String noteId) {
        // Add some actions if this is a comment notification

        boolean areActionsSet = false;

        if (SimperiumUtils.getNotesBucket() != null) {
            try {
                Note note = SimperiumUtils.getNotesBucket().get(noteId);
                if (note != null) {
                    //if note can be replied to, we'll always add this action first
                    if (note.canReply()) {
                        addCommentReplyActionForCommentNotification(builder, noteId);
                    }

                    // if the comment is lacking approval, offer moderation actions
                    if (note.getCommentStatus().equals(CommentStatus.UNAPPROVED)) {
                        if (note.canModerate()) {
                            addCommentApproveActionForCommentNotification(builder, noteId);
                        }
                    } else {
                        //else offer REPLY / LIKE actions
                        if (note.canLike()) {
                            addCommentLikeActionForCommentNotification(builder, noteId);
                        }
                    }
                }
                areActionsSet = true;
            } catch (BucketObjectMissingException e) {
                e.printStackTrace();
            }
        }

        // if we could not set the actions, set the default ones REPLY / LIKE
        if (!areActionsSet) {
            addCommentReplyActionForCommentNotification(builder, noteId);
            addCommentLikeActionForCommentNotification(builder, noteId);
        }
    }

    private void addCommentReplyActionForCommentNotification(NotificationCompat.Builder builder, String noteId) {
        // adding comment reply action
        Intent commentReplyIntent = getCommentActionIntent();
        commentReplyIntent.addCategory(KEY_CATEGORY_COMMENT_REPLY);
        commentReplyIntent.putExtra(NotificationsListFragment.NOTE_INSTANT_REPLY_EXTRA, true);
        if (noteId != null) {
            commentReplyIntent.putExtra(NotificationsListFragment.NOTE_ID_EXTRA, noteId);
        }
        PendingIntent commentReplyPendingIntent = PendingIntent.getActivity(this, 0, commentReplyIntent,
                PendingIntent.FLAG_CANCEL_CURRENT);
        builder.addAction(R.drawable.ic_reply_white_24dp, getText(R.string.reply),
                commentReplyPendingIntent);
    }

    private void addCommentLikeActionForCommentNotification(NotificationCompat.Builder builder, String noteId) {
        // adding comment like action
        Intent commentLikeIntent = getCommentActionIntent();
        commentLikeIntent.addCategory(KEY_CATEGORY_COMMENT_LIKE);
        commentLikeIntent.putExtra(NotificationsListFragment.NOTE_INSTANT_LIKE_EXTRA, true);
        if (noteId != null) {
            commentLikeIntent.putExtra(NotificationsListFragment.NOTE_ID_EXTRA, noteId);
        }
        PendingIntent commentLikePendingIntent = PendingIntent.getActivity(this, 0, commentLikeIntent,
                PendingIntent.FLAG_CANCEL_CURRENT);
        builder.addAction(R.drawable.ic_action_like, getText(R.string.like),
                commentLikePendingIntent);
    }

    private void addCommentApproveActionForCommentNotification(NotificationCompat.Builder builder, String noteId) {
        // adding comment approve action
        Intent commentApproveIntent = getCommentActionIntent();
        commentApproveIntent.addCategory(KEY_CATEGORY_COMMENT_MODERATE);
        commentApproveIntent.putExtra(NotificationsListFragment.NOTE_INSTANT_APPROVE_EXTRA, true);
        if (noteId != null) {
            commentApproveIntent.putExtra(NotificationsListFragment.NOTE_ID_EXTRA, noteId);
        }
        PendingIntent commentApprovePendingIntent = PendingIntent.getActivity(this, 0, commentApproveIntent,
                PendingIntent.FLAG_CANCEL_CURRENT);
        builder.addAction(R.drawable.ic_action_approve, getText(R.string.approve),
                commentApprovePendingIntent);
    }

    private Intent getCommentActionIntent(){
        Intent intent = new Intent(this, WPMainActivity.class);
        intent.putExtra(WPMainActivity.ARG_OPENED_FROM_PUSH, true);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        intent.setAction("android.intent.action.MAIN");
        intent.addCategory("android.intent.category.LAUNCHER");
        return intent;
    }

    private Bitmap getLargeIconBitmap(String iconUrl, boolean shouldCircularizeIcon){
        Bitmap largeIconBitmap = null;
        if (iconUrl != null) {
            try {
                iconUrl = URLDecoder.decode(iconUrl, "UTF-8");
                int largeIconSize = getResources().getDimensionPixelSize(
                        android.R.dimen.notification_large_icon_height);
                String resizedUrl = PhotonUtils.getPhotonImageUrl(iconUrl, largeIconSize, largeIconSize);
                largeIconBitmap = ImageUtils.downloadBitmap(resizedUrl);
                if (largeIconBitmap != null && shouldCircularizeIcon) {
                    largeIconBitmap = ImageUtils.getCircularBitmap(largeIconBitmap);
                }
            } catch (UnsupportedEncodingException e) {
                AppLog.e(T.NOTIFS, e);
            }
        }
        return largeIconBitmap;
    }

    private NotificationCompat.Builder getNotificationBuilder(String title, String message){
        // Build the new notification, add group to support wearable stacking
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
                .setSmallIcon(R.drawable.notification_icon)
                .setColor(getResources().getColor(R.color.blue_wordpress))
                .setContentTitle(title)
                .setContentText(message)
                .setTicker(message)
                .setAutoCancel(true)
                .setStyle(new NotificationCompat.BigTextStyle().bigText(message))
                .setGroup(NOTIFICATION_GROUP_KEY);

        return builder;
    }

    private void showGroupNotificationForBuilder(NotificationCompat.Builder builder, String message) {

        if (builder == null) {
            return;
        }

        if (sActiveNotificationsMap.size() > 1) {
            NotificationCompat.InboxStyle inboxStyle = new NotificationCompat.InboxStyle();
            int noteCtr = 1;
            for (Bundle pushBundle : sActiveNotificationsMap.values()) {
                // InboxStyle notification is limited to 5 lines
                if (noteCtr > MAX_INBOX_ITEMS) {
                    break;
                }
                if (pushBundle == null || pushBundle.getString(PUSH_ARG_MSG) == null) {
                    continue;
                }

                if (pushBundle.getString(PUSH_ARG_TYPE, "").equals(PUSH_TYPE_COMMENT)) {
                    String pnTitle = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_TITLE)));
                    String pnMessage = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_MSG)));
                    inboxStyle.addLine(pnTitle + ": " + pnMessage);
                } else {
                    String pnMessage = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_MSG)));
                    inboxStyle.addLine(pnMessage);
                }

                noteCtr++;
            }

            if (sActiveNotificationsMap.size() > MAX_INBOX_ITEMS) {
                inboxStyle.setSummaryText(String.format(getString(R.string.more_notifications),
                        sActiveNotificationsMap.size() - MAX_INBOX_ITEMS));
            }

            String subject = String.format(getString(R.string.new_notifications), sActiveNotificationsMap.size());
            NotificationCompat.Builder groupBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.notification_icon)
                    .setColor(getResources().getColor(R.color.blue_wordpress))
                    .setGroup(NOTIFICATION_GROUP_KEY)
                    .setGroupSummary(true)
                    .setAutoCancel(true)
                    .setTicker(message)
                    .setContentTitle(getString(R.string.app_name))
                    .setContentText(subject)
                    .setStyle(inboxStyle);

            showNotificationForBuilder(groupBuilder, this, GROUP_NOTIFICATION_ID);

        } else {
            // Set the individual notification we've already built as the group summary
            builder.setGroupSummary(true);
            showNotificationForBuilder(builder, this, GROUP_NOTIFICATION_ID);
        }
    }

    private void showIndividualNotificationForBuilder(NotificationCompat.Builder builder, String noteType, String noteId, int pushId) {
        if (builder == null) {
            return;
        }

        if (noteType.equals(PUSH_TYPE_COMMENT)) {
            addActionsForCommentNotification(builder, noteId);
        }
        showNotificationForBuilder(builder, this, pushId);
    }

    // Displays a notification to the user
    private void showNotificationForBuilder(NotificationCompat.Builder builder, Context context, int notificationId) {
        if (builder == null || context == null) {
            return;
        }

        Intent resultIntent = new Intent(this, WPMainActivity.class);
        resultIntent.putExtra(WPMainActivity.ARG_OPENED_FROM_PUSH, true);
        resultIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        resultIntent.setAction("android.intent.action.MAIN");
        resultIntent.addCategory("android.intent.category.LAUNCHER");
        if (sPreviousNoteId != null) {
            resultIntent.putExtra(NotificationsListFragment.NOTE_ID_EXTRA, sPreviousNoteId);
        }

        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);

        boolean shouldPlaySound = prefs.getBoolean("wp_pref_notification_sound", false);
        boolean shouldVibrate = prefs.getBoolean("wp_pref_notification_vibrate", false);
        boolean shouldBlinkLight = prefs.getBoolean("wp_pref_notification_light", false);
        String notificationSound = prefs.getString("wp_pref_custom_notification_sound", null); //"" if None is selected


        // use default sound if the legacy sound preference was ON but the custom sound was not selected (null)
        if (shouldPlaySound && notificationSound == null) {
            builder.setSound(Uri.parse("content://settings/system/notification_sound"));
        } else if (!TextUtils.isEmpty(notificationSound)) {
            builder.setSound(Uri.parse(notificationSound));
        }

        if (shouldVibrate) {
            builder.setVibrate(new long[]{500, 500, 500});
        }
        if (shouldBlinkLight) {
            builder.setLights(0xff0000ff, 1000, 5000);
        }

        // Call broadcast receiver when notification is dismissed
        Intent notificationDeletedIntent = new Intent(this, NotificationDismissBroadcastReceiver.class);
        notificationDeletedIntent.putExtra("notificationId", notificationId);
        notificationDeletedIntent.setAction(String.valueOf(notificationId));
        PendingIntent pendingDeleteIntent =
                PendingIntent.getBroadcast(context, notificationId, notificationDeletedIntent, 0);
        builder.setDeleteIntent(pendingDeleteIntent);

        builder.setCategory(NotificationCompat.CATEGORY_SOCIAL);

        PendingIntent pendingIntent = PendingIntent.getActivity(context, notificationId, resultIntent,
                PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_UPDATE_CURRENT);
        builder.setContentIntent(pendingIntent);
        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
        notificationManager.notify(notificationId, builder.build());
    }

    private void rebuildAndUpdateNotificationsOnSystemBar(Bundle data) {
        Bitmap largeIconBitmap = null;
        // here notify the existing group notification by eliminating the line that is now gone
        String title = getNotificationTitleOrAppNameFromBundle(data);
        String message = StringEscapeUtils.unescapeHtml(data.getString(PUSH_ARG_MSG));

        NotificationCompat.Builder builder = null;

        if (sActiveNotificationsMap.size() == 1) {
            //only one notification remains, so get the proper message for it and re-instate in the system dashboard
            Bundle remainingNote = sActiveNotificationsMap.values().iterator().next();
            if (remainingNote != null) {
                String remainingNoteTitle = StringEscapeUtils.unescapeHtml(remainingNote.getString(PUSH_ARG_TITLE));
                if (!TextUtils.isEmpty(remainingNoteTitle)) {
                    title = remainingNoteTitle;
                }
                String remainingNoteMessage = StringEscapeUtils.unescapeHtml(remainingNote.getString(PUSH_ARG_MSG));
                if (!TextUtils.isEmpty(remainingNoteMessage)) {
                    message = remainingNoteMessage;
                }
                largeIconBitmap = getLargeIconBitmap(remainingNote.getString("icon"),
                        shouldCircularizeNoteIcon(remainingNote.getString(PUSH_ARG_TYPE)));

                builder = getNotificationBuilder(title, message);

                String noteType = StringUtils.notNullStr(remainingNote.getString(PUSH_ARG_TYPE));
                String noteId = remainingNote.getString(PUSH_ARG_NOTE_ID, "");
                if (!sActiveNotificationsMap.isEmpty()) {
                    showIndividualNotificationForBuilder(builder, noteType, noteId, sActiveNotificationsMap.keyAt(0));
                }
            }
        }

        if (builder == null) {
            builder = getNotificationBuilder(title, message);
        }

        if (largeIconBitmap == null) {
            largeIconBitmap = getLargeIconBitmap(data.getString("icon"), shouldCircularizeNoteIcon(PUSH_TYPE_BADGE_RESET));
        }

        if (largeIconBitmap != null) {
            builder.setLargeIcon(largeIconBitmap);
        }

        showGroupNotificationForBuilder(builder, message);

    }

    private String getNotificationTitleOrAppNameFromBundle(Bundle data){
        String title = StringEscapeUtils.unescapeHtml(data.getString(PUSH_ARG_TITLE));
        if (title == null) {
            title = getString(R.string.app_name);
        }
        return title;
    }

    // Clear all notifications
    private void handleBadgeResetPN(Bundle data) {
        if (data == null || !data.containsKey(PUSH_ARG_NOTE_ID))  {
            // ignore the reset-badge PN if it's a global one
            return;
        }

        removeNotificationWithNoteIdFromSystemBar(this, data.getString(PUSH_ARG_NOTE_ID, ""));
        //now that we cleared the specific notif, we can check and make any visual updates
        if (sActiveNotificationsMap.size() > 0) {
            rebuildAndUpdateNotificationsOnSystemBar(data);
        }

        EventBus.getDefault().post(new NotificationEvents.NotificationsChanged());
    }

    // Show a notification for two-step auth users who sign in from a web browser
    private void handlePushAuth(String from, Bundle data) {
        if (data == null) {
            return;
        }

        String pushAuthToken = data.getString("push_auth_token", "");
        String title = data.getString("title", "");
        String message = data.getString("msg", "");
        long expirationTimestamp = Long.valueOf(data.getString("expires", "0"));

        // No strings, no service
        if (TextUtils.isEmpty(pushAuthToken) || TextUtils.isEmpty(title) || TextUtils.isEmpty(message)) {
            return;
        }

        // Show authorization intent
        Intent pushAuthIntent = new Intent(this, WPMainActivity.class);
        pushAuthIntent.putExtra(WPMainActivity.ARG_OPENED_FROM_PUSH, true);
        pushAuthIntent.putExtra(NotificationsUtils.ARG_PUSH_AUTH_TOKEN, pushAuthToken);
        pushAuthIntent.putExtra(NotificationsUtils.ARG_PUSH_AUTH_TITLE, title);
        pushAuthIntent.putExtra(NotificationsUtils.ARG_PUSH_AUTH_MESSAGE, message);
        pushAuthIntent.putExtra(NotificationsUtils.ARG_PUSH_AUTH_EXPIRES, expirationTimestamp);
        pushAuthIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        pushAuthIntent.setAction("android.intent.action.MAIN");
        pushAuthIntent.addCategory("android.intent.category.LAUNCHER");

        NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
                .setSmallIcon(R.drawable.notification_icon)
                .setColor(getResources().getColor(R.color.blue_wordpress))
                .setContentTitle(title)
                .setContentText(message)
                .setAutoCancel(true)
                .setStyle(new NotificationCompat.BigTextStyle().bigText(message))
                .setPriority(NotificationCompat.PRIORITY_MAX);

        PendingIntent pendingIntent = PendingIntent.getActivity(this, 1, pushAuthIntent,
                PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_UPDATE_CURRENT);
        builder.setContentIntent(pendingIntent);

        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
        notificationManager.notify(AUTH_PUSH_NOTIFICATION_ID, builder.build());
    }

    @Override
    public void onMessageReceived(String from, Bundle data) {
        AppLog.v(T.NOTIFS, "Received Message");

        if (data == null) {
            AppLog.v(T.NOTIFS, "No notification message content received. Aborting.");
            return;
        }

        // Handle helpshift PNs
        if (TextUtils.equals(data.getString("origin"), "helpshift")) {
            HelpshiftHelper.getInstance().handlePush(this, new Intent().putExtras(data));
            return;
        }

        // Handle mixpanel PNs
        if (data.containsKey("mp_message")) {
            String mpMessage = data.getString("mp_message");
            String title = getString(R.string.app_name);
            Intent resultIntent = new Intent(this, WPMainActivity.class);
            resultIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK
                    | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, resultIntent,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            AnalyticsTrackerMixpanel.showNotification(this, pendingIntent,
                    R.drawable.notification_icon, title, mpMessage);
            return;
        }

        if (!AccountHelper.isSignedInWordPressDotCom()) {
            return;
        }

        synchronizedHandleDefaultPush(from, data);
    }

    // Returns true if the note type is known to have a gravatar
    public boolean shouldCircularizeNoteIcon(String noteType) {
        if (TextUtils.isEmpty(noteType)) {
            return false;
        }

        switch (noteType) {
            case PUSH_TYPE_COMMENT:
            case PUSH_TYPE_LIKE:
            case PUSH_TYPE_COMMENT_LIKE:
            case PUSH_TYPE_AUTOMATTCHER:
            case PUSH_TYPE_FOLLOW:
            case PUSH_TYPE_REBLOG:
                return true;
            default:
                return false;
        }
    }

    public static synchronized void clearNotifications() {
        sActiveNotificationsMap.clear();
    }

    public static synchronized int getNotificationsCount() {
        return sActiveNotificationsMap.size();
    }

    public static synchronized boolean hasNotifications() {
        return !sActiveNotificationsMap.isEmpty();
    }

    // Removes a specific notification from the internal map - only use this when we know
    // the user has dismissed the app by swiping it off the screen
    public static synchronized void removeNotification(int notificationId) {
        sActiveNotificationsMap.remove(notificationId);
    }

    // Removes a specific notification from the system bar
    public static synchronized void removeNotificationWithNoteIdFromSystemBar(Context context, String noteID) {
        if (context == null || TextUtils.isEmpty(noteID) || !hasNotifications()) {
            return;
        }

        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        // here we loop with an Iterator as there might be several Notifications with the same Note ID (i.e. likes on the same Note)
        // so we need to keep cancelling them and removing them from our activeNotificationsMap as we find it suitable
        for(Iterator<Map.Entry<Integer, Bundle>> it = sActiveNotificationsMap.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<Integer, Bundle> row = it.next();
            Integer pushId = row.getKey();
            Bundle noteBundle = row.getValue();
            if (noteBundle.getString(PUSH_ARG_NOTE_ID, "").equals(noteID)) {
                notificationManager.cancel(pushId);
                it.remove();
            }
        }

        if (sActiveNotificationsMap.size() == 0) {
            notificationManager.cancel(GCMMessageService.GROUP_NOTIFICATION_ID);
        }
    }

    // Removes all app notifications from the system bar
    public static synchronized void removeAllNotifications(Context context) {
        if (context == null || !hasNotifications()) {
            return;
        }

        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        for (Integer pushId : sActiveNotificationsMap.keySet()) {
            notificationManager.cancel(pushId);
        }
        notificationManager.cancel(GCMMessageService.GROUP_NOTIFICATION_ID);

        clearNotifications();
    }

    // NoteID is the ID if the note in WordPress
    public static synchronized void bumpPushNotificationsTappedAnalytics(String noteID) {
        for (int id : sActiveNotificationsMap.keySet()) {
            Bundle noteBundle = sActiveNotificationsMap.get(id);
            if (noteBundle.getString(PUSH_ARG_NOTE_ID, "").equals(noteID)) {
                bumpPushNotificationsAnalytics(Stat.PUSH_NOTIFICATION_TAPPED, noteBundle, null);
                AnalyticsTracker.flush();
                return;
            }
        }
    }

    // Mark all notifications as tapped
    public static synchronized void bumpPushNotificationsTappedAllAnalytics() {
        for (int id : sActiveNotificationsMap.keySet()) {
            Bundle noteBundle = sActiveNotificationsMap.get(id);
            bumpPushNotificationsAnalytics(Stat.PUSH_NOTIFICATION_TAPPED, noteBundle, null);
        }
        AnalyticsTracker.flush();
    }

    private static void bumpPushNotificationsAnalytics(Stat stat, Bundle noteBundle,
                                                       Map<String, Object> properties) {
        // Bump Analytics for PNs if "Show notifications" setting is checked (default). Skip otherwise.
        if (!NotificationsUtils.isNotificationsEnabled(WordPress.getContext())) {
            return;
        }
        if (properties == null) {
            properties = new HashMap<>();
        }

        String notificationID = noteBundle.getString(PUSH_ARG_NOTE_ID, "");
        if (!TextUtils.isEmpty(notificationID)) {
            for (String currentPropertyToCopy : propertiesToCopyIntoAnalytics) {
                if (noteBundle.containsKey(currentPropertyToCopy)) {
                    properties.put("push_notification_" + currentPropertyToCopy, noteBundle.get(currentPropertyToCopy));
                }
            }
            SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(WordPress.getContext());
            String lastRegisteredGCMToken = preferences.getString(NotificationsUtils.WPCOM_PUSH_DEVICE_TOKEN, null);
            properties.put("push_notification_token", lastRegisteredGCMToken);
            AnalyticsTracker.track(stat, properties);
        }
    }
}