MainViewController.swift

//
//  MainViewController.swift
//  DuckDuckGo
//
//  Copyright © 2017 DuckDuckGo. All rights reserved.
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//

import UIKitExtensions
import WebKit
import WidgetKit
import Combine
import Common
import Core
import DDGSync
import Kingfisher
import BrowserServicesKit
import Bookmarks
import Persistence
import RemoteMessaging
import PrivacyDashboard
import Networking
import Suggestions
import Subscription
import SwiftUI
import VPN
import Onboarding
import os.log
import PageRefreshMonitor
import BrokenSitePrompt
import AIChat
import NetworkExtension
import DesignResourcesKit
import DesignResourcesKitIcons
import Configuration
import PixelKit
import SystemSettingsPiPTutorial
import DataBrokerProtection_iOS
import UserScript
import PrivacyConfig
import WebExtensions

struct StartupOnboardingDecision {
    let shouldShowOnboarding: Bool

    init(onboardingStatus: LaunchOptionsHandler.OnboardingStatus, tutorialSettings: TutorialSettings) {
        switch onboardingStatus {
        case .notOverridden:
            shouldShowOnboarding = !tutorialSettings.hasSeenOnboarding
        case let .overridden(.developer(completed: isOnboardingCompleted)):
            shouldShowOnboarding = !isOnboardingCompleted
        case let .overridden(.uiTests(completed: isOnboardingCompleted)):
            tutorialSettings.hasSeenOnboarding = isOnboardingCompleted
            shouldShowOnboarding = !tutorialSettings.hasSeenOnboarding
        }
    }
}

class MainViewController: UIViewController {

    override var preferredStatusBarStyle: UIStatusBarStyle {
        return ThemeManager.shared.currentTheme.statusBarStyle
    }

    override var preferredScreenEdgesDeferringSystemGestures: UIRectEdge {
        let isIPad = UIDevice.current.userInterfaceIdiom == .pad

        return isIPad ? [.left, .right] : []
    }

    weak var findInPageView: FindInPageView?

    weak var notificationView: UIView?

    var chromeManager: BrowserChromeManager!

#if DEBUG || ALPHA
    var automationServer: AutomationServer?
#endif

    var allowContentUnderflow = false {
        didSet {
            viewCoordinator.constraints.contentContainerTop.constant = allowContentUnderflow ? contentUnderflow : 0
        }
    }

    var contentUnderflow: CGFloat {
        return 3 + (allowContentUnderflow ? -viewCoordinator.navigationBarContainer.frame.size.height : 0)
    }

    var isShowingAutocompleteSuggestions: Bool {
        suggestionTrayController?.isShowingAutocompleteSuggestions == true
    }

    var isUnifiedURLPredictionEnabled: Bool {
        featureFlagger.isFeatureOn(.unifiedURLPredictor)
    }

    lazy var emailManager: EmailManager = {
        let emailManager = EmailManager()
        emailManager.aliasPermissionDelegate = self
        emailManager.requestDelegate = self
        return emailManager
    }()

    var newTabPageViewController: NewTabPageViewController?

    var tabsBarController: TabsBarViewController?
    var suggestionTrayController: SuggestionTrayViewController?

    let homePageConfiguration: HomePageConfiguration
    let remoteMessagingActionHandler: RemoteMessagingActionHandling
    let remoteMessagingImageLoader: RemoteMessagingImageLoading
    let remoteMessagingPixelReporter: RemoteMessagingPixelReporting?
    let whatsNewRepository: WhatsNewMessageRepository
    let tabManager: TabManager
    let previewsSource: TabPreviewsSource
    let appSettings: AppSettings
    let toggleModeStorage: ToggleModeStoring
    var fireExecutor: FireExecuting
    private var launchTabObserver: LaunchTabNotification.Observer?
    var isNewTabPageVisible: Bool {
        newTabPageViewController != nil
    }

    var autoClearInProgress = false
    var autoClearShouldRefreshUIAfterClear = true
    private var hasLoadedInitialView = false
    private weak var burningOverlayView: UIView?
    private var isStartupOnboardingPending = false
    private var hasPresentedStartupOnboarding = false
    private lazy var startupOnboardingCover = StartupOnboardingCover(
        parentViewController: self,
        fallbackBackgroundColor: themeManager.currentTheme.onboardingBackgroundColor
    )

    let privacyConfigurationManager: PrivacyConfigurationManaging

    let bookmarksDatabase: CoreDataDatabase
    private var favoritesViewModel: FavoritesListInteracting
    let syncService: DDGSyncing
    let syncDataProviders: SyncDataProviders
    let syncPausedStateManager: any SyncPausedStateManaging

    let userScriptsDependencies: DefaultScriptSourceProvider.Dependencies
    let contentBlockingAssetsPublisher: AnyPublisher<ContentBlockingUpdating.NewContent, Never>
    let duckAiNativeStorageHandler: DuckAiNativeStorageHandling?

    private let tutorialSettings: TutorialSettings
    private let contextualOnboardingLogic: ContextualOnboardingLogic
    let contextualOnboardingPixelReporter: OnboardingPixelReporting
    private let statisticsStore: StatisticsStore
    let voiceSearchHelper: VoiceSearchHelperProtocol
    let featureFlagger: FeatureFlagger
    let idleReturnEligibilityManager: IdleReturnEligibilityManaging
    let ntpAfterIdleInstrumentation: NTPAfterIdleInstrumentation
    let syncAutoRestoreHandler: SyncAutoRestoreHandling
    private let lastActiveTabStore: LastActiveTabStoring
    private let fireModeCapability: FireModeCapable

    @UserDefaultsWrapper(key: .syncDidShowSyncPausedByFeatureFlagAlert, defaultValue: false)
    private var syncDidShowSyncPausedByFeatureFlagAlert: Bool

    @UserDefaultsWrapper(key: .hadVPNEntitlements, defaultValue: false)
    private var hadVPNEntitlements: Bool

    private var localUpdatesCancellable: AnyCancellable?
    private var syncUpdatesCancellable: AnyCancellable?
    private var syncFeatureFlagsCancellable: AnyCancellable?
    private var favoritesDisplayModeCancellable: AnyCancellable?
    private var emailCancellables = Set<AnyCancellable>()
    private var urlInterceptorCancellables = Set<AnyCancellable>()
    private var settingsDeepLinkcancellables = Set<AnyCancellable>()
    private let tunnelDefaults = UserDefaults.networkProtectionGroupDefaults
    private var vpnCancellables = Set<AnyCancellable>()
    private var feedbackCancellable: AnyCancellable?
    private var aiChatCancellables = Set<AnyCancellable>()
    private var settingsCancellables = Set<AnyCancellable>()
    private var syncRecoveryPromptService: SyncRecoveryPromptService?
    private var currentNTPEscapeHatch: EscapeHatchModel?
    private var hasCompletedInitialLoad = false

    let subscriptionFeatureAvailability: SubscriptionFeatureAvailability
    let subscriptionDataReporter: SubscriptionDataReporting

    let contentScopeExperimentsManager: ContentScopeExperimentsManaging
    private lazy var faviconLoader: FavoritesFaviconLoading = FavoritesFaviconLoader()
    private lazy var faviconsFetcherOnboarding = FaviconsFetcherOnboarding(syncService: syncService, syncBookmarksAdapter: syncDataProviders.bookmarksAdapter)

    private lazy var browsingMenuHeaderDataSource = BrowsingMenuHeaderDataSource()
    private lazy var browsingMenuHeaderStateProvider = BrowsingMenuHeaderStateProvider()

    lazy var menuBookmarksViewModel: MenuBookmarksInteracting = {
        let viewModel = MenuBookmarksViewModel(bookmarksDatabase: bookmarksDatabase, syncService: syncService)
        viewModel.favoritesDisplayMode = appSettings.favoritesDisplayMode
        return viewModel
    }()

    weak var tabSwitcherController: TabSwitcherViewController?
    var tabSwitcherButton: TabSwitcherButton?
    var omniBarTabSwitcherButton: TabSwitcherButton?

    let gestureBookmarksButton = GestureToolbarButton()

    private lazy var fireButtonAnimator: FireButtonAnimator = FireButtonAnimator(appSettings: appSettings)

    let bookmarksCachingSearch: BookmarksCachingSearch

    lazy var tabSwitcherTransition = TabSwitcherTransitionDelegate()
    var currentTab: TabViewController? {
        return tabManager.current(createIfNeeded: false)
    }

    var searchBarRect: CGRect {
        let view = UIApplication.shared.firstKeyWindow?.rootViewController?.view
        return viewCoordinator.omniBar.barView.searchContainer.convert(viewCoordinator.omniBar.barView.searchContainer.bounds, to: view)
    }

    var keyModifierFlags: UIKeyModifierFlags?
    var showKeyboardAfterFireButton: DispatchWorkItem?

    // Skip SERP flow (focusing on autocomplete logic) and prepare for new navigation when selecting search bar
    private var skipSERPFlow = true

    var postClear: (() -> Void)?
    var clearInProgress = false

    required init?(coder: NSCoder) {
        fatalError("Use init?(code:")
    }

    let featureDiscovery: FeatureDiscovery
    let fireproofing: Fireproofing
    let favicons: FaviconManaging
    let websiteDataManager: WebsiteDataManaging
    let textZoomCoordinatorProvider: TextZoomCoordinatorProviding

    var historyManager: HistoryManaging
    var viewCoordinator: MainViewCoordinator!
    let aiChatSettings: AIChatSettingsProvider
    let aiChatAddressBarExperience: AIChatAddressBarExperienceProviding
    let privacyStats: PrivacyStatsProviding

    let customConfigurationURLProvider: CustomConfigurationURLProviding
    let experimentalAIChatManager: ExperimentalAIChatManager
    let daxDialogsManager: DaxDialogsManaging
    let dbpIOSPublicInterface: DBPIOSInterface.PublicInterface?
    let remoteMessagingDebugHandler: RemoteMessagingDebugHandling

    var appDidFinishLaunchingStartTime: CFAbsoluteTime?
    let maliciousSiteProtectionPreferencesManager: MaliciousSiteProtectionPreferencesManaging
    private lazy var themeColorManager: SiteThemeColorManager = {
        SiteThemeColorManager(viewCoordinator: viewCoordinator,
                              currentTabViewController: { [weak self] in self?.currentTab }(),
                              appSettings: appSettings,
                              themeManager: themeManager)
    }()

    private lazy var aiChatViewControllerManager: AIChatViewControllerManager = {
        let manager = AIChatViewControllerManager(privacyConfigurationManager: privacyConfigurationManager,
                                                  contentBlockingAssetsPublisher: contentBlockingAssetsPublisher,
                                                  experimentalAIChatManager: .init(featureFlagger: featureFlagger),
                                                  featureFlagger: featureFlagger,
                                                  featureDiscovery: featureDiscovery,
                                                  aiChatSettings: aiChatSettings,
                                                  productSurfaceTelemetry: productSurfaceTelemetry)
        manager.delegate = self
        manager.isFireModeProvider = { [weak self] in self?.tabManager.currentBrowsingMode == .fire }
        return manager
    }()

    private lazy var browsingMenuSheetCapability = BrowsingMenuSheetCapability.create()

    let themeManager: ThemeManaging
    let keyValueStore: ThrowingKeyValueStoring
    let systemSettingsPiPTutorialManager: SystemSettingsPiPTutorialManaging

    private var duckPlayerEntryPointVisible = false
    private var subscriptionManager = AppDependencyProvider.shared.subscriptionManager
    
    private let daxEasterEggPresenter: DaxEasterEggPresenting
    private let daxEasterEggLogoStore: DaxEasterEggLogoStoring

    private let internalUserCommands: URLBasedDebugCommands = InternalUserCommands()
    private let launchSourceManager: LaunchSourceManaging
    
    let winBackOfferVisibilityManager: WinBackOfferVisibilityManaging
    let mobileCustomization: MobileCustomization
    let productSurfaceTelemetry: ProductSurfaceTelemetry

    private let aichatFullModeFeature: AIChatFullModeFeatureProviding
    private let aichatIPadTabFeature: AIChatIPadTabFeatureProviding
    private let aiChatContextualModeFeature: AIChatContextualModeFeatureProviding
    let voiceShortcutFeature: DuckAIVoiceShortcutFeatureProviding
    lazy var unifiedToggleInputFeature: UnifiedToggleInputFeatureProviding = UnifiedToggleInputFeature()
    lazy var minimalChromeSettings: MinimalChromeSettingsProviding = MinimalChromeSettings()
    var unifiedToggleInputCoordinator: UnifiedToggleInputCoordinator?
    var unifiedToggleInputCancellables = Set<AnyCancellable>()
    var aiChatTabChatHeaderView: AIChatTabChatHeaderView?

    // MARK: - iPad Tab Mode Chat History
    private lazy var iPadTabChatHistoryCoordinator = IPadTabChatHistoryCoordinator(
        featureFlagger: featureFlagger,
        privacyConfigurationManager: privacyConfigurationManager,
        aiChatSettings: aiChatSettings,
        iPadTabFeature: aichatIPadTabFeature
    )
    private var iPadAIChatQuery = ""
    private var allowIPadAIAutocompleteShow = false
    private var isAwaitingIPadHistoryRefreshAfterModeSwitch = false

    private(set) var webExtensionEventsCoordinator: WebExtensionEventsCoordinator?
    func setWebExtensionEventsCoordinator(_ coordinator: WebExtensionEventsCoordinator?) {
        self.webExtensionEventsCoordinator = coordinator
    }

    private(set) var webExtensionManager: WebExtensionManaging?
    func setWebExtensionManager(_ manager: WebExtensionManaging?) {
        self.webExtensionManager = manager
    }

    private(set) var darkReaderFeatureSettings: DarkReaderFeatureSettings
    private let fireModePromotionEligibility: FireModePromotionCoordinating?

    init(
        privacyConfigurationManager: PrivacyConfigurationManaging,
        bookmarksDatabase: CoreDataDatabase,
        historyManager: HistoryManaging,
        homePageConfiguration: HomePageConfiguration,
        syncService: DDGSyncing,
        syncDataProviders: SyncDataProviders,
        userScriptsDependencies: DefaultScriptSourceProvider.Dependencies,
        contentBlockingAssetsPublisher: AnyPublisher<ContentBlockingUpdating.NewContent, Never>,
        duckAiNativeStorageHandler: DuckAiNativeStorageHandling? = nil,
        appSettings: AppSettings,
        previewsSource: TabPreviewsSource,
        tabManager: TabManager,
        syncPausedStateManager: any SyncPausedStateManaging,
        subscriptionDataReporter: SubscriptionDataReporting,
        contextualOnboardingLogic: ContextualOnboardingLogic,
        contextualOnboardingPixelReporter: OnboardingPixelReporting,
        tutorialSettings: TutorialSettings = DefaultTutorialSettings(),
        statisticsStore: StatisticsStore = StatisticsUserDefaults(),
        subscriptionFeatureAvailability: SubscriptionFeatureAvailability,
        voiceSearchHelper: VoiceSearchHelperProtocol,
        featureFlagger: FeatureFlagger,
        idleReturnEligibilityManager: IdleReturnEligibilityManaging,
        lastActiveTabStore: LastActiveTabStoring = LastActiveTabStore(),
        syncAutoRestoreHandler: SyncAutoRestoreHandling,
        contentScopeExperimentsManager: ContentScopeExperimentsManaging,
        fireproofing: Fireproofing,
        favicons: FaviconManaging,
        textZoomCoordinatorProvider: TextZoomCoordinatorProviding,
        websiteDataManager: WebsiteDataManaging,
        appDidFinishLaunchingStartTime: CFAbsoluteTime?,
        maliciousSiteProtectionPreferencesManager: MaliciousSiteProtectionPreferencesManaging,
        aiChatSettings: AIChatSettingsProvider,
        aiChatAddressBarExperience: AIChatAddressBarExperienceProviding,
        experimentalAIChatManager: ExperimentalAIChatManager = ExperimentalAIChatManager(),
        featureDiscovery: FeatureDiscovery = DefaultFeatureDiscovery(wasUsedBeforeStorage: UserDefaults.standard),
        themeManager: ThemeManaging,
        keyValueStore: ThrowingKeyValueStoring,
        customConfigurationURLProvider: CustomConfigurationURLProviding,
        systemSettingsPiPTutorialManager: SystemSettingsPiPTutorialManaging,
        daxDialogsManager: DaxDialogsManaging,
        daxEasterEggPresenter: DaxEasterEggPresenting? = nil,
        daxEasterEggLogoStore: DaxEasterEggLogoStoring = DaxEasterEggLogoStore(),
        dbpIOSPublicInterface: DBPIOSInterface.PublicInterface?,
        launchSourceManager: LaunchSourceManaging,
        winBackOfferVisibilityManager: WinBackOfferVisibilityManaging,
        aichatFullModeFeature: AIChatFullModeFeatureProviding = AIChatFullModeFeature(),
        aichatIPadTabFeature: AIChatIPadTabFeatureProviding = AIChatIPadTabFeature(),
        mobileCustomization: MobileCustomization,
        remoteMessagingActionHandler: RemoteMessagingActionHandling,
        remoteMessagingImageLoader: RemoteMessagingImageLoading,
        remoteMessagingPixelReporter: RemoteMessagingPixelReporting?,
        productSurfaceTelemetry: ProductSurfaceTelemetry,
        fireExecutor: FireExecuting,
        remoteMessagingDebugHandler: RemoteMessagingDebugHandling,
        privacyStats: PrivacyStatsProviding,
        aiChatContextualModeFeature: AIChatContextualModeFeatureProviding = AIChatContextualModeFeature(),
        whatsNewRepository: WhatsNewMessageRepository,
        darkReaderFeatureSettings: DarkReaderFeatureSettings,
        voiceShortcutFeature: DuckAIVoiceShortcutFeatureProviding = DuckAIVoiceShortcutFeature(),
        toggleModeStorage: ToggleModeStoring = ToggleModeStorage(),
        fireModePromotionEligibility: FireModePromotionCoordinating? = nil
    ) {
        self.remoteMessagingActionHandler = remoteMessagingActionHandler
        self.remoteMessagingImageLoader = remoteMessagingImageLoader
        self.remoteMessagingPixelReporter = remoteMessagingPixelReporter
        self.privacyConfigurationManager = privacyConfigurationManager
        self.bookmarksDatabase = bookmarksDatabase
        self.historyManager = historyManager
        self.homePageConfiguration = homePageConfiguration
        self.syncService = syncService
        self.syncDataProviders = syncDataProviders
        self.userScriptsDependencies = userScriptsDependencies
        self.contentBlockingAssetsPublisher = contentBlockingAssetsPublisher
        self.duckAiNativeStorageHandler = duckAiNativeStorageHandler
        self.favoritesViewModel = FavoritesListViewModel(bookmarksDatabase: bookmarksDatabase, favoritesDisplayMode: appSettings.favoritesDisplayMode)
        self.bookmarksCachingSearch = BookmarksCachingSearch(bookmarksStore: CoreDataBookmarksSearchStore(bookmarksStore: bookmarksDatabase))
        self.appSettings = appSettings
        self.aiChatSettings = aiChatSettings
        self.aiChatAddressBarExperience = aiChatAddressBarExperience
        self.experimentalAIChatManager = experimentalAIChatManager
        self.previewsSource = previewsSource
        self.tabManager = tabManager
        self.featureDiscovery = featureDiscovery
        self.themeManager = themeManager
        self.syncPausedStateManager = syncPausedStateManager
        self.subscriptionDataReporter = subscriptionDataReporter
        self.tutorialSettings = tutorialSettings
        self.contextualOnboardingLogic = contextualOnboardingLogic
        self.contextualOnboardingPixelReporter = contextualOnboardingPixelReporter
        self.statisticsStore = statisticsStore
        self.subscriptionFeatureAvailability = subscriptionFeatureAvailability
        self.voiceSearchHelper = voiceSearchHelper
        self.featureFlagger = featureFlagger
        self.idleReturnEligibilityManager = idleReturnEligibilityManager
        self.lastActiveTabStore = lastActiveTabStore
        self.ntpAfterIdleInstrumentation = DefaultNTPAfterIdleInstrumentation(eligibilityManager: idleReturnEligibilityManager)
        self.syncAutoRestoreHandler = syncAutoRestoreHandler
        self.fireproofing = fireproofing
        self.favicons = favicons
        self.textZoomCoordinatorProvider = textZoomCoordinatorProvider
        self.websiteDataManager = websiteDataManager
        self.appDidFinishLaunchingStartTime = appDidFinishLaunchingStartTime
        self.maliciousSiteProtectionPreferencesManager = maliciousSiteProtectionPreferencesManager
        self.contentScopeExperimentsManager = contentScopeExperimentsManager
        self.keyValueStore = keyValueStore
        self.customConfigurationURLProvider = customConfigurationURLProvider
        self.systemSettingsPiPTutorialManager = systemSettingsPiPTutorialManager
        self.daxDialogsManager = daxDialogsManager
        self.daxEasterEggLogoStore = daxEasterEggLogoStore
        self.daxEasterEggPresenter = daxEasterEggPresenter ?? DaxEasterEggPresenter(logoStore: daxEasterEggLogoStore, featureFlagger: featureFlagger)
        self.dbpIOSPublicInterface = dbpIOSPublicInterface
        self.launchSourceManager = launchSourceManager
        self.winBackOfferVisibilityManager = winBackOfferVisibilityManager
        self.mobileCustomization = mobileCustomization
        self.aichatFullModeFeature = aichatFullModeFeature
        self.aichatIPadTabFeature = aichatIPadTabFeature
        self.remoteMessagingDebugHandler = remoteMessagingDebugHandler
        self.productSurfaceTelemetry = productSurfaceTelemetry
        self.privacyStats = privacyStats
        self.fireExecutor = fireExecutor
        self.aiChatContextualModeFeature = aiChatContextualModeFeature
        self.whatsNewRepository = whatsNewRepository
        self.darkReaderFeatureSettings = darkReaderFeatureSettings
        self.voiceShortcutFeature = voiceShortcutFeature
        self.toggleModeStorage = toggleModeStorage
        self.fireModeCapability = FireModeCapability.create()
        self.fireModePromotionEligibility = fireModePromotionEligibility

        super.init(nibName: nil, bundle: nil)
        
        tabManager.delegate = self
        tabManager.aiChatContentDelegate = self
        tabManager.fireModeDelegate = self
        self.fireExecutor.delegate = self
        bindSyncService()
    }

    func loadFindInPage() {

        let view = FindInPageView.loadFromXib()
        self.view.addSubview(view)

        let container = view.container!

        // Avoids coercion swiftlint warnings
        let superview = self.view!

        NSLayoutConstraint.activate([

            container.bottomAnchor.constraint(equalTo: superview.keyboardLayoutGuide.topAnchor),
            view.bottomAnchor.constraint(equalTo: superview.bottomAnchor),
            view.heightAnchor.constraint(greaterThanOrEqualToConstant: 0),
            view.trailingAnchor.constraint(equalTo: superview.trailingAnchor),
            view.leadingAnchor.constraint(equalTo: superview.leadingAnchor),

        ])

        findInPageView = view

        findInPageView?.delegate = self

        updateFindInPage()
    }
    
    var swipeTabsCoordinator: SwipeTabsCoordinator?
    private var expandedOmniBarDismissTapGesture: UITapGestureRecognizer?

    lazy var newTabDaxDialogFactory: NewTabDaxDialogsProvider = {
        NewTabDaxDialogsProvider(
            featureFlagger: featureFlagger,
            delegate: self,
            daxDialogsFlowCoordinator: daxDialogsManager,
            onboardingPixelReporter: contextualOnboardingPixelReporter)
    }()

    lazy var newTabPageDependencies: SuggestionTrayViewController.NewTabPageDependencies = {
        SuggestionTrayViewController.NewTabPageDependencies(
            favoritesModel: favoritesViewModel,
            homePageMessagesConfiguration: homePageConfiguration,
            subscriptionDataReporting: subscriptionDataReporter,
            newTabDialogFactory: newTabDaxDialogFactory,
            newTabDaxDialogManager: daxDialogsManager,
            faviconLoader: faviconLoader,
            faviconsCache: favicons,
            remoteMessagingActionHandler: remoteMessagingActionHandler,
            remoteMessagingImageLoader: remoteMessagingImageLoader,
            remoteMessagingPixelReporter: remoteMessagingPixelReporter,
            fireModePromotionEligibility: fireModePromotionEligibility,
            appSettings: appSettings,
            subscriptionManager: subscriptionManager,
            internalUserCommands: internalUserCommands)
    }()

    lazy var suggestionTrayDependencies: SuggestionTrayDependencies = {
        SuggestionTrayDependencies(
            favoritesViewModel: favoritesViewModel,
            bookmarksDatabase: bookmarksDatabase,
            historyManager: historyManager,
            tabsModelProvider: { self.tabManager.currentTabsModel },
            featureFlagger: featureFlagger,
            appSettings: appSettings,
            aiChatSettings: aiChatSettings,
            featureDiscovery: featureDiscovery,
            newTabPageDependencies: newTabPageDependencies,
            productSurfaceTelemetry: productSurfaceTelemetry)
    }()

    override func viewDidLoad() {
        super.viewDidLoad()

        viewCoordinator = MainViewFactory.createViewHierarchy(self,
                                                              aiChatSettings: aiChatSettings,
                                                              aiChatAddressBarExperience: aiChatAddressBarExperience,
                                                              voiceSearchHelper: voiceSearchHelper,
                                                              featureFlagger: featureFlagger,
                                                              suggestionTrayDependencies: suggestionTrayDependencies,
                                                              appSettings: appSettings,
                                                              mobileCustomization: mobileCustomization)

        if featureFlagger.isFeatureOn(.iPadAIToggle) {
            viewCoordinator.navigationBarContainer.allowsOverflowHitTesting = true
            viewCoordinator.navigationBarCollectionView.allowsOverflowHitTesting = true
        }

        viewCoordinator.moveAddressBarToPosition(appSettings.currentAddressBarPosition)

        setUpToolbarButtonsActions()
        installSwipeTabs()
            
        loadSuggestionTray()
        loadTabsBarIfNeeded()
        attachOmniBar()

        view.addInteraction(UIDropInteraction(delegate: self))
        
        chromeManager = BrowserChromeManager()
        chromeManager.delegate = self
        initTabButton()
        initBookmarksButton()
        setUpUnifiedToggleInputIfNeeded()
        configureStartupPresentation()
        previewsSource.prepare()
        addLaunchTabNotificationObserver()
        subscribeToEmailProtectionStatusNotifications()
        subscribeToURLInterceptorNotifications()
        subscribeToSettingsDeeplinkNotifications()
        subscribeToNetworkProtectionEvents()
        subscribeToUnifiedFeedbackNotifications()
        subscribeToAIChatSettingsEvents()
        subscribeToRefreshButtonSettingsEvents()
        subscribeToCustomizationSettingsEvents()
        subscribeToDaxEasterEggLogoChanges()

        checkSubscriptionEntitlements()

        registerForKeyboardNotifications()
        registerForPageRefreshPatterns()
        registerForSyncFeatureFlagsUpdates()
        registerForWebExtensionNotifications()
        registerForAppBackgroundNotification()

        decorate()

        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)

        _ = AppWidthObserver.shared.willResize(toWidth: view.frame.width)
        applyWidth()

        registerForApplicationEvents()
        registerForCookiesManagedNotification()
        registerForSettingsChangeNotifications()

        tabManager.cleanupTabsFaviconCache()

        // Needs to be called here to established correct view hierarchy
        refreshViewsBasedOnAddressBarPosition(appSettings.currentAddressBarPosition)
        applyCustomizationState()

        mobileCustomization.delegate = self

        installContextualSheetDismissGesture()
    }

    private func configureStartupPresentation() {
        let startupOnboardingDecision = StartupOnboardingDecision(
            onboardingStatus: LaunchOptionsHandler().onboardingStatus,
            tutorialSettings: tutorialSettings
        )

        isStartupOnboardingPending = startupOnboardingDecision.shouldShowOnboarding

        if isStartupOnboardingPending {
            startupOnboardingCover.attach()
        }

        loadInitialViewIfNeeded()
    }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        loadFindInPage()

        productSurfaceTelemetry.dailyActiveUser()
        productSurfaceTelemetry.iPadUsed(isPad: isPad)

        defer {
            if let appDidFinishLaunchingStartTime {
                let launchTime = CFAbsoluteTimeGetCurrent() - appDidFinishLaunchingStartTime
                Pixel.fire(pixel: .appDidShowUITime(time: Pixel.Event.BucketAggregation(number: launchTime)),
                           withAdditionalParameters: [PixelParameters.time: String(launchTime)])
                self.appDidFinishLaunchingStartTime = nil /// We only want this pixel to be fired once
            }
        }

        // Always hide this, we use StyledTopBottomBorderView where needed instead
        viewCoordinator.hideToolbarSeparator()

        // Needs to be called here because sometimes the frames are not the expected size during didLoad
        refreshViewsBasedOnAddressBarPosition(appSettings.currentAddressBarPosition)

        startOnboardingFlowIfNotSeenBefore()
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)

        _ = AppWidthObserver.shared.willResize(toWidth: view.frame.width)
        applyWidth()

        if daxDialogsManager.shouldShowFireButtonPulse {
            showFireButtonPulse()
        }

        presentSyncRecoveryPromptIfNeeded()

        // Should be safe to call anyway but only really need for this specific scenario
        if #available(iOS 26, *), isPad {
            view.setNeedsUpdateConstraints()
        }
    }

    override func performSegue(withIdentifier identifier: String, sender: Any?) {
        assertionFailure()
        super.performSegue(withIdentifier: identifier, sender: sender)
    }

    private func fireExperimentalAddressBarPixel() {
        let isEnabledParam = "is_enabled"
        let isEnableValue = "\(aiChatSettings.isAIChatSearchInputUserSettingsEnabled)"

        DailyPixel.fireDaily(.aiChatExperimentalAddressBarIsEnabledDaily,
                             withAdditionalParameters: [isEnabledParam: isEnableValue])

    }

    private func fireIPadToggleStateOnAppOpenPixel() {
        guard aiChatAddressBarExperience.isIPadAIToggleExperienceEnabled else { return }

        let pixel: Pixel.Event = aiChatAddressBarExperience.shouldShowModeToggle ? .aiChatIPadToggleEnabledOnAppOpen : .aiChatIPadToggleDisabledOnAppOpen
        DailyPixel.fireDailyAndCount(pixel: pixel)
    }

    private func fireContextualAutoAttachPixel() {
        let isEnabled = "\(aiChatSettings.isAutomaticContextAttachmentEnabled)"
        DailyPixel.fireDaily(.aiChatContextualAutoAttachDAU,
                             withAdditionalParameters: ["is_enabled": isEnabled])
    }

    private func fireAIChatIsEnabledPixel() {
        let isEnabled = "\(aiChatSettings.isAIChatEnabled)"
        DailyPixel.fireDaily(.aiChatIsEnabledDaily,
                             withAdditionalParameters: ["is_enabled": isEnabled])
    }
    
    private func fireKeyboardSettingsPixels() {
        let keyboardSettings = KeyboardSettings()
        let isEnabledParam = "is_enabled"
        
        let onNewTabValue = "\(keyboardSettings.onNewTab)"
        DailyPixel.fireDaily(.keyboardSettingsOnNewTabEnabledDaily,
                             withAdditionalParameters: [isEnabledParam: onNewTabValue])
        
        let onAppLaunchValue = "\(keyboardSettings.onAppLaunch)"
        DailyPixel.fireDaily(.keyboardSettingsOnAppLaunchEnabledDaily,
                             withAdditionalParameters: [isEnabledParam: onAppLaunchValue])
    }

    private func installSwipeTabs() {
        guard swipeTabsCoordinator == nil else { return }

        let omnibarDependencies = OmnibarDependencies(voiceSearchHelper: voiceSearchHelper,
                                                      featureFlagger: featureFlagger,
                                                      aichatIPadTabFeature: aichatIPadTabFeature,
                                                      aiChatSettings: aiChatSettings,
                                                      aiChatAddressBarExperience: aiChatAddressBarExperience,
                                                      appSettings: appSettings,
                                                      daxEasterEggPresenter: daxEasterEggPresenter,
                                                      mobileCustomization: mobileCustomization)

        swipeTabsCoordinator = SwipeTabsCoordinator(coordinator: viewCoordinator,
                                                    tabPreviewsSource: previewsSource,
                                                    appSettings: appSettings,
                                                    omnibarDependencies: omnibarDependencies) { [weak self] in

            guard $0 !== self?.tabManager.currentTabsModel.currentTab else { return }

            DailyPixel.fire(pixel: .swipeTabsUsedDaily)
            self?.currentTab?.aiChatContextualSheetCoordinator.dismissSheet()
            self?.selectTab($0)

        } newTab: { [weak self] in
            Pixel.fire(pixel: .swipeToOpenNewTab)
            self?.currentTab?.aiChatContextualSheetCoordinator.dismissSheet()
            self?.newTab()
        } onSwipeStarted: { [weak self] in
            self?.performCancel()
            self?.hideKeyboard()
            self?.updatePreviewForCurrentTab()
        }
    }

    func updatePreviewForCurrentTab(completion: (() -> Void)? = nil) {
        assert(Thread.isMainThread)
        
        if !viewCoordinator.logoContainer.isHidden,
           self.tabManager.current()?.link == nil,
           let tab = self.tabManager.currentTabsModel.currentTab {
            // Home screen with logo
            if let image = viewCoordinator.logoContainer.createImageSnapshot(inBounds: viewCoordinator.contentContainer.frame) {
                previewsSource.update(preview: image, forTab: tab)
                completion?()
            }

        } else if let currentTab = self.tabManager.current(), currentTab.link != nil {
            // Web view
            currentTab.preparePreview(completion: { image in
                guard let image else { return }
                self.previewsSource.update(preview: image,
                                           forTab: currentTab.tabModel)
                completion?()
            })
        } else if let tab = self.tabManager.currentTabsModel.currentTab {
            // Favorites, etc
            if let image = viewCoordinator.contentContainer.createImageSnapshot() {
                previewsSource.update(preview: image, forTab: tab)
                completion?()
            }
        } else {
            completion?()
        }
    }

    func loadSuggestionTray() {

        let controller = SuggestionTrayViewController(favoritesViewModel: self.favoritesViewModel,
                                     bookmarksDatabase: self.bookmarksDatabase,
                                     historyManager: self.historyManager,
                                     tabsModelProvider: { self.tabManager.currentTabsModel },
                                     featureFlagger: self.featureFlagger,
                                     appSettings: self.appSettings,
                                     aiChatSettings: self.aiChatSettings,
                                     featureDiscovery: self.featureDiscovery,
                                     newTabPageDependencies: self.newTabPageDependencies,
                                     productSurfaceTelemetry: self.productSurfaceTelemetry,
                                     hideBorder: false)

        controller.view.frame = viewCoordinator.suggestionTrayContainer.bounds
        controller.newTabPageControllerDelegate = self
        viewCoordinator.suggestionTrayContainer.addSubview(controller.view)

        controller.dismissHandler = dismissSuggestionTray
        controller.autocompleteDelegate = self
        suggestionTrayController = controller
    }

    func loadTabsBarIfNeeded() {
        guard isPad else { return }

        let controller = TabsBarViewController.createFromXib()

        addChild(controller)
        controller.view.frame = viewCoordinator.tabBarContainer.bounds
        controller.delegate = self
        controller.historyManager = historyManager
        controller.fireproofing = fireproofing
        controller.aiChatSettings = aiChatSettings
        controller.keyValueStore = keyValueStore
        controller.tabManager = tabManager
        controller.daxDialogsManager = daxDialogsManager
        controller.fireModeCapability = fireModeCapability
        viewCoordinator.tabBarContainer.addSubview(controller.view)
        tabsBarController = controller
        controller.didMove(toParent: self)
    }

    func startAddFavoriteFlow() {
        contextualOnboardingLogic.enableAddFavoriteFlow()
        if tutorialSettings.hasSeenOnboarding {
            newTab()
        }
    }
    
    func startOnboardingFlowIfNotSeenBefore() {
        guard isStartupOnboardingPending, !hasPresentedStartupOnboarding else { return }
        hasPresentedStartupOnboarding = true
        startupOnboardingCover.bringToFront()
        segueToDaxOnboarding { [weak self] in
            self?.startupOnboardingCover.detach()
        }
    }

    func presentSyncRecoveryPromptIfNeeded() {
        syncRecoveryPromptService = SyncRecoveryPromptService(
            featureFlagger: featureFlagger,
            syncService: syncService,
            keyValueStore: keyValueStore,
            isOnboardingComplete: !needsToShowOnboardingIntro()
        )

        guard let syncRecoveryPromptService = syncRecoveryPromptService else { return }

        syncRecoveryPromptService.tryPresentSyncRecoveryPrompt(
            from: self,
            onSyncFlowSelected: { [weak self] source in
                self?.segueToSettingsSync(with: source)
            }
        )
    }

    func presentNetworkProtectionStatusSettingsModal() {
        Task {
            if let canShowVPNInUI = try? await subscriptionManager.isFeatureIncludedInSubscription(.networkProtection),
               canShowVPNInUI {
                segueToVPN()
            } else {
                segueToDuckDuckGoSubscription()
            }
        }
    }

    func presentDataBrokerProtectionDashboard() {
        segueToDataBrokerProtection()
    }

    private func registerForKeyboardNotifications() {
        NotificationCenter.default.addObserver(self,
                                               selector: #selector(keyboardWillChangeFrame),
                                               name: UIResponder.keyboardWillChangeFrameNotification,
                                               object: nil)

        NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide),
                                               name: UIResponder.keyboardWillHideNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(keyboardDidShow),
                                               name: UIResponder.keyboardDidShowNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(keyboardDidHide),
                                               name: UIResponder.keyboardDidHideNotification, object: nil)
    }


    var keyboardShowing = false
    private var didSendGestureDismissPixel: Bool = false
    var latestKeyboardFrame: CGRect = .zero

    @objc
    private func keyboardDidShow() {
        keyboardShowing = true
        productSurfaceTelemetry.keyboardActive()
        dismissContextualSheetIfKeyboardIsForBackgroundContent()
    }

    private func dismissContextualSheetIfKeyboardIsForBackgroundContent() {
        guard let currentTab,
              currentTab.aiChatContextualSheetCoordinator.isSheetPresented,
              let sheetVC = currentTab.aiChatContextualSheetCoordinator.sheetViewController else {
            return
        }

        // Check if first responder is within the sheet's view hierarchy
        if let firstResponder = UIResponder.currentFirstResponder(),
           firstResponder.isInViewHierarchy(of: sheetVC.view) {
            // Keyboard is for the sheet, don't dismiss
            return
        }

        // Keyboard is for background content (web view), dismiss the sheet
        currentTab.aiChatContextualSheetCoordinator.dismissSheet()
    }

    @objc
    private func keyboardWillHide() {
        if !didSendGestureDismissPixel, newTabPageViewController?.isDragging == true, keyboardShowing {
            Pixel.fire(pixel: .addressBarGestureDismiss)
            didSendGestureDismissPixel = true
        }
        collapseExpandedUTIOnKeyboardDismiss()
    }

    private func collapseExpandedUTIOnKeyboardDismiss() {
        guard unifiedToggleInputFeature.isAvailable,
              currentTab?.isAITab == true,
              let coordinator = unifiedToggleInputCoordinator,
              coordinator.shouldCollapseOnKeyboardDismiss,
              currentTab?.aiChatContextualSheetCoordinator.isSheetPresented != true else { return }
        coordinator.showCollapsed()
    }

    @objc
    private func keyboardDidHide() {
        keyboardShowing = false
        didSendGestureDismissPixel = false

        if #available(iOS 26, *) {
            latestKeyboardFrame = .zero
            adjustUI(withKeyboardFrame: .zero)
        }
    }

    private var isAnyAITabUTIState: Bool {
        guard unifiedToggleInputFeature.isAvailable,
              currentTab?.isAITab == true else { return false }
        return unifiedToggleInputCoordinator?.isAITabState == true
    }

    var isNavigationBarEffectivelyAtBottom: Bool {
        if appSettings.currentAddressBarPosition.isBottom {
            return true
        }
        return isAnyAITabUTIState
    }

    private func setUpToolbarButtonsActions() {

        viewCoordinator.toolbarBackButton.setCustomItemAction(on: self, action: #selector(onBackPressed))
        viewCoordinator.toolbarForwardButton.setCustomItemAction(on: self, action: #selector(onForwardPressed))
        viewCoordinator.toolbarPasswordsButton.setCustomItemAction(on: self, action: #selector(onPasswordsPressed))
        viewCoordinator.toolbarBookmarksButton.setCustomItemAction(on: self, action: #selector(onToolbarBookmarksPressed))
        viewCoordinator.menuToolbarButton.setCustomItemAction(on: self, action: #selector(onMenuPressed))

        viewCoordinator.toolbarFireBarButtonItem.setCustomItemAction(on: self, action: #selector(performCustomizationActionForToolbar))

        viewCoordinator.menuToolbarButton.customView?
            .addGestureRecognizer(UILongPressGestureRecognizer(target: self, action: #selector(onMenuLongPressed)))
    }

    private func registerForPageRefreshPatterns() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(attemptToShowBrokenSitePrompt(_:)),
            name: .pageRefreshMonitorDidDetectRefreshPattern,
            object: nil)
    }

    private func registerForSyncFeatureFlagsUpdates() {
        syncFeatureFlagsCancellable = syncService.featureFlagsPublisher
            .dropFirst()
            .map { $0.contains(.dataSyncing) }
            .receive(on: DispatchQueue.main)
            .sink { [weak self] isDataSyncingAvailable in
                guard let self else {
                    return
                }
                if isDataSyncingAvailable {
                    self.syncDidShowSyncPausedByFeatureFlagAlert = false
                } else if self.syncService.authState == .active, !self.syncDidShowSyncPausedByFeatureFlagAlert {
                    self.showSyncPausedByFeatureFlagAlert()
                    self.syncDidShowSyncPausedByFeatureFlagAlert = true
                }
            }
    }

    private func showSyncPausedByFeatureFlagAlert(upgradeRequired: Bool = false) {
        let title = UserText.syncPausedTitle
        let description = upgradeRequired ? UserText.syncUnavailableMessageUpgradeRequired : UserText.syncUnavailableMessage
        if self.presentedViewController is SyncSettingsViewController {
            return
        }
        self.presentedViewController?.dismiss(animated: true)
        let alert = UIAlertController(title: title,
                                      message: description,
                                      preferredStyle: .alert)
        if syncService.featureFlags.contains(.userInterface) {
            let learnMoreAction = UIAlertAction(title: UserText.syncPausedAlertLearnMoreButton, style: .default) { _ in
                self.segueToSettingsSync()
            }
            alert.addAction(learnMoreAction)
        }
        alert.addAction(UIAlertAction(title: UserText.syncPausedAlertOkButton, style: .cancel))
        self.present(alert, animated: true)
    }

    func registerForSettingsChangeNotifications() {
        NotificationCenter.default.addObserver(self, selector:
                                                #selector(onAddressBarPositionChanged),
                                               name: AppUserDefaults.Notifications.addressBarPositionChanged,
                                               object: nil)
        NotificationCenter.default.addObserver(self,
                                               selector: #selector(onShowFullURLAddressChanged),
                                               name: AppUserDefaults.Notifications.showsFullURLAddressSettingChanged,
                                               object: nil)
        NotificationCenter.default.addObserver(self,
                                               selector: #selector(refreshViewsBasedOnDuckPlayerPresentation),
                                               name: DuckPlayerNativeUIPresenter.Notifications.duckPlayerPillUpdated,
                                               object: nil)
    }

    private func registerForWebExtensionNotifications() {
        if #available(iOS 18.4, *) {
            NotificationCenter.default.addObserver(
                forName: .webExtensionAutoconsentDashboardStateRefresh,
                object: nil,
                queue: .main
            ) { [weak self] notification in
                self?.handleWebExtensionDashboardStateRefresh(notification)
            }
        }
    }

    @available(iOS 18.4, *)
    @objc private func handleWebExtensionDashboardStateRefresh(_ notification: Notification) {
        guard let domain = notification.userInfo?[AutoconsentNotification.UserInfoKeys.domain] as? String,
              let consentStatus = notification.userInfo?[AutoconsentNotification.UserInfoKeys.consentStatus] as? ConsentStatusInfo,
              currentTab?.url?.host == domain else {
            return
        }
        currentTab?.privacyInfo?.cookieConsentManaged = consentStatus.toCookieConsentInfo()
    }

    private func registerForAppBackgroundNotification() {
        NotificationCenter.default.addObserver(self,
                                               selector: #selector(onAppDidEnterBackground),
                                               name: UIApplication.didEnterBackgroundNotification,
                                               object: nil)
    }

    @objc private func onAppDidEnterBackground() {
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.appBackgroundedFromNTP(afterIdle: tab.openedAfterIdle)
        }

        /// Resign the web view's first responder when backgrounding with the tab switcher
        /// visible. The tab switcher uses .overCurrentContext so the WKWebView stays in the
        /// hierarchy; without this, the web process restores focus on foreground and the
        /// keyboard appears on top of the tab switcher.
        /// https://app.asana.com/1/137249556945/project/414709148257752/task/1213823670012997?focus=true
        if tabSwitcherController != nil {
            currentTab?.webView.resignFirstResponder()
        }
    }

    @objc func onAddressBarPositionChanged() {
        if !isAnyAITabUTIState {
            viewCoordinator.moveAddressBarToPosition(appSettings.currentAddressBarPosition)
            refreshViewsBasedOnAddressBarPosition(appSettings.currentAddressBarPosition)
        }
        if isInMinimalChromeLayout {
            applyMinimalChromeWidth()
        }
        updateStatusBarBackgroundColor()
        themeColorManager.updateThemeColor()
    }

    @objc private func onShowFullURLAddressChanged() {
        refreshOmniBar()
    }

    @objc func refreshViewsBasedOnDuckPlayerPresentation(notification: Notification) {
        guard let isVisible = notification.userInfo?[DuckPlayerNativeUIPresenter.NotificationKeys.isVisible] as? Bool else { return }
        duckPlayerEntryPointVisible = isVisible
        refreshViewsBasedOnAddressBarPosition(appSettings.currentAddressBarPosition)
    }

    func refreshViewsBasedOnAddressBarPosition(_ position: AddressBarPosition) {
        switch position {
        case .top:
            swipeTabsCoordinator?.addressBarPositionChanged(isTop: true)
            if shouldResetNavBarContainerBottomForTopPosition() {
                viewCoordinator.constraints.navigationBarContainerBottom.isActive = false
            }

        case .bottom:
            swipeTabsCoordinator?.addressBarPositionChanged(isTop: false)
        }

        omniBar.adjust(for: position)
        adjustNewTabPageSafeAreaInsets(for: position)
        updateChromeForDuckPlayer()
    }

    private func shouldResetNavBarContainerBottomForTopPosition() -> Bool {
        return unifiedToggleInputCoordinator?.isActive != true
    }

    private func updateChromeForDuckPlayer() {
        themeColorManager.updateThemeColor()
        let position = appSettings.currentAddressBarPosition
        switch position {
        case .top: break // no-op
        case .bottom:
            // Use higher delays then refreshViewsBasedOnAddressBarPosition
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.31) {
                if self.duckPlayerEntryPointVisible {
                    self.viewCoordinator.omniBar.hideSeparator()
                } else {
                    self.viewCoordinator.omniBar.showSeparator()
                }
            }
        }
    }

    private func adjustNewTabPageSafeAreaInsets(for addressBarPosition: AddressBarPosition) {
        switch addressBarPosition {
        case .top:
            newTabPageViewController?.additionalSafeAreaInsets = .zero
        case .bottom:
            newTabPageViewController?.additionalSafeAreaInsets = .init(top: 0, left: 0, bottom: viewCoordinator.omniBar.barView.expectedHeight, right: 0)
        }
    }

    @objc func onShowFullSiteAddressChanged() {
        refreshOmniBar()
    }

    /// Based on https://stackoverflow.com/a/46117073/73479
    ///  Handles iPhone X devices properly.
    @objc private func keyboardWillChangeFrame(_ notification: Notification) {

        guard let userInfo = notification.userInfo,
            let keyboardFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue else {
            return
        }

        latestKeyboardFrame = keyboardFrame
        let duration: TimeInterval = (userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve = UIView.AnimationOptions(rawValue: animationCurveRaw)

        adjustUI(withKeyboardFrame: keyboardFrame, in: duration, animationCurve: animationCurve)
    }

    func adjustUI(withKeyboardFrame keyboardFrame: CGRect, in duration: TimeInterval = 0.2, animationCurve: UIView.AnimationOptions = .curveEaseInOut) {
        var keyboardHeight = keyboardFrame.size.height

        let omniBarHeight = viewCoordinator.omniBar.barView.expectedHeight
        let keyboardFrameInView = view.convert(keyboardFrame, from: nil)
        let safeAreaFrame = view.safeAreaLayoutGuide.layoutFrame.insetBy(dx: 0, dy: -additionalSafeAreaInsets.bottom)
        let intersection = safeAreaFrame.intersection(keyboardFrameInView)
        let keyboardVisible = intersection.height > 0
        keyboardHeight = keyboardFrameInView.height
        updateUnifiedToggleInputKeyboardVisibility(keyboardVisible)

        let coordinator = unifiedToggleInputCoordinator
        let isAITabCollapsed = coordinator?.displayState == .aiTab(.collapsed)
        let isBottomExpandedUTIKeyboardAnchored = (coordinator?.isOmnibarSession == true || coordinator?.isAITabExpanded == true)
            && coordinator?.cardPosition == .bottom
            && viewCoordinator.isNavigationBarContainerBottomKeyboardBased

        let baseInputHeight: CGFloat
        if let coordinator, coordinator.isAITabExpanded || coordinator.isOmnibarSession {
            baseInputHeight = coordinator.omnibarEditingHeight()
        } else {
            baseInputHeight = omniBarHeight
        }

        if !isNavigationBarEffectivelyAtBottom {
            if !isAITabCollapsed, let coordinator, coordinator.isOmnibarSession {
                self.viewCoordinator.constraints.navigationBarContainerHeight.constant = baseInputHeight
            }
            return
        }

        let containerHeight = keyboardHeight > 0 ? intersection.height - toolbarHeight + baseInputHeight : 0
        if !isAITabCollapsed {
            let newHeight = isBottomExpandedUTIKeyboardAnchored ? baseInputHeight : max(baseInputHeight, containerHeight)
            self.viewCoordinator.constraints.navigationBarContainerHeight.constant = newHeight
        }

        if appSettings.currentAddressBarPosition.isBottom, let currentTab {
            let inset = intersection.height > 0 ? omniBarHeight : 0
            currentTab.webView.scrollView.contentInset = .init(top: 0, left: 0, bottom: inset, right: 0)

            let bottomOffset = intersection.height > 0 ? containerHeight - omniBarHeight : 0
            currentTab.borderView.bottomOffset = -bottomOffset
        } else if isAnyAITabUTIState, let currentTab {
            let inset = keyboardHeight > 0 ? baseInputHeight : 0
            if currentTab.webView.scrollView.contentInset.bottom != inset {
                currentTab.webView.scrollView.contentInset = .init(top: 0, left: 0, bottom: inset, right: 0)
            }
        }

        if appSettings.currentAddressBarPosition.isBottom,
           let ntp = self.newTabPageViewController,
           !ntp.isShowingLogo {
            self.newTabPageViewController?.additionalSafeAreaInsets.bottom = max(omniBarHeight, containerHeight)
        }

        UIView.animate(withDuration: duration, delay: 0, options: animationCurve) {
            self.viewCoordinator.navigationBarContainer.superview?.layoutIfNeeded()

            if self.appSettings.currentAddressBarPosition.isBottom,
               !self.aiChatSettings.isAIChatSearchInputUserSettingsEnabled,
               let ntp = self.newTabPageViewController,
               ntp.isShowingLogo {
                self.newTabPageViewController?.additionalSafeAreaInsets.bottom = max(omniBarHeight, containerHeight)
            } else {
                self.newTabPageViewController?.viewSafeAreaInsetsDidChange()
            }
            self.currentTab?.borderView.layoutIfNeeded()
        }
    }

    private func initTabButton() {
        assert(tabSwitcherButton == nil)

        tabSwitcherButton = TabSwitcherStaticButton(showMenuOnLongPress: fireModeCapability.isFireModeEnabled)

        tabSwitcherButton?.delegate = self
        viewCoordinator.toolbarTabSwitcherButton.customView = tabSwitcherButton

        assert(tabSwitcherButton != nil)

        viewCoordinator.toolbarTabSwitcherButton.isAccessibilityElement = true
        viewCoordinator.toolbarTabSwitcherButton.accessibilityTraits = .button

        // Omnibar tab switcher button (for iPhone landscape combined bar)
        let omniBarTabSwitcher = TabSwitcherStaticButton(showMenuOnLongPress: fireModeCapability.isFireModeEnabled)
        omniBarTabSwitcher.delegate = self
        omniBarTabSwitcher.translatesAutoresizingMaskIntoConstraints = false
        let container = viewCoordinator.omniBar.barView.tabSwitcherContainerView
        container.addSubview(omniBarTabSwitcher)
        NSLayoutConstraint.activate([
            omniBarTabSwitcher.centerXAnchor.constraint(equalTo: container.centerXAnchor),
            omniBarTabSwitcher.centerYAnchor.constraint(equalTo: container.centerYAnchor),
            omniBarTabSwitcher.widthAnchor.constraint(equalToConstant: 34),
            omniBarTabSwitcher.heightAnchor.constraint(equalToConstant: 44),
        ])
        omniBarTabSwitcherButton = omniBarTabSwitcher

        // Omnibar fire button (for iPhone landscape combined bar)
        viewCoordinator.omniBar.barView.onFirePressed = { [weak self] in
            self?.performCustomizationActionForToolbar()
        }
    }
    
    private func initBookmarksButton() {
        viewCoordinator.omniBar.barView.bookmarksButton.addGestureRecognizer(UILongPressGestureRecognizer(target: self,
                                                                                  action: #selector(quickSaveBookmarkLongPress(gesture:))))
        gestureBookmarksButton.delegate = self

        gestureBookmarksButton.image = DesignSystemImages.Glyphs.Size24.bookmarks
    }

    private func bindFavoritesDisplayMode() {
        favoritesDisplayModeCancellable = NotificationCenter.default.publisher(for: AppUserDefaults.Notifications.favoritesDisplayModeChange)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                guard let self else {
                    return
                }
                self.menuBookmarksViewModel.favoritesDisplayMode = self.appSettings.favoritesDisplayMode
                self.favoritesViewModel.favoritesDisplayMode = self.appSettings.favoritesDisplayMode
                WidgetCenter.shared.reloadAllTimelines()
            }
    }

    private func bindSyncService() {
        localUpdatesCancellable = favoritesViewModel.localUpdates
            .sink { [weak self] in
                self?.syncService.scheduler.notifyDataChanged()
            }

        syncUpdatesCancellable = syncDataProviders.bookmarksAdapter.syncDidCompletePublisher
            .sink { [weak self] _ in
                self?.favoritesViewModel.reloadData()
            }
    }

    @objc func quickSaveBookmarkLongPress(gesture: UILongPressGestureRecognizer) {
        if gesture.state == .began {
            quickSaveBookmark()
        }
    }

    @objc func quickSaveBookmark() {
        UIImpactFeedbackGenerator(style: .heavy).impactOccurred()
        guard currentTab != nil else {
            ActionMessageView.present(message: UserText.webSaveBookmarkNone,
                                      presentationLocation: .withBottomBar(andAddressBarBottom: appSettings.currentAddressBarPosition.isBottom))
            return
        }
        
        Pixel.fire(pixel: .tabBarBookmarksLongPressed)
        currentTab?.saveAsBookmark(favorite: true, viewModel: menuBookmarksViewModel)
    }
    
    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        if let presentedViewController {
            return presentedViewController.supportedInterfaceOrientations
        }
        return needsToShowOnboardingIntro() ? [.portrait] : [.allButUpsideDown]
    }

    override var shouldAutorotate: Bool {
        return true
    }
        
    @objc func dismissSuggestionTray() {
        omniBar.cancel()
        dismissOmniBar()
    }

    private func addLaunchTabNotificationObserver() {
        launchTabObserver = LaunchTabNotification.addObserver(handler: { [weak self] urlString in
            guard let self = self else { return }
            viewCoordinator.omniBar.endEditing()
            if let url = URL(trimmedAddressBarString: urlString, useUnifiedLogic: isUnifiedURLPredictionEnabled), url.isValid(usingUnifiedLogic: isUnifiedURLPredictionEnabled) {
                self.loadUrlInNewTab(url, inheritedAttribution: nil)
            } else {
                self.loadQuery(urlString)
            }
        })
    }

    private func loadInitialView() {
        if tabManager.currentTabsModel.tabs.isEmpty && tabManager.currentTabsModel.allowsEmpty {
            showTabSwitcher()
            return
        }

        if tabManager.currentTabsModel.currentTab?.link != nil {
            guard let tab = tabManager.current(createIfNeeded: true) else {
                fatalError("Unable to create tab")
            }
            attachTab(tab: tab)
        } else {
            attachHomeScreen()
        }
    }

    private func loadInitialViewIfNeeded() {
        guard !hasLoadedInitialView else { return }
        hasLoadedInitialView = true
        loadInitialView()
        hasCompletedInitialLoad = true
    }

    func handlePressEvent(event: UIPressesEvent?) {
        keyModifierFlags = event?.modifierFlags
    }

    override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
        super.pressesBegan(presses, with: event)
        handlePressEvent(event: event)
    }
    
    override func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
        super.pressesEnded(presses, with: event)
        handlePressEvent(event: event)
    }

    private func attachOmniBar() {
        viewCoordinator.omniBar.omniDelegate = self
    }
    
    private func makeEscapeHatchModel(targetTab: Tab) -> EscapeHatchModel? {
        if targetTab.fireTab {
            if targetTab.link != nil || targetTab.isAITab {
                return EscapeHatchModel(
                    title: UserText.escapeHatchFireTabTitle,
                    subtitle: "",
                    tabType: .fire,
                    domain: nil,
                    targetTab: targetTab
                )
            }
            return nil
        }
        if targetTab.isAITab {
            return EscapeHatchModel(
                title: targetTab.aiChatConversationTitle ?? UserText.omnibarFullAIChatModeDisplayTitle,
                subtitle: UserText.omnibarFullAIChatModeDisplayTitle,
                tabType: .aiChat,
                domain: nil,
                targetTab: targetTab
            )
        }
        if let link = targetTab.link {
            let subtitle = link.url.host?.droppingWwwPrefix() ?? link.url.absoluteString
            return EscapeHatchModel(
                title: link.displayTitle,
                subtitle: subtitle,
                tabType: .regular,
                domain: link.url.host,
                targetTab: targetTab
            )
        }
        return nil
    }

    private func buildEscapeHatch() -> EscapeHatchModel? {
        guard idleReturnEligibilityManager.isEligibleForNTPAfterIdle() else {
            return nil
        }
        let currentTab = tabManager.currentTabsModel.currentTab
        if currentTab?.fireTab == true {
            // Avoid showing a hatch on fire tabs
            return nil
        }
        guard let lastUID = lastActiveTabStore.lastActiveNonEmptyTabUID,
              let targetTab = tabManager.allTabsModel.tabs.first(where: { $0.uid == lastUID }),
              targetTab !== currentTab else {
            // Couldn't find the last active tab
            return nil
        }
        return makeEscapeHatchModel(targetTab: targetTab)
    }

    fileprivate func attachHomeScreen(isNewTab: Bool = false, allowingKeyboard: Bool = false, previousTab: TabViewController? = nil, openedAfterIdle: Bool = false) {
        guard !autoClearInProgress else { return }
        
        if tabManager.currentTabsModel.tabs.isEmpty && tabManager.currentTabsModel.allowsEmpty {
            showTabSwitcher()
            return
        }

        viewCoordinator.logoContainer.isHidden = false
        findInPageView?.isHidden = true
        chromeManager.detach()
        
        currentTab?.dismiss()
        removeHomeScreen()
        homePageConfiguration.refresh()

        // Access the tab model directly as we don't want to create a new tab controller here
        guard let tabModel = tabManager.currentTabsModel.currentTab else {
            fatalError("No tab model")
        }
        
        let shouldSaveTabs = tabModel.viewed == false || tabModel.openedAfterIdle != openedAfterIdle

        // Attaching HomeScreen means it's going to be displayed immediately.
        // This value gets updated on didAppear so after we leave this function so **after** `refreshControls` is done already, which leads to dot being visible on tab switcher icon on newly opened tab page.
        tabModel.viewed = true
        tabModel.openedAfterIdle = openedAfterIdle
        if shouldSaveTabs {
            tabManager.save()
        }

        let newTabDaxDialogFactory = NewTabDaxDialogsProvider(featureFlagger: featureFlagger, delegate: self, daxDialogsFlowCoordinator: daxDialogsManager, onboardingPixelReporter: contextualOnboardingPixelReporter)
        let narrowLayoutInLandscape = aiChatSettings.isAIChatSearchInputUserSettingsEnabled

        let controller = NewTabPageViewController(isFocussedState: false,
                                                  dismissKeyboardOnScroll: true,
                                                  tab: tabModel,
                                                  interactionModel: favoritesViewModel,
                                                  homePageMessagesConfiguration: homePageConfiguration,
                                                  subscriptionDataReporting: subscriptionDataReporter,
                                                  newTabDialogFactory: newTabDaxDialogFactory,
                                                  daxDialogsManager: daxDialogsManager,
                                                  faviconLoader: faviconLoader,
                                                  remoteMessagingActionHandler: remoteMessagingActionHandler,
                                                  remoteMessagingImageLoader: remoteMessagingImageLoader,
                                                  remoteMessagingPixelReporter: remoteMessagingPixelReporter,
                                                  fireModePromotionEligibility: fireModePromotionEligibility,
                                                  appSettings: appSettings,
                                                  faviconsCache: favicons,
                                                  subscriptionManager: subscriptionManager,
                                                  internalUserCommands: internalUserCommands,
                                                  narrowLayoutInLandscape: narrowLayoutInLandscape
        )

        controller.delegate = self
        controller.chromeDelegate = self

        newTabPageViewController = controller

        let hatch = buildEscapeHatch()
        controller.setEscapeHatch(hatch)
        currentNTPEscapeHatch = hatch
        
        if hasCompletedInitialLoad {
            lastActiveTabStore.recordActiveTab(uid: tabModel.uid)
        }

        addToContentContainer(controller: controller)
        viewCoordinator.logoContainer.isHidden = true
        adjustNewTabPageSafeAreaInsets(for: appSettings.currentAddressBarPosition)

        // This has to happen after the new tab controller is created so that it knows to set the buttons correctly
        // ie remove back/forward and show bookmarks/passwords
        // but also before any other UI updates so that data from the old tab doesn't find its way into the new one
        refreshControls()

        // It's possible for this to be called when in the background of the
        //  switcher, and we only want to show the pixel when it's actually
        // about to shown to the user.
        if presentedViewController == nil || presentedViewController?.isBeingDismissed == true {
            fireNewTabPixels()
            ntpAfterIdleInstrumentation.ntpShown(afterIdle: openedAfterIdle)
        }

        if isNewTab && allowingKeyboard && KeyboardSettings().onNewTab {
            omniBar.beginEditing(animated: true)
        }

        syncService.scheduler.requestSyncImmediately()
    }

    func fireNewTabPixels() {
        Pixel.fire(.homeScreenShown, withAdditionalParameters: [:])
        productSurfaceTelemetry.newTabPageUsed()
        let favoritesCount = favoritesViewModel.favorites.count
        let bucket = HomePageDisplayDailyPixelBucket(favoritesCount: favoritesCount)
        DailyPixel.fire(pixel: .newTabPageDisplayedDaily, withAdditionalParameters: [
            "FavoriteCount": bucket.value,
            PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue
        ])
    }

    fileprivate func removeHomeScreen() {
        newTabPageViewController?.willMove(toParent: nil)
        newTabPageViewController?.dismiss()
        newTabPageViewController = nil
        currentNTPEscapeHatch = nil
    }

    @IBAction func onFirePressed() {

        func showFireConfirmation() {
            let presenter = FireConfirmationPresenter()
            let source: UIView = findFireButton() ?? viewCoordinator.toolbar
            presenter.presentFireConfirmation(
                on: self,
                attachPopoverTo: source,
                tabViewModel: tabManager.viewModelForCurrentTab(),
                pixelSource: .browsing,
                daxDialogsManager: daxDialogsManager,
                browsingMode: tabManager.currentBrowsingMode,
                onConfirm: { [weak self] fireRequest in
                    self?.forgetAllWithAnimation(request: fireRequest) {}
                },
                onCancel: { }
            )
        }

        let browsingModeParam = [PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue]
        Pixel.fire(pixel: .forgetAllPressedBrowsing, withAdditionalParameters: browsingModeParam)
        DailyPixel.fire(pixel: .forgetAllPressedBrowsingDaily, withAdditionalParameters: browsingModeParam)

        performActionIfAITab { DailyPixel.fireDailyAndCount(pixel: .aiChatFireButtonTapped) }

        hideNotificationBarIfBrokenSitePromptShown()
        wakeLazyFireButtonAnimator()

        // Dismiss dax dialog and pulse animation when the user taps on the Fire Button.
        currentTab?.dismissContextualDaxFireDialog()
        ViewHighlighter.hideAll()
        showFireConfirmation()

        performCancel()
    }

    @objc func onPasswordsPressed() {
        launchAutofillLogins(source: .newTabPageToolbar)
    }

    func onQuickFirePressed() {
        wakeLazyFireButtonAnimator()
        let request = FireRequest(options: .all, trigger: .manualFire, scope: .all, source: .quickFire)
        forgetAllWithAnimation(request: request) {}
        dismiss(animated: true)
        if KeyboardSettings().onAppLaunch {
            enterSearch()
        }
    }
    
    private func wakeLazyFireButtonAnimator() {
        DispatchQueue.main.async {
            _ = self.fireButtonAnimator
        }
    }

    @IBAction func onBackPressed() {
        Pixel.fire(pixel: .tabBarBackPressed)
        performCancel()
        hideSuggestionTray()
        hideNotificationBarIfBrokenSitePromptShown()
        currentTab?.goBack()
    }

    @IBAction func onForwardPressed() {
        Pixel.fire(pixel: .tabBarForwardPressed)
        performCancel()
        hideSuggestionTray()
        hideNotificationBarIfBrokenSitePromptShown()
        currentTab?.goForward()
    }
    
    func onForeground() {
        fireExperimentalAddressBarPixel()
        fireIPadToggleStateOnAppOpenPixel()
        fireContextualAutoAttachPixel()
        fireAIChatIsEnabledPixel()
        fireKeyboardSettingsPixels()
        fireTemporaryTelemetryPixels()
        skipSERPFlow = true

        /// Dismiss any keyboard restored by WKWebView when returning to foreground
        /// with the tab switcher visible. The tab switcher uses .overCurrentContext so
        /// the WKWebView remains in the hierarchy and its web process can restore focus
        /// on a text input, causing the keyboard to appear on top of the tab switcher.
        /// https://app.asana.com/1/137249556945/project/414709148257752/task/1213823670012997?focus=true
        if tabSwitcherController != nil {
            currentTab?.webView.resignFirstResponder()
        }

        // Show Fire Pulse only if Privacy button pulse should not be shown. In control group onboarding `shouldShowPrivacyButtonPulse` is always false.
        if daxDialogsManager.shouldShowFireButtonPulse && !daxDialogsManager.shouldShowPrivacyButtonPulse {
            showFireButtonPulse()
        }
    }

    private func fireTemporaryTelemetryPixels() {
        // Sent as individual pixels to avoid creating parameter combinations that can identify users
        let fireButtonAnim = appSettings.currentFireButtonAnimation.rawValue
        DailyPixel.fireDaily(.temporaryTelemetrySettingsClearDataAnimation(animation: fireButtonAnim))

        let customizationState = mobileCustomization.state
        let addressBarButton = customizationState.currentAddressBarButton.rawValue
        DailyPixel.fireDaily(.temporaryTelemetrySettingsCustomizedAddressBarButton(button: addressBarButton))

        let toolbarButton = customizationState.currentToolbarButton.rawValue
        DailyPixel.fireDaily(.temporaryTelemetrySettingsCustomizedToolbarButton(button: toolbarButton))
    }

    /// Represents the policy for reusing existing tabs for a query or URL being opened.
    enum ExistingTabReusePolicy: Equatable {
        /// Reuse any existing tab that matches the URL or is a New Tab Page.
        case any
        /// Reuse a specific tab identified by its ID.
        case tabWithId(String)
    }

    /// Loads a search query in a new tab, with an option to reuse an existing tab.
    ///
    /// - Parameters:
    ///   - query: The search query to be loaded.
    ///   - reuseExisting: The policy for reusing an existing tab. Defaults to `none`, meaning no reuse.
    func loadQueryInNewTab(_ query: String, reuseExisting: ExistingTabReusePolicy? = .none, fromExternalLink: Bool = false) {
        dismissOmniBar()
        guard let url = URL.makeSearchURL(query: query, useUnifiedLogic: isUnifiedURLPredictionEnabled) else {
            Logger.lifecycle.error("Couldn't form URL for query: \(query, privacy: .public)")
            return
        }

        loadUrlInNewTab(url, reuseExisting: reuseExisting, inheritedAttribution: nil, fromExternalLink: fromExternalLink)
    }

    /// Load URL in a new tab, with option to reuse an existing tab.
    ///
    /// - Parameters:
    ///   - url: The URL to be loaded.
    ///   - reuseExisting: The policy for reusing an existing tab. Defaults to `none`, meaning no reuse.
    ///   - inheritedAttribution: The attribution state to be inherited from a parent tab, if any.
    ///   - fromExternalLink: A flag indicating if the URL is from an external link. Defaults to `false`.
    func loadUrlInNewTab(_ url: URL, reuseExisting: ExistingTabReusePolicy? = .none, inheritedAttribution: AdClickAttributionLogic.State?, fromExternalLink: Bool = false) {

        func worker() {
            allowContentUnderflow = false
            viewCoordinator.navigationBarContainer.alpha = 1
            loadViewIfNeeded()

            // Check if a specific tab ID should be reused.
            if case .tabWithId(let id) = reuseExisting, let existing = tabManager.first(withId: id) {
                selectTab(existing)
            }
            // Check if an existing tab with the same URL should be reused.
            else if reuseExisting != .none, let existing = tabManager.first(withUrl: url) {
                selectTab(existing)
                return
            }
            // Check if a tab presenting a New Tab page should be reused.
            else if reuseExisting != .none, let existing = tabManager.firstHomeTab() {
                if autoClearInProgress {
                    autoClearShouldRefreshUIAfterClear = false
                }
                tabManager.select(existing, dismissCurrent: false)
                loadUrl(url, fromExternalLink: fromExternalLink)
            }
            // Add a new tab if no existing tab is reused.
            else {
                addTab(url: url, inheritedAttribution: inheritedAttribution, fromExternalLink: fromExternalLink)
            }

            refreshOmniBar()
            refreshTabIcon()
            refreshControls()
            tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
            swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        }

        if clearInProgress {
            postClear = worker
        } else {
            worker()
        }
    }

    func enterSearch() {
        if presentedViewController == nil {
            showBars()
            viewCoordinator.omniBar.beginEditing(animated: true)
        }
    }

    func loadQuery(_ query: String) {
        guard let url = URL.makeSearchURL(query: query, useUnifiedLogic: isUnifiedURLPredictionEnabled, queryContext: currentTab?.url) else {
            Logger.general.error("Couldn't form URL for query \"\(query, privacy: .public)\" with context \"\(self.currentTab?.url?.absoluteString ?? "<nil>", privacy: .public)\"")
            return
        }
        // Make sure that once query is submitted, we don't trigger the non-SERP flow
        skipSERPFlow = false
        loadUrl(url)
    }

    func stopLoading() {
        currentTab?.stopLoading()
    }

    func loadUrl(_ url: URL, fromExternalLink: Bool = false) {
        prepareTabForRequest {
            self.currentTab?.load(url: url)
            if fromExternalLink {
                self.currentTab?.inferredOpenerContext = .external
            }
        }
    }
    
    /// Loads content into the current AI Chat tab with optional query, auto-send, payload, and tools.
    ///
    /// - Parameters:
    ///   - query: Optional query string to load in AI Chat
    ///   - autoSend: Whether to automatically send the query. Defaults to `false`.
    ///   - payload: Optional payload data for AI Chat. Defaults to `nil`.
    ///   - tools: Optional RAG tools available in AI Chat. Defaults to `nil`.
    func load(_ query: String? = nil, autoSend: Bool = false, payload: Any? = nil, tools: [AIChatRAGTool]? = nil, modelId: String? = nil, images: [AIChatNativePrompt.NativePromptImage]? = nil) {
        guard let currentTab else {
            assertionFailure("load called with no current tab")
            return
        }
        if currentTab.tabModel.link == nil {
            ntpAfterIdleInstrumentation.barUsedFromNTP(afterIdle: currentTab.tabModel.openedAfterIdle)
        }

        prepareTabForRequest {
            currentTab.load(query, autoSend: autoSend, payload: payload, tools: tools, modelId: modelId, images: images)
        }
    }

    func executeBookmarklet(_ url: URL) {
        if url.isBookmarklet() {
            currentTab?.executeBookmarklet(url: url)
        }
    }

    private func loadBackForwardItem(_ item: WKBackForwardListItem) {
        prepareTabForRequest {
            currentTab?.load(backForwardListItem: item)
        }
    }
    
    private func prepareTabForRequest(request: () -> Void) {
        viewCoordinator.navigationBarContainer.alpha = 1
        allowContentUnderflow = false

        guard let tab = tabManager.current(createIfNeeded: true) else {
            assertionFailure("prepareTabForRequest: no current tab available")
            return
        }

        tab.tabModel.openedAfterIdle = false
        request()
        lastActiveTabStore.recordActiveTab(uid: tab.tabModel.uid)
        dismissOmniBar()
        transitionTo(tab: tab, from: nil)
    }

    private func addTab(url: URL?, inheritedAttribution: AdClickAttributionLogic.State?, fromExternalLink: Bool = false) {
        let tab = tabManager.add(url: url, inheritedAttribution: inheritedAttribution)
        tab.inferredOpenerContext = .external

        // Mark tab as external launch if opened from external URL or shortcut
        if fromExternalLink {
            tabManager.markTabAsExternalLaunch(tab.tabModel)
            // For external launches, only the new tab should suppress tracker animations
            tabManager.setSuppressTrackerAnimationOnFirstLoad(for: tab.tabModel, shouldSuppress: true)
        }

        currentTab?.aiChatContextualSheetCoordinator.dismissSheet()
        dismissOmniBar()
        attachTab(tab: tab)
    }

    private func transitionTo(tab: TabViewController?, from previousTab: TabViewController?) {
        guard let tab else { return }
        previousTab?.aiChatContextualSheetCoordinator.dismissSheet()
        previousTab?.tabModel.openedAfterIdle = false
        previousTab?.dismiss()
        hideNotificationBarIfBrokenSitePromptShown()

        let shouldSaveTabs = tab.tabModel.viewed == false
        tab.tabModel.viewed = true
        if shouldSaveTabs {
            tabManager.save()
        }

        if tab.link == nil {
            attachHomeScreen(previousTab: previousTab)
        } else {
            attachTab(tab: tab)
        }
        themeColorManager.updateThemeColor()
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        if daxDialogsManager.shouldShowFireButtonPulse {
            showFireButtonPulse()
        }

        if #available(iOS 18.4, *) {
            if let previousTab {
                webExtensionEventsCoordinator?.didDeselectTabs([previousTab])
            }
            webExtensionEventsCoordinator?.didSelectTabs([tab])
            webExtensionEventsCoordinator?.didActivateTab(tab, previousActiveTab: previousTab)
        }
    }

    private func attachTab(tab: TabViewController) {
        if hasCompletedInitialLoad {
            lastActiveTabStore.recordActiveTab(uid: tab.tabModel.uid)
        }
        removeHomeScreen()
        updateFindInPage()
        hideNotificationBarIfBrokenSitePromptShown()
        currentTab?.progressWorker.progressBar = nil
        currentTab?.chromeDelegate = nil
            
        addToContentContainer(controller: tab)

        viewCoordinator.logoContainer.isHidden = true

        tab.progressWorker.progressBar = viewCoordinator.progress
        chromeManager.attach(to: tab.webView.scrollView)
        themeColorManager.attach(to: tab)
        tab.chromeDelegate = self
        tab.updateWebViewBottomAnchor(for: viewCoordinator.toolbar.alpha)

        refreshControls()
    }

    private func addToContentContainer(controller: UIViewController) {
        viewCoordinator.contentContainer.isHidden = false
        addChild(controller)
        viewCoordinator.contentContainer.subviews.forEach { $0.removeFromSuperview() }
        viewCoordinator.contentContainer.addSubview(controller.view)

        controller.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        controller.view.frame = viewCoordinator.contentContainer.bounds
        controller.didMove(toParent: self)
    }

    fileprivate func updateCurrentTab() {
        // prepopulate VC for current tab if needed
        if let currentTab = tabManager.current(createIfNeeded: true) {
            transitionTo(tab: currentTab, from: nil)
            viewCoordinator.omniBar.endEditing()
        } else if !tabManager.currentTabsModel.allowsEmpty {
            attachHomeScreen()
        } else {
            showTabSwitcher()
        }
    }

    fileprivate func refreshControls() {
        refreshTabIcon()
        refreshMenuButtonState()
        refreshOmniBar()
        refreshBackForwardButtons()
        refreshBackForwardMenuItems()
        updateChromeForDuckPlayer()
        refreshMiddleButton()
    }

    private func refreshMiddleButton() {
        applyCustomizationForToolbar(mobileCustomization.state)
    }

    private func refreshTabIcon() {
        viewCoordinator.toolbarTabSwitcherButton.accessibilityHint = UserText.numberOfTabs(tabManager.currentTabsModel.count)
        assert(tabSwitcherButton != nil)
        let count = tabManager.currentTabsModel.count
        let hasUnread = tabManager.currentTabsModel.hasUnread
        let isFireMode = tabManager.currentBrowsingMode == .fire
        tabSwitcherButton?.tabCount = count
        tabSwitcherButton?.hasUnread = hasUnread
        tabSwitcherButton?.isFireMode = isFireMode
        omniBarTabSwitcherButton?.tabCount = count
        omniBarTabSwitcherButton?.hasUnread = hasUnread
        omniBarTabSwitcherButton?.isFireMode = isFireMode
    }

    private func refreshOmniBar() {
        updateOmniBarLoadingState()
        viewCoordinator.omniBar.refreshFireMode(fireMode: isCurrentTabFireTab())

        guard let tab = currentTab, tab.link != nil else {
            viewCoordinator.omniBar.stopBrowsing()
            // Clear Dax Easter Egg logo when no tab is active
            viewCoordinator.omniBar.setDaxEasterEggLogoURL(nil)
            if let tabModel = tabManager.currentTabsModel.currentTab {
                viewCoordinator.omniBar.setSelectedTextEntryMode(tabModel.preferredTextEntryMode)
            }
            updateBrowsingMenuHeaderDataSource()
            if let tab = currentTab {
                refreshUnifiedToggleInput(for: tab)
            } else if let coordinator = unifiedToggleInputCoordinator, coordinator.isActive {
                coordinator.hide()
                coordinator.unbind()
                viewCoordinator.hideAITabChrome()
                applyUnifiedInputChromeBackground(.standardChrome)
            }
            return
        }

        viewCoordinator.omniBar.refreshText(forUrl: tab.url, forceFullURL: appSettings.showFullSiteAddress)

        if tab.isError {
            viewCoordinator.omniBar.hidePrivacyIcon()
        } else if let privacyInfo = tab.privacyInfo, privacyInfo.url.host == tab.url?.host {
            viewCoordinator.omniBar.updatePrivacyIcon(for: privacyInfo)
        } else {
            viewCoordinator.omniBar.resetPrivacyIcon(for: tab.url)
        }

        let logoURL = logoURLForCurrentPage(tab: tab)
        viewCoordinator.omniBar.setDaxEasterEggLogoURL(logoURL)

        if tab.isAITab && (aichatFullModeFeature.isAvailable || aichatIPadTabFeature.isAvailable) {
            // AI tabs use branding UI — skip setSelectedTextEntryMode to avoid
            // flashing the "ask privately" placeholder before branding covers the text field.
            viewCoordinator.omniBar.enterAIChatMode()
        } else {
            viewCoordinator.omniBar.startBrowsing()
            viewCoordinator.omniBar.setSelectedTextEntryMode(tab.tabModel.preferredTextEntryMode)
        }
        refreshUnifiedToggleInput(for: tab)

        if minimalChromeSettings.isFeatureEnabled && !AppWidthObserver.shared.isPad {
            applyWidth()
        }

        updateBrowsingMenuHeaderDataSource()
    }

    private func updateBrowsingMenuHeaderDataSource() {
        guard browsingMenuSheetCapability.isEnabled else { return }

        var easterEggLogoURL: String?
        if let tab = currentTab {
            easterEggLogoURL = logoURLForCurrentPage(tab: tab)
        }

        browsingMenuHeaderStateProvider.update(
            dataSource: browsingMenuHeaderDataSource,
            isNewTabPage: newTabPageViewController != nil,
            isAITab: currentTab?.isAITab ?? false,
            isError: currentTab?.isError ?? false,
            hasLink: currentTab?.link != nil,
            url: currentTab?.url,
            title: currentTab?.title,
            easterEggLogoURL: easterEggLogoURL
        )
    }

    private func updateOmniBarLoadingState() {
        if currentTab?.isLoading == true {
            omniBar.startLoading()
        } else {
            omniBar.stopLoading()
        }
    }

    func dismissOmniBar() {
        hideSuggestionTray()
        viewCoordinator.omniBar.endEditing()
        refreshOmniBar()
    }

    private var isModeToggleInAIChatMode: Bool {
        guard aiChatAddressBarExperience.shouldShowModeToggle,
              let omniBarVC = viewCoordinator.omniBar as? OmniBarViewController else {
            return false
        }
        return omniBarVC.selectedTextEntryMode == .aiChat
    }

    private func hideNotificationBarIfBrokenSitePromptShown(afterRefresh: Bool = false) {
        guard brokenSitePromptViewHostingController != nil else { return }
        brokenSitePromptViewHostingController = nil
        hideNotification()
    }

    fileprivate func refreshBackForwardButtons() {
        viewCoordinator.omniBar.isBackButtonEnabled = viewCoordinator.toolbarBackButton.isEnabled
        viewCoordinator.omniBar.isForwardButtonEnabled = viewCoordinator.toolbarForwardButton.isEnabled
    }
  
    var orientationPixelWorker: DispatchWorkItem?

    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)

        let isKeyboardShowing = omniBar.isTextFieldEditing
        if isKeyboardShowing && !AppWidthObserver.shared.isPad && minimalChromeSettings.isFeatureEnabled {
            omniBar.barView.textField.suppressResignFirstResponder = true
        }

        let wasMinimalChrome = isInMinimalChromeLayout
        // Capture a snapshot of the toolbar before applyWidth hides it, so we can animate it out.
        // We can't keep toolbar.isHidden = false because the async showBars() call in applyWidth
        // would reset toolbarBottom.constant via updateToolbarConstant.
        let toolbarSnapshot: UIView? = {
            guard !wasMinimalChrome, isMinimalChromeMode(for: size) else { return nil }
            guard let snapshot = viewCoordinator.toolbar.snapshotView(afterScreenUpdates: false) else { return nil }
            snapshot.frame = viewCoordinator.toolbar.frame
            view.addSubview(snapshot)
            return snapshot
        }()

        let needsWidthUpdate = AppWidthObserver.shared.willResize(toWidth: size.width)
            && (AppWidthObserver.shared.isPad || isInMinimalChromeLayout || minimalChromeSettings.isFeatureEnabled)
        if needsWidthUpdate {
            applyWidth(for: size)
        }

        let isShowingToolbar = wasMinimalChrome && !isInMinimalChromeLayout
        if isShowingToolbar {
            viewCoordinator.toolbar.alpha = 0
        }

        self.showMenuHighlighterIfNeeded()
        updateChromeForDuckPlayer()

        coordinator.animate { _ in
            toolbarSnapshot?.alpha = 0
            if isShowingToolbar {
                self.viewCoordinator.toolbar.alpha = 1
            }
            self.swipeTabsCoordinator?.invalidateLayout()
            self.deferredFireOrientationPixel()
        } completion: { _ in
            toolbarSnapshot?.removeFromSuperview()

            self.omniBar.barView.textField.suppressResignFirstResponder = false
            if isKeyboardShowing {
                self.omniBar.beginEditing(animated: false)
            }

            ViewHighlighter.updatePositions()
            self.recomputeOmnibarEditingHeightIfNeeded()
        }

        hideNotificationBarIfBrokenSitePromptShown()
    }

    private func deferredFireOrientationPixel() {
        orientationPixelWorker?.cancel()
        orientationPixelWorker = nil
        guard UIDevice.current.orientation.isLandscape else { return }

        let worker = DispatchWorkItem { [weak self] in
            Pixel.fire(pixel: .deviceOrientationLandscape)
            self?.productSurfaceTelemetry.landscapeModeUsed()
        }
        DispatchQueue.global(qos: .default).asyncAfter(deadline: .now() + 3, execute: worker)
        orientationPixelWorker = worker
    }

    private func isMinimalChromeMode(for size: CGSize? = nil) -> Bool {
        guard minimalChromeSettings.shouldApplyMinimalChrome(isCurrentTabAITab: currentTab?.isAITab ?? false) else { return false }
        let size = size ?? view.bounds.size
        return !AppWidthObserver.shared.isPad
            && (size.width > size.height)
    }

    private func applyWidth(for size: CGSize? = nil) {

        if AppWidthObserver.shared.isLargeWidth {
            applyLargeWidth()
        } else if isMinimalChromeMode(for: size) {
            applyMinimalChromeWidth()
        } else {
            applySmallWidth()
        }

        DispatchQueue.main.async {
            // Do this async otherwise the toolbar buttons skew to the right
            if self.viewCoordinator.constraints.navigationBarContainerTop.constant >= 0,
               !self.isInMinimalChromeLayout {
                self.showBars()
            }
            // If tabs have been udpated, do this async to make sure size calcs are current
            self.tabsBarController?.refresh(tabsModel: self.tabManager.currentTabsModel)
            self.swipeTabsCoordinator?.refresh(tabsModel: self.tabManager.currentTabsModel)
            
            // Do this on the next UI thread pass so we definitely have the right width
            self.applyWidthToTrayController()
            self.newTabPageViewController?.widthChanged()
        }
    }

    func refreshMenuButtonState() {
        if newTabPageViewController != nil {
            viewCoordinator.omniBar.barView.menuButton.accessibilityLabel = UserText.bookmarksButtonHint
            viewCoordinator.updateToolbarWithState(.newTab)
        } else {
            viewCoordinator.omniBar.barView.menuButton.accessibilityLabel = UserText.menuButtonHint
            if let currentTab = currentTab {
                viewCoordinator.updateToolbarWithState(.pageLoaded(currentTab: currentTab))
            }
        }
    }

    private func applyWidthToTrayController() {
        if AppWidthObserver.shared.isLargeWidth {
            self.suggestionTrayController?.float(withWidth: self.viewCoordinator.omniBar.barView.searchContainerWidth + 32)
        } else {
            self.suggestionTrayController?.coversFullScreen = isInMinimalChromeLayout
            let bottomOmniBarHeight = appSettings.currentAddressBarPosition.isBottom ? omniBar.barView.expectedHeight : 0
            self.suggestionTrayController?.fill(bottomOffset: bottomOmniBarHeight)
        }
    }
    
    private var isInMinimalChromeLayout: Bool = false

    var isUsingSingleBar: Bool {
        AppWidthObserver.shared.isLargeWidth || isInMinimalChromeLayout
    }

    private func setMinimalChromeMode(_ enabled: Bool) {
        isInMinimalChromeLayout = enabled
        viewCoordinator.omniBar.isExpandedPhone = enabled
    }

    private func applyLargeWidth() {
        if isInMinimalChromeLayout { tearDownMinimalChrome() }
        viewCoordinator.tabBarContainer.isHidden = false
        viewCoordinator.toolbar.isHidden = true
        viewCoordinator.omniBar.enterPadState()

        swipeTabsCoordinator?.isEnabled = false
    }

    private func applySmallWidth() {
        if isInMinimalChromeLayout { tearDownMinimalChrome() }
        viewCoordinator.tabBarContainer.isHidden = true
        viewCoordinator.toolbar.isHidden = false
        viewCoordinator.constraints.toolbarBottom.constant = 0
        viewCoordinator.omniBar.enterPhoneState()

        swipeTabsCoordinator?.isEnabled = true
    }

    private func tearDownMinimalChrome() {
        setMinimalChromeMode(false)
        viewCoordinator.navigationBarContainer.transform = .identity
        viewCoordinator.omniBar.barView.setLayoutMode(.compact, animated: false)
        viewCoordinator.resetMinimalChromeLayout()
    }

    private func applyMinimalChromeWidth() {
        viewCoordinator.tabBarContainer.isHidden = true
        viewCoordinator.toolbar.isHidden = true
        let bottomHeight = toolbarHeight + view.safeAreaInsets.bottom
        viewCoordinator.constraints.toolbarBottom.constant = bottomHeight
        setMinimalChromeMode(true)
        viewCoordinator.omniBar.enterPhoneState()
        viewCoordinator.moveAddressBarToPosition(appSettings.currentAddressBarPosition)

        if appSettings.currentAddressBarPosition.isBottom {
            viewCoordinator.applyMinimalChromeBottomLayout()
        } else {
            viewCoordinator.resetMinimalChromeLayout()
        }

        swipeTabsCoordinator?.isEnabled = true
    }

    @discardableResult
    func tryToShowSuggestionTray(_ type: SuggestionTrayViewController.SuggestionType) -> Bool {
        let canShow = suggestionTrayController?.canShow(for: type) ?? false
        if canShow {
            showSuggestionTray(type)
        }
        return canShow
    }
    
    private func showSuggestionTray(_ type: SuggestionTrayViewController.SuggestionType) {
        if iPadTabChatHistoryCoordinator.isInstalled {
            if case .autocomplete = type,
               isModeToggleInAIChatMode,
               !allowIPadAIAutocompleteShow {
                return
            }
        }

        suggestionTrayController?.show(for: type)
        applyWidthToTrayController()
        if !isUsingSingleBar {
            if !daxDialogsManager.shouldShowFireButtonPulse {
                ViewHighlighter.hideAll()
            }
            if type.hideOmnibarSeparator() && appSettings.currentAddressBarPosition != .bottom {
                viewCoordinator.omniBar.hideSeparator()
            }
        }
        viewCoordinator.suggestionTrayContainer.isHidden = false
        currentTab?.webView.accessibilityElementsHidden = true
    }
    
    func hideSuggestionTray() {
        viewCoordinator.omniBar.showSeparator()
        viewCoordinator.suggestionTrayContainer.isHidden = true
        currentTab?.webView.accessibilityElementsHidden = false
        suggestionTrayController?.didHide(animated: false)
    }
    
    func launchAutofillLogins(with currentTabUrl: URL? = nil, currentTabUid: String? = nil, openSearch: Bool = false, source: AutofillSettingsSource, selectedAccount: SecureVaultModels.WebsiteAccount? = nil, extensionPromotionManager: AutofillExtensionPromotionManaging? = nil) {
        let appSettings = AppDependencyProvider.shared.appSettings
        let autofillLoginListViewController = AutofillLoginListViewController(
            appSettings: appSettings,
            currentTabUrl: currentTabUrl,
            currentTabUid: currentTabUid,
            syncService: syncService,
            syncDataProviders: syncDataProviders,
            selectedAccount: selectedAccount,
            openSearch: openSearch,
            source: source,
            bookmarksDatabase: self.bookmarksDatabase,
            favoritesDisplayMode: self.appSettings.favoritesDisplayMode,
            keyValueStore: self.keyValueStore,
            extensionPromotionManager: extensionPromotionManager,
            productSurfaceTelemetry: productSurfaceTelemetry
        )
        autofillLoginListViewController.delegate = self
        let navigationController = UINavigationController(rootViewController: autofillLoginListViewController)
        autofillLoginListViewController.navigationItem.leftBarButtonItem = UIBarButtonItem(title: UserText.autofillNavigationButtonItemTitleClose,
                                                                                          style: .plain,
                                                                                          target: self,
                                                                                          action: #selector(closeAutofillModal))
        self.present(navigationController, animated: true, completion: nil)

        if selectedAccount == nil, let account = AppDependencyProvider.shared.autofillLoginSession.lastAccessedAccount {
            autofillLoginListViewController.showAccountDetails(account, animated: true)
        }
    }

    private func makeDataImportViewController(
          source: DataImportViewModel.ImportScreen,
          onFinished: (() -> Void)? = nil,
          onCancelled: (() -> Void)? = nil
      ) -> DataImportViewController {
          let dataImportManager = DataImportManager(
            reporter: SecureVaultReporter(),
            bookmarksDatabase: self.bookmarksDatabase,
            favoritesDisplayMode: self.appSettings.favoritesDisplayMode,
            tld: AppDependencyProvider.shared.storageCache.tld
          )

          return DataImportViewController(
            importManager: dataImportManager,
            importScreen: source,
            syncService: syncService,
            keyValueStore: keyValueStore,
            onFinished: onFinished,
            onCancelled: onCancelled
          )
      }


    func launchDataImport(source: DataImportViewModel.ImportScreen, onFinished: @escaping () -> Void, onCancelled: @escaping () -> Void) {
        let dataImportViewController = makeDataImportViewController(source: source, onFinished: onFinished, onCancelled: onCancelled)

        let navigationController = UINavigationController(rootViewController: dataImportViewController)
        dataImportViewController.navigationItem.leftBarButtonItem = UIBarButtonItem(title: UserText.autofillNavigationButtonItemTitleClose,
                                                                                          style: .plain,
                                                                                          target: self,
                                                                                          action: #selector(closeAutofillModal))
        self.present(navigationController, animated: true, completion: nil)
    }

    @objc private func closeAutofillModal() {
        dismiss(animated: true)
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        ViewHighlighter.updatePositions()
        omniBar.refreshCustomizableButton()
    }

    private func showNotification(title: String, message: String, dismissHandler: @escaping NotificationView.DismissHandler) {
        guard notificationView == nil else { return }

        let notificationView = NotificationView.loadFromNib(dismissHandler: dismissHandler)
        notificationView.setTitle(text: title)
        notificationView.setMessage(text: message)

        showNotification(with: notificationView)
    }

    private func showNotification(with contentView: UIView) {
        guard viewCoordinator.topSlideContainer.subviews.isEmpty else { return }
        viewCoordinator.topSlideContainer.addSubview(contentView)

        contentView.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            contentView.leadingAnchor.constraint(equalTo: viewCoordinator.topSlideContainer.leadingAnchor),
            contentView.trailingAnchor.constraint(equalTo: viewCoordinator.topSlideContainer.trailingAnchor),
            contentView.topAnchor.constraint(equalTo: viewCoordinator.topSlideContainer.topAnchor),
            contentView.bottomAnchor.constraint(equalTo: viewCoordinator.topSlideContainer.bottomAnchor),
        ])

        self.notificationView = contentView

        view.layoutIfNeeded()
        view.layoutSubviews()
        viewCoordinator.showTopSlideContainer()
        UIView.animate(withDuration: 0.3) {
            self.view.layoutIfNeeded()
        }
    }

    func hideNotification() {
        view.layoutIfNeeded()
        viewCoordinator.hideTopSlideContainer()
        UIView.animate(withDuration: 0.3) {
            self.view.layoutIfNeeded()
        } completion: { _ in
            self.notificationView?.removeFromSuperview()
            self.notificationView = nil
        }
    }

    func showHomeRowReminder() {
        // Show the reminder only if users have not seen the Add to Dock promo.
        // iPhone users would have seen Add to Dock promo during the onboarding.
        // iPad users don't see the Add to Dock promo during the onboarding.
        guard !OnboardingManager().userHasSeenAddToDockPromoDuringOnboarding else { return }
        let feature = HomeRowReminder()
        if feature.showNow() {
            showNotification(title: UserText.homeRowReminderTitle, message: UserText.homeRowReminderMessage) { tapped in
                if tapped {
                    self.segueToHomeRow()
                }
                self.hideNotification()
            }
            feature.setShown()
        }
    }

    func fireOnboardingCustomSearchPixelIfNeeded(query: String) {
        if contextualOnboardingLogic.isShowingSearchSuggestions {
            contextualOnboardingPixelReporter.measureCustomSearch()
        } else if contextualOnboardingLogic.isShowingSitesSuggestions {
            contextualOnboardingPixelReporter.measureCustomSite()
        }
    }

    private var brokenSitePromptViewHostingController: UIHostingController<BrokenSitePromptView>?
    lazy private var brokenSitePromptLimiter = BrokenSitePromptLimiter(privacyConfigManager: privacyConfigurationManager,
                                                                       store: BrokenSitePromptLimiterStore())

    @objc func attemptToShowBrokenSitePrompt(_ notification: Notification) {
        guard brokenSitePromptLimiter.shouldShowToast(),
            let url = currentTab?.url, !url.isDuckDuckGo,
            notificationView == nil,
            !isPad,
            DefaultTutorialSettings().hasSeenOnboarding,
            !daxDialogsManager.isStillOnboarding(),
            isPortrait else { return }
        // We're using async to ensure the view dismissal happens on the first runloop after a refresh. This prevents the scenario where the view briefly appears and then immediately disappears after a refresh.
        brokenSitePromptLimiter.didShowToast()
        DispatchQueue.main.async {
            self.showBrokenSitePrompt()
        }
    }

    private func showBrokenSitePrompt() {
        let host = makeBrokenSitePromptViewHostingController()
        brokenSitePromptViewHostingController = host
        Pixel.fire(pixel: .siteNotWorkingShown)
        showNotification(with: host.view)
    }

    private func makeBrokenSitePromptViewHostingController() -> UIHostingController<BrokenSitePromptView> {
        let viewModel = BrokenSitePromptViewModel(onDidDismiss: { [weak self] in
            Task { @MainActor in
                self?.hideNotification()
                self?.brokenSitePromptLimiter.didDismissToast()
                self?.brokenSitePromptViewHostingController = nil
            }
        }, onDidSubmit: { [weak self] in
            Task { @MainActor in
                self?.segueToReportBrokenSite(entryPoint: .prompt)
                self?.hideNotification()
                self?.brokenSitePromptLimiter.didOpenReport()
                self?.brokenSitePromptViewHostingController = nil
                Pixel.fire(pixel: .siteNotWorkingWebsiteIsBroken)
            }
        })
        return UIHostingController(rootView: BrokenSitePromptView(viewModel: viewModel), ignoreSafeArea: true)
    }

    func animateBackgroundTab() {
        showBars()
        tabSwitcherButton?.animateUpdate {
            self.refreshTabIcon()
        }
        tabsBarController?.backgroundTabAdded()
    }

    func newTab(reuseExisting: Bool = false, allowingKeyboard: Bool = true, openedAfterIdle: Bool = false) {
        if daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        daxDialogsManager.fireButtonPulseCancelled()
        // Reset omnibar editing state before creating a new tab.
        dismissOmniBar()
        hideNotificationBarIfBrokenSitePromptShown()
        currentTab?.aiChatContextualSheetCoordinator.dismissSheet()
        currentTab?.dismiss()

        let previousTab = tabManager.current()

        if reuseExisting, let existing = tabManager.firstHomeTab() {
            tabManager.select(existing, dismissCurrent: false)
        } else {
            tabManager.addHomeTab()
        }
        attachHomeScreen(isNewTab: true, allowingKeyboard: allowingKeyboard, previousTab: previousTab, openedAfterIdle: openedAfterIdle)
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        themeColorManager.updateThemeColor()
        showBars() // In case the browser chrome bars are hidden when calling this method
    }

    // MARK: - Idle return NTP (dismiss overlays so NTP is visible)
    /// Dismisses tab switcher and any presented view controller (e.g. Settings) so the caller can then show the NTP.
    func prepareForIdleReturnNTP(completion: @escaping () -> Void) {
        guard let presented = presentedViewController, !presented.isBeingDismissed else {
            completion()
            return
        }
        // Don't dismiss the omni bar's editing state (keyboard/switch), we're reusing NTP and want to preserve focus
        if presented is OmniBarEditingStateViewController {
            completion()
            return
        }
        presented.dismiss(animated: true, completion: completion)
    }
    
    func updateFindInPage() {
        currentTab?.findInPage?.delegate = self
        findInPageView?.update(with: currentTab?.findInPage, updateTextField: true)
        findInPageView?.updateConstraints()
    }

    func handleVoiceSearchOpenRequest(preferredTarget: VoiceSearchTarget? = nil) {
        SpeechRecognizer.requestMicAccess { [weak self] permission in
            guard let self = self else { return }
            if permission {
                if let target = preferredTarget {
                    self.showVoiceSearch(preferredTarget: target)
                } else {
                    self.showVoiceSearch()
                }
            } else {
                self.showNoMicrophonePermissionAlert()
            }
        }
    }

    private func showVoiceSearch(preferredTarget: VoiceSearchTarget? = nil) {
        // https://app.asana.com/0/0/1201408131067987
        UIMenuController.shared.hideMenu()
        dismissOmniBar()
        viewCoordinator.omniBar.removeTextSelection()
        
        Pixel.fire(pixel: .openVoiceSearch)
        let voiceSearchController = VoiceSearchViewController(preferredTarget: preferredTarget)
        voiceSearchController.delegate = self
        voiceSearchController.modalTransitionStyle = .crossDissolve
        voiceSearchController.modalPresentationStyle = .overFullScreen
        present(voiceSearchController, animated: true, completion: nil)
    }
    
    private func showNoMicrophonePermissionAlert() {
        let alertController = NoMicPermissionAlert.buildAlert()
        present(alertController, animated: true, completion: nil)
    }
    
    private func subscribeToEmailProtectionStatusNotifications() {
        NotificationCenter.default.publisher(for: .emailDidSignIn)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                self?.onDuckDuckGoEmailSignIn(notification)
            }
            .store(in: &emailCancellables)

        NotificationCenter.default.publisher(for: .emailDidSignOut)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                self?.onDuckDuckGoEmailSignOut(notification)
            }
            .store(in: &emailCancellables)
    }

    private func subscribeToURLInterceptorNotifications() {
        NotificationCenter.default.publisher(for: .urlInterceptSubscription)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                let deepLinkTarget: SettingsViewModel.SettingsDeepLinkSection
                if let redirectURLComponents = notification.userInfo?[TabURLInterceptorParameter.interceptedURLComponents] as? URLComponents {
                    if redirectURLComponents.path == "/subscriptions/plans" {
                        deepLinkTarget = .subscriptionPlanChangeFlow(redirectURLComponents: redirectURLComponents)
                    } else {
                        deepLinkTarget = .subscriptionFlow(redirectURLComponents: redirectURLComponents)
                    }
                } else {
                    deepLinkTarget = .subscriptionFlow()
                }
                self?.launchSettings(deepLinkTarget: deepLinkTarget)

            }
            .store(in: &urlInterceptorCancellables)

        NotificationCenter.default.publisher(for: .urlInterceptAIChat)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                let interceptedURL = notification.userInfo?[TabURLInterceptorParameter.interceptedURL] as? URL
                let payload = notification.object as? AIChatPayload
                
                var query: String?
                var shouldAutoSend = false
                if let url = interceptedURL,
                   let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
                   let queryItems = components.queryItems {
                    query = queryItems.first(where: { $0.name == AIChatURLParameters.promptQueryName })?.value
                    shouldAutoSend = queryItems.first(where: { $0.name == AIChatURLParameters.autoSubmitPromptQueryName })?.value == AIChatURLParameters.autoSubmitPromptQueryValue
                }
                
                if let query = query {
                    self?.openAIChat(query, autoSend: shouldAutoSend, payload: payload)
                } else {
                    self?.openAIChat(payload: payload)
                }
            }
            .store(in: &urlInterceptorCancellables)
    }

    private func subscribeToSettingsDeeplinkNotifications() {
        NotificationCenter.default.publisher(for: .settingsDeepLinkNotification)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                guard let self else { return }
                let handleSettingsDeepLink = {
                    self.handleSettingsDeepLink(notification)
                }
                if let presentedViewController {
                    if !(presentedViewController is SettingsUINavigationController) {
                        presentedViewController.dismiss(animated: true, completion: handleSettingsDeepLink)
                        return
                    }
                }
                
                handleSettingsDeepLink()
            }
            .store(in: &settingsDeepLinkcancellables)
    }
    
    private func handleSettingsDeepLink(_ notification: Notification) {
        switch notification.object as? SettingsViewModel.SettingsDeepLinkSection {
        
        case .duckPlayer:
            let deepLinkTarget: SettingsViewModel.SettingsDeepLinkSection
                deepLinkTarget = .duckPlayer
            launchSettings(deepLinkTarget: deepLinkTarget)
        case .subscriptionFlow(let components):
            launchSettings(deepLinkTarget: .subscriptionFlow(redirectURLComponents: components))
        case .subscriptionPlanChangeFlow(let components):
            launchSettings(deepLinkTarget: .subscriptionPlanChangeFlow(redirectURLComponents: components))
        case .subscriptionSettings:
            launchSettings(deepLinkTarget: .subscriptionSettings)
        case .restoreFlow:
            launchSettings(deepLinkTarget: .restoreFlow)
        default:
            return
        }
    }

    private func subscribeToAIChatSettingsEvents() {
        NotificationCenter.default.publisher(for: .aiChatSettingsChanged)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.refreshOmniBar()
                WidgetCenter.shared.reloadAllTimelines()
            }
            .store(in: &aiChatCancellables)
    }
    
    private func subscribeToRefreshButtonSettingsEvents() {
        NotificationCenter.default.publisher(for: AppUserDefaults.Notifications.refreshButtonSettingsChanged)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.refreshOmniBar()
            }
            .store(in: &settingsCancellables)
    }

    private func subscribeToNetworkProtectionEvents() {
        if !featureDiscovery.wasUsedBefore(.vpn) {
            // If the VPN was used before we don't care about this notification any more
            NotificationCenter.default.publisher(for: .NEVPNStatusDidChange)
                .sink { [weak self] notification in
                    self?.onVPNStatusDidChange(notification)
                }.store(in: &vpnCancellables)
        }

        // Subscribe to app foreground events to check entitlements
        NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                Logger.networkProtection.log("App foreground notification received, checking entitlements")
                guard let self else { return }
                self.performClientCheck(trigger: .appForegrounded)
            }
            .store(in: &vpnCancellables)

        NotificationCenter.default.publisher(for: .accountDidSignIn)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                self?.onNetworkProtectionAccountSignIn(notification)
            }
            .store(in: &vpnCancellables)

        NotificationCenter.default.publisher(for: .entitlementsDidChange)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                self?.onEntitlementsChange(notification)
            }
            .store(in: &vpnCancellables)

        NotificationCenter.default.publisher(for: .accountDidSignOut)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] notification in
                self?.onNetworkProtectionAccountSignOut(notification)
            }
            .store(in: &vpnCancellables)

        NotificationCenter.default.publisher(for: .vpnEntitlementMessagingDidChange)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.onNetworkProtectionEntitlementMessagingChange()
            }
            .store(in: &vpnCancellables)

        let notificationCallback: CFNotificationCallback = { _, _, name, _, _ in
            if let name {
                NotificationCenter.default.post(name: Notification.Name(name.rawValue as String),
                                                object: nil)
            }
        }

        CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(),
                                        UnsafeRawPointer(Unmanaged.passUnretained(self).toOpaque()),
                                        notificationCallback,
                                        Notification.Name.vpnEntitlementMessagingDidChange.rawValue as CFString,
                                        nil, .deliverImmediately)
    }

    private func subscribeToUnifiedFeedbackNotifications() {
        feedbackCancellable = NotificationCenter.default.publisher(for: .unifiedFeedbackNotification)
            .receive(on: DispatchQueue.main)
            .sink { _ in
                DispatchQueue.main.async { [weak self] in
                    guard let navigationController = self?.presentedViewController as? UINavigationController else { return }
                    navigationController.popToRootViewController(animated: true)
                    ActionMessageView.present(message: UserText.vpnFeedbackFormSubmittedMessage,
                                              presentationLocation: .withoutBottomBar)
                }
            }
    }

    private func onVPNStatusDidChange(_ notification: Notification) {
        guard let session = (notification.object as? NETunnelProviderSession),
           session.status == .connected else {
            return
        }
        self.featureDiscovery.setWasUsedBefore(.vpn)
    }

    private func onNetworkProtectionEntitlementMessagingChange() {
        if tunnelDefaults.showEntitlementAlert {
            presentExpiredEntitlementAlert()
        }

        presentExpiredEntitlementNotification()
    }

    private func presentExpiredEntitlementAlert() {
        let alertController = CriticalAlerts.makeExpiredEntitlementAlert { [weak self] in
            self?.segueToDuckDuckGoSubscription()
        }
        dismiss(animated: true) {
            self.present(alertController, animated: true, completion: nil)
            self.tunnelDefaults.showEntitlementAlert = false
        }
    }

    private func presentExpiredEntitlementNotification() {
        let presenter = VPNNotificationsPresenterTogglableDecorator(
            settings: AppDependencyProvider.shared.vpnSettings,
            defaults: .networkProtectionGroupDefaults,
            wrappee: NetworkProtectionUNNotificationPresenter()
        )
        presenter.showEntitlementNotification()
    }

    @objc
    private func onNetworkProtectionAccountSignIn(_ notification: Notification) {
        Task {
            let subscriptionManager = AppDependencyProvider.shared.subscriptionManager
            let isSubscriptionActive = try? await subscriptionManager.getSubscription(cachePolicy: .cacheFirst).isActive

            PixelKit.fire(
                VPNSubscriptionStatusPixel.signedIn(
                    isSubscriptionActive: isSubscriptionActive,
                    sourceObject: notification.object),
                frequency: .dailyAndCount)
            tunnelDefaults.resetEntitlementMessaging()
            Logger.networkProtection.info("[NetP Subscription] Reset expired entitlement messaging")
        }
    }

    var networkProtectionTunnelController: NetworkProtectionTunnelController {
        AppDependencyProvider.shared.networkProtectionTunnelController
    }

    private func performClientCheck(trigger: VPNSubscriptionClientCheckPixel.Trigger) {
        Task {
            do {
                let isSubscriptionActive = try? await subscriptionManager.getSubscription(cachePolicy: .cacheFirst).isActive
                let hasEntitlement = try await subscriptionManager.isFeatureEnabled(.networkProtection)

                if !hadVPNEntitlements && hasEntitlement {
                    PixelKit.fire(
                        VPNSubscriptionClientCheckPixel.vpnFeatureEnabled(
                            isSubscriptionActive: isSubscriptionActive,
                            trigger: trigger),
                        frequency: .dailyAndCount)
                    
                    hadVPNEntitlements = hasEntitlement
                } else if hadVPNEntitlements && !hasEntitlement {
                    PixelKit.fire(
                        VPNSubscriptionClientCheckPixel.vpnFeatureDisabled(
                            isSubscriptionActive: isSubscriptionActive,
                            trigger: trigger),
                        frequency: .dailyAndCount)
                    
                    hadVPNEntitlements = hasEntitlement
                }
            } catch {
                await handleClientCheckFailure(error: error, trigger: trigger)
            }
        }
    }

    private func handleClientCheckFailure(error: Error, trigger: VPNSubscriptionClientCheckPixel.Trigger) async {
        let isSubscriptionActive = try? await subscriptionManager.getSubscription(cachePolicy: .cacheFirst).isActive
        
        PixelKit.fire(
            VPNSubscriptionClientCheckPixel.failed(
                isSubscriptionActive: isSubscriptionActive,
                trigger: trigger,
                error: error),
            frequency: .daily)
    }

    func checkSubscriptionEntitlements() {
        performClientCheck(trigger: .appStartup)
    }

    @objc
    private func onEntitlementsChange(_ notification: Notification) {
        Task {
            guard let userInfo = notification.userInfo,
                  let payload = EntitlementsDidChangePayload(notificationUserInfo: userInfo) else {
                assertionFailure("Missing entitlements payload")
                Logger.subscription.fault("Missing entitlements payload")
                return
            }

            let userInitiatedSignOut = (userInfo[EntitlementsDidChangePayload.userInitiatedEntitlementChangeKey] as? Bool) ?? false
            let hasVPNEntitlements = payload.entitlements.contains(.networkProtection)
            let isSubscriptionActive = try? await subscriptionManager.getSubscription(cachePolicy: .cacheFirst).isActive

            if hasVPNEntitlements {
                PixelKit.fire(
                    VPNSubscriptionStatusPixel.vpnFeatureEnabled(
                        isSubscriptionActive: isSubscriptionActive,
                        sourceObject: notification.object),
                    frequency: .dailyAndCount)
            } else {
                PixelKit.fire(
                    VPNSubscriptionStatusPixel.vpnFeatureDisabled(
                        isSubscriptionActive: isSubscriptionActive,
                        sourceObject: notification.object),
                    frequency: .dailyAndCount)

                // Suppress entitlement messaging before stopping the VPN during user-initiated sign-out.
                // This prevents the extension from showing the "subscription expired" alert when it
                // detects the missing token. The suppress flag is checked in enableEntitlementMessaging().
                if userInitiatedSignOut {
                    tunnelDefaults.suppressEntitlementMessaging = true
                } else if await networkProtectionTunnelController.isInstalled {
                    tunnelDefaults.enableEntitlementMessaging()
                }

                await networkProtectionTunnelController.stop()

                if userInitiatedSignOut {
                    await networkProtectionTunnelController.removeVPN(reason: .signedOut)
                    tunnelDefaults.suppressEntitlementMessaging = false
                } else {
                    await networkProtectionTunnelController.removeVPN(reason: .entitlementCheck)
                }
            }

            hadVPNEntitlements = hasVPNEntitlements
        }
    }

    @objc
    private func onNetworkProtectionAccountSignOut(_ notification: Notification) {
        Task {
            let subscriptionManager = AppDependencyProvider.shared.subscriptionManager
            let isSubscriptionActive = try? await subscriptionManager.getSubscription(cachePolicy: .cacheFirst).isActive

            PixelKit.fire(
                VPNSubscriptionStatusPixel.signedOut(
                    isSubscriptionActive: isSubscriptionActive,
                    sourceObject: notification.object),
                frequency: .dailyAndCount)

            // Suppress entitlement messaging to prevent the "subscription expired" alert
            // from appearing during user-initiated sign-out.
            tunnelDefaults.suppressEntitlementMessaging = true

            await networkProtectionTunnelController.stop()
            await networkProtectionTunnelController.removeVPN(reason: .signedOut)

            tunnelDefaults.suppressEntitlementMessaging = false
        }
    }

    @objc
    private func onDuckDuckGoEmailSignIn(_ notification: Notification) {
        fireEmailPixel(.emailEnabled, notification: notification)
        if let object = notification.object as? EmailManager,
           let emailManager = syncDataProviders.settingsAdapter.emailManager,
           object !== emailManager {

            syncService.scheduler.notifyDataChanged()
        }
    }
    
    @objc
    private func onDuckDuckGoEmailSignOut(_ notification: Notification) {
        fireEmailPixel(.emailDisabled, notification: notification)
        presentEmailProtectionSignInAlertIfNeeded(notification)
        if let object = notification.object as? EmailManager,
           let emailManager = syncDataProviders.settingsAdapter.emailManager,
           object !== emailManager {

            syncService.scheduler.notifyDataChanged()
        }
    }

    private func presentEmailProtectionSignInAlertIfNeeded(_ notification: Notification) {
        guard let userInfo = notification.userInfo as? [String: String],
            userInfo[EmailManager.NotificationParameter.isForcedSignOut] != nil else {
            return
        }
        let alertController = CriticalAlerts.makeEmailProtectionSignInAlert()
        dismiss(animated: true) {
            self.present(alertController, animated: true, completion: nil)
        }
    }

    private func fireEmailPixel(_ pixel: Pixel.Event, notification: Notification) {
        var pixelParameters: [String: String] = [:]
        
        if let userInfo = notification.userInfo as? [String: String], let cohort = userInfo[EmailManager.NotificationParameter.cohort] {
            pixelParameters[PixelParameters.emailCohort] = cohort
        }
        
        Pixel.fire(pixel: pixel, withAdditionalParameters: pixelParameters, includedParameters: [.atb])
    }

    func openAIChat(_ query: String? = nil, autoSend: Bool = false, payload: Any? = nil, tools: [AIChatRAGTool]? = nil, modelId: String? = nil, images: [AIChatNativePrompt.NativePromptImage]? = nil, fromDeepLink: Bool = false) {
        if aichatFullModeFeature.isAvailable || aichatIPadTabFeature.isAvailable {
            openAIChatInTab(query, autoSend: autoSend, payload: payload, tools: tools, modelId: modelId, images: images, fromDeepLink: fromDeepLink)
        } else {
            aiChatViewControllerManager.openAIChat(query, payload: payload, autoSend: autoSend, tools: tools, on: self)
        }
    }

    func onDuckAIVoiceModeRequested() {
        Pixel.fire(pixel: .voiceEntryPointTapped, withAdditionalParameters: [PixelParameters.source: VoiceEntryPointSource.ntp.rawValue])
        openAIChatInVoiceMode()
    }

    func openAIVoiceChatFromDeepLink() {
        openAIChatInVoiceMode(fromDeepLink: true)
    }

    private func openAIChatInVoiceMode(fromDeepLink: Bool = false) {
        if aichatFullModeFeature.isAvailable || aichatIPadTabFeature.isAvailable {
            openAIChatVoiceModeInTab(fromDeepLink: fromDeepLink)
        } else {
            aiChatViewControllerManager.openAIChatVoiceMode(on: self)
        }
    }

    private func openAIChatVoiceModeInTab(fromDeepLink: Bool = false) {
        guard tabManager.current(createIfNeeded: true) != nil else {
            assertionFailure("openAIChatVoiceModeInTab: no current tab available")
            return
        }

        guard let currentTab else { return }

        if fromDeepLink, currentTab.tabModel.link != nil {
            let voiceURL = currentTab.aiChatContentHandler.buildVoiceModeURL()
            loadUrlInNewTab(voiceURL, inheritedAttribution: nil)
            // Collapse the input that was auto-expanded for the restored tab.
            // This cancels any pending async activateInput because showCollapsed
            // sets displayState to .collapsed, failing the guard in showExpanded's
            // async block.
            unifiedToggleInputCoordinator?.showCollapsed()
            return
        }

        prepareTabForRequest {
            currentTab.loadVoiceMode()
        }
    }
    
    /// Loads AI Chat into the current tab, creating one if needed. Selects the tab when done.
    ///
    /// - Parameters:
    ///   - query: Optional initial query to send to AI Chat
    ///   - autoSend: Whether to automatically send the query
    ///   - payload: Optional payload data for AI Chat
    ///   - tools: Optional RAG tools available in AI Chat
    ///   - fromDeepLink: When true and current tab has content, opens in a new tab instead
    private func openAIChatInTab(_ query: String? = nil, autoSend: Bool = false, payload: Any? = nil, tools: [AIChatRAGTool]? = nil, modelId: String? = nil, images: [AIChatNativePrompt.NativePromptImage]? = nil, fromDeepLink: Bool = false) {
        guard tabManager.current(createIfNeeded: true) != nil else {
            assertionFailure("openAIChatInTab: no current tab available")
            return
        }

        if fromDeepLink, let currentTab, currentTab.tabModel.link != nil {
            let chatURL = currentTab.aiChatContentHandler.buildQueryURL(query: query, autoSend: autoSend, tools: tools)
            loadUrlInNewTab(chatURL, inheritedAttribution: nil)
            return
        }

        load(query, autoSend: autoSend, payload: payload, tools: tools, modelId: modelId, images: images)
    }
    
    /// Executes the closure if the current tab is an AI tab
    private func performActionIfAITab(_ action: () -> Void) {
        guard currentTab?.isAITab == true else { return }
        action()
    }
    
    func navigateToFireMode(source: FireModeSwitchSource = .internal) {
        tabManager.setBrowsingMode(.fire, source: source)
        showTabSwitcher()
    }
}

extension MainViewController: FindInPageDelegate {
    
    func updated(findInPage: FindInPage) {
        findInPageView?.update(with: findInPage, updateTextField: false)
    }

}

extension MainViewController: FindInPageViewDelegate {
    
    func done(findInPageView: FindInPageView) {
        currentTab?.findInPage = nil
        viewCoordinator.toolbar.accessibilityElementsHidden = false

        viewCoordinator.showNavigationBarWithBottomPosition()
    }
}

extension MainViewController: BrowserChromeDelegate {

    struct ChromeAnimationConstants {
        static let duration = 0.1
    }

    var tabBarContainer: UIView {
        viewCoordinator.tabBarContainer
    }

    var omniBar: any OmniBar {
        viewCoordinator.omniBar
    }

    private func hideKeyboard() {
        dismissOmniBar()
        _ = findInPageView?.resignFirstResponder()
    }

    func setBarsHidden(_ hidden: Bool, animated: Bool, customAnimationDuration: CGFloat?) {
        if hidden { hideKeyboard() }

        setBarsVisibility(hidden ? 0 : 1.0, animated: animated, animationDuration: customAnimationDuration)
    }
    
    func setBarsVisibility(_ percent: CGFloat, animated: Bool, animationDuration: CGFloat?) {
        if percent < 1 {
            hideKeyboard()
            hideMenuHighlighter()
        } else {
            showMenuHighlighterIfNeeded()
        }
        
        let updateBlock = {
            self.updateToolbarConstant(percent)
            self.updateNavBarConstant(percent)
            self.currentTab?.updateWebViewBottomAnchor(for: percent)

            self.viewCoordinator.navigationBarContainer.alpha = percent
            self.viewCoordinator.tabBarContainer.alpha = percent
            self.viewCoordinator.toolbar.alpha = percent
            
            // Post notification only when bars are fully shown or hidden
            if percent == 0 || percent == 1 {
                NotificationCenter.default.post(
                    name: .browserChromeVisibilityChanged,
                    object: nil,
                    userInfo: ["isHidden": percent == 0]
                )
            }
        }
           
        if animated {
            self.view.layoutIfNeeded()
            UIView.animate(withDuration: animationDuration ?? ChromeAnimationConstants.duration) {
                updateBlock()
                self.view.layoutIfNeeded()
            }
        } else {
            updateBlock()

            // Calling this here is important as it causes the layout to run immediately inside current run loop,
            // instead of deferring it until next update block.
            // Late layout after change here could potentially cause a scroll offset update right before the next one,
            // which may cause an infitie loop layout loop in certain scenarios.
            // See https://app.asana.com/1/137249556945/project/414709148257752/task/1208671955053442 for details.
            self.view.layoutIfNeeded()
        }
    }

    func setNavigationBarHidden(_ hidden: Bool) {
        if hidden { hideKeyboard() }
        
        updateNavBarConstant(hidden ? 0 : 1.0)
        viewCoordinator.omniBar.barView.alpha = hidden ? 0 : 1
        viewCoordinator.tabBarContainer.alpha = hidden ? 0 : 1
        viewCoordinator.statusBackground.alpha = hidden ? 0 : 1
        
    }

    func setRefreshControlEnabled(_ isEnabled: Bool) {
        currentTab?.setRefreshControlEnabled(isEnabled)
    }

    var canHideBars: Bool {
        return !daxDialogsManager.shouldShowFireButtonPulse
    }

    var isToolbarHidden: Bool {
        return viewCoordinator.toolbar.isHidden || viewCoordinator.toolbar.alpha < 1
    }

    var toolbarHeight: CGFloat {
        return viewCoordinator.toolbar.frame.size.height
    }
    
    var barsMaxHeight: CGFloat {
        max(toolbarHeight, viewCoordinator.omniBar.barView.expectedHeight)
    }

    // 1.0 - full size, 0.0 - hidden
    private func updateToolbarConstant(_ ratio: CGFloat) {
        var bottomHeight = toolbarHeight
        if viewCoordinator.addressBarPosition.isBottom && !isInMinimalChromeLayout {
            // When position is set to bottom, contentContainer is pinned to top
            // of navigationBarContainer, hence the adjustment.
            // Skip in minimal chrome — nav bar is positioned independently via keyboard constraint.
            bottomHeight += viewCoordinator.navigationBarContainer.frame.height
        }
        bottomHeight += view.safeAreaInsets.bottom
        let multiplier = viewCoordinator.toolbar.isHidden ? 1.0 : 1.0 - ratio
        viewCoordinator.constraints.toolbarBottom.constant = bottomHeight * multiplier

        if isInMinimalChromeLayout, viewCoordinator.addressBarPosition.isBottom {
            let navBarHeight = viewCoordinator.navigationBarContainer.frame.height
            viewCoordinator.navigationBarContainer.transform = CGAffineTransform(translationX: 0, y: navBarHeight * (1.0 - ratio))
        }
    }

    // 1.0 - full size, 0.0 - hidden
    private func updateNavBarConstant(_ ratio: CGFloat) {
        let browserTabsOffset = (viewCoordinator.tabBarContainer.isHidden ? 0 : viewCoordinator.tabBarContainer.frame.size.height)
        let navBarTopOffset = viewCoordinator.navigationBarContainer.frame.size.height + browserTabsOffset
        if !viewCoordinator.tabBarContainer.isHidden {
            let topBarsConstant = -browserTabsOffset * (1.0 - ratio)
            viewCoordinator.constraints.tabBarContainerTop.constant = topBarsConstant
        }
        viewCoordinator.constraints.navigationBarContainerTop.constant = browserTabsOffset + -navBarTopOffset * (1.0 - ratio)
    }

    func handleFavoriteSelected(_ favorite: BookmarkEntity) {
        guard let url = favorite.urlObject else { return }

        // Handle shortcuts for internal testing
        if let favUrl = favorite.url, let url = URL(string: favUrl), internalUserCommands.handle(url: url) {
            dismissSuggestionTray()
            return
        }

        newTabPageViewController?.chromeDelegate = nil
        dismissOmniBar()
        favicons.loadFavicon(forDomain: url.host, intoCache: .fireproof, fromCache: .tabs)
        if url.isBookmarklet() {
            executeBookmarklet(url)
        } else {
            loadUrl(url)
        }
        showHomeRowReminder()
    }


    func handleSuggestionSelected(_ suggestion: Suggestion) {
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.barUsedFromNTP(afterIdle: tab.openedAfterIdle)
        }
        newTabPageViewController?.chromeDelegate = nil
        dismissOmniBar()
        viewCoordinator.omniBar.cancel()
        switch suggestion {
        case .phrase(phrase: let phrase):
            if let url = URL.makeSearchURL(query: phrase, useUnifiedLogic: isUnifiedURLPredictionEnabled, forceSearchQuery: true) {
                loadUrl(url)
            } else {
                Logger.lifecycle.error("Couldn't form URL for suggestion: \(phrase, privacy: .public)")
            }

        case .website(url: let url):
            if url.isBookmarklet() {
                executeBookmarklet(url)
            } else {
                loadUrl(url)
            }

        case .bookmark(_, url: let url, _, _):
            loadUrl(url)

        case .historyEntry(_, url: let url, _):
            loadUrl(url)

        case .openTab(title: _, url: let url, tabId: let tabId, _):
            if newTabPageViewController != nil, let tab = tabManager.currentTabsModel.currentTab {
                self.closeTab(tab)
            }
            loadUrlInNewTab(url, reuseExisting: tabId.map(ExistingTabReusePolicy.tabWithId) ?? .any, inheritedAttribution: .noAttribution)

        case .askAIChat(let value):
            openAIChat(value, autoSend: true)

        case .unknown(value: let value), .internalPage(title: let value, url: _, _):
            assertionFailure("Unknown suggestion: \(value)")
        }

        showHomeRowReminder()
    }
}

// MARK: - OmniBarDelegate Methods
extension MainViewController: OmniBarDelegate {

    func isSuggestionTrayVisible() -> Bool {
        suggestionTrayController?.isShowing == true
    }

    func onSelectFavorite(_ favorite: BookmarkEntity) {
        handleFavoriteSelected(favorite)
    }

    func onEditFavorite(_ favorite: BookmarkEntity) {
        segueToEditBookmark(favorite)
    }

    func onPromptSubmitted(_ query: String, tools: [AIChatRAGTool]?) {
        commitToggleStateToCurrentTab()
        openAIChat(query, autoSend: true, tools: tools)
    }

    func onChatHistorySelected(url: URL) {
        loadUrlInNewTab(url, inheritedAttribution: nil)
    }

    func onAIChatQueryUpdated(_ query: String) {
        iPadAIChatQuery = query
        iPadTabChatHistoryCoordinator.updateQuery(query)
        updateIPadURLFallbackSuggestions()
    }

    func didRequestCurrentURL() -> URL? {
        return currentTab?.url
    }
    
    func onCustomizableButtonPressed() {
        guard mobileCustomization.state.isEnabled else {
            shareCurrentURLFromAddressBar()
            return
        }

        handleCustomizableAddressBarButtonPressed()
    }

    func selectedSuggestion() -> Suggestion? {
        return suggestionTrayController?.selectedSuggestion
    }

    func onOmniSuggestionSelected(_ suggestion: Suggestion) {
        autocomplete(selectedSuggestion: suggestion)
    }

    func onOmniQueryUpdated(_ updatedQuery: String) {
        if iPadTabChatHistoryCoordinator.isInstalled {
            iPadAIChatQuery = updatedQuery
        }
        // During iPad mode toggle transitions, text can be copied to the textField
        // which triggers this method even in duck.ai mode — suppress suggestions.
        if isModeToggleInAIChatMode {
            hideSuggestionTray()
            return
        }

        if updatedQuery.isEmpty {
            if newTabPageViewController != nil || !omniBar.isTextFieldEditing {
                hideSuggestionTray()
            } else {
                let didShow = tryToShowSuggestionTray(.favorites)
                if !didShow {
                    hideSuggestionTray()
                }
            }
        } else {
            tryToShowSuggestionTray(.autocomplete(query: updatedQuery))
        }
        
    }

    func onOmniQuerySubmitted(_ query: String) {
        commitToggleStateToCurrentTab()
        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        omniBar.cancel()
        loadQuery(query)
        hideSuggestionTray()
        hideNotificationBarIfBrokenSitePromptShown()
        showHomeRowReminder()
        fireOnboardingCustomSearchPixelIfNeeded(query: query)
    }

    func onPrivacyIconPressed(isHighlighted: Bool) {
        guard !isSERPPresented else { return }

        // Measure first tap of privacy icon button
        if isHighlighted {
            contextualOnboardingPixelReporter.measurePrivacyDashboardOpenedForFirstTime()
        }
        // Dismiss privacy icon animation when showing privacy dashboard
        dismissPrivacyDashboardButtonPulse()

        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        hideSuggestionTray()
        currentTab?.showPrivacyDashboard()
    }

    @objc func onMenuPressed() {
        viewCoordinator.menuToolbarButton.isEnabled = false
        omniBar.cancel()

        // Dismiss privacy icon animation when showing menu
        if !daxDialogsManager.shouldShowPrivacyButtonPulse {
            dismissPrivacyDashboardButtonPulse()
        }

        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        performCancel()
        ActionMessageView.dismissAllMessages()
        launchBrowsingMenu()
    }

    private func launchBrowsingMenu() {
        guard let tab = currentTab ?? tabManager.current(createIfNeeded: true) else {
            return
        }

        tab.fireModePromotionCoordinator = fireModePromotionEligibility

        // Determine context for menu building
        let context: BrowsingMenuContext
        if newTabPageViewController != nil {
            context = .newTabPage
        } else if aichatFullModeFeature.isAvailable && tab.isAITab {
            context = .aiChatTab
        } else {
            context = .website
        }
        
        if browsingMenuSheetCapability.isEnabled {
            launchSheetBrowsingMenu(in: context, tabController: tab)
        } else {
            launchDefaultBrowsingMenu(in: context, tabController: tab)
        }

        // Remove view highlighter in this run loop. Menu items will be highlighted after presentation
        ViewHighlighter.hideAll()

        tab.didLaunchBrowsingMenu()

        let modeParam = [PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue]
        switch context {
        case .newTabPage:
            Pixel.fire(pixel: .browsingMenuOpenedNewTabPage)
        case .aiChatTab:
            Pixel.fire(pixel: .browsingMenuOpened, withAdditionalParameters: modeParam)
            DailyPixel.fireDailyAndCount(pixel: .aiChatSettingsMenuOpened)
        case .website:
            Pixel.fire(pixel: .browsingMenuOpened, withAdditionalParameters: modeParam)

            if tab.isError {
                Pixel.fire(pixel: .browsingMenuOpenedError)
            }
        }
    }

    private func launchDefaultBrowsingMenu(in context: BrowsingMenuContext, tabController tab: TabViewController) {
        let menuEntries: [BrowsingMenuEntry]
        let headerEntries: [BrowsingMenuEntry]

        switch context {
        case .newTabPage:
            menuEntries = tab.buildShortcutsMenu()
            headerEntries = []

        case .aiChatTab:
            menuEntries = tab.buildAITabMenu()
            headerEntries = tab.buildAITabMenuHeaderContent()

        case .website:
            menuEntries = tab.buildBrowsingMenu(with: menuBookmarksViewModel,
                                                mobileCustomization: mobileCustomization,
                                                clearTabsAndData: onFirePressed)
            headerEntries = tab.buildBrowsingMenuHeaderContent()
        }

        let browsingMenu: BrowsingMenuViewController =
        BrowsingMenuViewController.instantiate(headerEntries: headerEntries,
                                               menuEntries: menuEntries,
                                               daxDialogsManager: daxDialogsManager,
                                               productSurfaceTelemetry: productSurfaceTelemetry)
        browsingMenu.isUsingSingleBar = isUsingSingleBar
        browsingMenu.onDismiss = { wasActionSelected in
            self.showMenuHighlighterIfNeeded()
            self.viewCoordinator.menuToolbarButton.isEnabled = true
            if !wasActionSelected {
                Pixel.fire(pixel: .browsingMenuDismissed)
            }
        }

        let highlightTag = menuHighlightingTag

        let controller = browsingMenu
        let presentationCompletion = {
            guard let highlightTag else { return }
            switch highlightTag {
            case .favorite:
                browsingMenu.highlightAddFavorite()

            case .fire:
                browsingMenu.highlightFireButton()
            }
        }

        controller.modalPresentationStyle = .custom

        present(controller, animated: true, completion: presentationCompletion)
    }

    private func launchSheetBrowsingMenu(in context: BrowsingMenuContext, tabController tab: TabViewController) {
        guard let model = tab.buildSheetBrowsingMenu(
            context: context,
            with: menuBookmarksViewModel,
            mobileCustomization: mobileCustomization,
            browsingMenuSheetCapability: browsingMenuSheetCapability,
            clearTabsAndData: onFirePressed
        ) else {
            viewCoordinator.menuToolbarButton.isEnabled = true
            return
        }

        let view = BrowsingMenuSheetView(model: model,
                                         headerDataSource: browsingMenuHeaderDataSource,
                                         highlightRowWithTag: menuHighlightingTag,
                                         onDismiss: { wasActionSelected in
                                             self.showMenuHighlighterIfNeeded()
                                             self.viewCoordinator.menuToolbarButton.isEnabled = true
                                             if !wasActionSelected {
                                                 Pixel.fire(pixel: .browsingMenuDismissed)
                                             }
                                         })

        let controller = BrowsingMenuSheetViewController(rootView: view)
        let contentHeight = model.estimatedContentHeight(
            headerDataSource: browsingMenuHeaderDataSource,
            verticalSizeClass: traitCollection.verticalSizeClass
        )

        let initialDetentHeight = model.estimatedInitialDetentHeight(
            headerDataSource: browsingMenuHeaderDataSource,
            verticalSizeClass: traitCollection.verticalSizeClass
        )

        func configureSheetPresentationController(_ sheet: UISheetPresentationController) {
            if context == .newTabPage {
                if #available(iOS 16.0, *) {
                    sheet.detents = [.custom { _ in contentHeight }]
                } else {
                    sheet.detents = [.medium()]
                }
            } else if let initialDetentHeight, #available(iOS 16.0, *) {
                sheet.detents = [.custom { _ in initialDetentHeight }, .large()]
            } else {
                sheet.detents = [.medium(), .large()]
            }
            sheet.prefersGrabberVisible = true
            sheet.widthFollowsPreferredContentSizeWhenEdgeAttached = true
            if #unavailable(iOS 26) {
                sheet.preferredCornerRadius = 24
            }
        }

        let isiPad = UIDevice.current.userInterfaceIdiom == .pad
        controller.modalPresentationStyle = isiPad ? .popover : .pageSheet

        if let popoverController = controller.popoverPresentationController {
            popoverController.sourceView = omniBar.barView.menuButton
            controller.preferredContentSize = CGSize(width: 391, height: contentHeight)

            configureSheetPresentationController(popoverController.adaptiveSheetPresentationController)
        }

        if let sheet = controller.sheetPresentationController {
           configureSheetPresentationController(sheet)
        }

        self.present(controller, animated: true)
    }

    @objc func onBookmarksPressed() {
        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        performCancel()
        segueToBookmarks()
    }

    @objc func onToolbarBookmarksPressed() {
        Pixel.fire(pixel: .bookmarksOpenFromToolbar)
        onBookmarksPressed()
    }

    func onBookmarkEdit() {
        ViewHighlighter.hideAll()
        hideSuggestionTray()
        segueToEditCurrentBookmark()
    }
    
    func onEnterPressed() {
        fireControllerAwarePixel(ntp: .keyboardGoWhileOnNTP,
                                 serp: .keyboardGoWhileOnSERP,
                                 website: .keyboardGoWhileOnWebsite,
                                 aiChat: .keyboardGoWhileOnAIChat)
    }

    func fireControllerAwarePixel(ntp: Pixel.Event, serp: Pixel.Event, website: Pixel.Event, aiChat: Pixel.Event,
                                   additionalParameters: [String: String] = [:]) {
        if newTabPageViewController != nil {
            Pixel.fire(pixel: ntp, withAdditionalParameters: additionalParameters)
        } else if let currentTab {
            if currentTab.isAITab == true {
                Pixel.fire(pixel: aiChat, withAdditionalParameters: additionalParameters)
            } else if currentTab.url?.isDuckDuckGoSearch == true {
                Pixel.fire(pixel: serp, withAdditionalParameters: additionalParameters)
            } else {
                Pixel.fire(pixel: website, withAdditionalParameters: additionalParameters)
            }
        }
    }

    func onEditingEnd() -> OmniBarEditingEndResult {
        if isShowingAutocompleteSuggestions {
            return .suspended
        } else {
            dismissOmniBar()
            return .dismissed
        }
    }

    func onSettingsPressed() {
        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }
        segueToSettings()
    }

    @objc func onMenuLongPressed() {
        if featureFlagger.internalUserDecider.isInternalUser || isDebugBuild {
            segueToDebugSettings()
        } else {
            segueToSettings()
        }
    }

    override func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
        if motion == .motionShake, featureFlagger.internalUserDecider.isInternalUser || isDebugBuild {
            var topVC: UIViewController = self
            while let presented = topVC.presentedViewController {
                topVC = presented
            }
            if !(topVC is DebugScreensViewController),
               !((topVC as? UINavigationController)?.viewControllers.first is DebugScreensViewController) {
                segueToDebugSettings()
            }
        }
        super.motionEnded(motion, with: event)
    }

    func performCancel() {
        dismissOmniBar()
        omniBar.cancel()
        hideSuggestionTray()
        themeColorManager.updateThemeColor()
        self.showMenuHighlighterIfNeeded()
    }

    func onCancelPressed() {
        fireControllerAwarePixel(ntp: .addressBarCancelPressedOnNTP,
                                 serp: .addressBarCancelPressedOnSERP,
                                 website: .addressBarCancelPressedOnWebsite,
                                 aiChat: .addressBarCancelPressedOnAIChat)
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.backButtonUsedFromNTP(afterIdle: tab.openedAfterIdle)
        }
        performCancel()
    }

    func onAbortPressed() {
        Pixel.fire(pixel: .stopPageLoad)
        stopLoading()
    }

    func onClearTextPressed() {
        fireControllerAwarePixel(ntp: .addressBarClearPressedOnNTP,
                                 serp: .addressBarClearPressedOnSERP,
                                 website: .addressBarClearPressedOnWebsite,
                                 aiChat: .addressBarClearPressedOnAIChat)
    }

    private func newTabShortcutAction() {
        Pixel.fire(pixel: .tabSwitchLongPressNewTab, withAdditionalParameters: [
            PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue
        ])
        performCancel()
        newTab()
    }

    private func newFireTabLongPressMenuAction() {
        tabManager.setBrowsingMode(.fire, source: .longPressTabsIcon)
        performCancel()
        newTab()
    }

    private func newNormalTabLongPressMenuAction() {
        tabManager.setBrowsingMode(.normal, source: .longPressTabsIcon)
        performCancel()
        newTab()
    }

    private var isSERPPresented: Bool {
        guard let tabURL = currentTab?.url else { return false }
        return tabURL.isDuckDuckGoSearch
    }

    func onTextFieldWillBeginEditing(_ omniBar: OmniBarView, tapped: Bool) {
        // We don't want any action here if we're still in autocomplete context
        guard !isShowingAutocompleteSuggestions else { return }

        // Dismiss contextual AI chat sheet when omni bar becomes active
        if let currentTab, tapped {
            currentTab.aiChatContextualSheetCoordinator.dismissSheet()
        }

        if let currentTab {
            viewCoordinator.omniBar.refreshText(forUrl: currentTab.url, forceFullURL: true)
        }

        if tapped {
            let modeParam = [PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue]
            fireControllerAwarePixel(ntp: .addressBarClickOnNTP,
                                     serp: .addressBarClickOnSERP,
                                     website: .addressBarClickOnWebsite,
                                     aiChat: .addressBarClickOnAIChat,
                                     additionalParameters: modeParam)
        }

        guard newTabPageViewController == nil else { return }
        guard !isModeToggleInAIChatMode else { return }

        if !skipSERPFlow, isSERPPresented, let query = omniBar.text {
            tryToShowSuggestionTray(.autocomplete(query: query))
        } else {
            tryToShowSuggestionTray(.favorites)
        }
        themeColorManager.updateThemeColor()
    }

    private func installContextualSheetDismissGesture() {
        let tap = UITapGestureRecognizer(target: self, action: #selector(dismissContextualSheetOnBackgroundTap))
        tap.cancelsTouchesInView = false
        tap.delaysTouchesBegan = false
        tap.delaysTouchesEnded = false
        tap.delegate = self
        viewCoordinator.navigationBarContainer.addGestureRecognizer(tap)
    }

    @objc private func dismissContextualSheetOnBackgroundTap() {
        currentTab?.aiChatContextualSheetCoordinator.dismissSheet()
    }

    func dismissContextualSheetIfNeeded(completion: @escaping () -> Void) {
        guard let currentTab,
              currentTab.aiChatContextualSheetCoordinator.isSheetPresented,
              let sheetVC = currentTab.aiChatContextualSheetCoordinator.sheetViewController else {
            completion()
            return
        }

        sheetVC.dismiss(animated: true) {
            completion()
        }
    }

    func onTextFieldDidBeginEditing(_ omniBar: OmniBarView) -> Bool {

        let selectQueryText = !(isSERPPresented && !skipSERPFlow)
        skipSERPFlow = false
        
        if !daxDialogsManager.shouldShowFireButtonPulse {
            ViewHighlighter.hideAll()
        }

        return selectQueryText
    }

    func shouldAutoSelectTextForSERPQuery() -> Bool {
        let shouldSelect = isSERPPresented && skipSERPFlow
        skipSERPFlow = false
        return shouldSelect
    }

    func onRefreshPressed() {
        hideSuggestionTray()
        currentTab?.refresh()
        hideNotificationBarIfBrokenSitePromptShown(afterRefresh: true)
    }

    func onAIChatPressed() {
        hideSuggestionTray()

        if let currentTab, aiChatContextualModeFeature.isAvailable, newTabPageViewController == nil {
            omniBar.endEditing()
            currentTab.presentContextualAIChatSheet(from: self)
        } else {
            openAIChatFromAddressBar()
        }
    }

    private func shareCurrentURLFromAddressBar() {
        Pixel.fire(pixel: .addressBarShare)
        guard let link = currentTab?.link else { return }
        currentTab?.onShareAction(forLink: link, fromView: viewCoordinator.omniBar.barView.customizableButton)
    }

    private func shareCurrentURLFromToolbar() {
        guard let targetView = viewCoordinator.toolbarFireBarButtonItem.customView else {
            assertionFailure("Expected custom view on toolbar fire button")
            return
        }
        // Pixels coming later.
        guard let link = currentTab?.link else { return }
        currentTab?.onShareAction(forLink: link, fromView: targetView)
    }

    private func openAIChatFromAddressBar() {

        let isEditing = omniBar.isTextFieldEditing
        let textFieldValue = omniBar.text
        omniBar.endEditing()

        OpenAIChatFromAddressBarHandling().determineOpeningStrategy(
            isTextFieldEditing: isEditing,
            textFieldValue: textFieldValue,
            currentURL: currentTab?.url,
            openWithPromptAndSend: {
                openAIChat($0, autoSend: true)
            },
            open: {
                openAIChat()
            }
        )

        if !aiChatSettings.isAIChatSearchInputUserSettingsEnabled {
            DailyPixel.fireDailyAndCount(pixel: .aiChatLegacyOmnibarAichatButtonPressed)
        }
        fireAIChatUsagePixelAndSetFeatureUsed(.openAIChatFromAddressBar)
    }

    private func fireAIChatUsagePixelAndSetFeatureUsed(_ pixel: Pixel.Event) {
        Pixel.fire(pixel: pixel, withAdditionalParameters: featureDiscovery.addToParams([:], forFeature: .aiChat))
        featureDiscovery.setWasUsedBefore(.aiChat)
    }

    func onVoiceSearchPressed() {
        handleVoiceSearchOpenRequest()
    }

    func onVoiceSearchPressed(preferredTarget: VoiceSearchTarget) {
        handleVoiceSearchOpenRequest(preferredTarget: preferredTarget)
    }

    func onDidBeginEditing() { }
    func onDidEndEditing() {
        // Restore the tab's committed mode — the user may have toggled without submitting.
        // Safe on iPhone: the experimental editing state prevents textFieldDidEndEditing from
        // firing (text field never becomes first responder during that flow).
        if let tabMode = tabManager.currentTabsModel.currentTab?.preferredTextEntryMode {
            viewCoordinator.omniBar.setSelectedTextEntryMode(tabMode)
        }
    }

    // MARK: - iPad Expanded Omnibar

    func onOmniBarExpandedStateChanged(isExpanded: Bool) {
        if isExpanded {
            hideSuggestionTray()

            iPadTabChatHistoryCoordinator.delegate = self
            iPadTabChatHistoryCoordinator.install(
                in: view,
                parentViewController: self,
                searchContainer: viewCoordinator.omniBar.barView.searchContainer,
                isFireTab: isCurrentTabFireTab(),
                keyboardLayoutGuide: view.keyboardLayoutGuide
            )
            iPadTabChatHistoryCoordinator.onSuggestionsVisibilityChanged = { [weak self] _ in
                guard let self else { return }
                if self.isAwaitingIPadHistoryRefreshAfterModeSwitch {
                    self.isAwaitingIPadHistoryRefreshAfterModeSwitch = false
                }
                self.updateIPadURLFallbackSuggestions()
            }

            guard expandedOmniBarDismissTapGesture == nil else { return }
            let tap = UITapGestureRecognizer(target: self, action: #selector(dismissExpandedOmniBar))
            tap.cancelsTouchesInView = false
            viewCoordinator.contentContainer.addGestureRecognizer(tap)
            expandedOmniBarDismissTapGesture = tap
        } else {
            iPadTabChatHistoryCoordinator.tearDown()
            iPadAIChatQuery = ""
            suggestionTrayController?.suggestionFilter = .all
            suggestionTrayController?.additionalTopInset = 0

            if let tap = expandedOmniBarDismissTapGesture {
                viewCoordinator.contentContainer.removeGestureRecognizer(tap)
                expandedOmniBarDismissTapGesture = nil
            }
        }
    }

    @objc private func dismissExpandedOmniBar() {
        performCancel()
    }

    /// Shows URL-only suggestions below the AI text input only when chat history has no matches.
    private func updateIPadURLFallbackSuggestions() {
        let effectiveQuery = currentIPadAIQuery()
        iPadAIChatQuery = effectiveQuery

        guard iPadTabChatHistoryCoordinator.isInstalled else {
            suggestionTrayController?.suggestionFilter = .all
            suggestionTrayController?.additionalTopInset = 0
            return
        }
        guard isModeToggleInAIChatMode else {
            suggestionTrayController?.suggestionFilter = .all
            suggestionTrayController?.additionalTopInset = 0
            return
        }
        if isAwaitingIPadHistoryRefreshAfterModeSwitch {
            hideSuggestionTrayContainerForIPadAI()
            return
        }

        let shouldShowURLFallback = !effectiveQuery.isBlank && !iPadTabChatHistoryCoordinator.hasSuggestions
        if shouldShowURLFallback {
            suggestionTrayController?.suggestionFilter = .urlsOnly
            suggestionTrayController?.additionalTopInset = iPadURLFallbackTopInset()
            allowIPadAIAutocompleteShow = true
            let didShow = tryToShowSuggestionTray(.autocomplete(query: effectiveQuery))
            allowIPadAIAutocompleteShow = false
            if !didShow {
                hideSuggestionTrayContainerForIPadAI()
            }
        } else {
            suggestionTrayController?.suggestionFilter = .all
            suggestionTrayController?.additionalTopInset = 0
            hideSuggestionTrayContainerForIPadAI()
        }
    }

    private func iPadURLFallbackTopInset() -> CGFloat {
        guard let searchContainer = viewCoordinator.omniBar.barView.searchContainer else {
            return 0
        }
        let spacing: CGFloat = 12
        let containerFrame = searchContainer.convert(searchContainer.bounds, to: viewCoordinator.contentContainer)
        return max(0, containerFrame.maxY) + spacing
    }

    private func currentIPadAIQuery() -> String {
        guard let omniBarVC = viewCoordinator.omniBar as? OmniBarViewController else {
            return iPadAIChatQuery
        }
        if let expandable = omniBarVC.expandableBarView, expandable.isSearchAreaExpanded {
            return expandable.aiChatTextView.text ?? ""
        }
        return omniBarVC.text ?? iPadAIChatQuery
    }

    /// Hides only the tray container during iPad duck.ai transitions.
    /// Keeps tray content alive to avoid remove/reinstall flicker when toggling modes.
    private func hideSuggestionTrayContainerForIPadAI() {
        viewCoordinator.omniBar.showSeparator()
        viewCoordinator.suggestionTrayContainer.isHidden = true
        currentTab?.webView.accessibilityElementsHidden = false
    }

    // MARK: - Experimental Address Bar (pixels only)
    func onExperimentalAddressBarTapped() {
        let modeParam = [PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue]
        fireControllerAwarePixel(ntp: .addressBarClickOnNTP,
                                 serp: .addressBarClickOnSERP,
                                 website: .addressBarClickOnWebsite,
                                 aiChat: .addressBarClickOnAIChat,
                                 additionalParameters: modeParam)
    }

    func onExperimentalAddressBarClearPressed() {
        fireControllerAwarePixel(ntp: .addressBarClearPressedOnNTP,
                                 serp: .addressBarClearPressedOnSERP,
                                 website: .addressBarClearPressedOnWebsite,
                                 aiChat: .addressBarClearPressedOnAIChat)
    }

    func onExperimentalAddressBarCancelPressed() {
        fireControllerAwarePixel(ntp: .addressBarCancelPressedOnNTP,
                                 serp: .addressBarCancelPressedOnSERP,
                                 website: .addressBarCancelPressedOnWebsite,
                                 aiChat: .addressBarCancelPressedOnAIChat)
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.backButtonUsedFromNTP(afterIdle: tab.openedAfterIdle)
        }
    }

    /// Delegate method called when the AI Chat left button is tapped
    func onAIChatLeftButtonPressed() {
        DailyPixel.fireDailyAndCount(pixel: .aiChatOmnibarSidebarButtonTapped)
        currentTab?.submitToggleSidebarAction()
    }

    /// Delegate method called when the omnibar branding area is tapped while in AI Chat mode.
    func onAIChatBrandingPressed() {
        Pixel.fire(pixel: .addressBarClickOnAIChat, withAdditionalParameters: [
            PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue
        ])
        viewCoordinator.omniBar.beginEditing(animated: true, forTextEntryMode: .aiChat)
    }

    func escapeHatchForEditingState() -> EscapeHatchModel? {
        guard idleReturnEligibilityManager.isEligibleForNTPAfterIdle(),
              tabManager.currentTabsModel.currentTab?.link == nil else {
            return nil
        }
        return currentNTPEscapeHatch
    }

    func useNewOmnibarTransitionBehaviour() -> Bool {
        escapeHatchForEditingState() != nil
    }

    func onSwitchToTab(_ tab: Tab) {
        let targetTabsModel = tabManager.tabsModel(for: tab.mode)
        guard targetTabsModel.tabExists(tab: tab) else {
            viewCoordinator.omniBar.endEditing()
            return
        }
        let currentTab = tabManager.currentTabsModel.currentTab
        guard tab !== currentTab else {
            viewCoordinator.omniBar.endEditing()
            return
        }
        let wasAfterIdle = currentTab?.openedAfterIdle ?? false
        ntpAfterIdleInstrumentation.returnToPageTapped(afterIdle: wasAfterIdle)
        viewCoordinator.omniBar.endEditing()
        if let currentTab {
            closeTab(currentTab)
        }
        selectTab(tab)
    }

    func onToggleModeSwitched() {
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.toggleUsedFromNTP(afterIdle: tab.openedAfterIdle)
        }
        iPadAIChatQuery = currentIPadAIQuery()
        guard iPadTabChatHistoryCoordinator.isInstalled else { return }
        if isModeToggleInAIChatMode {
            // Hide visible search suggestions immediately, but keep content alive
            // to avoid raw teardown/reinstall flashes during quick mode toggles.
            hideSuggestionTrayContainerForIPadAI()
            isAwaitingIPadHistoryRefreshAfterModeSwitch = !iPadAIChatQuery.isBlank
            iPadTabChatHistoryCoordinator.updateQuery(iPadAIChatQuery)
            if !isAwaitingIPadHistoryRefreshAfterModeSwitch {
                updateIPadURLFallbackSuggestions()
            }
        } else {
            isAwaitingIPadHistoryRefreshAfterModeSwitch = false
            suggestionTrayController?.suggestionFilter = .all
            suggestionTrayController?.additionalTopInset = 0
        }
    }

    func onTextEntryModeDidChange(_ mode: TextEntryMode) {
        onToggleModeSwitched()
    }

    func preferredTextEntryModeForCurrentTab() -> TextEntryMode? {
        tabManager.currentTabsModel.currentTab?.preferredTextEntryMode
    }

    /// Saves the current omnibar toggle state to the tab on submission,
    /// and persists it globally so "Last Used" mode picks it up for new tabs.
    private func commitToggleStateToCurrentTab() {
        guard let omniBarVC = viewCoordinator.omniBar as? OmniBarViewController else { return }
        commitToggleMode(omniBarVC.selectedTextEntryMode)
    }

    /// Shared commit logic for all toggle paths (iPad, iPhone editing state, unified toggle input).
    func commitToggleMode(_ mode: TextEntryMode) {
        tabManager.currentTabsModel.currentTab?.preferredTextEntryMode = mode
        toggleModeStorage.save(mode)
    }
    
    func onFireModeRequested() {
        navigateToFireMode(source: .ntpPromotion)
    }

    func isCurrentTabFireTab() -> Bool {
        tabManager.currentTabsModel.currentTab?.fireTab ?? false
    }
}

// MARK: - AutocompleteViewControllerDelegate Methods
extension MainViewController: AutocompleteViewControllerDelegate {

    func autocompleteDidEndWithUserQuery() {
        if let query = omniBar.text {
            onOmniQuerySubmitted(query
            )
        }
    }

    func autocomplete(selectedSuggestion suggestion: Suggestion) {
        handleSuggestionSelected(suggestion)
    }

    func autocomplete(pressedPlusButtonForSuggestion suggestion: Suggestion) {
        switch suggestion {
        case .phrase(phrase: let phrase), .askAIChat(let phrase):
            viewCoordinator.omniBar.updateQuery(phrase)
        case .website(url: let url):
            if url.isDuckDuckGoSearch, let query = url.searchQuery {
                viewCoordinator.omniBar.updateQuery(query)
            } else if !url.isBookmarklet() {
                viewCoordinator.omniBar.updateQuery(url.absoluteString)
            }
        case .bookmark(title: let title, _, _, _):
            viewCoordinator.omniBar.updateQuery(title)
        case .historyEntry(title: let title, _, _):
            viewCoordinator.omniBar.updateQuery(title)
        case .openTab: break // no-op
        case .unknown(value: let value), .internalPage(title: let value, url: _, _):
            assertionFailure("Unknown suggestion: \(value)")
        }
    }
    
    func autocomplete(highlighted suggestion: Suggestion, for query: String) {

        switch suggestion {
        case .phrase(phrase: let phrase), .askAIChat(let phrase):
            viewCoordinator.omniBar.text = phrase
            if phrase.hasPrefix(query) {
                viewCoordinator.omniBar.selectTextToEnd(query.count)
            }
        case .website(url: let url):
            viewCoordinator.omniBar.text = url.absoluteString
        case .bookmark(title: let title, _, _, _), .openTab(title: let title, url: _, _, _):
            viewCoordinator.omniBar.text = title
            if title.hasPrefix(query) {
                viewCoordinator.omniBar.selectTextToEnd(query.count)
            }
        case .historyEntry(title: let title, let url, _):
            if url.isDuckDuckGoSearch, let query = url.searchQuery {
                viewCoordinator.omniBar.text = query
            }

            if (title ?? url.absoluteString).hasPrefix(query) {
                viewCoordinator.omniBar.selectTextToEnd(query.count)
            }

        case .unknown(value: let value), .internalPage(title: let value, url: _, _):
            assertionFailure("Unknown suggestion: \(value)")
        }
    }

    func autocompleteWasDismissed() {
        dismissOmniBar()
    }

}

extension MainViewController {
    private func handleRequestedURL(_ url: URL) {
        showKeyboardAfterFireButton?.cancel()

        if url.isBookmarklet() {
            executeBookmarklet(url)
        } else {
            loadUrl(url)
        }
    }
}

extension MainViewController: NewTabPageControllerDelegate {

    func newTabPageDidSelectFavorite(_ controller: NewTabPageViewController, favorite: BookmarkEntity) {
        self.onSelectFavorite(favorite)
    }

    func newTabPageDidEditFavorite(_ controller: NewTabPageViewController, favorite: BookmarkEntity) {
        segueToEditBookmark(favorite)
    }

    func newTabPageDidRequestFaviconsFetcherOnboarding(_ controller: NewTabPageViewController) {
        faviconsFetcherOnboarding.presentOnboardingIfNeeded(from: self)
    }

    func newTabPageDidRequestSwitchToTab(_ controller: NewTabPageViewController, tab: Tab) {
        let targetTabsModel = tabManager.tabsModel(for: tab.mode)
        guard targetTabsModel.tabExists(tab: tab) else {
            controller.setEscapeHatch(nil)
            currentNTPEscapeHatch = nil
            return
        }
        let currentTab = tabManager.currentTabsModel.currentTab
        guard tab !== currentTab else { return }
        let wasAfterIdle = currentTab?.openedAfterIdle ?? false
        ntpAfterIdleInstrumentation.returnToPageTapped(afterIdle: wasAfterIdle)
        if let currentTab {
            closeTab(currentTab)
        }
        selectTab(tab)
        currentNTPEscapeHatch = nil
    }

    func newTabPageDidRequestFireMode(_ controller: NewTabPageViewController) {
        navigateToFireMode(source: .ntpPromotion)
    }
}

extension MainViewController: TabDelegate {

    var isEmailProtectionSignedIn: Bool {
        emailManager.isSignedIn
    }
    
    func tabDidRequestNewPrivateEmailAddress(tab: TabViewController) {
        newEmailAddress()
    }

    func tabDidRequestFireMode(tab: TabViewController) {
        navigateToFireMode(source: .menuPromotion)
    }

    var isAIChatEnabled: Bool {
        return aiChatSettings.isAIChatEnabled
    }
    
    func tab(_ tab: TabViewController,
             didRequestNewWebViewWithConfiguration configuration: WKWebViewConfiguration,
             for navigationAction: WKNavigationAction,
             inheritingAttribution: AdClickAttributionLogic.State?) -> WKWebView? {
        hideNotificationBarIfBrokenSitePromptShown()
        showBars()
        currentTab?.dismiss()
        tab.aiChatContextualSheetCoordinator.dismissSheet()
        themeColorManager.updateThemeColor()

        // Don't use a request or else the page gets stuck on "about:blank"
        let newTab = tabManager.addURLRequest(nil,
                                              with: configuration,
                                              inheritedAttribution: inheritingAttribution)
        newTab.openedByPage = true
        newTab.openingTab = tab
        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)

        newTabAnimation {
            guard self.tabManager.currentTabsModel.tabs.contains(newTab.tabModel) else { return }

            self.dismissOmniBar()
            self.attachTab(tab: newTab)
            self.refreshOmniBar()
        }

        return newTab.webView
    }

    func tabDidRequestClose(_ tab: Tab,
                            behavior: TabClosingBehavior,
                            clearTabHistory: Bool) {
        closeTab(tab,
                 behavior: behavior,
                 clearTabHistory: clearTabHistory)
    }

    func tabLoadingStateDidChange(tab: TabViewController) {
        if currentTab == tab {
            refreshControls()
            themeColorManager.updateThemeColor()
        }
        _ = tabManager.save()
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel)
        // note: model in swipeTabsCoordinator doesn't need to be updated here
        // https://app.asana.com/0/414235014887631/1206847376910045/f
    }
    
    func tab(_ tab: TabViewController, didUpdatePreview preview: UIImage) {
        previewsSource.update(preview: preview, forTab: tab.tabModel)
    }

    func tabWillRequestNewTab(_ tab: TabViewController) -> UIKeyModifierFlags? {
        keyModifierFlags
    }

    func tabDidRequestNewTab(_ tab: TabViewController) {
        _ = findInPageView?.resignFirstResponder()
        newTab()
    }
    
    func newTab(reuseExisting: Bool) {
        newTab(reuseExisting: reuseExisting, allowingKeyboard: false)
    }

    func tabDidRequestActivate(_ tab: TabViewController) {
        transitionTo(tab: tab, from: nil)
    }

    func tab(_ tab: TabViewController,
             didRequestNewBackgroundTabForUrl url: URL,
             inheritingAttribution attribution: AdClickAttributionLogic.State?) {
        tabManager.add(url: url, inBackground: true, inheritedAttribution: attribution)
        animateBackgroundTab()
    }

    func tab(_ tab: TabViewController,
             didRequestNewFireTabForUrl url: URL,
             inheritingAttribution attribution: AdClickAttributionLogic.State?) {
        tabManager.setBrowsingMode(.fire, source: .longPressLink)
        loadUrlInNewTab(url, inheritedAttribution: attribution)
    }

    func tab(_ tab: TabViewController,
             didRequestNewTabForUrl url: URL,
             openedByPage: Bool,
             inheritingAttribution attribution: AdClickAttributionLogic.State?) {
        _ = findInPageView?.resignFirstResponder()
        hideNotificationBarIfBrokenSitePromptShown()
        tab.aiChatContextualSheetCoordinator.dismissSheet()
        if openedByPage {
            showBars()
            newTabAnimation {
                self.loadUrlInNewTab(url, inheritedAttribution: attribution)
                self.currentTab?.openedByPage = true
                self.currentTab?.openingTab = tab
            }
            tabSwitcherButton?.animateUpdate {
                self.tabSwitcherButton?.tabCount += 1
            }
            omniBarTabSwitcherButton?.animateUpdate {
                self.omniBarTabSwitcherButton?.tabCount += 1
            }
        } else {
            loadUrlInNewTab(url, inheritedAttribution: attribution)
            self.currentTab?.adClickExternalOpenDetector.invalidateForUserInitiated()
            self.currentTab?.openingTab = tab
        }

    }

    func tab(_ tab: TabViewController, didChangePrivacyInfo privacyInfo: PrivacyInfo?) {
        if currentTab == tab {
            viewCoordinator.omniBar.updatePrivacyIcon(for: privacyInfo)
            themeColorManager.updateThemeColor()
        }
    }
    
    func tab(_ tab: TabViewController, didExtractDaxEasterEggLogoURL logoURL: String?) {
        DispatchQueue.main.async { [weak self] in
            guard let self = self else { return }
            tab.tabModel.daxEasterEggLogoURL = logoURL
            if self.currentTab == tab {
                let finalLogoURL = self.logoURLForCurrentPage(tab: tab)
                self.viewCoordinator.omniBar.setDaxEasterEggLogoURL(finalLogoURL)
                self.updateBrowsingMenuHeaderDataSource()
            }
        }
    }

    private func logoURLForCurrentPage(tab: TabViewController) -> String? {
        guard let url = tab.url, url.isDuckDuckGoSearch else { return nil }
        guard featureFlagger.isFeatureOn(.daxEasterEggLogos) else { return nil }
        if featureFlagger.isFeatureOn(.daxEasterEggPermanentLogo) {
            return daxEasterEggLogoStore.logoURL ?? tab.tabModel.daxEasterEggLogoURL
        }
        return tab.tabModel.daxEasterEggLogoURL
    }

    func tabDidRequestReportBrokenSite(tab: TabViewController) {
        segueToReportBrokenSite()
    }

    func tab(_ tab: TabViewController, didRequestToggleReportWithCompletionHandler completionHandler: @escaping (Bool) -> Void) {
        segueToReportBrokenSite(entryPoint: .toggleReport(completionHandler: completionHandler))
    }

    func tabDidRequestAIChat(tab: TabViewController) {
        fireAIChatUsagePixelAndSetFeatureUsed(tab.link == nil ? .browsingMenuAIChatNewTabPage : .browsingMenuAIChatWebPage)
        if aichatIPadTabFeature.isAvailable {
            newTab(allowingKeyboard: false)
        }
        openAIChat()
    }

    func tabDidRequestBookmarks(tab: TabViewController) {
        Pixel.fire(pixel: .bookmarksButtonPressed,
                   withAdditionalParameters: [PixelParameters.originatedFromMenu: "1"])
        onBookmarksPressed()
    }
    
    func tabDidRequestEditBookmark(tab: TabViewController) {
        onBookmarkEdit()
    }
    
    func tabDidRequestDownloads(tab: TabViewController) {
        segueToDownloads()
    }
    
    func tab(_ tab: TabViewController,
             didRequestAutofillLogins account: SecureVaultModels.WebsiteAccount?,
             source: AutofillSettingsSource, extensionPromotionManager: AutofillExtensionPromotionManaging? = nil) {
        launchAutofillLogins(with: currentTab?.url, currentTabUid: tab.tabModel.uid, source: source, selectedAccount: account, extensionPromotionManager: extensionPromotionManager)
    }

    func tab(_ tab: TabViewController,
             didRequestDataImport source: DataImportViewModel.ImportScreen, onFinished: @escaping () -> Void, onCancelled: @escaping () -> Void) {
        launchDataImport(source: source, onFinished: onFinished, onCancelled: onCancelled)
    }

    func tabDidRequestSettings(tab: TabViewController) {
        segueToSettings()
    }

    func tab(_ tab: TabViewController,
             didRequestSettingsToLogins account: SecureVaultModels.WebsiteAccount,
             source: AutofillSettingsSource) {
        segueToSettingsAutofillWith(account: account, card: nil, source: source)
    }

    func tab(_ tab: TabViewController, didRequestSettingsToCreditCards card: SecureVaultModels.CreditCard, source: AutofillSettingsSource) {
        segueToSettingsAutofillWith(account: nil, card: card, source: source)
    }

    func tabDidRequestSettingsToCreditCardManagement(_ tab: TabViewController, source: AutofillSettingsSource) {
        segueToSettingsAutofillWith(account: nil, card: nil, showCardManagement: true, source: source)
    }

    func tabDidRequestSettingsToVPN(_ tab: TabViewController) {
        segueToVPN()
    }

    func tabDidRequestSettingsToAIChat(_ tab: TabViewController) {
        segueToSettingsAIChat()
    }

    func tabDidRequestSettingsToSync(_ tab: TabViewController) {
        segueToSettingsSync()
    }

    func tabContentProcessDidTerminate(tab: TabViewController) {
        findInPageView?.done()
        tabManager.invalidateCache(forController: tab)
    }

    func showBars() {
        chromeManager.reset()
    }
    
    func tabDidRequestFindInPage(tab: TabViewController) {
        updateFindInPage()
        _ = findInPageView?.becomeFirstResponder()

        viewCoordinator.hideNavigationBarWithBottomPosition()
    }

    func closeFindInPage(tab: TabViewController) {
        if tab === currentTab {
            findInPageView?.done()
        } else {
            tab.findInPage?.done()
            tab.findInPage = nil
        }
    }
    
    func tabDidRequestFireButtonPulse(tab: TabViewController) {
        showFireButtonPulse()
    }

    func tabDidRequestToggleSidebarOnCurrentTab(_ tab: TabViewController) {
        currentTab?.submitToggleSidebarAction()
    }

    func tabDidRequestDeleteContextualChat(tab: TabViewController, chatID: String) {
        let cleaner = HistoryCleaner(featureFlagger: featureFlagger,
                                     privacyConfig: privacyConfigurationManager)
        Task { @MainActor in
            await cleaner.deleteAIChat(chatID: chatID)
        }
    }
    
    func tabDidRequestPrivacyDashboardButtonPulse(tab: TabViewController, animated: Bool) {
        if animated {
            showPrivacyDashboardButtonPulse()
        } else {
            dismissPrivacyDashboardButtonPulse()
        }
    }

    func tabDidRequestSearchBarRect(tab: TabViewController) -> CGRect {
        searchBarRect
    }

    func tab(_ tab: TabViewController,
             didRequestPresentingTrackerAnimation privacyInfo: PrivacyInfo,
             isCollapsing: Bool) {
        guard currentTab === tab else { return }
        viewCoordinator.omniBar?.startTrackersAnimation(privacyInfo, forDaxDialog: !isCollapsing)
    }
    
    func tabDidRequestShowingMenuHighlighter(tab: TabViewController) {
        showMenuHighlighterIfNeeded()
    }

    private func newTabAnimation(completion: @escaping () -> Void) {
        UIImpactFeedbackGenerator(style: .heavy).impactOccurred()

        let x = view.frame.midX
        let y = view.frame.midY
        
        let theme = ThemeManager.shared.currentTheme
        let view = UIView(frame: CGRect(x: x, y: y, width: 5, height: 5))
        view.layer.borderWidth = 1
        view.layer.cornerRadius = 10
        view.layer.borderColor = theme.barTintColor.cgColor
        view.backgroundColor = theme.backgroundColor
        view.center = self.view.center
        self.view.addSubview(view)
        UIView.animate(withDuration: 0.3, animations: {
            view.frame = self.view.frame
            view.alpha = 0.9
        }, completion: { _ in
            view.removeFromSuperview()
            completion()
        })
    }
    
    func tab(_ tab: TabViewController, didRequestPresentingAlert alert: UIAlertController) {
        present(alert, animated: true)
    }

    func selectTab(_ tab: Tab) {
        viewCoordinator.navigationBarContainer.alpha = 1
        allowContentUnderflow = false

        let previousTab = tabManager.current()
        if let tab = tabManager.select(tab, dismissCurrent: false)  {
            transitionTo(tab: tab, from: previousTab)
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
            self.performCancel()
        }
    }

    func tabCheckIfItsBeingCurrentlyPresented(_ tab: TabViewController) -> Bool {
        return currentTab === tab
    }

    func tab(_ tab: TabViewController, didRequestLoadURL url: URL) {
        loadUrl(url, fromExternalLink: true)
    }

    func tab(_ tab: TabViewController, didRequestLoadQuery query: String) {
        loadQuery(query)
    }
    
    func tabDidRequestRefresh(tab: TabViewController) {
        hideNotificationBarIfBrokenSitePromptShown(afterRefresh: true)
    }

    func tabDidRequestNavigationToDifferentSite(tab: TabViewController) {
        hideNotificationBarIfBrokenSitePromptShown()
    }

}

extension MainViewController: TabSwitcherDelegate {

    func tabSwitcher(_ tabSwitcher: TabSwitcherViewController, didFinishWithSelectedTab tab: Tab?) {
        defer {
            showMenuHighlighterIfNeeded()
            applyWidth()
        }
        let previousTab = currentTab
        
        guard tab !== previousTab?.tabModel else {
            if daxDialogsManager.shouldShowFireButtonPulse {
                showFireButtonPulse()
            }
            themeColorManager.updateThemeColor()
            return
        }
        
        if let tab {
            tabManager.select(tab, dismissCurrent: false)
        }

        guard let newTab = tabManager.current(createIfNeeded: true) else {
            assertionFailure("Couldn't create new tab")
            return
        }
        transitionTo(tab: newTab, from: previousTab)
    }

    private func animateLogoAppearance() {
        newTabPageViewController?.view.transform = CGAffineTransform().scaledBy(x: 0.5, y: 0.5)
        newTabPageViewController?.view.alpha = 0.0
        UIView.animate(withDuration: 0.2, delay: 0.1, options: [.curveEaseInOut, .beginFromCurrentState]) {
            self.newTabPageViewController?.view.transform = .identity
            self.newTabPageViewController?.view.alpha = 1.0
        }
    }

    private func deferNTPAppearance() {
        newTabPageViewController?.view.alpha = 0.0
        UIView.animate(withDuration: 0.2, delay: 0.2, options: [.curveEaseInOut, .beginFromCurrentState]) {
            self.newTabPageViewController?.view.alpha = 1.0
        }
    }

    func tabSwitcherDidRequestNewTab(tabSwitcher: TabSwitcherViewController) {
        newTab()
        if newTabPageViewController?.isShowingLogo == true, !aiChatSettings.isAIChatSearchInputUserSettingsEnabled {
            animateLogoAppearance()
        } else if aiChatSettings.isAIChatSearchInputUserSettingsEnabled {
            deferNTPAppearance()
        }
        themeColorManager.updateThemeColor()
    }

    
    func tabSwitcher(_ tabSwitcher: TabSwitcherViewController, editBookmarkForUrl url: URL) {
        guard let bookmark = self.menuBookmarksViewModel.bookmark(for: url) else { return }
        tabSwitcher.dismiss(animated: true) {
            self.segueToEditBookmark(bookmark)
        }
    }
    
    func tabSwitcherDidBulkCloseTabs(tabSwitcher: TabSwitcherViewController) {
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        updateCurrentTab()
    }

    func tabSwitcher(_ tabSwitcher: TabSwitcherViewController, willCloseTabs tabs: [Tab]) {
        if #available(iOS 18.4, *) {
            for tab in tabs {
                if let tabController = tabManager.controller(for: tab) {
                    webExtensionEventsCoordinator?.didCloseTab(tabController)
                }
            }
        }
    }

    func closeTab(_ tab: Tab,
                  behavior: TabClosingBehavior = .onlyClose,
                  clearTabHistory: Bool = true) {
        
        func replaceTabWith(newTab: Tab) {
            tabManager.replace(tab: tab, withNewTab: newTab, clearTabHistory: clearTabHistory)
            tabManager.select(newTab, dismissCurrent: false)
            showBars() // In case the browser chrome bars are hidden when calling this method
        }
        if #available(iOS 18.4, *) {
            if let closingTabController = tabManager.controller(for: tab) {
                webExtensionEventsCoordinator?.didCloseTab(closingTabController)
            }
        }

        hideSuggestionTray()
        hideNotificationBarIfBrokenSitePromptShown()
        themeColorManager.updateThemeColor()

        switch behavior {
        case .createEmptyTabAtSamePosition:
            let newTab = Tab(fireTab: tabManager.currentTabsModel.shouldCreateFireTabs)
            replaceTabWith(newTab: newTab)
        case .createOrReuseEmptyTab:
            tabManager.remove(tab: tab, clearTabHistory: clearTabHistory)
            if let existing = tabManager.firstHomeTab() {
                tabManager.select(existing, dismissCurrent: false)
            } else {
                tabManager.addHomeTab()
            }
            showBars() // In case the browser chrome bars are hidden when calling this method
        case .createNewChat:
            let aiChatLink = Link(title: nil, url: aiChatSettings.aiChatURL)
            let newTab = Tab(link: aiChatLink, fireTab: tabManager.currentTabsModel.shouldCreateFireTabs)
            replaceTabWith(newTab: newTab)
        case .onlyClose:
            tabManager.remove(tab: tab, clearTabHistory: clearTabHistory)
        }

        updateCurrentTab()
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel)
    }

    func tabSwitcherDidRequestForgetAll(tabSwitcher: TabSwitcherViewController, fireRequest: FireRequest) {
        self.forgetAllWithAnimation(request: fireRequest) {
            tabSwitcher.dismissIfPossible(animated: false)
        }
    }

    func tabSwitcherDidRequestCloseAll(tabSwitcher: TabSwitcherViewController) {
        Task {
            let request: FireRequest
            switch tabSwitcher.selectedBrowsingMode {
            case .fire:
                request = FireRequest(options: .all, trigger: .manualFire, scope: .fireMode, source: .tabSwitcher)
            case .normal:
                request = FireRequest(options: .tabs, trigger: .manualFire, scope: .normalMode, source: .tabSwitcher)
            }
            await fireExecutor.burn(request: request, applicationState: .unknown)
            tabSwitcher.dismissIfPossible()
        }
    }

    func tabSwitcherDidReorderTabs(tabSwitcher: TabSwitcherViewController) {
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
        swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel, scrollToSelected: true)
    }

    func tabSwitcherDidRequestAIChat(tabSwitcher: TabSwitcherViewController) {
        fireAIChatUsagePixelAndSetFeatureUsed(.openAIChatFromTabManager)
        self.aiChatViewControllerManager.openAIChat(on: tabSwitcher)
    }
    
    func tabSwitcherDidRequestAIChatTab(tabSwitcher: TabSwitcherViewController) {
        fireAIChatUsagePixelAndSetFeatureUsed(.openAIChatFromTabManager)
        newTab(allowingKeyboard: false)
        openAIChat()
    }
    
}

extension MainViewController: BookmarksDelegate {
    func bookmarksDidSelect(url: URL) {

        dismissOmniBar()
        if url.isBookmarklet() {
            executeBookmarklet(url)
        } else {
            loadUrl(url)
        }
    }
}

extension MainViewController: TabSwitcherButtonDelegate {

    func launchNewTabWithCurrentMode(_ button: TabSwitcherButton) {
        newTabShortcutAction()
    }
    
    func launchNewNormalTab(_ button: any TabSwitcherButton) {
        newNormalTabLongPressMenuAction()
    }

    func launchNewFireTab(_ button: TabSwitcherButton) {
        newFireTabLongPressMenuAction()
    }

    func showTabSwitcher(_ button: TabSwitcherButton) {
        Pixel.fire(pixel: .tabBarTabSwitcherOpened,
                   withAdditionalParameters: [PixelParameters.browsingMode: tabManager.currentBrowsingMode.pixelParamValue])
        var openedDailyParams = TabSwitcherOpenDailyPixel().parameters(with: tabManager.allTabsModel.tabs)
        openedDailyParams[PixelParameters.browsingMode] = tabManager.currentBrowsingMode.pixelParamValue
        DailyPixel.fireDaily(.tabSwitcherOpenedDaily, withAdditionalParameters: openedDailyParams)

        performActionIfAITab { DailyPixel.fireDailyAndCount(pixel: .aiChatTabSwitcherOpened) }

        performCancel()
        showTabSwitcher()
    }

    func showTabSwitcher() {
        if !tabManager.currentTabsModel.allowsEmpty
            && tabManager.current(createIfNeeded: true) == nil {
            fatalError("Unable to get current tab")
        }
        if let tab = tabManager.currentTabsModel.currentTab, tab.link == nil {
            ntpAfterIdleInstrumentation.tabSwitcherSelectedFromNTP(afterIdle: tab.openedAfterIdle)
        }
        tabManager.currentTabsModel.currentTab?.openedAfterIdle = false
        hideNotificationBarIfBrokenSitePromptShown()
        updatePreviewForCurrentTab {
            ViewHighlighter.hideAll()
            Task { @MainActor in
                await self.segueToTabSwitcher()
            }
        }
    }
}

// MARK: - UIGestureRecognizerDelegate

extension MainViewController: UIGestureRecognizerDelegate {

    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
        return true
    }
}

extension MainViewController: GestureToolbarButtonDelegate {
    
    func singleTapDetected(in sender: GestureToolbarButton) {
        Pixel.fire(pixel: .bookmarksButtonPressed,
                   withAdditionalParameters: [PixelParameters.originatedFromMenu: "0"])
        onBookmarksPressed()
    }
    
    func longPressDetected(in sender: GestureToolbarButton) {
        quickSaveBookmark()
    }
    
}

// MARK: - Fire Button Logic

extension MainViewController {

    func clearNavigationStack() {
        dismissOmniBar()

        if let presented = presentedViewController {
            presented.dismiss(animated: false) { [weak self] in
                self?.clearNavigationStack()
            }
        }
    }

    func forgetAllWithAnimation(request: FireRequest,
                                transitionCompletion: (() -> Void)? = nil,
                                showNextDaxDialog: Bool = false) {
        let spid = Instruments.shared.startTimedEvent(.clearingData)
        let tabsCount = tabsCount(for: request.scope)
        firePixels(for: request)
        productSurfaceTelemetry.dataClearingUsed()
        
        fireExecutor.prepare(for: request)
        
        fireButtonAnimator.animate {
            await self.fireExecutor.burn(request: request, applicationState: .unknown)
            Instruments.shared.endTimedEvent(for: spid)
            self.daxDialogsManager.resumeRegularFlow()
        } onTransitionCompleted: { [weak self] in
            self?.presentPostBurnMessage(tabsCount: tabsCount)
            transitionCompletion?()
        } completion: {
            self.subscriptionDataReporter.saveFireCount()

            // Ideally this should happen once data clearing has finished AND the animation is finished
            if showNextDaxDialog {
                self.newTabPageViewController?.showNextDaxDialog()
            } else if request.options.contains(.tabs) && KeyboardSettings().onNewTab {
                let showKeyboardAfterFireButton = DispatchWorkItem {
                    if !self.aiChatSettings.isAIChatSearchInputUserSettingsEnabled {
                        self.enterSearch()
                    }
                }
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3, execute: showKeyboardAfterFireButton)
                self.showKeyboardAfterFireButton = showKeyboardAfterFireButton
            }

            self.daxDialogsManager.clearedBrowserData()
        }
    }
    
    private func tabsCount(for scope: FireRequest.Scope) -> Int {
        switch scope {
        case .tab:
            return 1
        case .fireMode:
            return tabManager.tabsModel(for: .fire).count
        case .normalMode:
            return tabManager.tabsModel(for: .normal).count
        case .all:
            return tabManager.allTabsModel.count
        }
    }
    
    @MainActor
    private func presentPostBurnMessage(tabsCount: Int) {
        let message = UserText.scopedFireConfirmationTabsDeletedToast(tabCount: tabsCount)
        ActionMessageView.present(message: message,
                                  presentationLocation: .withBottomBar(andAddressBarBottom: self.appSettings.currentAddressBarPosition.isBottom))
    }
    
    private func refreshUIAfterClear() {
        if tabManager.currentTabsModel.tabs.isEmpty && tabManager.currentTabsModel.allowsEmpty {
            showTabSwitcher()
            tabSwitcherController?.updateUIForSelectionMode()
            return
        }
        showBars()
        attachHomeScreen()
        tabsBarController?.refresh(tabsModel: tabManager.currentTabsModel)

        if !autoClearInProgress {
            // We don't need to refresh tabs if autoclear is in progress as nothing has happened yet
            swipeTabsCoordinator?.refresh(tabsModel: tabManager.currentTabsModel)
        }
    }
    
    private func showFireButtonPulse() {
        daxDialogsManager.fireButtonPulseStarted()
        guard let window = view.window else { return }
        
        let fireButtonView: UIView?
        if viewCoordinator.toolbar.isHidden { // This is the iPad case
            fireButtonView = tabsBarController?.fireButton
        } else {
            fireButtonView = findFireButton()
        }
        guard let view = fireButtonView else { return }
        
        if !ViewHighlighter.highlightedViews.contains(where: { $0.view == view }) {
            ViewHighlighter.hideAll()
            ViewHighlighter.showIn(window, focussedOnView: view)
        }
    }

    private func findFireButton() -> UIView? {
        let state = mobileCustomization.state

        if state.currentToolbarButton == .fire {
            if isInMinimalChromeLayout {
                return viewCoordinator.omniBar.barView.fireButton
            }
            return viewCoordinator.toolbarFireBarButtonItem.customView
        } else if state.currentAddressBarButton == .fire {
            return viewCoordinator.omniBar.barView.customizableButton
        } else {
            if isInMinimalChromeLayout {
                return viewCoordinator.omniBar.barView.menuButton
            }
            return viewCoordinator.menuToolbarButton.customView
        }

    }

    private func showPrivacyDashboardButtonPulse() {
        viewCoordinator.omniBar.showOrScheduleOnboardingPrivacyIconAnimation()
    }

    private func dismissPrivacyDashboardButtonPulse() {
        daxDialogsManager.setPrivacyButtonPulseSeen()
        viewCoordinator.omniBar.dismissOnboardingPrivacyIconAnimation()
    }
}

// MARK: - Data Clearing Overlay

extension MainViewController {

    /// Shows a transparent overlay that captures user interactions during data clearing.
    ///
    /// The overlay detects when users attempt to interact with the UI before clearing completes,
    /// which may indicate perceived slowness or incomplete clearing. A pixel is fired on the first
    /// interaction, then the overlay is removed to allow normal user interaction.
    ///
    /// Only shown for manual fire triggers (user-initiated), not auto-clear operations.
    private func showBurningOverlay() {
        guard let window = view.window else { return }

        hideBurningOverlay()

        let overlay = UIView(frame: window.bounds)
        overlay.backgroundColor = .clear

        let tap = UITapGestureRecognizer(target: self, action: #selector(burningOverlayTapped))
        tap.cancelsTouchesInView = false
        overlay.addGestureRecognizer(tap)

        window.addSubview(overlay)
        window.bringSubviewToFront(overlay)
        burningOverlayView = overlay
    }

    /// Removes the burning overlay if it exists.
    private func hideBurningOverlay() {
        burningOverlayView?.removeFromSuperview()
        burningOverlayView = nil
    }

    /// Removes the overlay when user taps during data clearing, and fires a pixel if possible.
    ///
    /// This indicates the user attempted to interact before clearing completed,
    /// which is a secondary SLI metric for measuring perceived clearing performance.
    /// The overlay is always removed to respect user action, even if pixel firing fails.
    @objc private func burningOverlayTapped() {
        if let fireExecutor = fireExecutor as? FireExecutor {
            fireExecutor.pixelsReporter.fireUserActionBeforeCompletionPixel()
        }
        hideBurningOverlay()
    }
}

extension MainViewController: TabManagerFireModeDelegate {

    func tabManagerDidCloseLastFireTab() {
        DailyPixel.fireDailyAndCount(pixel: .fireModeLastTabClosedBurn)
        Task {
            let request = FireRequest(options: [.data, .aiChats],
                                      trigger: .fireModeAutoClear,
                                      scope: .fireMode,
                                      source: .browsing)
            await fireExecutor.burn(request: request, applicationState: .unknown)
        }
    }

    func tabManagerDidChangeBrowsingMode(_ mode: BrowsingMode) {
        Task {
            await aiChatViewControllerManager.killSessionAndResetTimer()
        }
    }
}

extension MainViewController: FireExecutorDelegate {
    
    func willStartBurning(fireRequest: FireRequest) {
        switch fireRequest.trigger {
        case .manualFire:
            showBurningOverlay()
        case .autoClearOnLaunch:
            autoClearInProgress = true
        case .autoClearOnForeground:
            autoClearInProgress = true
            clearNavigationStack()
        case .fireModeAutoClear:
            break
        }
    }
    
    private func firePixels(for request: FireRequest) {
        let tabType = tabManager.viewModelForCurrentTab()?.tab.isAITab == true ? "ai" : "web"
        let browsingMode = tabManager.currentBrowsingMode.pixelParamValue
        let params: [String: String] = [
            PixelParameters.source: request.source.rawValue,
            PixelParameters.tabType: tabType,
            PixelParameters.browsingMode: browsingMode
        ]

        switch request.scope {
        case .all:
            Pixel.fire(pixel: .forgetAllExecuted, withAdditionalParameters: params)
            DailyPixel.fire(pixel: .forgetAllExecutedDaily, withAdditionalParameters: params)
        case .tab:
            DailyPixel.fireDailyAndCount(pixel: .singleTabBurnExecuted, withAdditionalParameters: params)
        case .fireMode:
            DailyPixel.fireDailyAndCount(pixel: .fireModeBurnExecuted, withAdditionalParameters: params)
        case .normalMode:
            DailyPixel.fireDailyAndCount(pixel: .normalModeBurnExecuted, withAdditionalParameters: params)
        }
    }
    
    func willStartBurningTabs(fireRequest: FireRequest) {
        omniBar.endEditing()
        findInPageView?.done()

        if #available(iOS 18.4, *) {
            let tabs: [Tab]
            switch fireRequest.scope {
            case .all:
                tabs = tabManager.allTabsModel.tabs
            case .fireMode:
                tabs = tabManager.tabsModel(for: .fire).tabs
            case .normalMode:
                tabs = tabManager.tabsModel(for: .normal).tabs
            case .tab:
                tabs = []
            }
            for tab in tabs {
                if let tabController = tabManager.controller(for: tab) {
                    webExtensionEventsCoordinator?.didCloseTab(tabController)
                }
            }
        }
    }
    
    func didFinishBurningTabs(fireRequest: FireRequest) {
        guard fireRequest.trigger == .manualFire else { return }
                
        switch fireRequest.scope {
        case .all, .fireMode, .normalMode:
            refreshUIAfterClear()
        case .tab:
            // For single tab, the UI was already updated in closeTab() → updateCurrentTab()
            return
        }
    }
    
    func willStartBurningData(fireRequest: FireRequest) {
        self.clearInProgress = true
        if #available(iOS 18.4, *) {
            webExtensionEventsCoordinator?.extensionsWillUnload()
            webExtensionManager?.unloadAllExtensions()
        }
    }
    
    func didFinishBurningData(fireRequest: FireRequest) {
        self.clearInProgress = false
        self.postClear?()
        self.postClear = nil
    }

    func willStartBurningAIHistory(fireRequest: FireRequest) {
        // No operation
    }
    
    func didFinishBurningAIHistory(fireRequest: FireRequest) {
        switch fireRequest.scope {
        case .all, .fireMode, .normalMode:
            Task {
                await aiChatViewControllerManager.killSessionAndResetTimer()
            }
        case .tab:
            // No custom logic for tab scope
            return
        }
    }
    
    func didFinishBurning(fireRequest: FireRequest) {
        if fireRequest.trigger == .manualFire {
            fireModePromotionEligibility?.markBurnPerformed()
        }

        // Trigger sync if needed after data and aichats finish
        // because data could potentially delete a contextual chat that needs syncing
        if syncService.authState != .inactive {
            syncService.scheduler.requestSyncImmediately()
        }
        if #available(iOS 18.4, *) {
            Task { @MainActor [weak self] in
                await self?.webExtensionManager?.loadInstalledExtensions()
                self?.webExtensionEventsCoordinator?.registerExistingTabsAndWindow()
            }
        }
        switch fireRequest.trigger {
        case .manualFire:
            hideBurningOverlay()
            return
        case .autoClearOnLaunch:
            autoClearInProgress = false
            autoClearShouldRefreshUIAfterClear = true
        case .autoClearOnForeground:
            autoClearInProgress = false
            if autoClearShouldRefreshUIAfterClear {
                refreshUIAfterClear()
            }
            autoClearShouldRefreshUIAfterClear = true
        case .fireModeAutoClear:
            break
        }
    }
}

extension MainViewController {

    override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
        super.traitCollectionDidChange(previousTraitCollection)

        if !themeColorManager.updateThemeColor() {
            updateStatusBarBackgroundColor()
        }

        updateFindInPage()
    }

    func refreshStatusBarBackgroundAfterAIChrome() {
        if !themeColorManager.updateThemeColor() {
            updateStatusBarBackgroundColor()
        }
    }

    private func updateStatusBarBackgroundColor() {
        let theme = ThemeManager.shared.currentTheme
        let color: UIColor

        if appSettings.currentAddressBarPosition == .bottom {
            color = theme.backgroundColor
        } else {
            if AppWidthObserver.shared.isPad && traitCollection.horizontalSizeClass == .regular {
                color = theme.tabsBarBackgroundColor
            } else {
                color = theme.omniBarBackgroundColor
            }
        }

        viewCoordinator.setStandardStatusBackgroundColor(color)
    }

    private func decorate() {
        let theme = ThemeManager.shared.currentTheme

        updateStatusBarBackgroundColor()

        setNeedsStatusBarAppearanceUpdate()

        view.backgroundColor = theme.mainViewBackgroundColor

        viewCoordinator.navigationBarContainer.backgroundColor = theme.barBackgroundColor
        viewCoordinator.navigationBarContainer.tintColor = theme.barTintColor

        viewCoordinator.toolbar.barTintColor = theme.barBackgroundColor
        viewCoordinator.toolbar.tintColor = UIColor(singleUseColor: .toolbarButton)

        viewCoordinator.toolbarTabSwitcherButton.tintColor = UIColor(singleUseColor: .toolbarButton)

        viewCoordinator.logoText.tintColor = theme.ddgTextTintColor
    }

}

extension MainViewController: OnboardingDelegate {
        
    func onboardingCompleted(controller: UIViewController) {
        markOnboardingSeen()

        controller.modalTransitionStyle = .crossDissolve
        controller.dismiss(animated: true)
        newTabPageViewController?.onboardingCompleted()
    }
    
    func markOnboardingSeen() {
        isStartupOnboardingPending = false
        tutorialSettings.hasSeenOnboarding = true
    }

    func needsToShowOnboardingIntro() -> Bool {
        isStartupOnboardingPending || !tutorialSettings.hasSeenOnboarding
    }

}

extension MainViewController: OnboardingNavigationDelegate {
    func navigateFromOnboarding(to url: URL) {
        self.loadUrl(url, fromExternalLink: true)
    }

    func searchFromOnboarding(for query: String) {
        self.loadQuery(query)
    }
}

extension MainViewController: UIDropInteractionDelegate {
    
    func dropInteraction(_ interaction: UIDropInteraction, canHandle session: UIDropSession) -> Bool {
        return session.canLoadObjects(ofClass: URL.self) || session.canLoadObjects(ofClass: String.self)
    }
    
    func dropInteraction(_ interaction: UIDropInteraction, sessionDidUpdate session: UIDropSession) -> UIDropProposal {
        return UIDropProposal(operation: .copy)
    }

    // won't drop on to a web view - only works by dropping on to the tabs bar or home screen
    func dropInteraction(_ interaction: UIDropInteraction, performDrop session: UIDropSession) {
        
        if session.canLoadObjects(ofClass: URL.self) {
            _ = session.loadObjects(ofClass: URL.self) { urls in
                urls.forEach { self.loadUrlInNewTab($0, inheritedAttribution: nil) }
            }
            
        } else if session.canLoadObjects(ofClass: String.self) {
            _ = session.loadObjects(ofClass: String.self) { strings in
                self.loadQuery(strings[0])
            }
            
        }
        
    }
}

// MARK: - VoiceSearchViewControllerDelegate

extension MainViewController: VoiceSearchViewControllerDelegate {

    func voiceSearchViewController(_ controller: VoiceSearchViewController, didFinishQuery query: String?, target: VoiceSearchTarget) {
        controller.dismiss(animated: true) { [weak self] in
            guard let self = self, let query = query else { return }
            self.handleVoiceSearchCompletion(with: query, for: target)
        }
    }

    private func handleVoiceSearchCompletion(with query: String, for target: VoiceSearchTarget) {
        switch target {
        case .SERP:
            Pixel.fire(pixel: .voiceSearchSERPDone)
            loadQuery(query)

        case .AIChat:
            Pixel.fire(pixel: .voiceSearchAIChatDone)
            if let coordinator = unifiedToggleInputCoordinator, coordinator.isAITabState, coordinator.hasBoundUserScript {
                coordinator.submitVoicePrompt(query)
            } else {
                performCancel()
                openAIChat(query, autoSend: true)
            }
        }
    }
}

// MARK: - History UIMenu Methods

extension MainViewController {

    private func refreshBackForwardMenuItems() {
        guard let currentTab = currentTab else {
            return
        }
        
        let backMenu = historyMenu(with: currentTab.webView.backForwardList.backList.reversed())
        viewCoordinator.omniBar.barView.backButton.menu = backMenu
        viewCoordinator.toolbarBackButton.setCustomItemMenu(backMenu)

        let forwardMenu = historyMenu(with: currentTab.webView.backForwardList.forwardList)
        viewCoordinator.omniBar.barView.forwardButton.menu = forwardMenu
        viewCoordinator.toolbarForwardButton.setCustomItemMenu(forwardMenu)
    }

    private func historyMenu(with backForwardList: [WKBackForwardListItem]) -> UIMenu {
        let historyItemList = backForwardList.map { BackForwardMenuHistoryItem(backForwardItem: $0) }
        let actions = historyMenuButton(with: historyItemList)
        return UIMenu(title: "", children: actions)
    }
    
    private func historyMenuButton(with menuHistoryItemList: [BackForwardMenuHistoryItem]) -> [UIAction] {
        let menuItems: [UIAction] = menuHistoryItemList.compactMap { historyItem in
            
            return UIAction(title: historyItem.title,
                            subtitle: historyItem.sanitizedURLForDisplay,
                            discoverabilityTitle: historyItem.sanitizedURLForDisplay) { [weak self] _ in
                self?.loadBackForwardItem(historyItem.backForwardItem)
            }
        }
        
        return menuItems
    }
}

// MARK: - AutofillLoginSettingsListViewControllerDelegate
extension MainViewController: AutofillLoginListViewControllerDelegate {
    func autofillLoginListViewControllerDidFinish(_ controller: AutofillLoginListViewController) {
        controller.dismiss(animated: true)
    }
}

// MARK: - AIChatViewControllerManagerDelegate
extension MainViewController: AIChatViewControllerManagerDelegate {
    func aiChatViewControllerManager(_ manager: AIChatViewControllerManager, didRequestToLoad url: URL) {
        if let tabSwitcher = tabSwitcherController {
            loadUrlInNewTab(url, inheritedAttribution: nil)
            tabSwitcher.dismiss(animated: true)
        } else {
            loadUrlInNewTab(url, inheritedAttribution: nil)
        }
    }

    func aiChatViewControllerManager(_ manager: AIChatViewControllerManager, didSubmitQuery query: String) {
        self.loadQuery(query)
    }

    func aiChatViewControllerManager(_ manager: AIChatViewControllerManager, didRequestOpenDownloadWithFileName fileName: String) {
        segueToDownloads()
    }

    func aiChatViewControllerManagerDidReceiveOpenSettingsRequest(_ manager: AIChatViewControllerManager) {
        if let controller = tabSwitcherController {
            controller.dismiss(animated: true) {
                self.segueToSettingsAIChat()
            }
        } else {
            segueToSettingsAIChat()
        }
    }

    func aiChatViewControllerManagerDidReceiveOpenSyncSettingsRequest(_ manager: AIChatViewControllerManager) {
        segueToSettingsSync()
    }
}

// MARK: - AIChatContentHandlingDelegate
extension MainViewController: AIChatContentHandlingDelegate {

    func aiChatContentHandlerDidReceiveOpenSettingsRequest(_ handler:
                                                           AIChatContentHandling) {
        if let controller = tabSwitcherController {
            controller.dismiss(animated: true) {
                self.segueToSettingsAIChat()
            }
        } else {
            segueToSettingsAIChat()
        }
    }

    func aiChatContentHandlerDidReceiveOpenSyncSettingsRequest(_ handler: any AIChatContentHandling) {
        segueToSettingsSync()
    }

    func aiChatContentHandlerDidReceiveCloseChatRequest(_ handler:
                                                        AIChatContentHandling) {
        guard let tab = self.currentTab?.tabModel else { return }
        self.closeTab(tab)
    }

    func aiChatContentHandlerDidReceivePromptSubmission(_ handler: AIChatContentHandling) {
        // No action needed for full mode - notification handles metrics
    }

}

private extension UIBarButtonItem {
    func setCustomItemAction(on target: Any?, action: Selector) {
        if let customControl = customView as? UIControl {
            customControl.addTarget(target, action: action, for: .touchUpInside)
        } else {
            self.action = action
        }
    }

    func setCustomItemMenu(_ menu: UIMenu) {
        if let customControl = customView as? UIButton {
            customControl.menu = menu
        } else {
            self.menu = menu
        }
    }
}

/// This extension allows delegating from the RMF action button when the action type is 'navigation'.  It shadows existing functions.
extension MainViewController: MessageNavigationDelegate {

    func segueToSettingsAIChat(openedFromSERPSettingsButton: Bool, presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToSettingsAIChat(openedFromSERPSettingsButton: openedFromSERPSettingsButton)
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }
    
    func segueToSettings(presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToSettings()
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }

    func segueToSettingsAppearance(presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToAppearanceSettings()
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }

    func segueToFeedback(presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToFeedback()
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }
    
    func segueToSettingsSync(with source: String?, pairingInfo: PairingInfo?, presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToSettingsSync(with: source, pairingInfo: pairingInfo)
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }
    
    func segueToImportPasswords(presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            assertionFailure("Not implemented yet.")
        case .withinCurrentContext:
            let dataImportVC = makeDataImportViewController(source: .whatsNew)
            guard let viewController = topMostPresentedViewController() else {
                assertionFailure("No ViewController presented.")
                return
            }
            viewController.show(dataImportVC, sender: nil)
        }
    }

    func segueToPIR(presentationStyle: PresentationContext.Style) {
        switch presentationStyle {
        case .dismissModalsAndPresentFromRoot:
            segueToPIRWithSubscriptionCheck()
        case .withinCurrentContext:
            assertionFailure("Not implemented yet.")
        }
    }

}

extension MainViewController: MainViewEditingStateTransitioning {

    private var isDaxLogoVisible: Bool {
        newTabPageViewController?.isShowingLogo == true
    }

    var logoView: UIView? {
        if newTabPageViewController?.isShowingLogo == true {
            // Treat NTP view as logo view, but only if it's visible.
            // This prevents favorites from flickering during transition.
            return newTabPageViewController?.view
        } else {
            return nil
        }
    }

    func hide(with barYOffset: CGFloat, contentYOffset: CGFloat) {
        if isDaxLogoVisible {
            omniBar.barView.layer.sublayerTransform = CATransform3DMakeTranslation(0, barYOffset, 0)
        } else {
            additionalSafeAreaInsets.top = contentYOffset
        }
        omniBar.barView.hideButtons()
    }

    func show() {
        omniBar.barView.layer.sublayerTransform = CATransform3DIdentity
        additionalSafeAreaInsets.top = 0
        omniBar.barView.revealButtons()
    }
}

// MARK: AutoClear Action Delegate
extension MainViewController: SettingsAutoClearActionDelegate {
    func performDataClearing(for request: FireRequest) {
        forgetAllWithAnimation(request: request)
    }
}

// MARK: Customization support
extension MainViewController: MobileCustomization.Delegate {

    func canEditBookmark() -> Bool {
        guard let url = currentTab?.url else { return false }
        return menuBookmarksViewModel.bookmark(for: url) != nil
    }
    
    func canEditFavorite() -> Bool {
        guard let url = currentTab?.url, let bookmark = menuBookmarksViewModel.bookmark(for: url) else { return false }
        return bookmark.isFavorite(on: .mobile)
    }

}

extension MainViewController {

    private func subscribeToCustomizationSettingsEvents() {
        NotificationCenter.default.publisher(for: AppUserDefaults.Notifications.customizationSettingsChanged)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.applyCustomizationState()
            }
            .store(in: &settingsCancellables)
    }

    private func subscribeToDaxEasterEggLogoChanges() {
        NotificationCenter.default.publisher(for: .logoDidChangeNotification)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.refreshOmniBar()
            }
            .store(in: &settingsCancellables)
    }

    func applyCustomizationState() {
        applyCustomizationForToolbar(mobileCustomization.state)
        applyCustomizationForAddressBar(mobileCustomization.state)
    }

    func applyCustomizationForAddressBar(_ state: MobileCustomization.State) {
        omniBar.refreshCustomizableButton()
        if state.isEnabled {
            omniBar.barView.customizableButton.menu = UIMenu(children: [
                UIAction(title: "Customize", image: DesignSystemImages.Glyphs.Size16.options) { [weak self] _ in
                    self?.segueToCustomizeAddressBarSettings()
                }
            ])
        } else {
            omniBar.barView.customizableButton.menu = nil
        }
    }

    @objc private func performCustomizationActionForToolbar() {
        // On NTP the default is fire button
        if isNewTabPageVisible {
            self.onFirePressed()
            return
        }

        // Will be removed when feature flag is removed
        guard mobileCustomization.state.isEnabled else {
            self.onFirePressed()
            return
        }

        let button = mobileCustomization.state.currentToolbarButton
        switch button {
        case .home:
            guard let tab = self.currentTab?.tabModel else { return }
            self.closeTab(tab, behavior: .createEmptyTabAtSamePosition)

        case .newTab:
            self.newTab()

        case .fire:
            self.onFirePressed()

        case .bookmarks:
            self.segueToBookmarks()

        case .passwords:
            self.launchAutofillLogins(with: currentTab?.url, currentTabUid: currentTab?.tabModel.uid, source: .customizedToolbarButton, selectedAccount: nil)

        case .vpn:
            self.presentNetworkProtectionStatusSettingsModal()

        case .share:
            self.shareCurrentURLFromToolbar()

        case .downloads:
            self.segueToDownloads()

        case .duckAIVoice:
            Pixel.fire(pixel: .voiceEntryPointTapped, withAdditionalParameters: [PixelParameters.source: VoiceEntryPointSource.toolbar.rawValue])
            self.openAIChatInVoiceMode()

        default:
            assertionFailure("Unexpected case \(button)")
        }
    }

    /// Applies customization if enabled, ensures default otherwise.
    private func applyCustomizationForToolbar(_ state: MobileCustomization.State) {
        guard let toolbarFireButton = viewCoordinator.toolbarFireBarButtonItem.customView as? BrowserChromeButton else {
            assertionFailure("Expected BrowserChromeButton")
            return
        }

        customizeFireButton(toolbarFireButton, state: state)

        if let omniBarFireButton = viewCoordinator.omniBar.barView.fireButton as? BrowserChromeButton {
            customizeFireButton(omniBarFireButton, state: state)
        }
    }

    private func customizeFireButton(_ button: BrowserChromeButton, state: MobileCustomization.State) {
        if !isNewTabPageVisible && state.isEnabled {
            button.setImage(state.currentToolbarButton.largeIcon)
            button.menu = UIMenu(children: [
                UIAction(title: "Customize", image: DesignSystemImages.Glyphs.Size16.options) { [weak self] _ in
                    self?.segueToCustomizeToolbarSettings()
                }
            ])
        } else {
            button.setImage(DesignSystemImages.Glyphs.Size24.fireSolid)
            button.menu = nil
        }
    }

    private func handleCustomizableAddressBarButtonPressed() {
        let button = mobileCustomization.state.currentAddressBarButton
        switch button {
        case .share:
            shareCurrentURLFromAddressBar()

        case .addEditBookmark:
            addOrEditBookmarkForCurrentTab()
            omniBar.refreshCustomizableButton()

        case .addEditFavorite:
            addOrEditFavoriteForCurrentTab()
            omniBar.refreshCustomizableButton()

        case .fire:
            onFirePressed()

        case .vpn:
            presentNetworkProtectionStatusSettingsModal()

        case .zoom:
            showTextZoomEditorIfPossible()

        case .duckAIVoice:
            Pixel.fire(pixel: .voiceEntryPointTapped, withAdditionalParameters: [PixelParameters.source: VoiceEntryPointSource.addressBar.rawValue])
            openAIChatInVoiceMode()

        default:
            assertionFailure("Unexpected case: \(button)")
            return
        }

    }

    private func addOrEditBookmarkForCurrentTab() {
        guard let webView = currentTab?.webView,
              let url = webView.url else {
            assertionFailure("Expecting current tab with web view")
            return
        }
        if let bookmark = menuBookmarksViewModel.bookmark(for: url) {
            segueToEditBookmark(bookmark)
        } else {
            currentTab?.saveAsBookmark(favorite: false, viewModel: menuBookmarksViewModel)
        }
    }

    private func addOrEditFavoriteForCurrentTab() {
        guard let webView = currentTab?.webView,
              let url = webView.url else {
            assertionFailure("Expecting current tab with web view")
            return
        }

        let bookmark = menuBookmarksViewModel.bookmark(for: url)
        if bookmark?.isFavorite(on: .mobile) == true {
            segueToEditBookmark(bookmark!)
        } else {
            currentTab?.saveAsBookmark(favorite: true, viewModel: menuBookmarksViewModel)
        }
    }

    private func showTextZoomEditorIfPossible() {
        guard let currentTab, let webView = currentTab.webView else {
            assertionFailure("Expecting current tab with web view")
            return
        }
        Task { @MainActor in
            let textZoomCoordinator = textZoomCoordinatorProvider.coordinator(for: currentTab.tabModel.textZoomContext)
            await textZoomCoordinator.showTextZoomEditor(inController: self, forWebView: webView)
        }
    }

}

// MARK: - AIChatHistoryManagerDelegate

extension MainViewController: AIChatHistoryManagerDelegate {

    func aiChatHistoryManager(_ manager: AIChatHistoryManager, didSelectChatURL url: URL) {
        onChatHistorySelected(url: url)
    }
}

// MARK: - ConsentStatusInfo to CookieConsentInfo Conversion

@available(iOS 18.4, *)
extension ConsentStatusInfo {
    func toCookieConsentInfo() -> CookieConsentInfo {
        CookieConsentInfo(
            consentManaged: consentManaged,
            cosmetic: cosmetic,
            optoutFailed: optoutFailed,
            selftestFailed: selftestFailed,
            consentReloadLoop: consentReloadLoop,
            consentRule: consentRule,
            consentHeuristicEnabled: consentHeuristicEnabled
        )
    }
}