// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.contextual_suggestions;

import static org.chromium.chrome.browser.dependency_injection.ChromeCommonQualifiers.LAST_USED_PROFILE;

import android.content.Context;
import android.os.Handler;
import android.os.SystemClock;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.view.View;

import org.chromium.base.ContextUtils;
import org.chromium.base.VisibleForTesting;
import org.chromium.base.metrics.RecordHistogram;
import org.chromium.base.metrics.RecordUserAction;
import org.chromium.chrome.R;
import org.chromium.chrome.browser.ChromeFeatureList;
import org.chromium.chrome.browser.compositor.layouts.EmptyOverviewModeObserver;
import org.chromium.chrome.browser.compositor.layouts.LayoutManager;
import org.chromium.chrome.browser.compositor.layouts.LayoutManagerChrome;
import org.chromium.chrome.browser.compositor.layouts.OverviewModeBehavior;
import org.chromium.chrome.browser.contextual_suggestions.ContextualSuggestionsBridge.ContextualSuggestionsResult;
import org.chromium.chrome.browser.dependency_injection.ActivityScope;
import org.chromium.chrome.browser.feature_engagement.TrackerFactory;
import org.chromium.chrome.browser.fullscreen.ChromeFullscreenManager;
import org.chromium.chrome.browser.fullscreen.ChromeFullscreenManager.FullscreenListener;
import org.chromium.chrome.browser.fullscreen.FullscreenManager;
import org.chromium.chrome.browser.profiles.Profile;
import org.chromium.chrome.browser.tabmodel.TabModelSelector;
import org.chromium.chrome.browser.toolbar.ToolbarManager;
import org.chromium.chrome.browser.toolbar.top.ToolbarPhone;
import org.chromium.chrome.browser.util.AccessibilityUtil;
import org.chromium.chrome.browser.widget.ListMenuButton;
import org.chromium.chrome.browser.widget.bottomsheet.BottomSheet;
import org.chromium.chrome.browser.widget.bottomsheet.BottomSheet.StateChangeReason;
import org.chromium.chrome.browser.widget.bottomsheet.BottomSheetObserver;
import org.chromium.chrome.browser.widget.bottomsheet.EmptyBottomSheetObserver;
import org.chromium.chrome.browser.widget.textbubble.ImageTextBubble;
import org.chromium.chrome.browser.widget.textbubble.TextBubble;
import org.chromium.components.feature_engagement.EventConstants;
import org.chromium.components.feature_engagement.FeatureConstants;
import org.chromium.components.feature_engagement.Tracker;
import org.chromium.content_public.browser.WebContents;
import org.chromium.ui.widget.ViewRectProvider;

import java.util.Collections;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Provider;

/**
 * A mediator for the contextual suggestions UI component responsible for interacting with
 * the contextual suggestions C++ components (via a bridge), updating the model, and communicating
 * with the component coordinator(s).
 */
@ActivityScope
class ContextualSuggestionsMediator
        implements EnabledStateMonitor.Observer, FetchHelper.Delegate, ListMenuButton.Delegate {
    @VisibleForTesting
    static final String IPH_CONFIDENCE_THRESHOLD_PARAM = "iph_confidence_threshold";
    private static final int IPH_AUTO_DISMISS_TIMEOUT_MS = 6000;
    private static final int IPH_AUTO_DISMISS_ACCESSIBILITY_TIMEOUT_MS = 10000;
    private static boolean sOverrideIPHTimeoutForTesting;

    private final Profile mProfile;
    private final TabModelSelector mTabModelSelector;
    private final ContextualSuggestionsModel mModel;
    private final ChromeFullscreenManager mFullscreenManager;
    private final ToolbarManager mToolbarManager;
    private final EnabledStateMonitor mEnabledStateMonitor;
    private final Handler mHandler = new Handler();
    private final Provider<ContextualSuggestionsSource> mSuggestionSourceProvider;
    private @Nullable final OverviewModeBehavior mOverviewModeBehavior;
    private final boolean mRequireReverseScrollForIPH;

    private ContextualSuggestionsCoordinator mCoordinator;

    private @Nullable ContextualSuggestionsSource mSuggestionsSource;
    private @Nullable FetchHelper mFetchHelper;
    private @Nullable String mCurrentRequestUrl;
    private @Nullable BottomSheetObserver mSheetObserver;
    private @Nullable TextBubble mHelpBubble;

    private boolean mModelPreparedForCurrentTab;
    private boolean mSuggestionsSetOnBottomSheet;
    private boolean mHasRecordedButtonShownForTab;

    /**
     * Whether the browser controls have fully hidden at least once since the last time
     * #clearSuggestions() was called. This is used as a proxy for whether the user has scrolled
     * down on the current page.
     */
    private boolean mHaveBrowserControlsFullyHidden;
    private int mFullscreenToken = FullscreenManager.INVALID_TOKEN;

    private boolean mHasPeekDelayPassed;

    /** Whether the content sheet is observed to be opened for the first time. */
    private boolean mHasSheetBeenOpened;

    /**
     * Whether in-product help may be shown. This is set to false if the IPH system indicates that
     * it wouldn't trigger our IPH if requested and when we attempt to show the IPH bubble.
     */
    private boolean mCanShowIph;

    /**
     * Whether the current results are eligible for IPH based on the confidence of the results and
     * the confidence threshold for showing IPH. Should be used in combination with other criteria
     * e.g. {@link #mCanShowIph} to determine whether to request to show IPH.
     */
    private boolean mCanShowIphForCurrentResults;

    /**
     * Construct a new {@link ContextualSuggestionsMediator}.
     * @param profile The last used {@link Profile}.
     * @param tabModelSelector The {@link TabModelSelector} for the containing activity.
     * @param fullscreenManager The {@link ChromeFullscreenManager} to listen for browser controls
     *         events.
     * @param model The {@link ContextualSuggestionsModel} for the component.
     * @param toolbarManager The {@link ToolbarManager} for the containing activity.
     * @param layoutManager The {@link LayoutManager} used to retrieve the
     *         {@link OverviewModeBehavior} if it exists.
     * @param enabledStateMonitor The state monitor that will alert the mediator if the enabled
     *         state for contextual suggestions changes.
     * @param suggestionSourceProvider The provider of {@link ContextualSuggestionsSource}
     *         instances.
     */
    @Inject
    ContextualSuggestionsMediator(@Named(LAST_USED_PROFILE) Profile profile,
            TabModelSelector tabModelSelector, ChromeFullscreenManager fullscreenManager,
            ContextualSuggestionsModel model, ToolbarManager toolbarManager,
            LayoutManager layoutManager, EnabledStateMonitor enabledStateMonitor,
            Provider<ContextualSuggestionsSource> suggestionSourceProvider) {
        mProfile = profile.getOriginalProfile();
        mTabModelSelector = tabModelSelector;
        mModel = model;
        mFullscreenManager = fullscreenManager;

        mToolbarManager = toolbarManager;
        mSuggestionSourceProvider = suggestionSourceProvider;

        mEnabledStateMonitor = enabledStateMonitor;
        mEnabledStateMonitor.addObserver(this);
        if (mEnabledStateMonitor.getEnabledState()) {
            enable();
        }

        mFullscreenManager.addListener(new FullscreenListener() {
            @Override
            public void onContentOffsetChanged(int offset) {}

            @Override
            public void onControlsOffsetChanged(
                    int topOffset, int bottomOffset, boolean needsAnimate) {
                if (!mHaveBrowserControlsFullyHidden) {
                    mHaveBrowserControlsFullyHidden =
                            mFullscreenManager.areBrowserControlsOffScreen();
                } else if (mCanShowIph && mCanShowIphForCurrentResults
                        && mRequireReverseScrollForIPH
                        && mFullscreenManager.areBrowserControlsFullyVisible()) {
                    mHandler.postDelayed(() -> maybeShowHelpBubble(),
                            ToolbarPhone.LOC_BAR_WIDTH_CHANGE_ANIMATION_DURATION_MS);
                }
                reportToolbarButtonShown();
            }

            @Override
            public void onToggleOverlayVideoMode(boolean enabled) {}

            @Override
            public void onBottomControlsHeightChanged(int bottomControlsHeight) {}
        });

        if (layoutManager instanceof LayoutManagerChrome) {
            mOverviewModeBehavior = (LayoutManagerChrome) layoutManager;
            mOverviewModeBehavior.addOverviewModeObserver(new EmptyOverviewModeObserver() {
                @Override
                public void onOverviewModeFinishedHiding() {
                    reportToolbarButtonShown();
                }
            });
        } else {
            mOverviewModeBehavior = null;
        }

        mRequireReverseScrollForIPH = ChromeFeatureList.isEnabled(
                ChromeFeatureList.CONTEXTUAL_SUGGESTIONS_IPH_REVERSE_SCROLL);
    }

    /**
     * Sets the {@link ContextualSuggestionsCoordinator} for bidirectional communication.
     */
    void initialize(ContextualSuggestionsCoordinator coordinator) {
        // TODO(pshmakov): get rid of this circular dependency by establishing an observer-observable
        // relationship between Mediator and Coordinator;
        mCoordinator = coordinator;
    }

    /** Destroys the mediator. */
    void destroy() {
        if (mFetchHelper != null) {
            mFetchHelper.destroy();
            mFetchHelper = null;
        }

        if (mSuggestionsSource != null) {
            mSuggestionsSource.destroy();
            mSuggestionsSource = null;
        }

        if (mHelpBubble != null) mHelpBubble.dismiss();

        mEnabledStateMonitor.removeObserver(this);
    }

    @Override
    public void onEnabledStateChanged(boolean enabled) {
        if (enabled) {
            enable();
        } else {
            disable();
        }
    }

    private void enable() {
        mSuggestionsSource = mSuggestionSourceProvider.get();
        mFetchHelper = new FetchHelper(this, mTabModelSelector);

        Tracker tracker = TrackerFactory.getTrackerForProfile(mProfile);
        tracker.addOnInitializedCallback(success -> {
            if (!success) return;
            mCanShowIph =
                    tracker.wouldTriggerHelpUI(FeatureConstants.CONTEXTUAL_SUGGESTIONS_FEATURE);
        });
    }

    private void disable() {
        clearSuggestions();

        if (mFetchHelper != null) {
            mFetchHelper.destroy();
            mFetchHelper = null;
        }

        if (mSuggestionsSource != null) {
            mSuggestionsSource.destroy();
            mSuggestionsSource = null;
        }
    }

    @Override
    public void onSettingsStateChanged(boolean enabled) {}

    @Override
    public void requestSuggestions(String url) {
        // Guard against null tabs when requesting suggestions. https://crbug.com/836672.
        if (mTabModelSelector.getCurrentTab() == null
                || mTabModelSelector.getCurrentTab().getWebContents() == null) {
            assert false;
            return;
        }

        reportEvent(ContextualSuggestionsEvent.FETCH_REQUESTED);
        mCurrentRequestUrl = url;
        mSuggestionsSource.fetchSuggestions(url, (suggestionsResult) -> {
            if (mTabModelSelector.getCurrentTab() == null
                    || mTabModelSelector.getCurrentTab().getWebContents() == null
                    || mSuggestionsSource == null) {
                return;
            }
            assert mFetchHelper != null;

            // Avoiding double fetches causing suggestions for incorrect context.
            if (!TextUtils.equals(url, mCurrentRequestUrl)) return;

            List<ContextualSuggestionsCluster> clusters = suggestionsResult.getClusters();

            if (clusters.isEmpty() || clusters.get(0).getSuggestions().isEmpty()) return;

            int globalSuggestionsCount = 0;
            for (ContextualSuggestionsCluster cluster : clusters) {
                cluster.buildChildren(globalSuggestionsCount);
                globalSuggestionsCount += cluster.getSuggestions().size();
            }

            prepareModel(clusters, suggestionsResult.getPeekText());

            // By default, we will show IPH if results have been sent to the UI layer unless
            // otherwise configured via a field trial.
            mCanShowIphForCurrentResults = suggestionsResult.getPeekConditions().getConfidence()
                    >= (float) ChromeFeatureList.getFieldTrialParamByFeatureAsDouble(
                            ChromeFeatureList.CONTEXTUAL_SUGGESTIONS_BUTTON,
                            IPH_CONFIDENCE_THRESHOLD_PARAM, 0.d);

            mToolbarManager.enableExperimentalButton(
                    view -> onToolbarButtonClicked(),
                    R.drawable.contextual_suggestions,
                    R.string.contextual_suggestions_button_description);
            RecordHistogram.recordBooleanHistogram(
                    "ContextualSuggestions.ResultsReturnedInOverviewMode", isOverviewModeVisible());
            reportToolbarButtonShown();
        });
    }

    private void onToolbarButtonClicked() {
        if (mSuggestionsSetOnBottomSheet || !mModelPreparedForCurrentTab) return;

        maybeShowContentInSheet();
        RecordUserAction.record("ContextualSuggestions.ToolbarButtonClicked");
        mCoordinator.showSuggestions(mSuggestionsSource);
        mCoordinator.expandBottomSheet();
    }

    // TODO(twellington): Use peek criteria to determine when to show toolbar button or remove
    //                   entirely.
    private void setPeekConditions(ContextualSuggestionsResult suggestionsResult) {
        PeekConditions peekConditions = suggestionsResult.getPeekConditions();
        long remainingDelay =
                mFetchHelper.getFetchTimeBaselineMillis(mTabModelSelector.getCurrentTab())
                + Math.round(peekConditions.getMinimumSecondsOnPage() * 1000)
                - SystemClock.uptimeMillis();

        if (remainingDelay <= 0) {
            // Don't postDelayed if the minimum delay has passed so that the suggestions may
            // be shown through the following call to show contents in the bottom sheet.
            mHasPeekDelayPassed = true;
        } else {
            // Once delay expires, the bottom sheet can be peeked if the browser controls are
            // already hidden, or the next time the browser controls are fully hidden and
            // reshown. Note that this triggering on the latter case is handled by
            // FullscreenListener#onControlsOffsetChanged() in this class.
            mHandler.postDelayed(() -> {
                mHasPeekDelayPassed = true;
                maybeShowContentInSheet();
            }, remainingDelay);
        }
    }

    private void reportToolbarButtonShown() {
        if (mHasRecordedButtonShownForTab || !mFullscreenManager.areBrowserControlsFullyVisible()
                || isOverviewModeVisible() || mSuggestionsSource == null
                || !mModel.hasSuggestions()) {
            return;
        }

        mHasRecordedButtonShownForTab = true;
        reportEvent(ContextualSuggestionsEvent.UI_BUTTON_SHOWN);
        TrackerFactory.getTrackerForProfile(mProfile).notifyEvent(
                EventConstants.CONTEXTUAL_SUGGESTIONS_BUTTON_SHOWN);
        if (mCanShowIph && mCanShowIphForCurrentResults && !mRequireReverseScrollForIPH) {
            mHandler.postDelayed(() -> maybeShowHelpBubble(),
                    ToolbarPhone.LOC_BAR_WIDTH_CHANGE_ANIMATION_DURATION_MS);
        }
    }

    @Override
    public void clearState() {
        clearSuggestions();
    }

    @Override
    public void reportFetchDelayed(WebContents webContents) {
        if (mTabModelSelector.getCurrentTab() != null
                && mTabModelSelector.getCurrentTab().getWebContents() == webContents) {
            reportEvent(ContextualSuggestionsEvent.FETCH_DELAYED);
        }
    }

    // ListMenuButton.Delegate implementation.
    @Override
    public ListMenuButton.Item[] getItems() {
        final Context context = ContextUtils.getApplicationContext();
        if (ChromeFeatureList.isEnabled(ChromeFeatureList.CONTEXTUAL_SUGGESTIONS_OPT_OUT)) {
            return new ListMenuButton.Item[] {
                    new ListMenuButton.Item(context, R.string.menu_preferences, true),
                    new ListMenuButton.Item(context, R.string.menu_send_feedback, true)};
        } else {
            return new ListMenuButton.Item[] {
                    new ListMenuButton.Item(context, R.string.menu_send_feedback, true)};
        }
    }

    @Override
    public void onItemSelected(ListMenuButton.Item item) {
        if (item.getTextId() == R.string.menu_preferences) {
            mCoordinator.showSettings();
        } else if (item.getTextId() == R.string.menu_send_feedback) {
            mCoordinator.showFeedback();
        } else {
            assert false : "Unhandled item detected.";
        }
    }

    private void removeSuggestionsFromSheet() {
        if (mSheetObserver != null) {
            mCoordinator.removeBottomSheetObserver(mSheetObserver);
            mSheetObserver = null;
        }
        mCoordinator.removeSuggestions();

        // Wait until suggestions are fully removed to reset {@code mSuggestionsSetOnBottomSheet}.
        mCoordinator.addBottomSheetObserver(new EmptyBottomSheetObserver() {
            @Override
            public void onSheetContentChanged(@Nullable BottomSheet.BottomSheetContent newContent) {
                if (!(newContent instanceof ContextualSuggestionsBottomSheetContent)) {
                    mSuggestionsSetOnBottomSheet = false;
                    mCoordinator.removeBottomSheetObserver(this);
                }
            }
        });
    }

    /**
     * Called when suggestions are cleared either due to the user explicitly dismissing
     * suggestions via the close button or due to the FetchHelper signaling state should
     * be cleared.
     */
    private void clearSuggestions() {
        mModelPreparedForCurrentTab = false;

        // Remove suggestions before clearing model state so that views don't respond to model
        // changes while suggestions are hiding. See https://crbug.com/840579.
        removeSuggestionsFromSheet();
        mToolbarManager.disableExperimentalButton();

        mHasRecordedButtonShownForTab = false;
        mHasSheetBeenOpened = false;
        mHandler.removeCallbacksAndMessages(null);
        mHasPeekDelayPassed = false;
        mHaveBrowserControlsFullyHidden = false;
        mModel.setClusterList(Collections.emptyList());
        mModel.setCloseButtonOnClickListener(null);
        mModel.setMenuButtonDelegate(null);
        mModel.setTitle(null);
        mCurrentRequestUrl = "";

        if (mSuggestionsSource != null) mSuggestionsSource.clearState();

        if (mHelpBubble != null) mHelpBubble.dismiss();
    }

    private void prepareModel(List<ContextualSuggestionsCluster> clusters, String title) {
        if (mSuggestionsSource == null) return;

        mModel.setClusterList(clusters);
        mModel.setCloseButtonOnClickListener(view -> {
            TrackerFactory.getTrackerForProfile(mProfile).notifyEvent(
                    EventConstants.CONTEXTUAL_SUGGESTIONS_DISMISSED);
            @ContextualSuggestionsEvent
            int openedEvent =
                    mHasSheetBeenOpened ? ContextualSuggestionsEvent.UI_DISMISSED_AFTER_OPEN
                                        : ContextualSuggestionsEvent.UI_DISMISSED_WITHOUT_OPEN;
            reportEvent(openedEvent);
            removeSuggestionsFromSheet();

        });
        mModel.setMenuButtonDelegate(this);
        mModel.setTitle(!TextUtils.isEmpty(title)
                        ? title
                        : ContextUtils.getApplicationContext().getResources().getString(
                                  R.string.contextual_suggestions_button_description));

        mModelPreparedForCurrentTab = true;
    }

    private void maybeShowContentInSheet() {
        if (!mModel.hasSuggestions() || mSuggestionsSource == null) return;

        mSuggestionsSetOnBottomSheet = true;

        mSheetObserver = new EmptyBottomSheetObserver() {
            @Override
            public void onSheetOffsetChanged(float heightFraction, float offsetPx) {
                if (mHelpBubble != null) mHelpBubble.dismiss();
            }

            @Override
            public void onSheetOpened(@StateChangeReason int reason) {
                if (!mHasSheetBeenOpened) {
                    mHasSheetBeenOpened = true;
                    TrackerFactory.getTrackerForProfile(mProfile).notifyEvent(
                            EventConstants.CONTEXTUAL_SUGGESTIONS_OPENED);
                    reportEvent(ContextualSuggestionsEvent.UI_OPENED);
                }
            }

            @Override
            public void onSheetClosed(@StateChangeReason int reason) {
                removeSuggestionsFromSheet();
            }
        };

        mCoordinator.addBottomSheetObserver(mSheetObserver);
        mCoordinator.showContentInSheet();
    }

    private void maybeShowHelpBubble() {
        View anchorView = mToolbarManager.getExperimentalButtonView();
        if (!mCanShowIph || !mCanShowIphForCurrentResults || mToolbarManager.isUrlBarFocused()
                || anchorView == null || anchorView.getVisibility() != View.VISIBLE
                || !mFullscreenManager.areBrowserControlsFullyVisible()
                || mSuggestionsSource == null || !mModel.hasSuggestions()) {
            return;
        }

        // Either we'll fail to show or we'll successfully show. Either way, we can't show IPH
        // after this attempt.
        mCanShowIph = false;
        Tracker tracker = TrackerFactory.getTrackerForProfile(mProfile);
        if (!tracker.shouldTriggerHelpUI(FeatureConstants.CONTEXTUAL_SUGGESTIONS_FEATURE)) {
            return;
        }

        ViewRectProvider rectProvider = new ViewRectProvider(anchorView);
        rectProvider.setInsetPx(0, 0, 0,
                anchorView.getResources().getDimensionPixelOffset(
                        R.dimen.text_bubble_menu_anchor_y_inset));

        mHelpBubble = new ImageTextBubble(anchorView.getContext(), anchorView,
                R.string.contextual_suggestions_in_product_help,
                R.string.contextual_suggestions_in_product_help_accessibility, true, rectProvider,
                R.drawable.ic_logo_googleg_24dp);

        mHelpBubble.setDismissOnTouchInteraction(false);
        if (!sOverrideIPHTimeoutForTesting) {
            mHelpBubble.setAutoDismissTimeout(AccessibilityUtil.isAccessibilityEnabled()
                            ? IPH_AUTO_DISMISS_ACCESSIBILITY_TIMEOUT_MS
                            : IPH_AUTO_DISMISS_TIMEOUT_MS);
        }
        mHelpBubble.addOnDismissListener(() -> {
            tracker.dismissed(FeatureConstants.CONTEXTUAL_SUGGESTIONS_FEATURE);
            mFullscreenManager.getBrowserVisibilityDelegate().releasePersistentShowingToken(
                    mFullscreenToken);
            mHelpBubble = null;
        });
        mFullscreenToken =
                mFullscreenManager.getBrowserVisibilityDelegate().showControlsPersistent();
        mHelpBubble.show();
    }

    private void reportEvent(@ContextualSuggestionsEvent int event) {
        if (mTabModelSelector.getCurrentTab() == null
                || mTabModelSelector.getCurrentTab().getWebContents() == null) {
            // This method is not expected to be called if the current tab or webcontents are null.
            // If this assert is hit, please alert someone on the Chrome Explore on Content team.
            // See https://crbug.com/836672.
            assert false;
            return;
        }

        mSuggestionsSource.reportEvent(mTabModelSelector.getCurrentTab().getWebContents(), event);
    }

    private boolean isOverviewModeVisible() {
        return mOverviewModeBehavior != null && mOverviewModeBehavior.overviewVisible();
    }

    @VisibleForTesting
    void showContentInSheetForTesting(boolean disablePeekDelay) {
        if (disablePeekDelay) mHasPeekDelayPassed = true;
        maybeShowContentInSheet();
    }

    @VisibleForTesting
    TextBubble getHelpBubbleForTesting() {
        return mHelpBubble;
    }

    @VisibleForTesting
    static void setOverrideIPHTimeoutForTesting(boolean override) {
        sOverrideIPHTimeoutForTesting = override;
    }

    @VisibleForTesting
    boolean getCanShowIphForCurrentResults() {
        return mCanShowIphForCurrentResults;
    }
}