// Copyright 2019 The Chromium Authors
// 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.tasks.tab_management;

import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.ANIMATE_VISIBILITY_CHANGES;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.BLOCK_TOUCH_INPUT;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.BOTTOM_CONTROLS_HEIGHT;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.BOTTOM_PADDING;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.INITIAL_SCROLL_INDEX;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.IS_INCOGNITO;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.IS_VISIBLE;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.MODE;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.SHADOW_TOP_OFFSET;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.TOP_MARGIN;
import static org.chromium.chrome.browser.tasks.tab_management.TabListContainerProperties.VISIBILITY_LISTENER;
import static org.chromium.chrome.browser.tasks.tab_management.TabSwitcherConstants.HARD_CLEANUP_DELAY_MS;
import static org.chromium.chrome.browser.tasks.tab_management.TabSwitcherConstants.SOFT_CLEANUP_DELAY_MS;

import android.content.Context;
import android.os.Handler;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;

import org.chromium.base.Callback;
import org.chromium.base.CallbackController;
import org.chromium.base.Log;
import org.chromium.base.ObserverList;
import org.chromium.base.metrics.RecordHistogram;
import org.chromium.base.metrics.RecordUserAction;
import org.chromium.base.supplier.LazyOneshotSupplier;
import org.chromium.base.supplier.ObservableSupplier;
import org.chromium.base.supplier.ObservableSupplierImpl;
import org.chromium.base.supplier.OneshotSupplier;
import org.chromium.base.supplier.TransitiveObservableSupplier;
import org.chromium.chrome.browser.back_press.BackPressManager;
import org.chromium.chrome.browser.browser_controls.BrowserControlsStateProvider;
import org.chromium.chrome.browser.flags.ChromeFeatureList;
import org.chromium.chrome.browser.incognito.reauth.IncognitoReauthController;
import org.chromium.chrome.browser.incognito.reauth.IncognitoReauthManager;
import org.chromium.chrome.browser.layouts.LayoutStateProvider;
import org.chromium.chrome.browser.layouts.LayoutStateProvider.LayoutStateObserver;
import org.chromium.chrome.browser.layouts.LayoutType;
import org.chromium.chrome.browser.price_tracking.PriceTrackingUtilities;
import org.chromium.chrome.browser.profiles.Profile;
import org.chromium.chrome.browser.tab.Tab;
import org.chromium.chrome.browser.tab.TabCreationState;
import org.chromium.chrome.browser.tab.TabSelectionType;
import org.chromium.chrome.browser.tab.state.ShoppingPersistedTabData;
import org.chromium.chrome.browser.tab_ui.TabSwitcher;
import org.chromium.chrome.browser.tab_ui.TabSwitcher.TabSwitcherType;
import org.chromium.chrome.browser.tab_ui.TabSwitcher.TabSwitcherViewObserver;
import org.chromium.chrome.browser.tab_ui.TabSwitcherCustomViewManager;
import org.chromium.chrome.browser.tabmodel.TabList;
import org.chromium.chrome.browser.tabmodel.TabModel;
import org.chromium.chrome.browser.tabmodel.TabModelFilter;
import org.chromium.chrome.browser.tabmodel.TabModelObserver;
import org.chromium.chrome.browser.tabmodel.TabModelSelector;
import org.chromium.chrome.browser.tabmodel.TabModelSelectorObserver;
import org.chromium.chrome.browser.tabmodel.TabModelUtils;
import org.chromium.chrome.browser.tasks.tab_management.TabGridDialogMediator.DialogController;
import org.chromium.chrome.browser.tasks.tab_management.TabListCoordinator.TabListMode;
import org.chromium.chrome.browser.tasks.tab_management.TabListEditorCoordinator.TabListEditorController;
import org.chromium.chrome.browser.ui.messages.snackbar.SnackbarManager;
import org.chromium.chrome.features.start_surface.StartSurfaceUserData;
import org.chromium.chrome.tab_ui.R;
import org.chromium.components.browser_ui.widget.gesture.BackPressHandler;
import org.chromium.ui.base.DeviceFormFactor;
import org.chromium.ui.modelutil.PropertyModel;

import java.util.List;

/**
 * The Mediator that is responsible for resetting the tab grid or carousel based on visibility and
 * model changes.
 */
class TabSwitcherMediator
        implements TabSwitcher.Controller,
                TabListRecyclerView.VisibilityListener,
                TabListMediator.GridCardOnClickListenerProvider,
                PriceMessageService.PriceWelcomeMessageReviewActionProvider,
                TabSwitcherCustomViewManager.Delegate,
                BackPressHandler {
    private static final String TAG = "TabSwitcherMediator";

    private final Handler mHandler;

    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
    final Runnable mSoftClearTabListRunnable;

    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
    final Runnable mClearTabListRunnable;

    private final TabSwitcherResetHandler mResetHandler;
    private final PropertyModel mContainerViewModel;
    private final TabModelSelector mTabModelSelector;
    private final TabModelObserver mTabModelObserver;
    private final TabModelSelectorObserver mTabModelSelectorObserver;
    private final ObserverList<TabSwitcherViewObserver> mObservers = new ObserverList<>();
    private final BrowserControlsStateProvider mBrowserControlsStateProvider;
    private final BrowserControlsStateProvider.Observer mBrowserControlsObserver;
    private final ViewGroup mContainerView;
    private final boolean mIsTablet;
    private final ObservableSupplierImpl<Boolean> mBackPressChangedSupplier =
            new ObservableSupplierImpl<>();
    private final ObservableSupplierImpl<Boolean> mIsDialogVisibleSupplier =
            new ObservableSupplierImpl<>();
    private final Callback<Boolean> mNotifyBackPressedCallback = this::notifyBackPressStateChanged;
    private final @NonNull LazyOneshotSupplier<TabGridDialogMediator.DialogController>
            mTabGridDialogControllerSupplier;
    private Runnable mOnTabSwitcherShownCallback;

    /**
     * The callback which is supplied to the {@link IncognitoReauthController} that takes care of
     * resetting the Incognito tab list with actual Incognito tabs upon successful authentication.
     */
    private final IncognitoReauthManager.IncognitoReauthCallback mIncognitoReauthCallback =
            new IncognitoReauthManager.IncognitoReauthCallback() {
                @Override
                public void onIncognitoReauthNotPossible() {}

                @Override
                public void onIncognitoReauthSuccess() {
                    assert mTabModelSelector
                                    .getTabModelFilterProvider()
                                    .getCurrentTabModelFilter()
                                    .isIncognito()
                            : "The incognito re-auth controller only affects Incognito tab list.";
                    mResetHandler.resetWithTabList(
                            mTabModelSelector
                                    .getTabModelFilterProvider()
                                    .getCurrentTabModelFilter(),
                            false);
                    setInitialScrollIndexOffset();
                    requestAccessibilityFocusOnCurrentTab();
                }

                @Override
                public void onIncognitoReauthFailure() {}
            };

    private CallbackController mCallbackController;
    private @Nullable ObservableSupplier<TabListEditorController> mTabListEditorControllerSupplier;
    private @Nullable TransitiveObservableSupplier<TabListEditorController, Boolean>
            mCurrentTabListEditorControllerBackSupplier;
    private TabSwitcher.OnTabSelectingListener mOnTabSelectingListener;

    /**
     * This allows to check if re-auth is pending when tab switcher is shown in Incognito mode.
     * If so, we clear the Incognito tab lists until the re-auth is successful.
     */
    private @Nullable IncognitoReauthController mIncognitoReauthController;

    /**
     * A custom view that can be supplied by clients to be shown inside the tab grid.
     * Only one client at a time is supported. The custom view is set to null when the client
     * signals the mediator for removal.
     */
    private @Nullable View mCustomView;

    /** A back press {@link Runnable} that can be supplied by clients when adding a custom view. */
    private @Nullable Runnable mCustomViewBackPressRunnable;

    /**
     * In cases where a didSelectTab was due to switching models with a toggle,
     * we don't change tab grid visibility.
     */
    private boolean mShouldIgnoreNextSelect;

    private boolean mIncognitoStateWhenShown;
    private int mTabIdWhenShown;
    private int mIndexInNewModelWhenSwitched;
    private boolean mIsSelectingInTabSwitcher;

    private @TabListCoordinator.TabListMode int mMode;
    private Context mContext;
    private SnackbarManager mSnackbarManager;
    private boolean mIsTransitionInProgress;
    private boolean mIsTabSwitcherShowing;

    @Nullable private LayoutStateProvider mLayoutStateProvider;
    @Nullable private LayoutStateObserver mLayoutStateObserver;
    // The layout type of the last active layout which was shown before showing the TAB_SWITCHER
    // layout.
    private @LayoutType int mLastActiveLayoutType;

    /**
     * Basic constructor for the Mediator.
     *
     * @param context The context to use for accessing {@link android.content.res.Resources}.
     * @param resetHandler The {@link TabSwitcherResetHandler} that handles reset for this Mediator.
     * @param containerViewModel The {@link PropertyModel} to keep state on the View containing the
     *     grid or carousel.
     * @param tabModelSelector {@link TabModelSelector} to observer for model and selection changes.
     * @param browserControlsStateProvider {@link BrowserControlsStateProvider} to use.
     * @param containerView The container {@link ViewGroup} to use.
     * @param handler The {@link Handler} for running cleanup callbacks.
     * @param mode One of the {@link TabListMode}.
     * @param incognitoReauthControllerSupplier {@link OneshotSupplier<IncognitoReauthController>}
     *     to detect pending re-auth when tab switcher is shown.
     * @param backPressManager {@link BackPressManager} to handle back press gesture.
     * @param tabGridDialogControllerSupplier {@link DialogController} supplier for lazy
     *     initialization on first use.
     * @param onTabSwitcherShownCallback is a callback method to notify {@link
     *     TabSwitcherCoordinator} class to attach empty view when #showTabSwitcherView is invoked.
     * @param layoutStateProviderSupplier {@link OneshotSupplier<LayoutStateProvider>} to provide
     *     layout state changes.
     */
    TabSwitcherMediator(
            Context context,
            TabSwitcherResetHandler resetHandler,
            PropertyModel containerViewModel,
            TabModelSelector tabModelSelector,
            BrowserControlsStateProvider browserControlsStateProvider,
            ViewGroup containerView,
            @NonNull Handler handler,
            @TabListMode int mode,
            @Nullable OneshotSupplier<IncognitoReauthController> incognitoReauthControllerSupplier,
            @Nullable BackPressManager backPressManager,
            @NonNull LazyOneshotSupplier<DialogController> tabGridDialogControllerSupplier,
            Runnable onTabSwitcherShownCallback,
            @Nullable OneshotSupplier<LayoutStateProvider> layoutStateProviderSupplier) {
        mResetHandler = resetHandler;
        mContainerViewModel = containerViewModel;
        mTabModelSelector = tabModelSelector;
        mBrowserControlsStateProvider = browserControlsStateProvider;
        mMode = mode;
        mHandler = handler;
        mContainerViewModel.set(MODE, mode);
        mContext = context;
        mIsTablet = DeviceFormFactor.isNonMultiDisplayContextOnTablet(context);
        mOnTabSwitcherShownCallback = onTabSwitcherShownCallback;
        mTabGridDialogControllerSupplier = tabGridDialogControllerSupplier;
        // Any observer events get posted so it is safe to set up early.
        mTabGridDialogControllerSupplier.onAvailable(
                (tabGridDialogController) -> {
                    tabGridDialogController
                            .getHandleBackPressChangedSupplier()
                            .addObserver(mNotifyBackPressedCallback);
                });
        if (layoutStateProviderSupplier != null) {
            if (layoutStateProviderSupplier.hasValue()) {
                onLayoutStateProviderAvailable(layoutStateProviderSupplier.get());
            } else {
                // Only use onAvailable if no value is available as waiting for the Promise to
                // resolve risks getActiveLayoutType changing before the value is supplied.
                layoutStateProviderSupplier.onAvailable(this::onLayoutStateProviderAvailable);
            }
        }

        if (incognitoReauthControllerSupplier != null) {
            mCallbackController = new CallbackController();
            incognitoReauthControllerSupplier.onAvailable(
                    mCallbackController.makeCancelable(
                            (incognitoReauthController) -> {
                                mIncognitoReauthController = incognitoReauthController;
                                mIncognitoReauthController.addIncognitoReauthCallback(
                                        mIncognitoReauthCallback);
                            }));
        }

        mTabModelSelectorObserver =
                new TabModelSelectorObserver() {
                    @Override
                    public void onTabModelSelected(TabModel newModel, TabModel oldModel) {
                        mShouldIgnoreNextSelect = true;
                        mIndexInNewModelWhenSwitched = newModel.index();

                        TabList currentTabModelFilter =
                                mTabModelSelector
                                        .getTabModelFilterProvider()
                                        .getCurrentTabModelFilter();
                        mContainerViewModel.set(IS_INCOGNITO, currentTabModelFilter.isIncognito());
                        notifyBackPressStateChangedInternal();
                        if (mTabGridDialogControllerSupplier.hasValue()) {
                            mTabGridDialogControllerSupplier.get().hideDialog(false);
                        }
                        if (!mContainerViewModel.get(IS_VISIBLE)) return;

                        if (clearIncognitoTabListForReauth()) return;
                        mResetHandler.resetWithTabList(currentTabModelFilter, false);
                        setInitialScrollIndexOffset();
                        requestAccessibilityFocusOnCurrentTab();
                    }
                };
        mTabModelSelector.addObserver(mTabModelSelectorObserver);

        mTabModelObserver =
                new TabModelObserver() {
                    @Override
                    public void didAddTab(
                            Tab tab,
                            int type,
                            @TabCreationState int creationState,
                            boolean markedForSelection) {
                        // TODO(wychen): move didAddTab and didSelectTab to another observer and
                        // inject
                        //  after restoreCompleted.
                        if (!mTabModelSelector.isTabStateInitialized()) {
                            return;
                        }
                        mShouldIgnoreNextSelect = false;
                    }

                    @Override
                    public void didSelectTab(Tab tab, int type, int lastId) {
                        if (!mTabModelSelector.isTabStateInitialized()) {
                            return;
                        }
                        notifyBackPressStateChangedInternal();
                        if (type == TabSelectionType.FROM_CLOSE
                                || mShouldIgnoreNextSelect
                                || type == TabSelectionType.FROM_UNDO) {
                            mShouldIgnoreNextSelect = false;
                            return;
                        }
                        if (mIsSelectingInTabSwitcher) {
                            mIsSelectingInTabSwitcher = false;

                            // Use TabSelectionType.From_USER to filter the new tab creation case.
                            if (type == TabSelectionType.FROM_USER) {
                                recordUserSwitchedTab(tab, lastId);
                            }
                        }

                        if (mContainerViewModel.get(IS_VISIBLE)) {
                            onTabSelecting(tab.getId(), false);
                        }
                    }

                    @Override
                    public void restoreCompleted() {
                        if (!mContainerViewModel.get(IS_VISIBLE)) return;

                        mResetHandler.resetWithTabList(
                                mTabModelSelector
                                        .getTabModelFilterProvider()
                                        .getCurrentTabModelFilter(),
                                false);
                        setInitialScrollIndexOffset();
                    }


                    @Override
                    public void tabClosureUndone(Tab tab) {
                        notifyBackPressStateChangedInternal();
                    }

                    @Override
                    public void tabPendingClosure(Tab tab) {
                        notifyBackPressStateChangedInternal();
                    }

                    @Override
                    public void onFinishingTabClosure(Tab tab) {
                        // If tab is closed by the site itself rather than user's input,
                        // tabPendingClosure & tabClosureCommitted won't be called.
                        notifyBackPressStateChangedInternal();
                    }

                    @Override
                    public void tabRemoved(Tab tab) {
                        notifyBackPressStateChangedInternal();
                    }

                    @Override
                    public void multipleTabsPendingClosure(List<Tab> tabs, boolean isAllTabs) {
                        notifyBackPressStateChangedInternal();
                    }

                };

        mBrowserControlsObserver =
                new BrowserControlsStateProvider.Observer() {
                    @Override
                    public void onControlsOffsetChanged(
                            int topOffset,
                            int topControlsMinHeightOffset,
                            int bottomOffset,
                            int bottomControlsMinHeightOffset,
                            boolean needsAnimate) {
                        updateTopControlsProperties();
                    }

                    @Override
                    public void onTopControlsHeightChanged(
                            int topControlsHeight, int topControlsMinHeight) {
                        updateTopControlsProperties();
                    }

                    @Override
                    public void onBottomControlsHeightChanged(
                            int bottomControlsHeight, int bottomControlsMinHeight) {
                        mContainerViewModel.set(BOTTOM_CONTROLS_HEIGHT, bottomControlsHeight);
                    }
                };

        mBrowserControlsStateProvider.addObserver(mBrowserControlsObserver);

        if (mTabModelSelector.getModels().isEmpty()) {
            TabModelSelectorObserver selectorObserver =
                    new TabModelSelectorObserver() {
                        @Override
                        public void onChange() {
                            assert !mTabModelSelector.getModels().isEmpty();
                            assert mTabModelSelector
                                            .getTabModelFilterProvider()
                                            .getTabModelFilter(false)
                                    != null;
                            assert mTabModelSelector
                                            .getTabModelFilterProvider()
                                            .getTabModelFilter(true)
                                    != null;
                            mTabModelSelector.removeObserver(this);
                            mTabModelSelector
                                    .getTabModelFilterProvider()
                                    .addTabModelFilterObserver(mTabModelObserver);
                        }
                    };
            mTabModelSelector.addObserver(selectorObserver);
        } else {
            mTabModelSelector
                    .getTabModelFilterProvider()
                    .addTabModelFilterObserver(mTabModelObserver);
        }

        mContainerViewModel.set(VISIBILITY_LISTENER, this);
        TabModelFilter tabModelFilter =
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter();
        mContainerViewModel.set(
                IS_INCOGNITO, tabModelFilter == null ? false : tabModelFilter.isIncognito());
        mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, true);

        updateTopControlsProperties();
        mContainerViewModel.set(
                BOTTOM_CONTROLS_HEIGHT, browserControlsStateProvider.getBottomControlsHeight());

        if (mMode == TabListMode.GRID) {
            mContainerViewModel.set(
                    BOTTOM_PADDING,
                    (int) context.getResources().getDimension(R.dimen.tab_grid_bottom_padding));
            if (backPressManager != null && BackPressManager.isEnabled()) {
                backPressManager.addHandler(this, BackPressHandler.Type.TAB_SWITCHER);
                notifyBackPressStateChangedInternal();
            }
        }

        mContainerView = containerView;

        mSoftClearTabListRunnable = mResetHandler::softCleanup;
        mClearTabListRunnable =
                () -> {
                    mResetHandler.hardCleanup();
                    mResetHandler.resetWithTabList(null, false);
                };

        notifyBackPressStateChangedInternal();
    }

    /** Called after native initialization is completed. */
    public void initWithNative(@Nullable SnackbarManager snackbarManager) {
        mSnackbarManager = snackbarManager;
    }

    /**
     * @param tabListEditorControllerSupplier The supllier for the controller of the tab list
     *     editor.
     */
    public void setTabListEditorControllerSupplier(
            @NonNull ObservableSupplier<TabListEditorController> tabListEditorControllerSupplier) {
        assert mTabListEditorControllerSupplier == null
                : "setTabListEditorControllerSupplier should be called only once.";
        mTabListEditorControllerSupplier = tabListEditorControllerSupplier;
        mCurrentTabListEditorControllerBackSupplier =
                new TransitiveObservableSupplier<>(
                        tabListEditorControllerSupplier,
                        tabListEditorController -> {
                            return tabListEditorController.getHandleBackPressChangedSupplier();
                        });
        mCurrentTabListEditorControllerBackSupplier.addObserver(mNotifyBackPressedCallback);
    }

    private void setVisibility(boolean isVisible) {
        if (isVisible) {
            RecordUserAction.record("MobileToolbarShowStackView");
        }

        mContainerViewModel.set(IS_VISIBLE, isVisible);
        notifyBackPressStateChangedInternal();
    }

    private void blockTouchInput(boolean blockTouchInput) {
        mContainerViewModel.set(BLOCK_TOUCH_INPUT, blockTouchInput);
    }

    private void updateTopControlsProperties() {
        // The grid tab switcher for tablets translates up over top of the browser controls.
        if (mIsTablet) {
            final int toolbarHeight = getToolbarHeight();

            mContainerViewModel.set(TOP_MARGIN, toolbarHeight);
            mContainerViewModel.set(SHADOW_TOP_OFFSET, toolbarHeight);
            return;
        }

        final int contentOffset = mBrowserControlsStateProvider.getContentOffset();

        mContainerViewModel.set(TOP_MARGIN, contentOffset);
        mContainerViewModel.set(SHADOW_TOP_OFFSET, contentOffset);
    }

    /**
     * Record tab switch related metric for GTS.
     * @param tab The new selected tab.
     * @param lastId The id of the previous selected tab, and that tab is still a valid tab
     *               in TabModel.
     */
    private void recordUserSwitchedTab(Tab tab, int lastId) {
        if (tab == null) {
            assert false : "New selected tab cannot be null when recording tab switch.";
            return;
        }

        Tab fromTab = TabModelUtils.getTabById(mTabModelSelector.getCurrentModel(), lastId);
        assert fromTab != null;
        TabModelFilter filter =
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter();
        if (mIncognitoStateWhenShown == mTabModelSelector.isIncognitoSelected()) {
            if (tab.getId() == mTabIdWhenShown) {
                if (mMode == TabListCoordinator.TabListMode.GRID) {
                    RecordUserAction.record("MobileTabReturnedToCurrentTab.TabGrid");
                } else {
                    // TODO(crbug.com/40132120): Differentiate others.
                }
                RecordUserAction.record("MobileTabReturnedToCurrentTab");
                RecordHistogram.recordSparseHistogram(
                        "Tabs.TabOffsetOfSwitch." + TabSwitcherCoordinator.COMPONENT_NAME, 0);
            } else {
                int fromIndex = filter.indexOf(fromTab);
                int toIndex = filter.indexOf(tab);

                if (fromIndex != toIndex) {
                    // Only log when you switch a tab page directly from tab switcher.
                    if (!filter.isTabInTabGroup(tab)) {
                        RecordUserAction.record(
                                "MobileTabSwitched." + TabSwitcherCoordinator.COMPONENT_NAME);
                    }
                    RecordHistogram.recordSparseHistogram(
                            "Tabs.TabOffsetOfSwitch." + TabSwitcherCoordinator.COMPONENT_NAME,
                            fromIndex - toIndex);
                }
            }
        } else {
            int newSelectedTabIndex =
                    TabModelUtils.getTabIndexById(mTabModelSelector.getCurrentModel(), tab.getId());
            if (newSelectedTabIndex == mIndexInNewModelWhenSwitched) {
                // TabModelImpl logs this action only when a different index is set within a
                // TabModelImpl. If we switch between normal tab model and incognito tab model and
                // leave the index the same (i.e. after switched tab model and select the
                // highlighted tab), TabModelImpl doesn't catch this case. Therefore, we record it
                // here.
                RecordUserAction.record("MobileTabSwitched");
            }
            // Only log when you switch a tab page directly from tab switcher.
            if (!filter.isTabInTabGroup(tab)) {
                RecordUserAction.record(
                        "MobileTabSwitched." + TabSwitcherCoordinator.COMPONENT_NAME);
            }
        }
        Profile profile = mTabModelSelector.getCurrentModel().getProfile();
        if (mMode == TabListCoordinator.TabListMode.GRID
                && !profile.isOffTheRecord()
                && PriceTrackingUtilities.isTrackPricesOnTabsEnabled(profile)) {
            RecordUserAction.record(
                    "Commerce.TabGridSwitched."
                            + (ShoppingPersistedTabData.hasPriceDrop(tab)
                                    ? "HasPriceDrop"
                                    : "NoPriceDrop"));
        }
    }

    @Override
    public ViewGroup getTabSwitcherContainer() {
        return mContainerView;
    }

    @Override
    public void addTabSwitcherViewObserver(TabSwitcherViewObserver observer) {
        mObservers.addObserver(observer);
    }

    @Override
    public void removeTabSwitcherViewObserver(TabSwitcherViewObserver observer) {
        mObservers.removeObserver(observer);
    }

    @Override
    public void prepareHideTabSwitcherView() {
        hideTabSwitcherViewInternal(/* animate= */ false, /* skipVisibility= */ true);
    }

    @Override
    public void hideTabSwitcherView(boolean animate) {
        hideTabSwitcherViewInternal(animate, /* skipVisibility= */ false);
    }

    private void hideTabSwitcherViewInternal(boolean animate, boolean skipVisibility) {
        if (mMode == TabListMode.GRID) {
            mIsTransitionInProgress = true;
            notifyBackPressStateChangedInternal();
        }

        blockTouchInput(true);

        if (!skipVisibility) {
            if (!animate) mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, false);
            setVisibility(false);
            mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, true);
        }

        if (mTabGridDialogControllerSupplier.hasValue()) {
            // Don't wait until didSelectTab(), which is after the GTS animation.
            // We need to hide the dialog immediately.
            mTabGridDialogControllerSupplier.get().hideDialog(false);
        }
    }

    boolean prepareTabSwitcherView() {
        mHandler.removeCallbacks(mSoftClearTabListRunnable);
        mHandler.removeCallbacks(mClearTabListRunnable);
        boolean quick = false;
        if (!mTabModelSelector.isTabStateInitialized()) return quick;
        if (TabUiFeatureUtilities.isTabToGtsAnimationEnabled(mContext)) {
            quick =
                    mResetHandler.resetWithTabList(
                            mTabModelSelector
                                    .getTabModelFilterProvider()
                                    .getCurrentTabModelFilter(),
                            false);
        }
        setInitialScrollIndexOffset();

        return quick;
    }

    private void setInitialScrollIndexOffset() {
        int initialPosition =
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter().index();

        mContainerViewModel.set(INITIAL_SCROLL_INDEX, initialPosition);
    }

    @Override
    public void prepareShowTabSwitcherView() {
        if (mMode != TabListMode.GRID) return;

        mIsTransitionInProgress = true;
        notifyBackPressStateChangedInternal();
    }

    // @Todo(crbug.com/1464856) clean up empty state implementation after Start Surface Refactor is
    // fully launched.
    @Override
    public void showTabSwitcherView(boolean animate) {
        mIsTransitionInProgress = false;
        mHandler.removeCallbacks(mSoftClearTabListRunnable);
        mHandler.removeCallbacks(mClearTabListRunnable);
        mOnTabSwitcherShownCallback.run();

        if (!mTabModelSelector.isIncognitoSelected() || !clearIncognitoTabListForReauth()) {
            if (mTabModelSelector.isTabStateInitialized()) {
                mResetHandler.resetWithTabList(
                        mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter(),
                        TabUiFeatureUtilities.isTabToGtsAnimationEnabled(mContext));
                // When |mTabModelSelector.isTabStateInitialized| is false and INSTANT_START is
                // enabled, the scrolling request is already processed in
                // TabModelObserver#restoreCompleted. Therefore, we only need to handle the case
                // with isTabStateInitialized() here.
                setInitialScrollIndexOffset();
            }
        }

        if (!animate) mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, false);
        setVisibility(true);
        blockTouchInput(false);
        mIncognitoStateWhenShown = mTabModelSelector.isIncognitoSelected();
        mTabIdWhenShown = mTabModelSelector.getCurrentTabId();
        mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, true);
    }

    @Override
    public void startedShowing(boolean isAnimating) {
        for (TabSwitcherViewObserver observer : mObservers) {
            observer.startedShowing();
        }
    }

    @Override
    public void finishedShowing() {
        mIsTabSwitcherShowing = true;

        requestAccessibilityFocusOnCurrentTab();

        for (TabSwitcherViewObserver observer : mObservers) {
            observer.finishedShowing();
        }
    }

    @Override
    public void startedHiding(boolean isAnimating) {
        for (TabSwitcherViewObserver observer : mObservers) {
            observer.startedHiding();
        }
    }

    @Override
    public void finishedHiding() {
        mIsTabSwitcherShowing = false;
        for (TabSwitcherViewObserver observer : mObservers) {
            observer.finishedHiding();
        }
    }

    @Override
    public boolean onBackPressed() {
        boolean ret = onBackPressedInternal();
        if (ret) {
            // When SS is enabled or refactor is disabled, StartSurfaceMediator will consume back
            // press and call this method if necessary.
            BackPressManager.record(BackPressHandler.Type.TAB_SWITCHER);
        }
        return ret;
    }

    private boolean onBackPressedInternal() {
        // The TabListEditor dialog can be shown on the Start surface without showing the Grid
        // Tab switcher, so skip the check of visibility of mContainerViewModel here.
        TabListEditorController editorController = getTabListEditorController();
        if (editorController != null && editorController.handleBackPressed()) {
            return true;
        }

        if (mCustomViewBackPressRunnable != null) {
            mCustomViewBackPressRunnable.run();
            return true;
        }

        if (!mIsTablet && mIsTransitionInProgress && mMode == TabListCoordinator.TabListMode.GRID) {
            // crbug.com/1420410: intentionally do nothing to wait for tab-to-GTS transition to be
            // finished. Note this has to be before following if-branch since during transition, the
            // container is still invisible. On tablet, the translation transition replaces the
            // tab-to-GTS (expand/shrink) animation, which does not suffer from the same issue.
            return true;
        }

        if (!mContainerViewModel.get(IS_VISIBLE)) {
            assert !BackPressManager.isEnabled()
                    : "Invisible container: Back press must be handled";
            return false;
        }

        if (mTabGridDialogControllerSupplier.hasValue()
                && mTabGridDialogControllerSupplier.get().handleBackPressed()) {
            return true;
        }

        if (mTabModelSelector.getCurrentTab() == null) {
            assert !BackPressManager.isEnabled() : "No tab: Back press must be handled";
            return false;
        }

        // Going back to the Start surface isn't handled by the TabSwitcherMediator any more, but in
        // {@link ReturnToChromeBackPressHandler} when it isn't in incognito mode.
        if (mLastActiveLayoutType == LayoutType.START_SURFACE
                && !mTabModelSelector.isIncognitoSelected()) {
            return false;
        }

        onTabSelecting(mTabModelSelector.getCurrentTabId(), false);

        return true;
    }

    @Override
    public @BackPressResult int handleBackPress() {
        return onBackPressedInternal() ? BackPressResult.SUCCESS : BackPressResult.FAILURE;
    }

    @Override
    public ObservableSupplier<Boolean> getHandleBackPressChangedSupplier() {
        return mBackPressChangedSupplier;
    }

    @Override
    public boolean isDialogVisible() {
        TabListEditorController editorController = getTabListEditorController();
        if (editorController != null && editorController.isVisible()) {
            return true;
        }

        if (mTabGridDialogControllerSupplier.hasValue()
                && mTabGridDialogControllerSupplier.get().isVisible()) {
            return true;
        }
        return false;
    }

    @Override
    public ObservableSupplier<Boolean> isDialogVisibleSupplier() {
        return mIsDialogVisibleSupplier;
    }

    @Override
    public void onOverviewShownAtLaunch(long activityCreationTimeMs) {}

    @Override
    public @TabSwitcherType int getTabSwitcherType() {
        switch (mMode) {
            case TabListMode.GRID:
                return TabSwitcherType.GRID;
            case TabListMode.LIST:
            case TabListMode.STRIP:
            default:
                return TabSwitcherType.NONE;
        }
    }

    @Override
    public void onHomepageChanged() {
        notifyBackPressStateChangedInternal();
    }

    @Override
    public void setSnackbarParentView(ViewGroup parentView) {
        if (mSnackbarManager == null) return;
        mSnackbarManager.setParentView(parentView);
    }

    /**
     * A method to handle signal from outside world that a client is requesting to show a custom
     * view inside the tab switcher.
     *
     * @param customView        A {@link View} view that needs to be shown.
     * @param backPressRunnable A {@link Runnable} which can be supplied if clients also wish to
     *                          handle back presses while the custom view is shown. A null value
     *                          can be passed to not
     *                          intercept back presses.
     * @param clearTabList      A boolean to indicate whether we should clear the tab list when
     *                          showing the custom view.
     */
    @Override
    public void addCustomView(
            @NonNull View customView, @Nullable Runnable backPressRunnable, boolean clearTabList) {
        assert mCustomView == null : "Only one client at a time is supported to add a custom view.";

        // Hide any tab grid dialog before we add the custom view.
        if (mTabGridDialogControllerSupplier.hasValue()) {
            mTabGridDialogControllerSupplier.get().hideDialog(false);
        }

        if (clearTabList) {
            mResetHandler.resetWithTabList(null, false);
        }

        // The grid tab switcher for tablets translates up over top of the browser controls, causing
        // the custom view to do the same.
        if (mIsTablet) {
            LinearLayout.LayoutParams params =
                    new LinearLayout.LayoutParams(
                            LinearLayout.LayoutParams.MATCH_PARENT,
                            LinearLayout.LayoutParams.MATCH_PARENT);
            params.topMargin = getToolbarHeight();

            mContainerView.addView(customView, params);
        } else {
            mContainerView.addView(customView);
        }

        mCustomView = customView;
        mCustomViewBackPressRunnable = backPressRunnable;
        notifyBackPressStateChangedInternal();
    }

    /**
     * A method to handle signal from outside world that a client is requesting to remove the custom
     * view from the tab switcher.
     *
     * @param customView A {@link View} view that needs to be removed.
     */
    @Override
    public void removeCustomView(@NonNull View customView) {
        assert mCustomView != null
                : "No client previously passed a custom view that needs removal.";
        mContainerView.removeView(customView);
        mCustomView = null;
        mCustomViewBackPressRunnable = null;
        notifyBackPressStateChangedInternal();
        mResetHandler.resetWithTabList(
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter(),
                /* quickMode= */ false);
    }

    /**
     * Do clean-up work after the overview hiding animation is finished.
     * @see TabSwitcher.TabListDelegate#postHiding
     */
    void postHiding() {
        Log.d(TAG, "SoftCleanupDelay = " + SOFT_CLEANUP_DELAY_MS);
        mHandler.postDelayed(mSoftClearTabListRunnable, SOFT_CLEANUP_DELAY_MS);
        Log.d(TAG, "HardCleanupDelay = " + HARD_CLEANUP_DELAY_MS);
        mHandler.postDelayed(mClearTabListRunnable, HARD_CLEANUP_DELAY_MS);
        mIsTransitionInProgress = false;
        notifyBackPressStateChangedInternal();
        if (ChromeFeatureList.sGridTabSwitcherAndroidAnimations.isEnabled()) {
            // Ensure we skip animating here as the UI is entirely occluded already.
            boolean previousAnimateVisibilityChangesValue =
                    mContainerViewModel.get(ANIMATE_VISIBILITY_CHANGES);
            mContainerViewModel.set(ANIMATE_VISIBILITY_CHANGES, false);
            setVisibility(false);
            mContainerViewModel.set(
                    ANIMATE_VISIBILITY_CHANGES, previousAnimateVisibilityChangesValue);
        }
    }

    /** Destroy any members that needs clean up. */
    public void destroy() {
        if (mCurrentTabListEditorControllerBackSupplier != null) {
            mCurrentTabListEditorControllerBackSupplier.removeObserver(mNotifyBackPressedCallback);
        }

        if (mTabGridDialogControllerSupplier.hasValue()) {
            mTabGridDialogControllerSupplier
                    .get()
                    .getHandleBackPressChangedSupplier()
                    .removeObserver(mNotifyBackPressedCallback);
        }

        if (mIncognitoReauthController != null) {
            mIncognitoReauthController.removeIncognitoReauthCallback(mIncognitoReauthCallback);
        }

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

        if (mLayoutStateProvider != null) {
            mLayoutStateProvider.removeObserver(mLayoutStateObserver);
        }

        mTabModelSelector.removeObserver(mTabModelSelectorObserver);
        mBrowserControlsStateProvider.removeObserver(mBrowserControlsObserver);
        mTabModelSelector
                .getTabModelFilterProvider()
                .removeTabModelFilterObserver(mTabModelObserver);
    }

    void setOnTabSelectingListener(TabSwitcher.OnTabSelectingListener listener) {
        mOnTabSelectingListener = listener;
    }


    void requestAccessibilityFocusOnCurrentTab() {
        if (!mIsTabSwitcherShowing || !mTabModelSelector.isTabStateInitialized()) {
            return;
        }

        if (mTabModelSelector.isIncognitoSelected()
                && mIncognitoReauthController != null
                && mIncognitoReauthController.isReauthPageShowing()) {
            return;
        }

        mContainerViewModel.set(
                TabListContainerProperties.FOCUS_TAB_INDEX_FOR_ACCESSIBILITY,
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter().index());
    }

    // GridCardOnClickListenerProvider implementation.
    @Override
    @Nullable
    public TabListMediator.TabActionListener openTabGridDialog(Tab tab) {
        if (!ableToOpenDialog(tab)) return null;
        assert isTabInTabGroup(tab);
        return (view, tabId) -> {
            List<Tab> relatedTabs = getRelatedTabs(tabId);
            if (relatedTabs.size() == 0) {
                relatedTabs = null;
            }
            mTabGridDialogControllerSupplier.get().resetWithListOfTabs(relatedTabs);
            RecordUserAction.record("TabGridDialog.ExpandedFromSwitcher");
        };
    }

    @Override
    public void onTabSelecting(int tabId, boolean fromActionButton) {
        if (fromActionButton && mMode == TabListMode.GRID) {
            Tab newlySelectedTab =
                    TabModelUtils.getTabById(mTabModelSelector.getCurrentModel(), tabId);
            StartSurfaceUserData.setKeepTab(newlySelectedTab, true);
        }
        mIsSelectingInTabSwitcher = true;
        if (mOnTabSelectingListener != null) {
            mShouldIgnoreNextSelect = true;
            mOnTabSelectingListener.onTabSelecting(tabId);
        }
    }

    @Override
    public void scrollToTab(int tabIndex) {
        mContainerViewModel.set(TabListContainerProperties.INITIAL_SCROLL_INDEX, tabIndex);
    }

    private boolean ableToOpenDialog(Tab tab) {
        return mTabModelSelector.isIncognitoSelected() == tab.isIncognito() && isTabInTabGroup(tab);
    }

    private TabModelFilter getCurrentTabModelFilter() {
        return mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter();
    }

    private List<Tab> getRelatedTabs(int tabId) {
        return getCurrentTabModelFilter().getRelatedTabList(tabId);
    }

    private boolean isTabInTabGroup(Tab tab) {
        return getCurrentTabModelFilter().isTabInTabGroup(tab);
    }

    private void notifyBackPressStateChanged(boolean noop) {
        notifyBackPressStateChangedInternal();
    }

    private void notifyBackPressStateChangedInternal() {
        mIsDialogVisibleSupplier.set(isDialogVisible());
        mBackPressChangedSupplier.set(shouldInterceptBackPress());
    }

    private int getToolbarHeight() {
        return mContext.getResources().getDimensionPixelSize(R.dimen.toolbar_height_no_shadow);
    }

    /**
     * A method to indicate whether back press should be intercepted. The respective interceptors
     * should also take care of invoking #notifyBackPressStateChangedInternal each time their
     * decision to intercept back press has changed.
     *
     * @return A boolean to indicate if back press should be intercepted or not.
     */
    @VisibleForTesting
    boolean shouldInterceptBackPress() {
        if (isDialogVisible()) return true;
        if (mCustomViewBackPressRunnable != null) return true;

        if (!mIsTablet && mIsTransitionInProgress && mMode == TabListCoordinator.TabListMode.GRID) {
            return true;
        }

        if (!mContainerViewModel.get(IS_VISIBLE)) return false;

        if (mTabModelSelector.getCurrentTab() == null) return false;

        // Going back to the Start surface isn't handled by the TabSwitcherMediator any more, but in
        // {@link ReturnToChromeBackPressHandler} when it isn't in incognito mode.
        if (mLastActiveLayoutType == LayoutType.START_SURFACE
                && !mTabModelSelector.isIncognitoSelected()) {
            return false;
        }

        return true;
    }

    /**
     * A method which clears the Incognito tab lists when a re-auth is pending.
     *
     * @return True, if the Incognito tab list was requested to be cleared and false otherwise.
     */
    private boolean clearIncognitoTabListForReauth() {
        if (!mTabModelSelector.isIncognitoSelected()) return false;

        if (mIncognitoReauthController != null
                && mIncognitoReauthController.isIncognitoReauthPending()) {
            mResetHandler.resetWithTabList(null, false);
            return true;
        }

        return false;
    }

    private void onLayoutStateProviderAvailable(LayoutStateProvider layoutStateProvider) {
        mLayoutStateProvider = layoutStateProvider;
        mLastActiveLayoutType = mLayoutStateProvider.getActiveLayoutType();
        if (mLayoutStateObserver == null) {
            mLayoutStateObserver =
                    new LayoutStateObserver() {
                        @Override
                        public void onFinishedHiding(int layoutType) {
                            mLastActiveLayoutType = layoutType;
                        }

                        @Override
                        public void onStartedShowing(int layoutType) {
                            if (layoutType == LayoutType.TAB_SWITCHER) {
                                mIsTransitionInProgress = true;
                                notifyBackPressStateChangedInternal();
                            }
                        }
                    };
        }
        mLayoutStateProvider.addObserver(mLayoutStateObserver);
    }

    public void setLastActiveLayoutTypeForTesting(@LayoutType int lastActiveLayoutType) {
        mLastActiveLayoutType = lastActiveLayoutType;
    }

    private TabListEditorController getTabListEditorController() {
        return mTabListEditorControllerSupplier == null
                ? null
                : mTabListEditorControllerSupplier.get();
    }

    /**
     * Refresh the tab switcher's tab list and perform an out-of-band update on the UI. If the tab
     * switcher is not visible, this will no-op.
     */
    public void refreshTabList() {
        if (!mContainerViewModel.get(IS_VISIBLE)) return;

        mResetHandler.resetWithTabList(
                mTabModelSelector.getTabModelFilterProvider().getCurrentTabModelFilter(), false);
    }
}