/*
 * Copyright © 2019-2021 Soren Stoutner <soren@stoutner.com>.
 *
 * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
 *
 * Privacy Browser is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Privacy Browser is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.stoutner.privacybrowser.views

import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Bitmap
import android.graphics.drawable.BitmapDrawable
import android.os.Bundle
import android.util.AttributeSet
import android.view.MotionEvent
import android.webkit.WebView
import android.webkit.SslErrorHandler
import android.webkit.HttpAuthHandler

import androidx.core.content.ContextCompat
import androidx.core.view.NestedScrollingChild2
import androidx.core.view.NestedScrollingChildHelper
import androidx.core.view.ViewCompat

import com.stoutner.privacybrowser.R

import java.util.Collections
import java.util.Date

import kotlin.collections.ArrayList

import kotlin.jvm.JvmOverloads

// Define the saved state constants.
private const val DOMAIN_SETTINGS_APPLIED = "domain_settings_applied"
private const val DOMAIN_SETTINGS_DATABASE_ID = "domain_settings_database_id"
private const val CURRENT_DOMAIN_NAME = "current_domain_name"
private const val CURRENT_URl = "current_url"
private const val ACCEPT_COOKIES = "accept_cookies"
private const val EASYLIST_ENABLED = "easylist_enabled"
private const val EASYPRIVACY_ENABLED = "easyprivacy_enabled"
private const val FANBOYS_ANNOYANCE_LIST_ENABLED = "fanboys_annoyance_list_enabled"
private const val FANBOYS_SOCIAL_BLOCKING_LIST_ENABLED = "fanboys_social_blocking_list_enabled"
private const val ULTRALIST_ENABLED = "ultralist_enabled"
private const val ULTRAPRIVACY_ENABLED = "ultraprivacy_enabled"
private const val BLOCK_ALL_THIRD_PARTY_REQUESTS = "block_all_third_party_requests"
private const val HAS_PINNED_SSL_CERTIFICATE = "has_pinned_ssl_certificate"
private const val PINNED_SSL_ISSUED_TO_CNAME = "pinned_ssl_issued_to_cname"
private const val PINNED_SSL_ISSUED_TO_ONAME = "pinned_ssl_issued_to_oname"
private const val PINNED_SSL_ISSUED_TO_UNAME = "pinned_ssl_issued_to_uname"
private const val PINNED_SSL_ISSUED_BY_CNAME = "pinned_ssl_issued_by_cname"
private const val PINNED_SSL_ISSUED_BY_ONAME = "pinned_ssl_issued_by_oname"
private const val PINNED_SSL_ISSUED_BY_UNAME = "pinned_ssl_issued_by_uname"
private const val PINNED_SSL_START_DATE = "pinned_ssl_start_date"
private const val PINNED_SSL_END_DATE = "pinned_ssl_end_date"
private const val PINNED_IP_ADDRESSES = "pinned_ip_addresses"
private const val IGNORE_PINNED_DOMAIN_INFORMATION = "ignore_pinned_domain_information"
private const val SWIPE_TO_REFRESH = "swipe_to_refresh"
private const val JAVASCRIPT_ENABLED = "javascript_enabled"
private const val DOM_STORAGE_ENABLED = "dom_storage_enabled"
private const val USER_AGENT = "user_agent"
private const val WIDE_VIEWPORT = "wide_viewport"
private const val FONT_SIZE = "font_size"

// NestedScrollWebView extends WebView to handle nested scrolls (scrolling the app bar off the screen).  It also stores extra information about the state of the WebView used by Privacy Browser.
class NestedScrollWebView @JvmOverloads constructor(context: Context, attributeSet: AttributeSet? = null, defaultStyle: Int = android.R.attr.webViewStyle) : WebView(context, attributeSet, defaultStyle),
    NestedScrollingChild2 {

    companion object {
        // Define the companion object blocklists constants.  These can be moved to class constants once all of the code has transitioned to Kotlin.
        const val BLOCKED_REQUESTS = 0
        const val EASYLIST = 1
        const val EASYPRIVACY = 2
        const val FANBOYS_ANNOYANCE_LIST = 3
        const val FANBOYS_SOCIAL_BLOCKING_LIST = 4
        const val ULTRALIST = 5
        const val ULTRAPRIVACY = 6
        const val THIRD_PARTY_REQUESTS = 7
    }

    // Define the public variables.
    var acceptCookies = false
    var blockAllThirdPartyRequests = false
    var currentDomainName = ""
    var currentIpAddresses = ""
    var currentUrl = ""
    var domainSettingsApplied = false
    var domainSettingsDatabaseId = 0
    var easyListEnabled = true
    var easyPrivacyEnabled = true
    var fanboysAnnoyanceListEnabled = true
    var fanboysSocialBlockingListEnabled = true
    var httpAuthHandler: HttpAuthHandler? = null
    var ignorePinnedDomainInformation = false
    var pinnedIpAddresses = ""
    var sslErrorHandler: SslErrorHandler? = null
    var swipeToRefresh = false
    var ultraListEnabled = true
    var ultraPrivacyEnabled = true
    var waitingForProxyUrlString = ""
    var webViewFragmentId: Long = 0


    // Define the private variables.
    private val nestedScrollingChildHelper: NestedScrollingChildHelper = NestedScrollingChildHelper(this)
    private lateinit var favoriteOrDefaultIcon: Bitmap
    private var previousYPosition = 0  // The previous Y position needs to be tracked between motion events.
    private var hasPinnedSslCertificate = false
    private var pinnedSslIssuedToCName = ""
    private var pinnedSslIssuedToOName = ""
    private var pinnedSslIssuedToUName = ""
    private var pinnedSslIssuedByCName = ""
    private var pinnedSslIssuedByOName = ""
    private var pinnedSslIssuedByUName = ""
    private var pinnedSslStartDate = Date(0)
    private var pinnedSslEndDate = Date(0)
    private val resourceRequests = Collections.synchronizedList(ArrayList<Array<String>>())  // Using a synchronized list makes adding resource requests thread safe.
    private var blockedRequests = 0
    private var easyListBlockedRequests = 0
    private var easyPrivacyBlockedRequests = 0
    private var fanboysAnnoyanceListBlockedRequests = 0
    private var fanboysSocialBlockingListBlockedRequests = 0
    private var ultraListBlockedRequests = 0
    private var ultraPrivacyBlockedRequests = 0
    private var thirdPartyBlockedRequests = 0

    init {
        // Enable nested scrolling by default.
        nestedScrollingChildHelper.isNestedScrollingEnabled = true

        // Initialize the favorite icon.
        initializeFavoriteIcon()
    }


    // Favorite or default icon.
    fun initializeFavoriteIcon() {
        // Get the default favorite icon drawable.  `ContextCompat` must be used until API >= 21.
        val favoriteIconDrawable = ContextCompat.getDrawable(context, R.drawable.world)

        // Cast the favorite icon drawable to a bitmap drawable.
        val favoriteIconBitmapDrawable = (favoriteIconDrawable as BitmapDrawable?)!!

        // Store the default icon bitmap.
        favoriteOrDefaultIcon = favoriteIconBitmapDrawable.bitmap
    }

    fun setFavoriteOrDefaultIcon(icon: Bitmap) {
        // Scale the favorite icon bitmap down if it is larger than 256 x 256.  Filtering uses bilinear interpolation.
        favoriteOrDefaultIcon = if (icon.height > 256 || icon.width > 256) {
            Bitmap.createScaledBitmap(icon, 256, 256, true)
        } else {
            // Store the icon as presented.
            icon
        }
    }

    fun getFavoriteOrDefaultIcon(): Bitmap {
        // Return the favorite or default icon.  This is the only way to return a non-nullable variable while retaining the custom initialization and setter functions above.
        return favoriteOrDefaultIcon
    }


    // Reset the handlers.
    fun resetSslErrorHandler() {
        // Reset the current SSL error handler.
        sslErrorHandler = null
    }

    fun resetHttpAuthHandler() {
        // Reset the current HTTP authentication handler.
        httpAuthHandler = null
    }


    // Pinned SSL certificates.
    fun hasPinnedSslCertificate(): Boolean {
        // Return the status of the pinned SSL certificate.
        return hasPinnedSslCertificate
    }

    fun setPinnedSslCertificate(issuedToCName: String, issuedToOName: String, issuedToUName: String, issuedByCName: String, issuedByOName: String, issuedByUName: String, startDate: Date, endDate: Date) {
        // Store the pinned SSL certificate information.
        pinnedSslIssuedToCName = issuedToCName
        pinnedSslIssuedToOName = issuedToOName
        pinnedSslIssuedToUName = issuedToUName
        pinnedSslIssuedByCName = issuedByCName
        pinnedSslIssuedByOName = issuedByOName
        pinnedSslIssuedByUName = issuedByUName
        pinnedSslStartDate = startDate
        pinnedSslEndDate = endDate

        // Set the pinned SSL certificate tracker.
        hasPinnedSslCertificate = true
    }

    fun getPinnedSslCertificate(): ArrayList<Any> {
        // Initialize an array list.
        val arrayList = ArrayList<Any>()

        // Create the SSL certificate string array.
        val sslCertificateStringArray = arrayOf(pinnedSslIssuedToCName, pinnedSslIssuedToOName, pinnedSslIssuedToUName, pinnedSslIssuedByCName, pinnedSslIssuedByOName, pinnedSslIssuedByUName)

        // Create the SSL certificate date array.
        val sslCertificateDateArray = arrayOf(pinnedSslStartDate, pinnedSslEndDate)

        // Add the arrays to the array list.
        arrayList.add(sslCertificateStringArray)
        arrayList.add(sslCertificateDateArray)

        // Return the pinned SSL certificate array list.
        return arrayList
    }

    fun clearPinnedSslCertificate() {
        // Clear the pinned SSL certificate.
        pinnedSslIssuedToCName = ""
        pinnedSslIssuedToOName = ""
        pinnedSslIssuedToUName = ""
        pinnedSslIssuedByCName = ""
        pinnedSslIssuedByOName = ""
        pinnedSslIssuedByUName = ""
        pinnedSslStartDate = Date(0)
        pinnedSslEndDate = Date(0)

        // Clear the pinned SSL certificate tracker.
        hasPinnedSslCertificate = false
    }


    // Resource requests.
    fun addResourceRequest(resourceRequest: Array<String>) {
        // Add the resource request to the list.
        resourceRequests.add(resourceRequest)
    }

    fun getResourceRequests(): List<Array<String>> {
        // Return the list of resource requests as an array list.
        return resourceRequests
    }

    fun clearResourceRequests() {
        // Clear the resource requests.
        resourceRequests.clear()
    }


    // Resource request counters.
    fun incrementRequestsCount(blocklist: Int) {
        // Increment the count of the indicated blocklist.
        when (blocklist) {
            BLOCKED_REQUESTS -> blockedRequests++
            EASYLIST -> easyListBlockedRequests++
            EASYPRIVACY -> easyPrivacyBlockedRequests++
            FANBOYS_ANNOYANCE_LIST -> fanboysAnnoyanceListBlockedRequests++
            FANBOYS_SOCIAL_BLOCKING_LIST -> fanboysSocialBlockingListBlockedRequests++
            ULTRALIST -> ultraListBlockedRequests++
            ULTRAPRIVACY -> ultraPrivacyBlockedRequests++
            THIRD_PARTY_REQUESTS -> thirdPartyBlockedRequests++
        }
    }

    fun getRequestsCount(blocklist: Int): Int {
        // Return the count of the indicated blocklist.
        return when (blocklist) {
            BLOCKED_REQUESTS -> blockedRequests
            EASYLIST -> easyListBlockedRequests
            EASYPRIVACY -> easyPrivacyBlockedRequests
            FANBOYS_ANNOYANCE_LIST -> fanboysAnnoyanceListBlockedRequests
            FANBOYS_SOCIAL_BLOCKING_LIST -> fanboysSocialBlockingListBlockedRequests
            ULTRALIST -> ultraListBlockedRequests
            ULTRAPRIVACY -> ultraPrivacyBlockedRequests
            THIRD_PARTY_REQUESTS -> thirdPartyBlockedRequests
            else -> 0 // Return 0.  This should never be called, but it is required by the return when statement.
        }
    }

    fun resetRequestsCounters() {
        // Reset all the resource request counters.
        blockedRequests = 0
        easyListBlockedRequests = 0
        easyPrivacyBlockedRequests = 0
        fanboysAnnoyanceListBlockedRequests = 0
        fanboysSocialBlockingListBlockedRequests = 0
        ultraListBlockedRequests = 0
        ultraPrivacyBlockedRequests = 0
        thirdPartyBlockedRequests = 0
    }


    // Publicly expose the scroll ranges.
    fun getHorizontalScrollRange(): Int {
        // Return the horizontal scroll range.
        return computeHorizontalScrollRange()
    }

    fun getVerticalScrollRange(): Int {
        // Return the vertical scroll range.
        return computeVerticalScrollRange()
    }


    // Handle touches.
    @SuppressLint("ClickableViewAccessibility")
    override fun onTouchEvent(motionEvent: MotionEvent): Boolean {
        // Run the commands for the given motion event action.
        when (motionEvent.action) {
            MotionEvent.ACTION_DOWN -> {
                // Start nested scrolling along the vertical axis.  `ViewCompat` must be used until the minimum API >= 21.
                startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL)

                // Save the current Y position.  Action down will not be called again until a new motion starts.
                previousYPosition = motionEvent.y.toInt()
            }
            MotionEvent.ACTION_MOVE -> {
                // Get the current Y position.
                val currentYMotionPosition = motionEvent.y.toInt()

                // Calculate the pre-scroll delta Y.
                val preScrollDeltaY = previousYPosition - currentYMotionPosition

                // Initialize a variable to track how much of the scroll is consumed.
                val consumedScroll = IntArray(2)

                // Initialize a variable to track the offset in the window.
                val offsetInWindow = IntArray(2)

                // Get the WebView Y position.
                val webViewYPosition = scrollY

                // Set the scroll delta Y to initially be the same as the pre-scroll delta Y.
                var scrollDeltaY = preScrollDeltaY

                // Dispatch the nested pre-school.  This scrolls the app bar if it needs it.  `offsetInWindow` will be returned with an updated value.
                if (dispatchNestedPreScroll(0, preScrollDeltaY, consumedScroll, offsetInWindow)) {
                    // Update the scroll delta Y if some of it was consumed.
                    scrollDeltaY = preScrollDeltaY - consumedScroll[1]
                }

                // Check to see if the WebView is at the top and and the scroll action is downward.
                if (webViewYPosition == 0 && scrollDeltaY < 0) {  // Swipe to refresh is being engaged.
                    // Stop the nested scroll so that swipe to refresh has complete control.  This way releasing the scroll to refresh circle doesn't scroll the WebView at the same time.
                    stopNestedScroll()
                } else {  // Swipe to refresh is not being engaged.
                    // Start the nested scroll so that the app bar can scroll off the screen.
                    startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL)

                    // Dispatch the nested scroll.  This scrolls the WebView.  The delta Y unconsumed normally controls the swipe refresh layout, but that is handled with the `if` statement above.
                    dispatchNestedScroll(0, scrollDeltaY, 0, 0, offsetInWindow)

                    // Store the current Y position for use in the next action move.
                    previousYPosition -= scrollDeltaY
                }
            }
            else -> stopNestedScroll()  // Stop nested scrolling.
        }

        // Perform a click.  This is required by the Android accessibility guidelines.
        performClick()

        // Run the default commands and return the result.
        return super.onTouchEvent(motionEvent)
    }


    // Save and restore state.
    fun saveNestedScrollWebViewState(): Bundle {
        // Create a saved state bundle.
        val savedState = Bundle()

        // Populate the saved state bundle.
        savedState.putBoolean(DOMAIN_SETTINGS_APPLIED, domainSettingsApplied)
        savedState.putInt(DOMAIN_SETTINGS_DATABASE_ID, domainSettingsDatabaseId)
        savedState.putString(CURRENT_DOMAIN_NAME, currentDomainName)
        savedState.putString(CURRENT_URl, currentUrl)
        savedState.putBoolean(ACCEPT_COOKIES, acceptCookies)
        savedState.putBoolean(EASYLIST_ENABLED, easyListEnabled)
        savedState.putBoolean(EASYPRIVACY_ENABLED, easyPrivacyEnabled)
        savedState.putBoolean(FANBOYS_ANNOYANCE_LIST_ENABLED, fanboysAnnoyanceListEnabled)
        savedState.putBoolean(FANBOYS_SOCIAL_BLOCKING_LIST_ENABLED, fanboysSocialBlockingListEnabled)
        savedState.putBoolean(ULTRALIST_ENABLED, ultraListEnabled)
        savedState.putBoolean(ULTRAPRIVACY_ENABLED, ultraPrivacyEnabled)
        savedState.putBoolean(BLOCK_ALL_THIRD_PARTY_REQUESTS, blockAllThirdPartyRequests)
        savedState.putBoolean(HAS_PINNED_SSL_CERTIFICATE, hasPinnedSslCertificate)
        savedState.putString(PINNED_SSL_ISSUED_TO_CNAME, pinnedSslIssuedToCName)
        savedState.putString(PINNED_SSL_ISSUED_TO_ONAME, pinnedSslIssuedToOName)
        savedState.putString(PINNED_SSL_ISSUED_TO_UNAME, pinnedSslIssuedToUName)
        savedState.putString(PINNED_SSL_ISSUED_BY_CNAME, pinnedSslIssuedByCName)
        savedState.putString(PINNED_SSL_ISSUED_BY_ONAME, pinnedSslIssuedByOName)
        savedState.putString(PINNED_SSL_ISSUED_BY_UNAME, pinnedSslIssuedByUName)
        savedState.putLong(PINNED_SSL_START_DATE, pinnedSslStartDate.time)
        savedState.putLong(PINNED_SSL_END_DATE, pinnedSslEndDate.time)
        savedState.putString(PINNED_IP_ADDRESSES, pinnedIpAddresses)
        savedState.putBoolean(IGNORE_PINNED_DOMAIN_INFORMATION, ignorePinnedDomainInformation)
        savedState.putBoolean(SWIPE_TO_REFRESH, swipeToRefresh)
        savedState.putBoolean(JAVASCRIPT_ENABLED, this.settings.javaScriptEnabled)
        savedState.putBoolean(DOM_STORAGE_ENABLED, this.settings.domStorageEnabled)
        savedState.putString(USER_AGENT, this.settings.userAgentString)
        savedState.putBoolean(WIDE_VIEWPORT, this.settings.useWideViewPort)
        savedState.putInt(FONT_SIZE, this.settings.textZoom)

        // Return the saved state bundle.
        return savedState
    }

    fun restoreNestedScrollWebViewState(savedState: Bundle) {
        // Restore the class variables.
        domainSettingsApplied = savedState.getBoolean(DOMAIN_SETTINGS_APPLIED)
        domainSettingsDatabaseId = savedState.getInt(DOMAIN_SETTINGS_DATABASE_ID)
        currentDomainName = savedState.getString(CURRENT_DOMAIN_NAME)!!
        currentUrl = savedState.getString(CURRENT_URl)!!
        acceptCookies = savedState.getBoolean(ACCEPT_COOKIES)
        easyListEnabled = savedState.getBoolean(EASYLIST_ENABLED)
        easyPrivacyEnabled = savedState.getBoolean(EASYPRIVACY_ENABLED)
        fanboysAnnoyanceListEnabled = savedState.getBoolean(FANBOYS_ANNOYANCE_LIST_ENABLED)
        fanboysSocialBlockingListEnabled = savedState.getBoolean(FANBOYS_SOCIAL_BLOCKING_LIST_ENABLED)
        ultraListEnabled = savedState.getBoolean(ULTRALIST_ENABLED)
        ultraPrivacyEnabled = savedState.getBoolean(ULTRAPRIVACY_ENABLED)
        blockAllThirdPartyRequests = savedState.getBoolean(BLOCK_ALL_THIRD_PARTY_REQUESTS)
        hasPinnedSslCertificate = savedState.getBoolean(HAS_PINNED_SSL_CERTIFICATE)
        pinnedSslIssuedToCName = savedState.getString(PINNED_SSL_ISSUED_TO_CNAME)!!
        pinnedSslIssuedToOName = savedState.getString(PINNED_SSL_ISSUED_TO_ONAME)!!
        pinnedSslIssuedToUName = savedState.getString(PINNED_SSL_ISSUED_TO_UNAME)!!
        pinnedSslIssuedByCName = savedState.getString(PINNED_SSL_ISSUED_BY_CNAME)!!
        pinnedSslIssuedByOName = savedState.getString(PINNED_SSL_ISSUED_BY_ONAME)!!
        pinnedSslIssuedByUName = savedState.getString(PINNED_SSL_ISSUED_BY_UNAME)!!
        pinnedSslStartDate = Date(savedState.getLong(PINNED_SSL_START_DATE))
        pinnedSslEndDate = Date(savedState.getLong(PINNED_SSL_END_DATE))
        pinnedIpAddresses = savedState.getString(PINNED_IP_ADDRESSES)!!
        ignorePinnedDomainInformation = savedState.getBoolean(IGNORE_PINNED_DOMAIN_INFORMATION)
        swipeToRefresh = savedState.getBoolean(SWIPE_TO_REFRESH)
        this.settings.javaScriptEnabled = savedState.getBoolean(JAVASCRIPT_ENABLED)
        this.settings.domStorageEnabled = savedState.getBoolean(DOM_STORAGE_ENABLED)
        this.settings.userAgentString = savedState.getString(USER_AGENT)
        this.settings.useWideViewPort = savedState.getBoolean(WIDE_VIEWPORT)
        this.settings.textZoom = savedState.getInt(FONT_SIZE)
    }


    // Method from NestedScrollingChild.
    override fun setNestedScrollingEnabled(status: Boolean) {
        // Set the status of the nested scrolling.
        nestedScrollingChildHelper.isNestedScrollingEnabled = status
    }

    // Method from NestedScrollingChild.
    override fun isNestedScrollingEnabled(): Boolean {
        // Return the status of nested scrolling.
        return nestedScrollingChildHelper.isNestedScrollingEnabled
    }

    // Method from NestedScrollingChild.
    override fun startNestedScroll(axes: Int): Boolean {
        // Start a nested scroll along the indicated axes.
        return nestedScrollingChildHelper.startNestedScroll(axes)
    }

    // Method from NestedScrollingChild2.
    override fun startNestedScroll(axes: Int, type: Int): Boolean {
        // Start a nested scroll along the indicated axes for the given type of input which caused the scroll event.
        return nestedScrollingChildHelper.startNestedScroll(axes, type)
    }

    // Method from NestedScrollingChild.
    override fun stopNestedScroll() {
        // Stop the nested scroll.
        nestedScrollingChildHelper.stopNestedScroll()
    }

    // Method from NestedScrollingChild2.
    override fun stopNestedScroll(type: Int) {
        // Stop the nested scroll of the given type of input which caused the scroll event.
        nestedScrollingChildHelper.stopNestedScroll(type)
    }

    // Method from NestedScrollingChild.
    override fun hasNestedScrollingParent(): Boolean {
        // Return the status of the nested scrolling parent.
        return nestedScrollingChildHelper.hasNestedScrollingParent()
    }

    // Method from NestedScrollingChild2.
    override fun hasNestedScrollingParent(type: Int): Boolean {
        // return the status of the nested scrolling parent for the given type of input which caused the scroll event.
        return nestedScrollingChildHelper.hasNestedScrollingParent(type)
    }

    // Method from NestedScrollingChild.
    override fun dispatchNestedPreScroll(deltaX: Int, deltaY: Int, consumed: IntArray?, offsetInWindow: IntArray?): Boolean {
        // Dispatch a nested pre-scroll with the specified deltas, which lets a parent to consume some of the scroll if desired.
        return nestedScrollingChildHelper.dispatchNestedPreScroll(deltaX, deltaY, consumed, offsetInWindow)
    }

    // Method from NestedScrollingChild2.
    override fun dispatchNestedPreScroll(deltaX: Int, deltaY: Int, consumed: IntArray?, offsetInWindow: IntArray?, type: Int): Boolean {
        // Dispatch a nested pre-scroll with the specified deltas for the given type of input which caused the scroll event, which lets a parent to consume some of the scroll if desired.
        return nestedScrollingChildHelper.dispatchNestedPreScroll(deltaX, deltaY, consumed, offsetInWindow, type)
    }

    // Method from NestedScrollingChild.
    override fun dispatchNestedScroll(deltaXConsumed: Int, deltaYConsumed: Int, deltaXUnconsumed: Int, deltaYUnconsumed: Int, offsetInWindow: IntArray?): Boolean {
        // Dispatch a nested scroll with the specified deltas.
        return nestedScrollingChildHelper.dispatchNestedScroll(deltaXConsumed, deltaYConsumed, deltaXUnconsumed, deltaYUnconsumed, offsetInWindow)
    }

    // Method from NestedScrollingChild2.
    override fun dispatchNestedScroll(deltaXConsumed: Int, deltaYConsumed: Int, deltaXUnconsumed: Int, deltaYUnconsumed: Int, offsetInWindow: IntArray?, type: Int): Boolean {
        // Dispatch a nested scroll with the specified deltas for the given type of input which caused the scroll event.
        return nestedScrollingChildHelper.dispatchNestedScroll(deltaXConsumed, deltaYConsumed, deltaXUnconsumed, deltaYUnconsumed, offsetInWindow, type)
    }

    // Method from NestedScrollingChild.
    override fun dispatchNestedPreFling(velocityX: Float, velocityY: Float): Boolean {
        // Dispatch a nested pre-fling with the specified velocity, which lets a parent consume the fling if desired.
        return nestedScrollingChildHelper.dispatchNestedPreFling(velocityX, velocityY)
    }

    // Method from NestedScrollingChild.
    override fun dispatchNestedFling(velocityX: Float, velocityY: Float, consumed: Boolean): Boolean {
        // Dispatch a nested fling with the specified velocity.
        return nestedScrollingChildHelper.dispatchNestedFling(velocityX, velocityY, consumed)
    }
}