package org.wordpress.android.ui.comments;

import android.app.AlertDialog;
import android.app.Fragment;
import android.content.DialogInterface;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.view.ActionMode;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;

import org.wordpress.android.R;
import org.wordpress.android.WordPress;
import org.wordpress.android.datasets.CommentTable;
import org.wordpress.android.models.Blog;
import org.wordpress.android.models.Comment;
import org.wordpress.android.models.CommentList;
import org.wordpress.android.models.CommentStatus;
import org.wordpress.android.models.FilterCriteria;
import org.wordpress.android.ui.EmptyViewMessageType;
import org.wordpress.android.ui.FilteredRecyclerView;
import org.wordpress.android.ui.prefs.AppPrefs;
import org.wordpress.android.util.AppLog;
import org.wordpress.android.util.NetworkUtils;
import org.wordpress.android.util.ToastUtils;
import org.xmlrpc.android.ApiHelper;
import org.xmlrpc.android.ApiHelper.ErrorType;
import org.xmlrpc.android.XMLRPCFault;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import de.greenrobot.event.EventBus;

public class CommentsListFragment extends Fragment implements CommentAdapter.OnDataLoadedListener,
        CommentAdapter.OnLoadMoreListener, CommentAdapter.OnSelectedItemsChangeListener, CommentAdapter.OnCommentPressedListener {

    interface OnCommentSelectedListener {
        void onCommentSelected(long commentId);
    }

    private boolean mIsUpdatingComments = false;
    private boolean mCanLoadMoreComments = true;
    boolean mHasAutoRefreshedComments = false;

    private final CommentStatus[] commentStatuses = {CommentStatus.UNKNOWN, CommentStatus.UNAPPROVED,
            CommentStatus.APPROVED, CommentStatus.TRASH, CommentStatus.SPAM};

    private EmptyViewMessageType mEmptyViewMessageType = EmptyViewMessageType.NO_CONTENT;
    private FilteredRecyclerView mFilteredCommentsView;
    private CommentAdapter mAdapter;
    private ActionMode mActionMode;
    private CommentStatus mCommentStatusFilter;

    private UpdateCommentsTask mUpdateCommentsTask;

    public static final int COMMENTS_PER_PAGE = 30;

    private CommentAdapterState mCommentAdapterState;


    private boolean hasAdapter() {
        return (mAdapter != null);
    }

    private int getSelectedCommentCount() {
        return getAdapter().getSelectedCommentCount();
    }

    public void removeComment(Comment comment) {
        if (hasAdapter() && comment != null) {
            getAdapter().removeComment(comment);
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        Bundle extras = getActivity().getIntent().getExtras();
        if (extras != null) {
            mHasAutoRefreshedComments = extras.getBoolean(CommentsActivity.KEY_AUTO_REFRESHED);
            mEmptyViewMessageType = EmptyViewMessageType.getEnumFromString(extras.getString(
                    CommentsActivity.KEY_EMPTY_VIEW_MESSAGE));
        } else {
            mHasAutoRefreshedComments = false;
            mEmptyViewMessageType = EmptyViewMessageType.NO_CONTENT;
        }

        if (savedInstanceState != null) {
            mCommentAdapterState = savedInstanceState.getParcelable(CommentAdapterState.KEY);
        }

        if (!NetworkUtils.isNetworkAvailable(getActivity())) {
            mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.NETWORK_ERROR);
            return;
        }

        // Restore the empty view's message
        mFilteredCommentsView.updateEmptyView(mEmptyViewMessageType);

        if (!mHasAutoRefreshedComments) {
            updateComments(false);
            mFilteredCommentsView.setRefreshing(true);
            mHasAutoRefreshedComments = true;
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.comment_list_fragment, container, false);

        mFilteredCommentsView = (FilteredRecyclerView) view.findViewById(R.id.filtered_recycler_view);
        mFilteredCommentsView.setLogT(AppLog.T.COMMENTS);
        mFilteredCommentsView.setFilterListener(new FilteredRecyclerView.FilterListener() {
            @Override
            public List<FilterCriteria> onLoadFilterCriteriaOptions(boolean refresh) {
                @SuppressWarnings("unchecked")
                ArrayList<FilterCriteria> criteria = new ArrayList();
                Collections.addAll(criteria, commentStatuses);
                return criteria;
            }

            @Override
            public void onLoadFilterCriteriaOptionsAsync(FilteredRecyclerView.FilterCriteriaAsyncLoaderListener listener, boolean refresh) {
            }

            @Override
            public void onLoadData() {
                updateComments(false);
            }

            @Override
            public void onFilterSelected(int position, FilterCriteria criteria) {
                //trackCommentsAnalytics();
                AppPrefs.setCommentsStatusFilter((CommentStatus) criteria);
                mCommentStatusFilter = (CommentStatus) criteria;
                finishActionMode();
            }

            @Override
            public FilterCriteria onRecallSelection() {
                mCommentStatusFilter = AppPrefs.getCommentsStatusFilter();
                return mCommentStatusFilter;
            }

            @Override
            public String onShowEmptyViewMessage(EmptyViewMessageType emptyViewMsgType) {

                if (emptyViewMsgType == EmptyViewMessageType.NO_CONTENT) {
                    FilterCriteria filter = mFilteredCommentsView.getCurrentFilter();
                    if (filter == null || CommentStatus.UNKNOWN.equals(filter)) {
                        return getString(R.string.comments_empty_list);
                    } else {
                        switch (mCommentStatusFilter) {
                            case APPROVED:
                                return getString(R.string.comments_empty_list_filtered_approved);
                            case UNAPPROVED:
                                return getString(R.string.comments_empty_list_filtered_pending);
                            case SPAM:
                                return getString(R.string.comments_empty_list_filtered_spam);
                            case TRASH:
                                return getString(R.string.comments_empty_list_filtered_trashed);
                            default:
                                return getString(R.string.comments_empty_list);
                        }
                    }

                } else {
                    int stringId = 0;
                    switch (emptyViewMsgType) {
                        case LOADING:
                            stringId = R.string.comments_fetching;
                            break;
                        case NETWORK_ERROR:
                            stringId = R.string.no_network_message;
                            break;
                        case PERMISSION_ERROR:
                            stringId = R.string.error_refresh_unauthorized_comments;
                            break;
                        case GENERIC_ERROR:
                            stringId = R.string.error_refresh_comments;
                            break;
                    }
                    return getString(stringId);
                }

            }

            @Override
            public void onShowCustomEmptyView(EmptyViewMessageType emptyViewMsgType) {
            }
        });

        // the following will change the look and feel of the toolbar to match the current design
        mFilteredCommentsView.setToolbarBackgroundColor(ContextCompat.getColor(getActivity(), R.color.blue_medium));
        mFilteredCommentsView.setToolbarSpinnerTextColor(ContextCompat.getColor(getActivity(), R.color.white));
        mFilteredCommentsView.setToolbarSpinnerDrawable(R.drawable.arrow);
        mFilteredCommentsView.setToolbarLeftAndRightPadding(
                getResources().getDimensionPixelSize(R.dimen.margin_filter_spinner),
                getResources().getDimensionPixelSize(R.dimen.margin_none));

        return view;
    }

    @Override
    public void onResume() {
        super.onResume();
        if (mFilteredCommentsView.getAdapter() == null) {
            mFilteredCommentsView.setAdapter(getAdapter());
            if (!NetworkUtils.isNetworkAvailable(getActivity())) {
                ToastUtils.showToast(getActivity(), getString(R.string.error_refresh_comments_showing_older));
            }
            getAdapter().loadComments(mCommentStatusFilter);
        }
    }

    public void setCommentStatusFilter(CommentStatus statusFilter) {
        mCommentStatusFilter = statusFilter;
    }

    private void moderateSelectedComments(final CommentStatus newStatus) {
        if (!NetworkUtils.checkConnection(getActivity())) return;

        final CommentList selectedComments = getAdapter().getSelectedComments();
        final CommentList updateComments = new CommentList();

        // build list of comments whose status is different than passed
        for (Comment comment : selectedComments) {
            if (comment.getStatusEnum() != newStatus) {
                setCommentIsModerating(comment.commentID, true);
                updateComments.add(comment);
            }

        }
        if (updateComments.size() == 0) return;

        CommentActions.OnCommentsModeratedListener listener = new CommentActions.OnCommentsModeratedListener() {
            @Override
            public void onCommentsModerated(final CommentList moderatedComments) {
                EventBus.getDefault().post(
                        new CommentEvents.CommentsBatchModerationFinishedEvent(moderatedComments, false));
            }
        };

        getAdapter().clearSelectedComments();
        finishActionMode();

        CommentActions.moderateComments(
                WordPress.getCurrentLocalTableBlogId(),
                updateComments,
                newStatus,
                listener);
    }


    private void confirmDeleteComments() {
        if (CommentStatus.TRASH.equals(mCommentStatusFilter)) {
            AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(
                    getActivity());
            dialogBuilder.setTitle(getResources().getText(R.string.delete));
            int resId = getAdapter().getSelectedCommentCount() > 1 ? R.string.dlg_sure_to_delete_comments : R.string.dlg_sure_to_delete_comment;
            dialogBuilder.setMessage(getResources().getText(resId));
            dialogBuilder.setPositiveButton(getResources().getText(R.string.yes),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int whichButton) {
                            deleteSelectedComments(true);
                        }
                    });
            dialogBuilder.setNegativeButton(
                    getResources().getText(R.string.no),
                    null);
            dialogBuilder.setCancelable(true);
            dialogBuilder.create().show();

        } else {

            AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
            builder.setMessage(R.string.dlg_confirm_trash_comments);
            builder.setTitle(R.string.trash);
            builder.setCancelable(true);
            builder.setPositiveButton(R.string.trash_yes, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int id) {
                    deleteSelectedComments(false);
                }
            });
            builder.setNegativeButton(R.string.trash_no, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int id) {
                    dialog.cancel();
                }
            });
            AlertDialog alert = builder.create();
            alert.show();
        }
    }

    private void deleteSelectedComments(boolean deletePermanently) {
        if (!NetworkUtils.checkConnection(getActivity())) return;


        final CommentList selectedComments = getAdapter().getSelectedComments();

        for (Comment comment : selectedComments) {
            setCommentIsModerating(comment.commentID, true);
        }

        final CommentStatus newStatus = deletePermanently ? CommentStatus.DELETE : CommentStatus.TRASH;


        CommentActions.OnCommentsModeratedListener listener = new CommentActions.OnCommentsModeratedListener() {
            @Override
            public void onCommentsModerated(final CommentList deletedComments) {
                EventBus.getDefault().post(
                        new CommentEvents.CommentsBatchModerationFinishedEvent(deletedComments, true));
            }
        };

        getAdapter().clearSelectedComments();
        CommentActions.moderateComments(
                WordPress.getCurrentLocalTableBlogId(), selectedComments, newStatus, listener);
    }

    void loadComments() {
        // this is called from CommentsActivity when a comment was changed in the detail view,
        // and the change will already be in SQLite so simply reload the comment adapter
        // to show the change
        getAdapter().loadComments(mCommentStatusFilter);
    }

    void updateEmptyView() {
        //this is called from CommentsActivity in the case the last moment for a given type has been changed from that
        //status, leaving the list empty, so we need to update the empty view. The method inside FilteredRecyclerView
        //does the handling itself, so we only check for null here.
        if (mFilteredCommentsView != null) {
            mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.NO_CONTENT);
        }
    }

    /*
     * get latest comments from server, or pass loadMore=true to get comments beyond the
     * existing ones
     */
    void updateComments(boolean loadMore) {
        if (mIsUpdatingComments) {
            AppLog.w(AppLog.T.COMMENTS, "update comments task already running");
            return;
        } else if (!NetworkUtils.isNetworkAvailable(getActivity())) {
            mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.NETWORK_ERROR);
            mFilteredCommentsView.setRefreshing(false);
            ToastUtils.showToast(getActivity(), getString(R.string.error_refresh_comments_showing_older));
            //we're offline, load/refresh whatever we have in our local db
            getAdapter().loadComments(mCommentStatusFilter);
            return;
        }

        //immediately load/refresh whatever we have in our local db as we wait for the API call to get latest results
        if (!loadMore) {
            getAdapter().loadComments(mCommentStatusFilter);
        }

        mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.LOADING);

        mUpdateCommentsTask = new UpdateCommentsTask(loadMore, mCommentStatusFilter);
        mUpdateCommentsTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    }

    public void setCommentIsModerating(long commentId, boolean isModerating) {
        if (!hasAdapter()) return;

        if (isModerating) {
            getAdapter().addModeratingCommentId(commentId);
        } else {
            getAdapter().removeModeratingCommentId(commentId);
        }
    }

    public String getEmptyViewMessage() {
        return mEmptyViewMessageType.name();
    }

    /*
     * task to retrieve latest comments from server
     */
    private class UpdateCommentsTask extends AsyncTask<Void, Void, CommentList> {
        ErrorType mErrorType = ErrorType.NO_ERROR;
        final boolean mIsLoadingMore;
        final CommentStatus mStatusFilter;

        private UpdateCommentsTask(boolean loadMore, CommentStatus statusFilter) {
            mIsLoadingMore = loadMore;
            mStatusFilter = statusFilter;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mIsUpdatingComments = true;
            if (mIsLoadingMore) {
                mFilteredCommentsView.showLoadingProgress();
            }
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            mIsUpdatingComments = false;
            mUpdateCommentsTask = null;
            mFilteredCommentsView.setRefreshing(false);
        }

        @Override
        protected CommentList doInBackground(Void... args) {
            if (!isAdded()) {
                return null;
            }

            final Blog blog = WordPress.getCurrentBlog();
            if (blog == null) {
                mErrorType = ErrorType.INVALID_CURRENT_BLOG;
                return null;
            }

            Map<String, Object> hPost = new HashMap<>();
            if (mIsLoadingMore) {
                int numExisting = getAdapter().getItemCount();
                hPost.put("offset", numExisting);
                hPost.put("number", COMMENTS_PER_PAGE);
            } else {
                hPost.put("number", COMMENTS_PER_PAGE);
            }

            if (mStatusFilter != null) {
                //if this is UNKNOWN that means show ALL, i.e., do not apply filter
                if (!mStatusFilter.equals(CommentStatus.UNKNOWN)) {
                    hPost.put("status", CommentStatus.toString(mStatusFilter));
                }
            }

            Object[] params = {blog.getRemoteBlogId(),
                    blog.getUsername(),
                    blog.getPassword(),
                    hPost};
            try {
                return ApiHelper.refreshComments(blog, params, new ApiHelper.DatabasePersistCallback() {
                    @Override
                    public void onDataReadyToSave(List list) {
                        int localBlogId = blog.getLocalTableBlogId();

                        if (!mIsLoadingMore) { //existing comments should be deleted only if we are not "loading more"
                            CommentTable.deleteCommentsForBlogWithFilter(localBlogId, mStatusFilter);
                        }
                        CommentTable.saveComments(localBlogId, (CommentList) list);
                    }
                });
            } catch (XMLRPCFault xmlrpcFault) {
                mErrorType = ErrorType.UNKNOWN_ERROR;
                if (xmlrpcFault.getFaultCode() == 401) {
                    mErrorType = ErrorType.UNAUTHORIZED;
                }
            } catch (Exception e) {
                mErrorType = ErrorType.UNKNOWN_ERROR;
            }
            return null;
        }

        protected void onPostExecute(CommentList comments) {

            boolean isRefreshing = mFilteredCommentsView.isRefreshing();
            mIsUpdatingComments = false;
            mUpdateCommentsTask = null;

            if (!isAdded()) return;

            if (mIsLoadingMore) {
                mFilteredCommentsView.hideLoadingProgress();
            }
            mFilteredCommentsView.setRefreshing(false);

            if (isCancelled()) return;

            mCanLoadMoreComments = (comments != null && comments.size() > 0);

            // result will be null on error OR if no more comments exists
            if (comments == null && !getActivity().isFinishing() && mErrorType != ErrorType.NO_ERROR) {
                switch (mErrorType) {
                    case UNAUTHORIZED:
                        if (!mFilteredCommentsView.emptyViewIsVisible()) {
                            ToastUtils.showToast(getActivity(), getString(R.string.error_refresh_unauthorized_comments));
                        }
                        mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.PERMISSION_ERROR);
                        return;
                    default:
                        ToastUtils.showToast(getActivity(), getString(R.string.error_refresh_comments));
                        mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.GENERIC_ERROR);
                        return;
                }
            }

            if (!getActivity().isFinishing()) {
                if (comments != null && comments.size() > 0) {
                    getAdapter().loadComments(mStatusFilter);
                } else {
                    if (isRefreshing) {
                        //if refreshing and no errors, we only want freshest stuff, so clear old data
                        getAdapter().clearComments();
                    }
                    mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.NO_CONTENT);
                }
            }
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        if (outState.isEmpty()) {
            outState.putBoolean("bug_19917_fix", true);
        }

        if (hasAdapter()) {
            outState.putParcelable(CommentAdapterState.KEY, getAdapter().getAdapterState());
        }

        super.onSaveInstanceState(outState);
    }

    /****
     * Contextual ActionBar (CAB) routines
     ***/
    private void updateActionModeTitle() {
        if (mActionMode == null)
            return;
        int numSelected = getSelectedCommentCount();
        if (numSelected > 0) {
            mActionMode.setTitle(Integer.toString(numSelected));
        } else {
            mActionMode.setTitle("");
        }
    }

    private void finishActionMode() {
        if (mActionMode != null) {
            mActionMode.finish();
        }
    }

    private final class ActionModeCallback implements ActionMode.Callback {
        @Override
        public boolean onCreateActionMode(ActionMode actionMode, Menu menu) {
            mActionMode = actionMode;
            MenuInflater inflater = actionMode.getMenuInflater();
            inflater.inflate(R.menu.menu_comments_cab, menu);
            mFilteredCommentsView.setSwipeToRefreshEnabled(false);
            return true;
        }

        private void setItemEnabled(Menu menu, int menuId, boolean isEnabled) {
            final MenuItem item = menu.findItem(menuId);
            if (item == null || item.isEnabled() == isEnabled)
                return;
            item.setEnabled(isEnabled);
            if (item.getIcon() != null) {
                // must mutate the drawable to avoid affecting other instances of it
                Drawable icon = item.getIcon().mutate();
                icon.setAlpha(isEnabled ? 255 : 128);
                item.setIcon(icon);
            }
        }

        @Override
        public boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
            final CommentList selectedComments = getAdapter().getSelectedComments();

            boolean hasSelection = (selectedComments.size() > 0);
            boolean hasApproved = hasSelection && selectedComments.hasAnyWithStatus(CommentStatus.APPROVED);
            boolean hasUnapproved = hasSelection && selectedComments.hasAnyWithStatus(CommentStatus.UNAPPROVED);
            boolean hasSpam = hasSelection && selectedComments.hasAnyWithStatus(CommentStatus.SPAM);
            boolean hasAnyNonSpam = hasSelection && selectedComments.hasAnyWithoutStatus(CommentStatus.SPAM);
            boolean hasTrash = hasSelection && selectedComments.hasAnyWithStatus(CommentStatus.TRASH);

            setItemEnabled(menu, R.id.menu_approve, hasUnapproved || hasSpam || hasTrash);
            setItemEnabled(menu, R.id.menu_unapprove, hasApproved);
            setItemEnabled(menu, R.id.menu_spam, hasAnyNonSpam);
            setItemEnabled(menu, R.id.menu_trash, hasSelection);

            final MenuItem trashItem = menu.findItem(R.id.menu_trash);
            if (trashItem != null) {
                if (CommentStatus.TRASH.equals(mCommentStatusFilter)) {
                    trashItem.setTitle(R.string.mnu_comment_delete_permanently);
                }
            }

            return true;
        }

        @Override
        public boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
            int numSelected = getSelectedCommentCount();
            if (numSelected == 0)
                return false;

            int i = menuItem.getItemId();
            if (i == R.id.menu_approve) {
                moderateSelectedComments(CommentStatus.APPROVED);
                return true;
            } else if (i == R.id.menu_unapprove) {
                moderateSelectedComments(CommentStatus.UNAPPROVED);
                return true;
            } else if (i == R.id.menu_spam) {
                moderateSelectedComments(CommentStatus.SPAM);
                return true;
            } else if (i == R.id.menu_trash) {// unlike the other status changes, we ask the user to confirm trashing
                confirmDeleteComments();
                return true;
            } else {
                return false;
            }
        }

        @Override
        public void onDestroyActionMode(ActionMode mode) {
            getAdapter().setEnableSelection(false);
            mFilteredCommentsView.setSwipeToRefreshEnabled(true);
            mActionMode = null;
        }
    }

    private CommentAdapter getAdapter() {
        if (mAdapter == null) {
            mAdapter = new CommentAdapter(getActivity(), WordPress.getCurrentLocalTableBlogId());
            mAdapter.setInitialState(mCommentAdapterState);
            mAdapter.setOnCommentPressedListener(this);
            mAdapter.setOnDataLoadedListener(this);
            mAdapter.setOnLoadMoreListener(this);
            mAdapter.setOnSelectedItemsChangeListener(this);
        }

        return mAdapter;
    }


    // adapter calls this when selected comments have changed (CAB)
    @Override
    public void onSelectedItemsChanged() {
        if (mActionMode != null) {
            if (getSelectedCommentCount() == 0) {
                mActionMode.finish();
            } else {
                updateActionModeTitle();
                // must invalidate to ensure onPrepareActionMode is called
                mActionMode.invalidate();
            }
        }
    }

    @Override
    public void onCommentPressed(int position, View view) {
        // if the comment is being moderated ignore the press
        Comment comment = getAdapter().getItem(position);
        if (!isCommentSelectable(comment)) {
            return;
        }

        if (mActionMode == null) {
            mFilteredCommentsView.invalidate();
            if (getActivity() instanceof OnCommentSelectedListener) {
                ((OnCommentSelectedListener) getActivity()).onCommentSelected(comment.commentID);
            }
        } else {
            getAdapter().toggleItemSelected(position, view);
        }
    }

    @Override
    public void onCommentLongPressed(int position, View view) {
        // if the comment is being moderated ignore the press
        Comment comment = getAdapter().getItem(position);
        if (!isCommentSelectable(comment)) {
            return;
        }
        
        // enable CAB if it's not already enabled
        if (mActionMode == null) {
            if (getActivity() instanceof AppCompatActivity) {
                ((AppCompatActivity) getActivity()).startSupportActionMode(new ActionModeCallback());
                getAdapter().setEnableSelection(true);
                getAdapter().setItemSelected(position, true, view);
            }
        } else {
            getAdapter().toggleItemSelected(position, view);
        }
    }

    private boolean isCommentSelectable(Comment comment){
        return comment != null && !getAdapter().isModeratingCommentId(comment.commentID);
    }

    private boolean shouldRestoreCab() {
        return hasAdapter() && !getAdapter().getSelectedCommentsId().isEmpty() && mActionMode == null;
    }

    private void restoreCab() {
        if (getActivity() instanceof AppCompatActivity) {
            ((AppCompatActivity) getActivity()).startSupportActionMode(new ActionModeCallback());
            updateActionModeTitle();
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
        EventBus.getDefault().unregister(this);
        super.onStop();
    }

    @SuppressWarnings("unused")
    public void onEventMainThread(CommentEvents.CommentModerationFinishedEvent event) {
        if (!isAdded()) return;

        setCommentIsModerating(event.getCommentId(), false);

        if (!event.isSuccess()) {
            ToastUtils.showToast(getActivity(), R.string.error_moderate_comment, ToastUtils.Duration.LONG);
        }

        if (event.isCommentsRefreshRequired() || event.getNewStatus() != mCommentStatusFilter) {
            loadComments();
        }
    }

    @SuppressWarnings("unused")
    public void onEventMainThread(CommentEvents.CommentsBatchModerationFinishedEvent moderatedComments) {
        if (!isAdded()) return;

        if (moderatedComments.getComments().size() > 0) {
            for (Comment comment : moderatedComments.getComments()) {
                setCommentIsModerating(comment.commentID, false);
            }

            if (moderatedComments.isDeleted()) {
                getAdapter().deleteComments(moderatedComments.getComments());
            } else {
                getAdapter().replaceComments(moderatedComments.getComments());
            }

            loadComments();
        } else {
            ToastUtils.showToast(getActivity(), R.string.error_moderate_comment);
        }
    }


    // called after comments have been loaded
    @Override
    public void onDataLoaded(boolean isEmpty) {
        if (!isAdded()) return;

        if (!isEmpty) {
            // After comments are loaded, we should check if some of them are selected and show CAB if necessary
            if (shouldRestoreCab()) {
                restoreCab();
            }

            // Hide the empty view if there are already some displayed comments
            mFilteredCommentsView.hideEmptyView();
        } else if (!mIsUpdatingComments) {
            // Change LOADING to NO_CONTENT message
            mFilteredCommentsView.updateEmptyView(EmptyViewMessageType.NO_CONTENT);
        }
    }

    @Override
    public void onLoadMore() {
        if (mCanLoadMoreComments && !mIsUpdatingComments) {
            updateComments(true);
        }
    }

}