/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * 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.
 */
package com.android.systemui.unfold

import android.animation.ValueAnimator
import android.content.Context
import android.graphics.PixelFormat
import android.hardware.devicestate.DeviceStateManager
import android.hardware.devicestate.DeviceStateManager.FoldStateListener
import android.hardware.display.DisplayManager
import android.os.Handler
import android.os.Trace
import android.view.Choreographer
import android.view.Display
import android.view.DisplayInfo
import android.view.Surface
import android.view.SurfaceControl
import android.view.SurfaceControlViewHost
import android.view.SurfaceSession
import android.view.WindowManager
import android.view.WindowlessWindowManager
import com.android.systemui.dagger.qualifiers.Main
import com.android.systemui.dagger.qualifiers.UiBackground
import com.android.systemui.statusbar.LightRevealEffect
import com.android.systemui.statusbar.LightRevealScrim
import com.android.systemui.statusbar.LinearLightRevealEffect
import com.android.systemui.unfold.UnfoldTransitionProgressProvider.TransitionProgressListener
import com.android.wm.shell.displayareahelper.DisplayAreaHelper
import java.util.Optional
import java.util.concurrent.Executor
import java.util.function.Consumer
import javax.inject.Inject

@SysUIUnfoldScope
class UnfoldLightRevealOverlayAnimation @Inject constructor(
    private val context: Context,
    private val deviceStateManager: DeviceStateManager,
    private val displayManager: DisplayManager,
    private val unfoldTransitionProgressProvider: UnfoldTransitionProgressProvider,
    private val displayAreaHelper: Optional<DisplayAreaHelper>,
    @Main private val executor: Executor,
    @Main private val handler: Handler,
    @UiBackground private val backgroundExecutor: Executor
) {

    private val transitionListener = TransitionListener()
    private val displayListener = DisplayChangeListener()

    private lateinit var wwm: WindowlessWindowManager
    private lateinit var unfoldedDisplayInfo: DisplayInfo
    private lateinit var overlayContainer: SurfaceControl

    private var root: SurfaceControlViewHost? = null
    private var scrimView: LightRevealScrim? = null
    private var isFolded: Boolean = false
    private var isUnfoldHandled: Boolean = true

    private var currentRotation: Int = context.display!!.rotation

    fun init() {
        deviceStateManager.registerCallback(executor, FoldListener())
        unfoldTransitionProgressProvider.addCallback(transitionListener)

        val containerBuilder = SurfaceControl.Builder(SurfaceSession())
            .setContainerLayer()
            .setName("unfold-overlay-container")

        displayAreaHelper.get().attachToRootDisplayArea(Display.DEFAULT_DISPLAY,
            containerBuilder) { builder ->
            executor.execute {
                overlayContainer = builder.build()

                SurfaceControl.Transaction()
                    .setLayer(overlayContainer, Integer.MAX_VALUE)
                    .show(overlayContainer)
                    .apply()

                wwm = WindowlessWindowManager(context.resources.configuration,
                    overlayContainer, null)
            }
        }

        displayManager.registerDisplayListener(displayListener, handler,
            DisplayManager.EVENT_FLAG_DISPLAY_CHANGED)

        // Get unfolded display size immediately as 'current display info' might be
        // not up-to-date during unfolding
        unfoldedDisplayInfo = getUnfoldedDisplayInfo()
    }

    /**
     * Called when screen starts turning on, the contents of the screen might not be visible yet.
     * This method reports back that the overlay is ready in [onOverlayReady] callback.
     *
     * @param onOverlayReady callback when the overlay is drawn and visible on the screen
     * @see [com.android.systemui.keyguard.KeyguardViewMediator]
     */
    fun onScreenTurningOn(onOverlayReady: Runnable) {
        Trace.beginSection("UnfoldLightRevealOverlayAnimation#onScreenTurningOn")
        try {
            // Add the view only if we are unfolding and this is the first screen on
            if (!isFolded && !isUnfoldHandled && ValueAnimator.areAnimatorsEnabled()) {
                addView(onOverlayReady)
                isUnfoldHandled = true
            } else {
                // No unfold transition, immediately report that overlay is ready
                ensureOverlayRemoved()
                onOverlayReady.run()
            }
        } finally {
            Trace.endSection()
        }
    }

    private fun addView(onOverlayReady: Runnable? = null) {
        if (!::wwm.isInitialized) {
            // Surface overlay is not created yet on the first SysUI launch
            onOverlayReady?.run()
            return
        }

        ensureOverlayRemoved()

        val newRoot = SurfaceControlViewHost(context, context.display!!, wwm, false)
        val newView = LightRevealScrim(context, null)
            .apply {
                revealEffect = createLightRevealEffect()
                isScrimOpaqueChangedListener = Consumer {}
                revealAmount = 0f
            }

        val params = getLayoutParams()
        newRoot.setView(newView, params)

        onOverlayReady?.let { callback ->
            Trace.beginAsyncSection(
                "UnfoldLightRevealOverlayAnimation#relayout", 0)

            newRoot.relayout(params) { transaction ->
                val vsyncId = Choreographer.getSfInstance().vsyncId

                backgroundExecutor.execute {
                    // Apply the transaction that contains the first frame of the overlay
                    // synchronously and apply another empty transaction with
                    // 'vsyncId + 1' to make sure that it is actually displayed on
                    // the screen. The second transaction is necessary to remove the screen blocker
                    // (turn on the brightness) only when the content is actually visible as it
                    // might be presented only in the next frame.
                    // See b/197538198
                    transaction.setFrameTimelineVsync(vsyncId)
                        .apply(/* sync */true)

                    transaction
                        .setFrameTimelineVsync(vsyncId + 1)
                        .apply(/* sync */ true)

                    Trace.endAsyncSection(
                        "UnfoldLightRevealOverlayAnimation#relayout", 0)
                    callback.run()
                }
            }
        }

        scrimView = newView
        root = newRoot
    }

    private fun getLayoutParams(): WindowManager.LayoutParams {
        val params: WindowManager.LayoutParams = WindowManager.LayoutParams()

        val rotation = context.display!!.rotation
        val isNatural = rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180

        params.height = if (isNatural)
            unfoldedDisplayInfo.naturalHeight else unfoldedDisplayInfo.naturalWidth
        params.width = if (isNatural)
            unfoldedDisplayInfo.naturalWidth else unfoldedDisplayInfo.naturalHeight

        params.format = PixelFormat.TRANSLUCENT
        params.type = WindowManager.LayoutParams.TYPE_DISPLAY_OVERLAY
        params.title = "Unfold Light Reveal Animation"
        params.layoutInDisplayCutoutMode =
            WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
        params.fitInsetsTypes = 0
        params.flags = (WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
            or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
        params.setTrustedOverlay()

        val packageName: String = context.opPackageName
        params.packageName = packageName

        return params
    }

    private fun createLightRevealEffect(): LightRevealEffect {
        val isVerticalFold = currentRotation == Surface.ROTATION_0 ||
            currentRotation == Surface.ROTATION_180
        return LinearLightRevealEffect(isVertical = isVerticalFold)
    }

    private fun ensureOverlayRemoved() {
        root?.release()
        root = null
        scrimView = null
    }

    private fun getUnfoldedDisplayInfo(): DisplayInfo =
        displayManager.displays
            .asSequence()
            .map { DisplayInfo().apply { it.getDisplayInfo(this) } }
            .filter { it.type == Display.TYPE_INTERNAL }
            .maxByOrNull { it.naturalWidth }!!

    private inner class TransitionListener : TransitionProgressListener {

        override fun onTransitionProgress(progress: Float) {
            scrimView?.revealAmount = progress
        }

        override fun onTransitionFinished() {
            ensureOverlayRemoved()
        }

        override fun onTransitionStarted() {
            // Add view for folding case (when unfolding the view is added earlier)
            if (scrimView == null) {
                addView()
            }
        }
    }

    private inner class DisplayChangeListener : DisplayManager.DisplayListener {

        override fun onDisplayChanged(displayId: Int) {
            val newRotation: Int = context.display!!.rotation
            if (currentRotation != newRotation) {
                currentRotation = newRotation
                scrimView?.revealEffect = createLightRevealEffect()
                root?.relayout(getLayoutParams())
            }
        }

        override fun onDisplayAdded(displayId: Int) {
        }

        override fun onDisplayRemoved(displayId: Int) {
        }
    }

    private inner class FoldListener : FoldStateListener(context, Consumer { isFolded ->
        if (isFolded) {
            ensureOverlayRemoved()
            isUnfoldHandled = false
        }
        this.isFolded = isFolded
    })
}